JPA Prepared by: John Tan 20 March, 2018 Contents 1 what is JPA 2 1.1 Introduction 2 1.2 architectrue 2 1.3 jpa-EntityManagers and Relationship 3 1.4 jpa-ORM Componments 4 1.5 jpa-annotations 4 1.6 a simple example 6 2 Where to use JPA 9 2.1 adventage 9 2.2 Relationship of JPA and Hibernate 9 2.3 example of JPA+Hibernate+spring 9 4 Difference between JPA and Mybatis 10 1THE DESCRIPTION OF JPA 1.1Introduction JPA (Java Persistence API) is a collection of classes and methods to persistently store the vast amounts of data into database.It is use XML5 or annotations to description the mapping relationship object-relation table.You can use the JPA in Web applications and even desktop.The purpose of JPA is provide the Standard Specification for the persistence of POJO.Generally the JPA forms a bridge between object model(Java program) and relational models(database program) 1.2 architecture EntityManageFactory:This is factory of EntityManager.It creates and manager multiple EntityManager instance. EntityManager:It is an Interface, it manages the persistence operations on objects. It works like factory for Query instance. Entity:Entities are the persistence objects, stores as records in the database. Query:This interface is implemented by each JPA vendor to obtain relational objects that meet the criteria. EntityTransaction:It has one-to-one relationship with EntityManager. For each EntityManager, operations are maintained by EntityTransaction class. Persistence:This class contain static methods obtain EntityManagerFactory instance. 1.3 Jpa class relationship The relationship between EntityManagerFactory and EntityManager is one-to-many. It is a factory class to EntityManager instances. The relationship between EntityManager and EntityTransaction is one-to-one. For each EntityManager operation, there is an EntityTransaction instance. The relationship between EntityManager and Query is one-to-many. Many number of queries can execute using one EntityManager instance. The relationship between EntityManager and Entity is one-to-many. One EntityManager instance can manage multiple Entities. 1.4 Orm components ORM (Object Relational Mapping) is a programming ability to covert data from object type to relational type and vice versa. ORM Advantage: Idiomatic persistence : It enables you to write the persistence classes using object oriented classes. High Performance : It has many fetching techniques and hopeful locking techniques. Reliable : It is highly stable and eminent. Used by many industrial programmers. 1.5 Jpa annotations 1.5.1Some annotations @Entity declares the class as an entity.It is must to declares @Table declares table name,if you not declares table name then you must declares the primary key policy for “create-tables” in persistence.xml configuration file @Id Specifies the property, use for identity (primary key of a table) of the class. @OneToOne,@ManyToMany,@OneToMany,@ManyToOne, if you want to implements cascading delete You must set “cascade = CascadeType.REMOVE” and the CascadeType has five attribute: CascadeType.ALL : It is contain all methods CascadeType.REMOVE: if we set this in A entity,and we delete on records in A table that will delete B table which have relation record,but we can’t delete B records,It will be throws a Exception CascadeType.PERSIST : cascade save,we can add records in A Object then B Object will increase with A add records CascadeType.MERGE:With the A Object had change then B Object has change CascadeType.REFRESH : cascade refresh @ManyToMany,@OneToMany :if we use those annotations that we must be target a entity,like @OneToMany( targetEntity=Employee.class ) @OneToMany( targetEntity=Employee.class ) 1.5.2Automatic generation of JPA entity identify The uniqueness of data is the basic requirement of all application,if developer or user to contain the data uniqueness that the data is not safe.So automatic generation is the method which often to use.OpenJPA support four kinds to automatic generation entity identify. Container automatic generation entity identify Use the database automatic increment to automatic generation entity identify According the database sequence technology Use the database table field to generation entity identify We can use these annotations @GenerateValue,@SequenceGenerator and @TableGenerator all the these annotations are under the package javax.persistence.* The @GenerateValue automatic generation entity identify be numeric type file,for example int ,long,short,byte etc. or their corresponding wrapper , such as Short,Long,Byte,Integer. @GenerateValue automatic generation entity identify can be String type also. the @GenerateValue have two attributes are strategy and generator. Strategy is the enumeration of GenerationType GenerationType.AUTO is OpenJPA container automatic generation entity identify,this is default GenertaionType.INENTITY is using database auto increment field as the new increase entity unique value GenerationType.SEQUENCE which is define using the sequence number of database as assign unique value to newly entity object as an entity sign GenerationType.TABLE is using database one filed to record entity object sign,by this filed increase for newly entity object to assign unique value Annotation Description @Entity Declares the class as an entity or a table. @Table Declares table name. @Basic Specifies non-constraint fields explicitly. @Embedded Specifies the properties of class or an entity whose value is an instance of an embeddable class. @Id Specifies the property, use for identity (primary key of a table) of the class. @GeneratedValue Specifies how the identity attribute can be initialized such as automatic, manual, or value taken from a sequence table. @Transient Specifies the property that is not persistent, i.e., the value is never stored in the database. @Column Specifies the column attribute for the persistence property. @SequenceGenerator Specifies the value for the property that is specified in the @GeneratedValue annotation. It creates a sequence. @TableGenerator Specifies the value generator for the property specified in the @GeneratedValue annotation. It creates a table for value generation. @AccessType This type of annotation is used to set the access type. If you set @AccessType(FIELD), then access occurs Field wise. If you set @AccessType(PROPERTY), then access occurs Property wise. @JoinColumn Specifies an entity association or entity collection. This is used in many- to-one and one-to-many associations. @UniqueConstraint Specifies the fields and the unique constraints for the primary or the secondary table. @ColumnResult References the name of a column in the SQL query using select clause. @ManyToMany Defines a many-to-many relationship between the join Tables. @ManyToOne Defines a many-to-one relationship between the join Tables. @OneToMany Defines a one-to-many relationship between the join Tables. @OneToOne Defines a one-to-one relationship between the join Tables. @NamedQueries specifies list of named queries. @NamedQuery Specifies a Query using static name. 1.6 JPA transaction 1.7 example Phase 1:create employee entity Attention: 1.the entity class can’t define final 2.It must use @Entity to declare 3.The entity class must have one constructor which without parameters 4.It can extends others Entity or non entity class vice versa 5.It can’t have public attribute,should define to private and make getter an setter to exposure the class members 6.As a POJO entity,The entity can’t implement others interface but if user to sent message the it can implements serialize interface @Entity @Table(name = "EMPLOYEEA") public class EmployeeA { @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = "DID",nullable = false) private Integer eid; @Column(name = "ENAME",nullable = false) private Integer ename; @Column(name = "SALARY",nullable = false) private Integer salary; public Integer getEid() { return eid; } public void setEid(Integer eid) { this.eid = eid; } public Integer getEname() { return ename; } public void setEname(Integer ename) { this.ename = ename; } public Integer getSalary() { return salary; } public void setSalary(Integer salary) { this.salary = salary; } public EmployeeA() { super(); // TODO Auto-generated constructor stub } public EmployeeA(Integer eid, Integer ename, Integer salary) { super(); this.eid = eid; this.ename = ename; this.salary = salary; } } Create department entity @Entity @Table(name = "DEPARTMENTA") public class DepartmentA { @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name = "DID",nullable = false) private Integer did; @Column(name = "DNAME",nullable = false) private String dname; @Column(name = "CATE",nullable = false) private String cate; @OneToMany(cascade = CascadeType.REMOVE) private List<EmployeeA> employee; public List<EmployeeA> getEmployee() { return employee; } public void setEmployee(List<EmployeeA> employee) { this.employee = employee; } public Integer getDid() { return did; } public void setDid(Integer did) { this.did = did; } public String getDname() { return dname; } public void setDname(String dname) { this.dname = dname; } public String getCate() { return cate; } public void setCate(String cate) { this.cate = cate; } } Persistence.xml <persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"> <persistence-unit name="tutorialspoint_JPA_Eclipselink" transaction-type="RESOURCE_LOCAL"> <class>com.eclipselink.entity.example.DepartmentA</class> <class>com.eclipselink.entity.example.EmployeeA</class> <properties> <property name="javax.persistence.jdbc.url" value="jdbc:mysql://192.168.18.139:3306/stu"/> <property name="javax.persistence.jdbc.user" value="root"/> <property name="javax.persistence.jdbc.password" value="123456"/> <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/> <property name="eclipselink.logging.level" value="FINE"/> <!-- --> <property name="eclipselink.ddl-generation" value="create-or-extend-tables"/> </properties> </persistence-unit> </persistence> test public class JPATest { private static EntityManagerFactory managerFactory; private static String jpa; private static EntityManager entityManager; static { Properties properties = new Properties(); InputStream inputStream = JPATest.class.getClassLoader() .getResourceAsStream("JPA.properties"); try { properties.load(inputStream); jpa = properties.getProperty("JAP"); System.err.println(jpa); } catch (IOException e) { e.printStackTrace(); } managerFactory = Persistence.createEntityManagerFactory(jpa); entityManager = managerFactory.createEntityManager(); } @Test public void insert() { entityManager.getTransaction().begin(); Student student = new Student(); student.setStudent_id(9); student.setCourse("english"); student.setName("wangwu2"); student.setScore("80"); entityManager.persist(student); entityManager.getTransaction().commit(); entityManager.close(); managerFactory.close(); } @Test public void update() { entityManager.getTransaction().begin(); Student student = entityManager.find(Student.class, 5); System.err.println(student); student.setScore("100"); entityManager.getTransaction().commit(); System.err.println(student); entityManager.close(); managerFactory.close(); } @Test public void del() { entityManager.getTransaction().begin(); Student student = entityManager.find(Student.class, 3); System.err.println(student); entityManager.remove(student); entityManager.getTransaction().commit(); System.err.println(student); entityManager.close(); managerFactory.close(); } @Test public void getAll() { Query query = entityManager.createQuery("Select s from Student s"); // entityManager.getTransaction().begin(); // List<Student> list = (List<Student>)query.getResultList(); List<Student> list = query.getResultList(); for(Student student : list) { System.err.println(student); } // entityManager.getTransaction().commit(); entityManager.close(); managerFactory.close(); } JPA Entity life cycle manager by Entity Manager and the Entity Manager is an instance of javax.persistence.EntityManager Reference: https://www.tutorialspoint.com/jpa/jpa_quick_guide.htm 2THE JPA advantage To reduce the burden of writing codes for relational object management, a programmer follows the ‘JPA Provider’ framework, which allows easy interaction with database instance. Here the required framework is taken over by JPA. 2.1 advantage JPA support OOP features,for example extends and polymorphic and so on JPA and Hibernate have a complete ORM solution. JPA provides support for container-level features,for example support container level transactions, such as large data sets, transactions, concurrency, and so on 2.3 jap and hibernate In short JPA is a specification,not a framework.but hibernate is a framework which is implement JPA 3THE difference JPA and Mybatis JPA is a specification not a framework,Mybatis is a framework.The hibernate implement JPA standards and specifications.So we can use Hibernate compared to mybatis. First :Hibernate is a more powerful and advanced framework. After all, at the level of Java code, most of SQL is omitted, instead of data manipulation in relational database. MyBatis is a persistent layer framework that can flexibly write SQL statements and map the input and query results of SQL into a POJOs. So, on the surface, hibernate is more convenient and more automated, and MyBatis is more flexible in the writing of Sql statements.
