JPA浅谈

最新推荐文章于 2022-03-06 17:57:02 发布
最新推荐文章于 2022-03-06 17:57:02 发布
阅读量7.3k 收藏
点赞数
分类专栏： java技术 文章标签： jpa 数据库 hibernate jdbc import
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouhoujia/article/details/7475497
版权 
JPA入门例子(采用JPA的hibernate实现版本) 
（1）、JPA介绍：
      JPA全称为Java Persistence API ，Java持久化API是Sun公司在Java EE 5规范中提出的Java持久化接口。JPA吸取了目前Java持久化技术的优点，旨在规范、简化Java对象的持久化工作。使用JPA持久化对象，并不是依赖于某一个ORM框架。 
     为什么要使用JAP?
      在说为什么要使用JPA之前，我们有必要了解为什么要使用ORM技术。
ORM 是Object-Relation-Mapping，即对象关系影射技术，是对象持久化的核心。ORM是对JDBC的封装，从而解决了JDBC的各种存在问题：
a) 繁琐的代码问题
用JDBC的API编程访问数据库，代码量较大，特别是访问字段较多的表的时候，代码显得繁琐、累赘，容易出错。例如：PreparedStatement pstmt=con.prepareStatment("insert into account value(?,?,?,?,?,?,?,?,?)");
ORM则建立了Java对象与数据库对象之间的影射关系，程序员不需要编写复杂的SQL语句，直接操作Java对象即可，从而大大降低了代码量，也使程序员更加专注于业务逻辑的实现。
b) 数据库对象连接问题
关系数据对象之间，存在各种关系，包括1对1、1对多、多对1、多对多、级联等。在数据库对象更新的时候，采用JDBC编程，必须十分小心处理这些关系，以保证维持这些关系不会出现错误，而这个过程是一个很费时费力的过程。
ORM建立Java对象与数据库对象关系影射的同时，也自动根据数据库对象之间的关系创建Java对象的关系，并且提供了维持这些关系完整、有效的机制。
c) 系统架构问题
JDBC属于数据访问层，但是使用JDBC编程时，必须知道后台是用什么数据库、有哪些表、各个表有有哪些字段、各个字段的类型是什么、表与表之间什么关系、创建了什么索引等等与后台数据库相关的详细信息。
使用ORM技术，可以将数据库层完全隐蔽，呈献给程序员的只有Java的对象，程序员只需要根据业务逻辑的需要调用Java对象的Getter和 Setter方法，即可实现对后台数据库的操作，程序员不必知道后台采用什么数据库、有哪些表、有什么字段、表与表之间有什么关系。
d) 性能问题
采用JDBC编程，在很多时候存在效率低下的问题。
pstmt =conn.prepareStatement("insert into user_info values(?,?)");
       for (int i=0; i<1000; i++) {
          pstmt.setInt(1,i);
          pstmt.setString(2,"User"+i.toString());
          pstmt.executeUpdate();
       }
以上程序将向后台数据库发送1000次SQL语句执行请求，运行效率较低。
采用ORM技术，ORM框架将根据具体数据库操作需要，会自动延迟向后台数据库发送SQL请求，ORM也可以根据实际情况，将数据库访问操作合成，尽量减少不必要的数据库操作请求。
 
JPA是目前比较流行的一种ORM技术之一，所以他拥有ORM技术的各种特点，当然他还有自己的一些优势：
1 标准化
　　JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问 API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。
2 对容器级特性的支持
　　JPA 框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发挥更大的作用。
3 简单易用，集成方便
　　JPA的主要目标之一就是提供更加简单的编程模型：在JPA框架下创建实体和创建Java 类一样简单，没有任何的约束和限制，只需要使用 javax.persistence.Entity进行注释；JPA的框架和接口也都非常简单，没有太多特别的规则和设计模式的要求，开发者可以很容易的掌握。JPA基于非侵入式原则设计，因此可以很容易的和其它框架或者容器集成。
4 可媲美JDBC的查询能力
　　JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。
5 支持面向对象的高级特性
　　JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化。
 
 
（2）、具体例子
    完成工程后工程结构如下图：
    
 (注意：persistence.xml文件的位置决定持久性的根(Persistence Root)。持久性的根为JAR文件或者包含META-INF目录（前提是persistence.xml位于此）的目录。一般将这个persistence.xml文件放在src下的META-INF中。命名及位置都不能变)
 
a)、导入相关jar包（见上图）和创建META-INF和persistence.xml文件.
persistence.xml配置如下：(我用的数据为mysql,采用不同数据库及JPA的不同实现版本会导致配置内容不同)
    [xhtml] view plaincopyprint?<persistence xmlns="http://java.sun.com/xml/ns/persistence"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_version=1">  
    <persistence-unit name="mysqlJPA" transaction-type="RESOURCE_LOCAL">  
        <properties>  
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />  
            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />  
            <property name="hibernate.connection.username" value="root" />  
            <property name="hibernate.connection.password" value="123456" />  
            <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/db1" />  
            <property name="hibernate.max_fetch_depth" value="3" />  
            <property name="hibernate.hbm2ddl.auto" value="update" />  
        </properties>  
    </persistence-unit>  
</persistence>  
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_version=1">
 <persistence-unit name="mysqlJPA" transaction-type="RESOURCE_LOCAL">
  <properties>
   <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />
   <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
   <property name="hibernate.connection.username" value="root" />
   <property name="hibernate.connection.password" value="123456" />
   <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/db1" />
   <property name="hibernate.max_fetch_depth" value="3" />
   <property name="hibernate.hbm2ddl.auto" value="update" />
  </properties>
 </persistence-unit>
</persistence> 
 
b）、编写实体bean，如下：
    [c-sharp] view plaincopyprint?package com.hmk.bean;  
  
import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.GeneratedValue;  
import javax.persistence.Id;  
  
@Entity  
public class Person {  
    private int id;  
    private String name;  
      
    @Id @GeneratedValue  
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    @Column(length=12)  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
      
}  
package com.hmk.bean;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class Person {
 private int id;
 private String name;
 
 @Id @GeneratedValue
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 @Column(length=12)
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 
}
   
 
c）、编写junit测试代码，如下：
   
     [java] view plaincopyprint?package junit.test;  
  
  
import javax.persistence.EntityManager;  
import javax.persistence.EntityManagerFactory;  
import javax.persistence.Persistence;  
  
import org.junit.BeforeClass;  
import org.junit.Test;  
  
import com.hmk.bean.Person;  
  
public class JpaTest {  
  
    @BeforeClass  
    public static void setUpBeforeClass() throws Exception {  
    }  
      
    @Test public void createTable(){  
        //可以验证生成表是否正确   
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        factory.close();  
    }  
  
    @Test public void save(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = new Person(); //person为new状态   
        person.setName("zhang san");  
        em.persist(person); //持久化实体   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
    //new 、托管、脱管、删除   
      
    @Test public void update(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        person.setName("hmk"); //person为托管状态   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
      
    @Test public void update2(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        em.clear(); //把实体管理器中的所有实体变为脱管状态   
        person.setName("hmk2");  
        em.merge(person); //把脱管状态变为托管状态,merge可以自动选择insert or update 数据   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
  
    @Test public void remove(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        em.remove(person); //删除实体   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
      
    @Test public void find(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        Person person = em.find(Person.class, 2); //类似于hibernate的get方法,没找到数据时，返回null   
        System.out.println(person.getName());  
        em.close();  
        factory.close();  
    }  
    @Test public void find2(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        Person person = em.getReference(Person.class, 2); //类似于hibernate的load方法,延迟加载.没相应数据时会出现异常   
        System.out.println(person.getName()); //真正调用时才查找数据   
        em.close();  
        factory.close();  
    }  
}  
package junit.test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.junit.BeforeClass;
import org.junit.Test;
import com.hmk.bean.Person;
public class JpaTest {
 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
 }
 
 @Test public void createTable(){
  //可以验证生成表是否正确
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  factory.close();
 }
 @Test public void save(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = new Person(); //person为new状态
  person.setName("zhang san");
  em.persist(person); //持久化实体
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 //new 、托管、脱管、删除
 
 @Test public void update(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  person.setName("hmk"); //person为托管状态
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 
 @Test public void update2(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  em.clear(); //把实体管理器中的所有实体变为脱管状态
  person.setName("hmk2");
  em.merge(person); //把脱管状态变为托管状态,merge可以自动选择insert or update 数据
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 @Test public void remove(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  em.remove(person); //删除实体
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 
 @Test public void find(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  Person person = em.find(Person.class, 2); //类似于hibernate的get方法,没找到数据时，返回null
  System.out.println(person.getName());
  em.close();
  factory.close();
 }
 @Test public void find2(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  Person person = em.getReference(Person.class, 2); //类似于hibernate的load方法,延迟加载.没相应数据时会出现异常
  System.out.println(person.getName()); //真正调用时才查找数据
  em.close();
  factory.close();
 }
}
 
 
 
d）、运行junit测试代码里的相应方法就行可以。


（1）、JPA介绍：
      JPA全称为Java Persistence API ，Java持久化API是Sun公司在Java EE 5规范中提出的Java持久化接口。JPA吸取了目前Java持久化技术的优点，旨在规范、简化Java对象的持久化工作。使用JPA持久化对象，并不是依赖于某一个ORM框架。 
     为什么要使用JAP?
      在说为什么要使用JPA之前，我们有必要了解为什么要使用ORM技术。
ORM 是Object-Relation-Mapping，即对象关系影射技术，是对象持久化的核心。ORM是对JDBC的封装，从而解决了JDBC的各种存在问题：
a) 繁琐的代码问题
用JDBC的API编程访问数据库，代码量较大，特别是访问字段较多的表的时候，代码显得繁琐、累赘，容易出错。例如：PreparedStatement pstmt=con.prepareStatment("insert into account value(?,?,?,?,?,?,?,?,?)");
ORM则建立了Java对象与数据库对象之间的影射关系，程序员不需要编写复杂的SQL语句，直接操作Java对象即可，从而大大降低了代码量，也使程序员更加专注于业务逻辑的实现。
b) 数据库对象连接问题
关系数据对象之间，存在各种关系，包括1对1、1对多、多对1、多对多、级联等。在数据库对象更新的时候，采用JDBC编程，必须十分小心处理这些关系，以保证维持这些关系不会出现错误，而这个过程是一个很费时费力的过程。
ORM建立Java对象与数据库对象关系影射的同时，也自动根据数据库对象之间的关系创建Java对象的关系，并且提供了维持这些关系完整、有效的机制。
c) 系统架构问题
JDBC属于数据访问层，但是使用JDBC编程时，必须知道后台是用什么数据库、有哪些表、各个表有有哪些字段、各个字段的类型是什么、表与表之间什么关系、创建了什么索引等等与后台数据库相关的详细信息。
使用ORM技术，可以将数据库层完全隐蔽，呈献给程序员的只有Java的对象，程序员只需要根据业务逻辑的需要调用Java对象的Getter和 Setter方法，即可实现对后台数据库的操作，程序员不必知道后台采用什么数据库、有哪些表、有什么字段、表与表之间有什么关系。
d) 性能问题
采用JDBC编程，在很多时候存在效率低下的问题。
pstmt =conn.prepareStatement("insert into user_info values(?,?)");
       for (int i=0; i<1000; i++) {
          pstmt.setInt(1,i);
          pstmt.setString(2,"User"+i.toString());
          pstmt.executeUpdate();
       }
以上程序将向后台数据库发送1000次SQL语句执行请求，运行效率较低。
采用ORM技术，ORM框架将根据具体数据库操作需要，会自动延迟向后台数据库发送SQL请求，ORM也可以根据实际情况，将数据库访问操作合成，尽量减少不必要的数据库操作请求。
 
JPA是目前比较流行的一种ORM技术之一，所以他拥有ORM技术的各种特点，当然他还有自己的一些优势：
1 标准化
　　JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问 API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。
2 对容器级特性的支持
　　JPA 框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发挥更大的作用。
3 简单易用，集成方便
　　JPA的主要目标之一就是提供更加简单的编程模型：在JPA框架下创建实体和创建Java 类一样简单，没有任何的约束和限制，只需要使用 javax.persistence.Entity进行注释；JPA的框架和接口也都非常简单，没有太多特别的规则和设计模式的要求，开发者可以很容易的掌握。JPA基于非侵入式原则设计，因此可以很容易的和其它框架或者容器集成。
4 可媲美JDBC的查询能力
　　JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。
5 支持面向对象的高级特性
　　JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化。
 
 
（2）、具体例子
    完成工程后工程结构如下图：
    
 (注意：persistence.xml文件的位置决定持久性的根(Persistence Root)。持久性的根为JAR文件或者包含META-INF目录（前提是persistence.xml位于此）的目录。一般将这个persistence.xml文件放在src下的META-INF中。命名及位置都不能变)
 
a)、导入相关jar包（见上图）和创建META-INF和persistence.xml文件.
persistence.xml配置如下：(我用的数据为mysql,采用不同数据库及JPA的不同实现版本会导致配置内容不同)
    [xhtml] view plaincopyprint?<persistence xmlns="http://java.sun.com/xml/ns/persistence"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_version=1">  
    <persistence-unit name="mysqlJPA" transaction-type="RESOURCE_LOCAL">  
        <properties>  
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />  
            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />  
            <property name="hibernate.connection.username" value="root" />  
            <property name="hibernate.connection.password" value="123456" />  
            <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/db1" />  
            <property name="hibernate.max_fetch_depth" value="3" />  
            <property name="hibernate.hbm2ddl.auto" value="update" />  
        </properties>  
    </persistence-unit>  
</persistence>  
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_version=1">
 <persistence-unit name="mysqlJPA" transaction-type="RESOURCE_LOCAL">
  <properties>
   <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />
   <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
   <property name="hibernate.connection.username" value="root" />
   <property name="hibernate.connection.password" value="123456" />
   <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/db1" />
   <property name="hibernate.max_fetch_depth" value="3" />
   <property name="hibernate.hbm2ddl.auto" value="update" />
  </properties>
 </persistence-unit>
</persistence> 
 
b）、编写实体bean，如下：
    [c-sharp] view plaincopyprint?package com.hmk.bean;  
  
import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.GeneratedValue;  
import javax.persistence.Id;  
  
@Entity  
public class Person {  
    private int id;  
    private String name;  
      
    @Id @GeneratedValue  
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    @Column(length=12)  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
      
}  
package com.hmk.bean;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class Person {
 private int id;
 private String name;
 
 @Id @GeneratedValue
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 @Column(length=12)
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 
}
   
 
c）、编写junit测试代码，如下：
   
     [java] view plaincopyprint?package junit.test;  
  
  
import javax.persistence.EntityManager;  
import javax.persistence.EntityManagerFactory;  
import javax.persistence.Persistence;  
  
import org.junit.BeforeClass;  
import org.junit.Test;  
  
import com.hmk.bean.Person;  
  
public class JpaTest {  
  
    @BeforeClass  
    public static void setUpBeforeClass() throws Exception {  
    }  
      
    @Test public void createTable(){  
        //可以验证生成表是否正确   
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        factory.close();  
    }  
  
    @Test public void save(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = new Person(); //person为new状态   
        person.setName("zhang san");  
        em.persist(person); //持久化实体   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
    //new 、托管、脱管、删除   
      
    @Test public void update(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        person.setName("hmk"); //person为托管状态   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
      
    @Test public void update2(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        em.clear(); //把实体管理器中的所有实体变为脱管状态   
        person.setName("hmk2");  
        em.merge(person); //把脱管状态变为托管状态,merge可以自动选择insert or update 数据   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
  
    @Test public void remove(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        em.remove(person); //删除实体   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
      
    @Test public void find(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        Person person = em.find(Person.class, 2); //类似于hibernate的get方法,没找到数据时，返回null   
        System.out.println(person.getName());  
        em.close();  
        factory.close();  
    }  
    @Test public void find2(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        Person person = em.getReference(Person.class, 2); //类似于hibernate的load方法,延迟加载.没相应数据时会出现异常   
        System.out.println(person.getName()); //真正调用时才查找数据   
        em.close();  
        factory.close();  
    }  
}  
package junit.test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.junit.BeforeClass;
import org.junit.Test;
import com.hmk.bean.Person;
public class JpaTest {
 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
 }
 
 @Test public void createTable(){
  //可以验证生成表是否正确
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  factory.close();
 }
 @Test public void save(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = new Person(); //person为new状态
  person.setName("zhang san");
  em.persist(person); //持久化实体
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 //new 、托管、脱管、删除
 
 @Test public void update(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  person.setName("hmk"); //person为托管状态
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 
 @Test public void update2(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  em.clear(); //把实体管理器中的所有实体变为脱管状态
  person.setName("hmk2");
  em.merge(person); //把脱管状态变为托管状态,merge可以自动选择insert or update 数据
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 @Test public void remove(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  em.remove(person); //删除实体
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 
 @Test public void find(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  Person person = em.find(Person.class, 2); //类似于hibernate的get方法,没找到数据时，返回null
  System.out.println(person.getName());
  em.close();
  factory.close();
 }
 @Test public void find2(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  Person person = em.getReference(Person.class, 2); //类似于hibernate的load方法,延迟加载.没相应数据时会出现异常
  System.out.println(person.getName()); //真正调用时才查找数据
  em.close();
  factory.close();
 }
}
 
 
 
d）、运行junit测试代码里的相应方法就行可以。

（1）、JPA介绍：
      JPA全称为Java Persistence API ，Java持久化API是Sun公司在Java EE 5规范中提出的Java持久化接口。JPA吸取了目前Java持久化技术的优点，旨在规范、简化Java对象的持久化工作。使用JPA持久化对象，并不是依赖于某一个ORM框架。 
     为什么要使用JAP?
      在说为什么要使用JPA之前，我们有必要了解为什么要使用ORM技术。
ORM 是Object-Relation-Mapping，即对象关系影射技术，是对象持久化的核心。ORM是对JDBC的封装，从而解决了JDBC的各种存在问题：
a) 繁琐的代码问题
用JDBC的API编程访问数据库，代码量较大，特别是访问字段较多的表的时候，代码显得繁琐、累赘，容易出错。例如：PreparedStatement pstmt=con.prepareStatment("insert into account value(?,?,?,?,?,?,?,?,?)");
ORM则建立了Java对象与数据库对象之间的影射关系，程序员不需要编写复杂的SQL语句，直接操作Java对象即可，从而大大降低了代码量，也使程序员更加专注于业务逻辑的实现。
b) 数据库对象连接问题
关系数据对象之间，存在各种关系，包括1对1、1对多、多对1、多对多、级联等。在数据库对象更新的时候，采用JDBC编程，必须十分小心处理这些关系，以保证维持这些关系不会出现错误，而这个过程是一个很费时费力的过程。
ORM建立Java对象与数据库对象关系影射的同时，也自动根据数据库对象之间的关系创建Java对象的关系，并且提供了维持这些关系完整、有效的机制。
c) 系统架构问题
JDBC属于数据访问层，但是使用JDBC编程时，必须知道后台是用什么数据库、有哪些表、各个表有有哪些字段、各个字段的类型是什么、表与表之间什么关系、创建了什么索引等等与后台数据库相关的详细信息。
使用ORM技术，可以将数据库层完全隐蔽，呈献给程序员的只有Java的对象，程序员只需要根据业务逻辑的需要调用Java对象的Getter和 Setter方法，即可实现对后台数据库的操作，程序员不必知道后台采用什么数据库、有哪些表、有什么字段、表与表之间有什么关系。
d) 性能问题
采用JDBC编程，在很多时候存在效率低下的问题。
pstmt =conn.prepareStatement("insert into user_info values(?,?)");
       for (int i=0; i<1000; i++) {
          pstmt.setInt(1,i);
          pstmt.setString(2,"User"+i.toString());
          pstmt.executeUpdate();
       }
以上程序将向后台数据库发送1000次SQL语句执行请求，运行效率较低。
采用ORM技术，ORM框架将根据具体数据库操作需要，会自动延迟向后台数据库发送SQL请求，ORM也可以根据实际情况，将数据库访问操作合成，尽量减少不必要的数据库操作请求。
 
JPA是目前比较流行的一种ORM技术之一，所以他拥有ORM技术的各种特点，当然他还有自己的一些优势：
1 标准化
　　JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问 API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。
2 对容器级特性的支持
　　JPA 框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发挥更大的作用。
3 简单易用，集成方便
　　JPA的主要目标之一就是提供更加简单的编程模型：在JPA框架下创建实体和创建Java 类一样简单，没有任何的约束和限制，只需要使用 javax.persistence.Entity进行注释；JPA的框架和接口也都非常简单，没有太多特别的规则和设计模式的要求，开发者可以很容易的掌握。JPA基于非侵入式原则设计，因此可以很容易的和其它框架或者容器集成。
4 可媲美JDBC的查询能力
　　JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。
5 支持面向对象的高级特性
　　JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化。
 
 
（2）、具体例子
    完成工程后工程结构如下图：
    
 (注意：persistence.xml文件的位置决定持久性的根(Persistence Root)。持久性的根为JAR文件或者包含META-INF目录（前提是persistence.xml位于此）的目录。一般将这个persistence.xml文件放在src下的META-INF中。命名及位置都不能变)
 
a)、导入相关jar包（见上图）和创建META-INF和persistence.xml文件.
persistence.xml配置如下：(我用的数据为mysql,采用不同数据库及JPA的不同实现版本会导致配置内容不同)
    [xhtml] view plaincopyprint?<persistence xmlns="http://java.sun.com/xml/ns/persistence"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_version=1">  
    <persistence-unit name="mysqlJPA" transaction-type="RESOURCE_LOCAL">  
        <properties>  
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />  
            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />  
            <property name="hibernate.connection.username" value="root" />  
            <property name="hibernate.connection.password" value="123456" />  
            <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/db1" />  
            <property name="hibernate.max_fetch_depth" value="3" />  
            <property name="hibernate.hbm2ddl.auto" value="update" />  
        </properties>  
    </persistence-unit>  
</persistence>  
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_version=1">
 <persistence-unit name="mysqlJPA" transaction-type="RESOURCE_LOCAL">
  <properties>
   <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />
   <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
   <property name="hibernate.connection.username" value="root" />
   <property name="hibernate.connection.password" value="123456" />
   <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/db1" />
   <property name="hibernate.max_fetch_depth" value="3" />
   <property name="hibernate.hbm2ddl.auto" value="update" />
  </properties>
 </persistence-unit>
</persistence> 
 
b）、编写实体bean，如下：
    [c-sharp] view plaincopyprint?package com.hmk.bean;  
  
import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.GeneratedValue;  
import javax.persistence.Id;  
  
@Entity  
public class Person {  
    private int id;  
    private String name;  
      
    @Id @GeneratedValue  
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    @Column(length=12)  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
      
}  
package com.hmk.bean;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class Person {
 private int id;
 private String name;
 
 @Id @GeneratedValue
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 @Column(length=12)
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 
}
   
 
c）、编写junit测试代码，如下：
   
     [java] view plaincopyprint?package junit.test;  
  
  
import javax.persistence.EntityManager;  
import javax.persistence.EntityManagerFactory;  
import javax.persistence.Persistence;  
  
import org.junit.BeforeClass;  
import org.junit.Test;  
  
import com.hmk.bean.Person;  
  
public class JpaTest {  
  
    @BeforeClass  
    public static void setUpBeforeClass() throws Exception {  
    }  
      
    @Test public void createTable(){  
        //可以验证生成表是否正确   
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        factory.close();  
    }  
  
    @Test public void save(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = new Person(); //person为new状态   
        person.setName("zhang san");  
        em.persist(person); //持久化实体   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
    //new 、托管、脱管、删除   
      
    @Test public void update(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        person.setName("hmk"); //person为托管状态   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
      
    @Test public void update2(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        em.clear(); //把实体管理器中的所有实体变为脱管状态   
        person.setName("hmk2");  
        em.merge(person); //把脱管状态变为托管状态,merge可以自动选择insert or update 数据   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
  
    @Test public void remove(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        em.remove(person); //删除实体   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
      
    @Test public void find(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        Person person = em.find(Person.class, 2); //类似于hibernate的get方法,没找到数据时，返回null   
        System.out.println(person.getName());  
        em.close();  
        factory.close();  
    }  
    @Test public void find2(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        Person person = em.getReference(Person.class, 2); //类似于hibernate的load方法,延迟加载.没相应数据时会出现异常   
        System.out.println(person.getName()); //真正调用时才查找数据   
        em.close();  
        factory.close();  
    }  
}  
package junit.test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.junit.BeforeClass;
import org.junit.Test;
import com.hmk.bean.Person;
public class JpaTest {
 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
 }
 
 @Test public void createTable(){
  //可以验证生成表是否正确
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  factory.close();
 }
 @Test public void save(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = new Person(); //person为new状态
  person.setName("zhang san");
  em.persist(person); //持久化实体
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 //new 、托管、脱管、删除
 
 @Test public void update(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  person.setName("hmk"); //person为托管状态
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 
 @Test public void update2(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  em.clear(); //把实体管理器中的所有实体变为脱管状态
  person.setName("hmk2");
  em.merge(person); //把脱管状态变为托管状态,merge可以自动选择insert or update 数据
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 @Test public void remove(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  em.remove(person); //删除实体
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 
 @Test public void find(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  Person person = em.find(Person.class, 2); //类似于hibernate的get方法,没找到数据时，返回null
  System.out.println(person.getName());
  em.close();
  factory.close();
 }
 @Test public void find2(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  Person person = em.getReference(Person.class, 2); //类似于hibernate的load方法,延迟加载.没相应数据时会出现异常
  System.out.println(person.getName()); //真正调用时才查找数据
  em.close();
  factory.close();
 }
}
 
 
 
d）、运行junit测试代码里的相应方法就行可以。

 
（1）、JPA介绍：
      JPA全称为Java Persistence API ，Java持久化API是Sun公司在Java EE 5规范中提出的Java持久化接口。JPA吸取了目前Java持久化技术的优点，旨在规范、简化Java对象的持久化工作。使用JPA持久化对象，并不是依赖于某一个ORM框架。 
     为什么要使用JAP?
      在说为什么要使用JPA之前，我们有必要了解为什么要使用ORM技术。
ORM 是Object-Relation-Mapping，即对象关系影射技术，是对象持久化的核心。ORM是对JDBC的封装，从而解决了JDBC的各种存在问题：
a) 繁琐的代码问题
用JDBC的API编程访问数据库，代码量较大，特别是访问字段较多的表的时候，代码显得繁琐、累赘，容易出错。例如：PreparedStatement pstmt=con.prepareStatment("insert into account value(?,?,?,?,?,?,?,?,?)");
ORM则建立了Java对象与数据库对象之间的影射关系，程序员不需要编写复杂的SQL语句，直接操作Java对象即可，从而大大降低了代码量，也使程序员更加专注于业务逻辑的实现。
b) 数据库对象连接问题
关系数据对象之间，存在各种关系，包括1对1、1对多、多对1、多对多、级联等。在数据库对象更新的时候，采用JDBC编程，必须十分小心处理这些关系，以保证维持这些关系不会出现错误，而这个过程是一个很费时费力的过程。
ORM建立Java对象与数据库对象关系影射的同时，也自动根据数据库对象之间的关系创建Java对象的关系，并且提供了维持这些关系完整、有效的机制。
c) 系统架构问题
JDBC属于数据访问层，但是使用JDBC编程时，必须知道后台是用什么数据库、有哪些表、各个表有有哪些字段、各个字段的类型是什么、表与表之间什么关系、创建了什么索引等等与后台数据库相关的详细信息。
使用ORM技术，可以将数据库层完全隐蔽，呈献给程序员的只有Java的对象，程序员只需要根据业务逻辑的需要调用Java对象的Getter和 Setter方法，即可实现对后台数据库的操作，程序员不必知道后台采用什么数据库、有哪些表、有什么字段、表与表之间有什么关系。
d) 性能问题
采用JDBC编程，在很多时候存在效率低下的问题。
pstmt =conn.prepareStatement("insert into user_info values(?,?)");
       for (int i=0; i<1000; i++) {
          pstmt.setInt(1,i);
          pstmt.setString(2,"User"+i.toString());
          pstmt.executeUpdate();
       }
以上程序将向后台数据库发送1000次SQL语句执行请求，运行效率较低。
采用ORM技术，ORM框架将根据具体数据库操作需要，会自动延迟向后台数据库发送SQL请求，ORM也可以根据实际情况，将数据库访问操作合成，尽量减少不必要的数据库操作请求。
 
JPA是目前比较流行的一种ORM技术之一，所以他拥有ORM技术的各种特点，当然他还有自己的一些优势：
1 标准化
　　JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问 API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。
2 对容器级特性的支持
　　JPA 框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发挥更大的作用。
3 简单易用，集成方便
　　JPA的主要目标之一就是提供更加简单的编程模型：在JPA框架下创建实体和创建Java 类一样简单，没有任何的约束和限制，只需要使用 javax.persistence.Entity进行注释；JPA的框架和接口也都非常简单，没有太多特别的规则和设计模式的要求，开发者可以很容易的掌握。JPA基于非侵入式原则设计，因此可以很容易的和其它框架或者容器集成。
4 可媲美JDBC的查询能力
　　JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。
5 支持面向对象的高级特性
　　JPA 中能够支持面向对象的高级特性，如类之间的继承、多态和类之间的复杂关系，这样的支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化。
 
 
（2）、具体例子
    完成工程后工程结构如下图：
    
 (注意：persistence.xml文件的位置决定持久性的根(Persistence Root)。持久性的根为JAR文件或者包含META-INF目录（前提是persistence.xml位于此）的目录。一般将这个persistence.xml文件放在src下的META-INF中。命名及位置都不能变)
 
a)、导入相关jar包（见上图）和创建META-INF和persistence.xml文件.
persistence.xml配置如下：(我用的数据为mysql,采用不同数据库及JPA的不同实现版本会导致配置内容不同)
    [xhtml] view plaincopyprint?<persistence xmlns="http://java.sun.com/xml/ns/persistence"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_version=1">  
    <persistence-unit name="mysqlJPA" transaction-type="RESOURCE_LOCAL">  
        <properties>  
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />  
            <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />  
            <property name="hibernate.connection.username" value="root" />  
            <property name="hibernate.connection.password" value="123456" />  
            <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/db1" />  
            <property name="hibernate.max_fetch_depth" value="3" />  
            <property name="hibernate.hbm2ddl.auto" value="update" />  
        </properties>  
    </persistence-unit>  
</persistence>  
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_version=1">
 <persistence-unit name="mysqlJPA" transaction-type="RESOURCE_LOCAL">
  <properties>
   <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect" />
   <property name="hibernate.connection.driver_class" value="com.mysql.jdbc.Driver" />
   <property name="hibernate.connection.username" value="root" />
   <property name="hibernate.connection.password" value="123456" />
   <property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/db1" />
   <property name="hibernate.max_fetch_depth" value="3" />
   <property name="hibernate.hbm2ddl.auto" value="update" />
  </properties>
 </persistence-unit>
</persistence> 
 
b）、编写实体bean，如下：
    [c-sharp] view plaincopyprint?package com.hmk.bean;  
  
import javax.persistence.Column;  
import javax.persistence.Entity;  
import javax.persistence.GeneratedValue;  
import javax.persistence.Id;  
  
@Entity  
public class Person {  
    private int id;  
    private String name;  
      
    @Id @GeneratedValue  
    public int getId() {  
        return id;  
    }  
    public void setId(int id) {  
        this.id = id;  
    }  
    @Column(length=12)  
    public String getName() {  
        return name;  
    }  
    public void setName(String name) {  
        this.name = name;  
    }  
      
}  
package com.hmk.bean;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class Person {
 private int id;
 private String name;
 
 @Id @GeneratedValue
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 @Column(length=12)
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 
}
   
 
c）、编写junit测试代码，如下：
   
     [java] view plaincopyprint?package junit.test;  
  
  
import javax.persistence.EntityManager;  
import javax.persistence.EntityManagerFactory;  
import javax.persistence.Persistence;  
  
import org.junit.BeforeClass;  
import org.junit.Test;  
  
import com.hmk.bean.Person;  
  
public class JpaTest {  
  
    @BeforeClass  
    public static void setUpBeforeClass() throws Exception {  
    }  
      
    @Test public void createTable(){  
        //可以验证生成表是否正确   
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        factory.close();  
    }  
  
    @Test public void save(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = new Person(); //person为new状态   
        person.setName("zhang san");  
        em.persist(person); //持久化实体   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
    //new 、托管、脱管、删除   
      
    @Test public void update(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        person.setName("hmk"); //person为托管状态   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
      
    @Test public void update2(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        em.clear(); //把实体管理器中的所有实体变为脱管状态   
        person.setName("hmk2");  
        em.merge(person); //把脱管状态变为托管状态,merge可以自动选择insert or update 数据   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
  
    @Test public void remove(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        em.getTransaction().begin();  
        Person person = em.find(Person.class, 1);  
        em.remove(person); //删除实体   
        em.getTransaction().commit();  
        em.close();  
        factory.close();  
    }  
      
    @Test public void find(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        Person person = em.find(Person.class, 2); //类似于hibernate的get方法,没找到数据时，返回null   
        System.out.println(person.getName());  
        em.close();  
        factory.close();  
    }  
    @Test public void find2(){  
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");  
        EntityManager em = factory.createEntityManager();  
        Person person = em.getReference(Person.class, 2); //类似于hibernate的load方法,延迟加载.没相应数据时会出现异常   
        System.out.println(person.getName()); //真正调用时才查找数据   
        em.close();  
        factory.close();  
    }  
}  
package junit.test;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.junit.BeforeClass;
import org.junit.Test;
import com.hmk.bean.Person;
public class JpaTest {
 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
 }
 
 @Test public void createTable(){
  //可以验证生成表是否正确
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  factory.close();
 }
 @Test public void save(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = new Person(); //person为new状态
  person.setName("zhang san");
  em.persist(person); //持久化实体
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 //new 、托管、脱管、删除
 
 @Test public void update(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  person.setName("hmk"); //person为托管状态
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 
 @Test public void update2(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  em.clear(); //把实体管理器中的所有实体变为脱管状态
  person.setName("hmk2");
  em.merge(person); //把脱管状态变为托管状态,merge可以自动选择insert or update 数据
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 @Test public void remove(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  em.getTransaction().begin();
  Person person = em.find(Person.class, 1);
  em.remove(person); //删除实体
  em.getTransaction().commit();
  em.close();
  factory.close();
 }
 
 @Test public void find(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  Person person = em.find(Person.class, 2); //类似于hibernate的get方法,没找到数据时，返回null
  System.out.println(person.getName());
  em.close();
  factory.close();
 }
 @Test public void find2(){
  EntityManagerFactory factory = Persistence.createEntityManagerFactory("mysqlJPA");
  EntityManager em = factory.createEntityManager();
  Person person = em.getReference(Person.class, 2); //类似于hibernate的load方法,延迟加载.没相应数据时会出现异常
  System.out.println(person.getName()); //真正调用时才查找数据
  em.close();
  factory.close();
 }
}
 
 
 
d）、运行junit测试代码里的相应方法就行可以。
zhouhoujia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈JPA框架
啊Q老师
03-18 3716
JPA介绍
浅谈Springboot之整合JPA
ergouy's blog
04-02 238
最近学习了模仿天猫商城项目，对springboot项目中的JPA做了一些了解，做一些必要的笔记，一来是对自己学习的知识的巩固，二来对有同样问题的人有参考作用 文章目录一 概述1 概念2 使用场景二 主要接口1 Repository2 CrudRepository3 PagingAndSortingRepository4 JpaRepository5 JpaSpecificationExecu...
spring data jpa浅谈
游语
05-07 606
spring data jpa介绍 首先了解JPA是什么？ JPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。他的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在hibernate，TopLink，JDO等ORM框架各自为营的局面。值得注意的是，JPA是
JPA浅谈之一
wendy专栏
05-04 539
1）JPA概述 JPA（Java Persistence API）是基于
浅谈JPA
StreamlineWq的博客
03-06 380
上周跳槽到了一家新公司，数据持久化层用的不是mybatis，而是用的JPA，由于以前都没有用过，所以周末学习了一下，并且做一下记录，方便以后查看。 先说说jpa是什么？ 我们来看看官方回答： 其实说白了，你可以把它当做hibernate、mybatis的同类。 学习了之后，我更觉得这是mybatis-plus的前身，提供了很多写好的crud的接口，后面总结的时候我再做一下对比。 先看看主要代码，文末会附上完整项目链接，欢迎大家下载。 1.pom.xml文件 <dependencies>
浅谈JPA一：JPA是什么？
热门推荐
localhost01
10-27 4万+
定义 JPA 即Java Persistence API。 JPA 是一个基于O/R映射的标准规范（目前最新版本是JPA 2.1 ）。所谓规范即只定义标准规则（如注解、接口），不提供实现，软件提供商可以按照标准规范来实现，而使用者只需按照规范中定义的方式来使用，而不用和软件提供商的实现打交道。 JPA的出现有两个原因： 简化现有Java EE和Java SE应用的对象持久化的开发工作； Sun希......
浅谈Jpa的对象关联
GiantCrocodile的博客
06-13 783
数据库中表的关联为主外键，在程序中是对象与对象之间的关联，站在ORM的角度上，每一个对象都对应着一张表，而每一个属性都对应着一个列，关系型数据库的核心是建立关系，也就是表和表之间，对象和对象之间。这就形成了一对一，一对多，多对一，多对多等关系。 一对一和多对多是一对多的两种特例，为啥这么说呢？ 一对多外键唯一形成一对一，多对多呢？举例，一个人可以玩很多种游戏，对于人来说是一对多，一种游戏可以被很多...
jpa 数据库方言_浅谈JPA数据库方言适配
weixin_39639260的博客
12-19 740
文章以Mysql、Oracle为例，其他类型的数据库还没试过，理论上其他数据库也是类似的实现。一、什么是方言？对于方言，其实很简单，按我的理解，就是遵从原有一些语言的规则，再结合自身特点而衍生出来的语言，就叫做方言。对于关系型数据库，不同的数据库虽然都遵循着jdbc规范设计，但在一些细节上还是存在不同，比如某个定义，某个函数的实现，就像我们国家56个名族都说普通话，但每个名族说出来的普通话还是会有...
浅谈Spring Boot
蔡茂的博客
06-14 977
Spring Boot Spring Boot的设计目的是用来简化Spring应用的初始搭建以及开发过程。使用springboot以后,搭建一个spring应用和开发变得很简单。该框架使用了特定的方式(继承starter，约定优先于配置)来进行配置，从而使开发人员不再需要定义样板化的配置。 Spring Boot并不是一个框架，从根本上将，它就是一些maven库的集合，maven或者gradl...
JPA深入浅出
09-10
该文档描述了JPA的来世今生，由浅入深地讲述了JPA概要、实体定义和基本注解、开发流程、JPA API和JPQL语言。将每个涉及到的细节讲得清晰、全面，可以作为学习JPA的指导文档！
springboot整合jpa
04-26
SpringBoot 整合 JPA（Java Persistence API）是现代Java应用中常见的数据访问技术栈，它简化了数据库操作，提供了ORM（对象关系映射）功能，使得开发者可以用面向对象的方式来处理数据库事务。以下是对这个主题的...
SpringBoot+JPA
04-03
**SpringBoot+JPA 整合指南** SpringBoot以其便捷的快速启动和自动配置特性，大大简化了Java Web应用的开发流程。而JPA（Java Persistence API）是Java平台上的ORM（Object-Relational Mapping）标准，它允许开发者...
JPA.rar_jpa
09-21
Java Persistence API（JPA）是Java平台上的一个标准，它为开发者提供了一种持久化对象到关系数据库的机制。JPA允许开发人员在Java应用程序中使用面向对象的方式来处理数据库操作，而无需深入理解底层SQL语言。这个...
如何顺利找到Java高级程序员的工作
厚嘉的it窝
03-02 1171
找到一份高薪的java工作，从程序员走向高级程序员、架构师、分析员，是所有java程序员们的追求。 找一份好工作，自然要看工作经历、项目积累、综合能力。但是，在繁忙、琐碎的日常工作之余，如何准备，才能高效高分通过各种IT公司的java面试、笔试呢？ 本人（blog.csdn.net/zhouhoujia），特地总结一下，如何在短期内，密集学习，顺利通过各大名企的java面试及笔试题。也许不用面
jsp动态动作指令
厚嘉的it窝
03-11 546
一、include动作指令   标签表示包含一个静态的或者动态的文件。 语法：                          或者                             />            ...............            />              注： 1、flush="true" 必须使
文字图片渐隐效果实现
厚嘉的it窝
02-18 535
http://ajax.googleapis.com/ajax/libs /jquery/1.4.0/jquery.min.js"> $(document).ready( function(){ $(".ex .hide").click(function(){ $(this).parents(".ex").hide("slow"); }); }); .ex{ back
破解myeclipse注册
厚嘉的it窝
03-03 413
原创：欢迎光临我的博客http://blog.csdn.net/zhouhoujia 自己先配置好jdk环境 简单说一下吧：添加三个系统变量 1.JAVA_HOME  值：c:\program files\java\jdk1.5 (自己jdk安装环境) 2. PATH              值：;%JAVA_HOME%\jre\bin;%JAVA_HOME%\bin 3.CLASSP
JAVA程序日常运维面临的问题与思考
厚嘉的it窝
09-02 357
JAVA程序日常运维面临的问题与思考 频繁FGC 如何给出合理的jvm配置？ class文件被jvm装载以后，经过jvm的内存空间调配，最终由执行引擎完成class文件的执行 JVM体系结构 类装载器（ClassLoader）（用来装载.class文件） 执行引擎（执行字节码，或者执行本地方法） 运行时数据区（方法区、堆、java栈、PC寄存器、本地方法栈） JVM内存结构 堆内存（新生代、老年代） 栈内存（java虚拟机栈...
jpa blob mysql_浅谈JPA的Blob和Clob注解方法 | 学步园
最新发布
05-27
关于 JPA 的 Blob 和 Clob 注解方法，我可以简单地给您介绍一下。 在 JPA 中，我们可以使用 @Lob 注解来标记一个属性为大对象（LOB，Large Object）。LOB 可以是二进制对象（Blob）或字符对象（Clob）。当我们需要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值