Introducción a Java Persistence API

1. Lo hemos logrado. Qué sigue? Ya hemos desarrollado una aplicación web con JAVA EE, utilizando Derby como base de datos, esta misma aplicación puede desarrollarse de diferentes maneras, las cuales no sólo resultan más eficientes sino más seguras

3. Java Server Faces CRUD

4. Spring MVC 2.5

6. El lenguaje de consultas de Persistence

7. Los metadatos para los objetos y sus relaciones

9. Las instancias de una entidad corresponden a filas dentro de la tabla

10. Generalmente las entidades se relacionan con otras entidades, estas relaciones se expresan mediante los metadatos

11. Los metadatos de las relaciones que se dan entre los objetos se pueden definir en un archivo XML o empleando anotaciones en el archivo de cada clase

13. POJO : Plain Old Java Object -> clases que no extienden a ninguna otra: MyDb.java es POJO, NewPostServlet no es POJO

17. Identidad: cada instancia de la entidad es única

18. Soporte Transaccional: las operaciones CRUD (CReate, Update, Delete ) para esta entidad se realizan de forma transaccional

20. private String post_title;

21. private Date post_date;

22. private String post_body;

23. //getter & setter methods }

25. set_id

26. get_title

27. set_title

30. private String post_title;

31. ...

34. Nombre de la clase: MiTabla

35. Nombre de las columnas: ATTR1, ATTR2, ATTR3

36. Nombre de los atributos: attr1, attr2, attr3

39. EntityManager: se refiere a una API que ofrece los servicios requeridos para trabajar con una entidad

40. En J2SE se define un EntityManager de la siguiente manera (explícita): EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(“PersistentUnitName”); EntityManager eManager = entityManagerFactory.createEntityManager();

44. Con las transacciones JTA el programador no debe preocuparse por nada, pero en las transacciones tipo Resource-local las validaciones corren por su cuenta y basado en los resultados de las mismas debe determinar si envía una transacción (commit) o por el contrario la anula (roll-back)

46. postObject.set();//definir valores para el objeto

47. entityManager.persist(postObject);

49. find() es un método propio de la clase EntityManager y permite recuperar una instancia de una entidad empleando el nombre de la clase y la llave primaria: postEntity elPost = entityManager.find(postEntity.class, 1); If (elPost != null){ // post object puede o no ser null. // Procesar el objecto }

55. Existen 2 tipos de consultas diferentes: estáticas y dinámicas

62. name = “Post.findByTitle”

63. query = “SELECT P FROM POSTENTITY WHERE P.TITLE LIKE '% :keyword %'

65. namedQuery.setParameter(“keyword”, entradaUsuario);

67. Paginación de Resultados int maxRecords = 10; int startPosition = 0; String queryString = “SELECT M FROM MOBILEENTITY”; while( true ){ Query selectQuery = entityManager.createQuery(queryString); selectQuery.setMaxResults(maxRecords); selectQuery.setFirstResult(startPosition); List mobiles = entityManager.getResultList(queryString); if (mobiles.isEmpty()){ break; } //Process the mobile entities. process(mobiles); entityManager.clear(); startPosition = startPosition + mobiles.size(); }

70. private EntityManager entityManager;

73. Paso 3: crear el Servlet para que el usuario pueda buscar

74. Paso 4: asociar el EntityManager al Servlet

75. Paso 5: definir el método de búsqueda y la interfaz

76. Creación Unidad Persistencia

77. Creación Unidad Persistencia

78. Creación Entidad

81. Creación Servlet

84. Asociando el EntityManager

86. Posts auxPost = null;

87. try {

88. Context ctx = (Context) new InitialContext().lookup("java:comp/env");

89. utx.begin();

90. EntityManager em = (EntityManager) ctx.lookup("persistence/LogicalName");

91. //em.persist(object);

92. auxPost = em.find(Posts.class, auxPostId);

93. utx.commit();

94. } catch (Exception e) {

95. Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", e);

96. throw new RuntimeException(e);

98. return auxPost;

101. // TODO output your page here

102. …

103. out.println("<h1>Motor de Busqueda - Blog</h1>");

104. String uiAuxId = request.getParameter("post_id");

105. if (uiAuxId != null && !uiAuxId.isEmpty()) {

106. //resultados de la busqueda

107. Posts resultadoBusqueda = this.findPostById(Integer.parseInt(uiAuxId));

108. if (resultadoBusqueda != null) {

109. out.println("<table>");

110. out.println("<tr>");

111. out.println("<td>Resultado de su búsqueda:</td>");

112. out.println("<td>" + resultadoBusqueda.getPostTitle() + "</td>");

113. out.println("</tr>");

114. out.println("</table>");

118. out.println("<td>Su búsqueda no arrojo resultados</td>");

121. }

122. } else {

123. //formulario de busqueda

124. out.println("<form method='POST' action='./SearchPost'>");

127. out.println("<td>Codigo del Post:</td>");

128. out.println("<td><input type='text' name='post_id'></td>");

131. out.println("<td colspan='2'><input type='submit' name='sendBtn' label='Search'></td>");

134. out.println("</form>");

135. }

137. Paso 2: definir la unidad de persistencia

138. Paso 3: implementar en él un método que permita recuperar el último id empleado

139. Paso 4: implementar la interfaz gráfica

141. Posts postAux = null;

142. try {

143. Context ctx = (Context) new InitialContext().lookup("java:comp/env");

144. utx.begin();

145. EntityManager em = (EntityManager) ctx.lookup("persistence/LogicalName");

146. //em.persist(object);

147. Query findAllQuery = em.createNamedQuery("Posts.findAll");

148. List posts = findAllQuery.getResultList();

150. Iterator auxiliar = posts.iterator();

151. while(auxiliar.hasNext()){

152. postAux = (Posts)auxiliar.next();//cast

153. }

154. utx.commit();

155. } catch (Exception e) {

156. Logger.getLogger(getClass().getName()).log(Level.SEVERE, "exception caught", e);

157. throw new RuntimeException(e);

158. }

159. return postAux.getPostId();

160. }

162. //formulario para la creacion de un nuevo post

163. out.println("<form method='POST' action='./ NewPost '>");

166. ...

168. out.println("<td colspan='2'><input type='submit' name='btnSubmit' value='savePost' label='Save'></td>");

171. out.println("</form>");

172. }

173. out.println("</body>");

174. out.println("</html>");

176. request.getParameter("post_date") != null && request.getParameter("post_body") != null) {

177. Posts nuevoPost = new Posts();

178. … //manipulacion de la fecha

179. nuevoPost.setPostDate(fechaSql);

180. nuevoPost.setPostTitle(request.getParameter("post_title"));

181. nuevoPost.setPostBody(request.getParameter("post_body"));

182. nuevoPost.setPostId(this.getLastId()+1);

183. this.persist(nuevoPost);

184. response.sendRedirect("./SearchPost");

Introducción a Java Persistence API

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Similar to Introducción a Java Persistence API

Similar to Introducción a Java Persistence API (20)

More from Jose Martinez

More from Jose Martinez (9)

Recently uploaded

Recently uploaded (20)

Introducción a Java Persistence API