JPA is a hibernate specification that helps us in managing, accessing & persisting data between RDBMS and Java objects & one of its main features is Criteria API, which is a pre-defined API and was introduced in JPA 2.0. It defines platform-independent criteria queries written in Java and enables us to achieve the same result as a raw query programmatically. It provides us with some object-oriented control over the raw SQL queries. By writing a criteria you define the where clause of a query for your specified domain class.<\/p>\n
import lombok.*;\r\nimport javax.persistence.*;\r\n\r\n@Entity\r\n@Getter\r\n@Setter\r\n@NoArgsConstructor\r\n@AllArgsConstructor\r\n@EqualsAndHashCode\r\npublic class DemoEmp {\r\n@Id\r\n@GeneratedValue(strategy= GenerationType.AUTO)\r\nprivate int id;\r\nprivate String name;\r\nprivate int salary;\r\nprivate int experience;\r\nprivate String departmentName;\r\n}<\/pre>\nDefine the Criteria Builder<\/h3>\nEntityManagerFactory emf = Persistence.createEntityManagerFactory(\"my-persistence-unit\");\r\nEntityManager em = emf.createEntityManager();\r\nCriteriaBuilder criteria = em.getCriteriaBuilder(); \r\nCriteriaQuery<DemoEmp> cq = criteria.createQuery(DemoEmp .class); \r\nRoot<DemoEmp> root = cq.from(DemoEmp .class); \r\ncq.select(root); \r\nQuery<DemoEmp> query = em.createQuery(cq);<\/pre>\nThe above code will get all the rows of the DemoEmp entity from the database.<\/p>\n
We can also use CriteriaBuilder for restricting query results based on the conditions using expressions<\/h3>\n\n- Fetch entities with salary greater than 50000<\/li>\n<\/ul>\n
cq.select(root).where(criteria.gt(root.get(\"salary\"), 50000));<\/pre>\n
\n- Fetch entities having experience between 2 and 5<\/li>\n<\/ul>\n
cq.select(root).where(criteria.between(root.get(\"experience\"), 2, 5));<\/pre>\nThere are various other methods as well like isNull(), isNotNull(), isEmpty(), isNotEmpty(), in(), like(), aggregate methods etc.<\/p>\n
We can also chain these expressions to achieve our desired condition using Predicates.<\/h3>\nPredicate greaterThanSalary = criteria.gt(root.get(\"salary\"), 50000);\r\nPredicate experience = criteria.between(root.get(\"experience\"), 2, 5);<\/pre>\nNow we can join these 2 conditions with either a Logical “AND”<\/strong> or a Logical “OR”<\/strong> based on our requirement.<\/p>\ncq.select(root).where(criteria.or(greaterThanSalary, experience));\r\ncq.select(root).where(criteria.and(greaterThanSalary, experience));<\/pre>\nGroupBy & Having Clause<\/h2>\n
The AbstractQuery interface of Criteria API has two methods groupBy()<\/strong> and having()<\/strong> which are used to filter the data by grouping them and to set the desired conditions on the grouped data respectively.<\/p>\nCriteriaQuery<DemoEmp> cq = criteria.createQuery(DemoEmp .class); \r\nRoot<DemoEmp> root = cq.from(DemoEmp .class); \r\ncq.multiselect(root.get(\"experience\"),criteria.count(root)).groupBy(root.get(\"experience\")); \r\nList<Object[]> results = em.createQuery(cq).getResultList();<\/pre>\nIn the above code, we are grouping the number of DempEmp based on their experience.<\/p>\n
CriteriaQuery<DemoEmp> cq = criteria.createQuery(DemoEmp .class); \r\nRoot<DemoEmp> root = cq.from(DemoEmp .class); \r\ncq.multiselect(root.get(\"experience\"),criteria.count(root)).groupBy(root.get(\"experience\")).having(criteria.ge(root.get(\"experience\"),\u00a05));\u00a0\u00a0\r\nList<Object[]> results = em.createQuery(cq).getResultList();<\/pre>\nIn the above code, we are grouping the number of DempEmp having an experience<\/strong> either equal or greater than 5<\/strong>.<\/p>\nCriteriaUpdates<\/h2>\n
CriteriaUpdates feature allows us to update multiple records in the database using Criteria API. We can create a CriteriaUpdate instance using CriteriaBuilder’s createCriteriaUpdate() method.<\/p>\n
This interface has a set()<\/strong> method that enables us to update the existing record with the desired value. We can update multiple attributes & multiple records simultaneously.<\/p>\nCriteriaUpdate<DemoEmp> criteriaUpdate = criteria.createCriteriaUpdate(DemoEmp.class); \r\nRoot<DemoEmp> root = criteriaUpdate.from(DemoEmp.class); \r\ncriteriaUpdate.set(\"experience\", 10); \r\ncriteriaUpdate.set(\"salary\", 1000000); \r\ncriteriaUpdate.where(criteria.equal(root.get(\"id\"), 5))\r\nem.createQuery(criteriaUpdate).executeUpdate();<\/pre>\nThe above code will update the experience<\/strong> attribute value to 10<\/strong> & salary<\/strong> attribute value to 100000<\/strong> for the DemoEmp with id =5<\/strong><\/p>\nCriteriaDelete<\/h2>\n
CriteriaDelete feature allows us to delete multiple records from the database using Criteria API. We can create a CriteriaDelete instance using CriteriaBuilder’s createCriteriaDelete() method. We can delete multiple records by providing a where clause for restrictions.<\/p>\n
CriteriaDelete<DemoEmp> criteriaDelete = criteria.createCriteriaDelete(DemoEmp.class);\r\nRoot<DemoEmp> root = criteriaDelete.from(DemoEmp.class); \r\ncriteriaDelete.where(criteria.equal(root.get(\"departmentName\"), \"Research\")); \r\nem.createQuery(criteriaDelete).executeUpdate();<\/pre>\nThe above code will delete all the employees of the “Research<\/strong>” department.<\/p>\nCriteria Join<\/h2>\n
JPA provides a Join interface for performing joins for retrieving data from various interconnected database tables. We can perform multiple joins within a single query as well. To understand this in detail let’s change our entity and add some relationships to practice joins.<\/p>\n
Updated Entity<\/h3>\nimport lombok.*;\r\nimport javax.persistence.*; \r\nimport java.util.List;\r\n\r\n@Entity \r\n@Getter \r\n@Setter \r\n@NoArgsConstructor \r\n@AllArgsConstructor \r\n@Builder \r\n@EqualsAndHashCode \r\npublic class DemoEmp { \r\n@Id \r\n@GeneratedValue(strategy= GenerationType.AUTO) \r\nprivate int id; \r\nprivate String name; \r\nprivate int salary; \r\nprivate int experience; \r\nprivate String departmentName;\r\n\r\n@ManyToMany(fetch = FetchType.LAZY)\r\n@JoinTable(name = \"demo_emp_project_mapping\",\r\njoinColumns = {@JoinColumn(name = \"demo_emp_id\")},\r\ninverseJoinColumns = {@JoinColumn(name = \"project_id\")}\r\n)\r\n@JsonBackReference\r\nprivate List<Project> projects;\r\n\r\n@ElementCollection\r\nprivate List<String> certifications;\r\n}<\/pre>\nimport lombok.*;\r\nimport javax.persistence.*;\r\n\r\n@Entity \r\n@Getter \r\n@Setter \r\n@NoArgsConstructor \r\n@AllArgsConstructor \r\n@EqualsAndHashCode \r\npublic class Project {\r\n@Id \r\n@GeneratedValue(strategy= GenerationType.AUTO) \r\nprivate int id; \r\nprivate String name;\r\n\r\n@ManyToMany(mappedBy = \"projects\")\r\n@JsonBackReference\r\nprivate List<DemoEmp> employees;\r\n}<\/pre>\nCriteriaQuery<DemoEmp> cq = criteria.createQuery(DemoEmp .class); \r\nRoot<DemoEmp> root = cq.from(DemoEmp .class); \r\nList<Predicate> conditions = new ArrayList();\r\n\r\nListJoin<DemoEmp, String> empCertificationJoin = root.joinList(\"certifications\");\r\nconditions.add(criteria.equal(empCertificationJoin, \"XYZ_Certification\"));\r\n\r\nJoin<DemoEmp, Project> empProjectJoin = root.join(\"projects\");\r\nconditions.add(criteria.equal(empProjectJoin.get(\"id\"), 1));\r\n\r\ncq.orderBy( criteria.asc(root.get(\"salary\")), criteria.desc(root.get(\"experience\")));\r\ncq.select(root).where(conditions.toArray(new Predicate[]{})).distinct(true);\r\n\r\nList<DempEmp> finalOutput = em.createQuery(cq).getResultList;<\/pre>\nThe above code will retrieve all the employees having “XYZ_Certification<\/strong>” and worked on the project with id “1<\/strong>“. CriteriaQuery’s “where(conditions.toArray(new Predicate[]{}))<\/strong>” combines all the predicates present in the list in a logical “and<\/strong>“.<\/p>\nBenefits of using Criteria Queries<\/h2>\n\n- Dynamic Query Building<\/strong> \u2014 Nice, clean & object-oriented API dynamic code<\/li>\n
- Type-Safety<\/strong> \u2014 It has the type-safety benefits of Java.<\/li>\n
- Metamodel Integration<\/strong> \u2014 Compile time error detection.<\/li>\n
- Refactoring Support<\/strong> \u2014 Easy to modify as it provides better support for dynamic queries as compared to HQL & JPQL.<\/li>\n<\/ul>\n
Conclusion<\/h2>\n
JPA Criteria Query API is a powerful feature that allows you to write a clean, object-oriented, type-safe code. The CriteriaUpdate & CriteriaDelete introduced in JPA 2.1 make JPA Criteria API a better solution by providing the condition-specific bulk update & delete functionality that was missing in the earlier version. Criteria Joins provides us precision, flexibility, and efficiency as we can define complex conditions for merging data using multiple criteria and logical operators. Using criteria for joins helps us ignore the unnecessary matches and reduces the dataset size which helps to improve performance while dealing with large datasets.<\/p>\n","protected":false},"excerpt":{"rendered":"
Introduction JPA is a hibernate specification that helps us in managing, accessing & persisting data between RDBMS and Java objects & one of its main features is Criteria API, which is a pre-defined API and was introduced in JPA 2.0. It defines platform-independent criteria queries written in Java and enables us to achieve the same […]<\/p>\n","protected":false},"author":1819,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":134},"categories":[446],"tags":[5991,4844,5902],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/62294"}],"collection":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/users\/1819"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/comments?post=62294"}],"version-history":[{"count":2,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/62294\/revisions"}],"predecessor-version":[{"id":62298,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/posts\/62294\/revisions\/62298"}],"wp:attachment":[{"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/media?parent=62294"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/categories?post=62294"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tothenew.com\/blog\/wp-json\/wp\/v2\/tags?post=62294"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}