JPA学习

灰太狼 2024-02-19 12:09 12阅读 0赞

## JPA ##

备注：虽然程序中JPA的实现是Hibernate，但是学习jpa，包括使用Hibernate提供的JPA实现，可以不用了解Hibernate相关知识。

### 一.第一个JPA程序 ###

**1.新建一个JPA工程**

#### 1.Persistence.xml中的基本配置 ####

<?xml version="1.0" encoding="UTF-8"?>
    <persistence version="2.0" 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_2_0.xsd">
    	<persistence-unit name="Jap">
    		
    		<provider>org.hibernate.ejb.HibernatePersistence</provider>
    		
    		<properties>
    			
    			<property name="javax.persistence.user" value="root"/>
    			<property name="javax.persistence.password" value="mysql123" />
    			<property name="javax.persistence.driver" value="com.mysql.jdbc.Driver"/>
    			<property name="javax.persistence.url" value="jdbc:mysql://192.168.1.67:3306/jpa?characterEncoding=utf8"/>
    			
    			
    			
    			<property name="hibernate.show_sql" value="true"/>
    			
    			<property name="hibernate.format_sql" value="true"/>
    			
    			<property name="hibernate.hbm2ddl.auto" value="update"/>
    		</properties>
    		
    	</persistence-unit>
    </persistence>

#### 2.新建一个实体类 ####

package com.jpa.entity;
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.Table;
    
    @Table(name = "tb_user") //指定对应的数据表的表名
    @Entity // 指定这是一个数据库表实体
    public class User {
         
    	
    	private Integer id;
    	
    	private String firstName;
    	
    	private Integer age;
    	
    	public User() {
         
    		super();
    	}
    
    	public User( String firstName, Integer age) {
         
    		super();
    		this.firstName = firstName;
    		this.age = age;
    	}
    
    	@Id //设置主键
    	@Column(name = "id") // 设置对应的列名
    	@GeneratedValue(strategy = GenerationType.AUTO) // 设置主键生成策略
    	public Integer getId() {
         
    		return id;
    	}
    
    	public void setId(Integer id) {
         
    		this.id = id;
    	}
    
    	@Column(name = "first_name")
    	public String getFirstName() {
         
    		return firstName;
    	}
    
    	public void setFirstName(String firstName) {
         
    		this.firstName = firstName;
    	}
    	
        // 没使用@Column，也能写到数据库，默认为属性名
    	public Integer getAge() {
         
    		return age;
    	}
    
    	public void setAge(Integer age) {
         
    		this.age = age;
    	}
    
    	@Override
    	public String toString() {
         
    		return "User [id=" + id + ", firstName=" + firstName + ", age=" + age + "]";
    	}
    
    }

#### 3.在persistence.xml中添加实体类信息 ####

<?xml version="1.0" encoding="UTF-8"?>
    <persistence version="2.0" 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_2_0.xsd">
    	<persistence-unit name="Jap">
    		
    		<provider>org.hibernate.ejb.HibernatePersistence</provider>
            
    		<class>com.jpa.entity.User</class>
    		<properties>
    			
    			<property name="javax.persistence.user" value="root"/>
    			<property name="javax.persistence.password" value="mysql123" />
    			<property name="javax.persistence.driver" value="com.mysql.jdbc.Driver"/>
    			<property name="javax.persistence.url" value="jdbc:mysql://192.168.1.67:3306/jpa?characterEncoding=utf8"/>
    			
    			
    			
    			<property name="hibernate.show_sql" value="true"/>
    			
    			<property name="hibernate.format_sql" value="true"/>
    			
    			<property name="hibernate.hbm2ddl.auto" value="update"/>
    		</properties>
    		
    	</persistence-unit>
    </persistence>

#### 4.编写测试类，执行测试 ####

@Test
    public void test() {
         
        String persistenceUnitName = "Jap";
        // 创建EntityManagerFactory
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
    
        // 创建EntityManagerFactory
        EntityManager entityManager = entityManagerFactory.createEntityManager();
    
        // 获取事务
        EntityTransaction transaction = entityManager.getTransaction();
    
        // 开启事务
        transaction.begin();
    
        // 持久化操作
        User user = new User("张三", 12);
        entityManager.persist(user);
    
        // 提交事务
        transaction.commit();
    
        // 关闭entityManager
        entityManager.close();
    
        // 关闭EntityManagerFactory
        entityManagerFactory.close();
    
    }

***如果出现报错，可买在src下导入hibernate.properties文件***

报错：javax.persistence.PersistenceException: org.hibernate.PersistentObjectException: detached entity passed to persist: com.jpa.entity.Employee 	at org.hibernate.ejb.AbstractEntityManagerImpl.convert(AbstractEntityManagerImpl.java:1387) 	at org.hibernate.ejb.

hibernate.connection.driver_class=com.mysql.jdbc.Driver
    hibernate.connection.password=mysql123 # 修改为使用的数据库的连接信息
    hibernate.connection.url=jdbc:mysql://localhost:3306/jpa?characterEncoding=utf8
    hibernate.connection.username=root
    hibernate.dialect=org.hibernate.dialect.MySQLDialect

配置了show\_sql和format\_sql，控制台输出：

Hibernate: 
        insert 
        into
            tb_user
            (age, first_name) 
        values
            (?, ?)

### 二.JPA基本注解 ###

#### 1.@Entity、@Id、@GeneratedValue ####

@Entity // 指定这是一个实体类，这个类需要在persistence.xml中配置
    // 对应的数据中表的表名就是该实体的类名
    public class Student {
         
    	
    	// 一个实体类中必需指定主键 以及主键生成策略，否则程序执行会报错
    	@Id
    	// 主键生成策略,可以省略，省略后自动匹配
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private Integer id;
    	
    	private String name;
    	//...
    }

#### 2.@Column、@Table ####

@Table(name = "tb_student") // @Table 为表指定一个表名
    @Entity // 指定这是一个实体类，这个类需要在persistence.xml中配置
    public class Student {
         
    	
    	// 一个实体类中必需指定主键 以及主键生成策略，否则程序执行会报错
    	@Id
    	// 主键生成策略
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private Integer id;
    	
        // 指定对应数据库表的列名，可以省略属性,也可以省略这个注解，如果省略，默认使用@Basic注解
        // @Column注解推荐加在get方法上
    	@Column(name = "name", length = 30, nullable = true)
    	private String name;
        //...
    }

#### 3.@Transient ####

@Table(name = "tb_student") // @Table 为表指定一个表名
    @Entity // 指定这是一个实体类，这个类需要在persistence.xml中配置
    public class Student {
         
    	
    	// 一个实体类中必需指定主键 以及主键生成策略，否则程序执行会报错
    	@Id
    	// 主键生成策略
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private Integer id;
    	
    	@Column(name = "name", length = 30, nullable = true)
    	private String name;
    	
        // 默认情况下，get方法会被映射到数据表作为数据表的一个字段，如果没有set方法也会报错
        // 使用@Transient 可以使该属性不被映射为数据库表字段 
    	@Transient
    	public String getInfo() {
         
    		return " info ...";
    	}
        //...
    }

#### 4.@Temporal ####

@Table(name = "tb_student") // @Table 为表指定一个表名
    @Entity // 指定这是一个实体类，这个类需要在persistence.xml中配置
    public class Student {
         
    	
    	// 一个实体类中必需指定主键 以及主键生成策略，否则程序执行会报错
    	@Id
    	// 主键生成策略
    	@GeneratedValue(strategy = GenerationType.AUTO)
    	private Integer id;
    	
    	@Column(name = "name", length = 30, nullable = true)
    	private String name;
    	
    	// 指定存到数据库中的date类型的精确度 dateTime
    	@Temporal(TemporalType.TIMESTAMP)
    	private Date createDate;
        // birth 存在数据库中应该为date
    	@Temporal(TemporalType.DATE)
    	private Date birth;
        // ...
        
    }

### 三.主键生成策略 ###

### 1.table ###

以第三方数据表为其它表生成主键

@Table(name = "tb_student") // @Table 为表指定一个表名
    @Entity // 指定这是一个实体类，这个类需要在persistence.xml中配置
    public class Student {
         
    	
    	// 一个实体类中必需指定主键 以及主键生成策略，否则程序执行会报错
    	@Id
    // 主键生成策略，GenerationType.TABLE，generator= "table_generator" 使用的对应的策略的名字
    	@GeneratedValue(strategy = GenerationType.TABLE, generator = "table_generator")
    	@TableGenerator(name = "table_generator",  // 指定这个策略的名字
    					table = "jpa_table_generators", // 指定要使用的表
    					pkColumnName="PK_NAME", // 指定数据表中列名
    					pkColumnValue="ORDER_ID", // 指定列值
    					valueColumnName="PK_VALUE", // 指定数据表中的字段名
    					allocationSize=101) // 指定每次主键增长的大小
    	private Integer id;
    	
    	@Column(name = "name", length = 30, nullable = true)
    	private String name;
    	// ...
    }

### 四.JPA API ###

#### 1.Persistence ####

Persistence主要用于获取EntityManagerFactory

@Test
    public void test02() {
         
        String persistenceUnitName = "Jap";
        // 第一种获取EntityManagerFactory的方式
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
    
        Map<String, Object> properties = new HashMap<>();
        properties.put("hibernate.show_sql", false);
        // 第二种获取数据库的方式 properties是对属性的配置
        EntityManagerFactory createEntityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName, properties);
    }

#### 2.EntityManagerFactory、EntityManager ####

#### 3.find()方法 ####

@Test
    public void test03() {
         
       String persistenceUnitName = "Jap";
       EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName); 
       EntityManager entityManager = entityManagerFactory.createEntityManager();
    
       // find() 根据主键查询 
       User find = entityManager.find(User.class, 1);
       System.out.println("-------------");
       System.out.println(find);
    
       entityManager.close();
       entityManagerFactory.close();
    }

控制台打印结果：先打印sql后打印的结果
    Hibernate: 
        select
            user0_.id as id1_1_0_,
            user0_.age as age2_1_0_,
            user0_.first_name as first_na3_1_0_ 
        from
            tb_user user0_ 
        where
            user0_.id=?
    --------------------------------
    User [id=1, firstName=张三, age=12]

#### 4.getReference()方法 ####

@Test
    	public void test04() {
         
    		String persistenceUnitName = "Jap";
    		EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
    		EntityManager entityManager = entityManagerFactory.createEntityManager();
    		
    		// 根据主键获取数据，懒加载，在使用获取的对象的时候才执行查询操作
    		User user = entityManager.getReference(User.class, 1);
    		System.out.println("-------------------------");
    		System.out.println(user);
    		
    		entityManager.close();
    		entityManagerFactory.close();
    	}

控制台打印：在使用这个对象时才去查询
    -------------------------
    Hibernate: 
        select
            user0_.id as id1_1_0_,
            user0_.age as age2_1_0_,
            user0_.first_name as first_na3_1_0_ 
        from
            tb_user user0_ 
        where
            user0_.id=?
    User [id=1, firstName=张三, age=12]

getReference()：懒加载，在需要用到查询到的对象的时候才会去数据库中查询，但是会遇到一个问题就是EntityManager关闭后再获取这个对象就会出错,例如：

@Test
    public void test04() {
         
        String persistenceUnitName = "Jap";
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
        EntityManager entityManager = entityManagerFactory.createEntityManager();
    
        // 根据主键获取数据，懒加载，在使用获取的对象的时候才执行查询操作
        User user = entityManager.getReference(User.class, 1);
        System.out.println("-------------------------");
        // 这里entityManager关闭后，后面在使用这个对象的时候，再去数据库中查询就会报错
        entityManager.close();
        System.out.println(user);
    
        //entityManager.close();
        entityManagerFactory.close();
    }

#### 5.persist()方法 ####

@Test
    public void test05() {
         
        String persistenceUnitName = "Jap";
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
    
        // 构建一个对象，通过persist()方法存到数据库中，执行结束后返回一个插入后的数据（包含了id）
        User user = new User("Tom", 20);
        // persist()方法插入一个对象的时候，这个对象不能有id方法，否则插入不进去
        entityManager.persist(user);
        System.out.println(user);
        // 提交了事务，插入方法才会执行成功
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

#### 6.remove()方法 ####

@Test
    public void test06() {
         
        String persistenceUnitName = "Jap";
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
    
        // 自己创建的一个对象，不是从数据库中查出的对象是一个游离的对象，是不能通过remove()方法删除的
        User user = new User("Tom", 20);
        user.setId(2);
    
        entityManager.remove(user);
    
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    
    }

// 正确的删除方式
    	@Test
    	public void test06() {
         
    		String persistenceUnitName = "Jap";
    		EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
    		EntityManager entityManager = entityManagerFactory.createEntityManager();
    		EntityTransaction transaction = entityManager.getTransaction();
    		transaction.begin();
    		
    //		// 自己创建的一个对象，不是从数据库中查出的对象是一个游离的对象(缓存中没有)，是不能通过remove()方法删除的
    //		User user = new User("Tom", 20);
    //		user.setId(2);
    //		
    //		entityManager.remove(user);
    		// 只有通过数据库查询方法得到的对象才能通过remove()方法删除
    		User user = entityManager.find(User.class, 3);
    		entityManager.remove(user);
    		
    		transaction.commit();
    		entityManager.close();
    		entityManagerFactory.close();
    	}

#### 7.merage()方法 ####

@Test
    public void test01() throws Exception {
         
    
        String persistenceUnitName = "jpapro";
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
    
        // 游离状态,数据库不存在，就插入
        Employee emp = new Employee("张三", 3333.33);
        emp.setId(100);
        Employee merge = entityManager.merge(emp);
        System.out.println("--------------------");
        System.out.println(emp);
        System.out.println(merge);
    
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

@Test
    public void test02() {
         
        String persistenceUnitName = "jpapro";
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName); 
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction transaction = entityManager.getTransaction();
        transaction.begin();
    
        // 如果对应的数据在数据库中存在就更新
        Employee emp = new Employee("张三", 4444.33);
        emp.setId(3);
        Employee emp2 = entityManager.merge(emp);
        System.out.println("-------");
        System.out.println(emp);
        System.out.println(emp2);
    
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    
    }

#### 8.flush()方法 ####

@Test
    public void test03() {
         
        String persistenceUnitName = "jpapro";
        EntityManagerFactory entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
        EntityManager entityManager = entityManagerFactory.createEntityManager();
        EntityTransaction entityTransaction = entityManager.getTransaction();
        entityTransaction.begin();
    
        Employee emp = entityManager.find(Employee.class, 1);
        System.out.println(emp);
        emp.setSalary(4.0);
        // 更新，执行update,在commit的时候才发送sql语句执行，如果调用了flush()
        entityManager.merge(emp);
        // 执行flush(), 发送sql语句
        entityManager.flush();
        entityTransaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }

#### 9.getFlushMode()、setFlushMode() ####

\#\#\#10.refresh()

@Test
    public void test05() {
         
        // 发送sql 执行查询操作
        Employee emp = entityManager.find(Employee.class, 1);
        System.out.println(emp);
        // 重新发送sql，执行操作
        entityManager.refresh(emp);
    }

#### 11.EntityTransaction ####

entityTransaction.begin() 开始事务
    entityTransaction.commit() 提交事务
    entityTransaction.rollback() 回滚	
    entityTransaction.isActive() 查看当前事务是否是活动的，活动的事务才可用,开启了事务才是活跃的

### 五.关联表 ###

\#\#\#1.一对多关联

增加：

@Entity
    @Table(name = "tb_customer")
    public class Customer {
         
    	
    	@Id
    	@GeneratedValue
    	private Integer id;
    	@Column(name = "last_name")
    	private String lastName;
    	@Column
    	private Integer age;
    	@Column
    	@Temporal(TemporalType.DATE)
    	private Date date;
    	public String getLastName() {
         
    		return lastName;
    	}
    	public void setLastName(String lastName) {
         
    		this.lastName = lastName;
    	}
    	public Integer getAge() {
         
    		return age;
    	}
    	public void setAge(Integer age) {
         
    		this.age = age;
    	}
    	public Date getDate() {
         
    		return date;
    	}
    	public void setDate(Date date) {
         
    		this.date = date;
    	}
    	public Integer getId() {
         
    		return id;
    	}
    	public void setId(Integer id) {
         
    		this.id = id;
    	}
    	@Override
    	public String toString() {
         
    		return "Customer [id=" + id + ", lastName=" + lastName + ", age=" + age + ", date=" + date + "]";
    	}
    	
    }

@Entity
    @Table(name = "tb_order")
    public class Order {
         
    	
    	@GeneratedValue
    	@Id
    	private Integer id;
    	@Column(name = "order_name")
    	private String orderName;
    	
        // @JoinColumn 指定在当前表中关联对应的列，指定列名
    	@JoinColumn(name = "customer_id")
    	@ManyToOne //当前实体多个关联一个
    	private Customer customer;
    	public Integer getId() {
         
    		return id;
    	}
    	public void setId(Integer id) {
         
    		this.id = id;
    	}
    	public String getOrderName() {
         
    		return orderName;
    	}
    	public void setOrderName(String orderName) {
         
    		this.orderName = orderName;
    	}
    	public Customer getCustomer() {
         
    		return customer;
    	}
    	public void setCustomer(Customer customer) {
         
    		this.customer = customer;
    	}
    	@Override
    	public String toString() {
         
    		return "Order [id=" + id + ", orderName=" + orderName + ", customer=" + customer + "]";
    	}
    	
    }

@Test
    public void manyToOne() {
         
        Customer customer = new Customer("小明", 18, new Date());
        Order order1 = new Order();
        order1.setCustomer(customer);
        order1.setOrderName("order1");
        Order order2 = new Order();
        // 设置关联关系
        order2.setCustomer(customer);
        order2.setOrderName("order2");
        // 设置关联关系
        entityManager.persist(customer);
        entityManager.persist(order1);
        entityManager.persist(order2);
    
    }

数据库显示结果 ：
    customer:
    +----+------+------------+-----------+
    | id | age  | date       | last_name |
    +----+------+------------+-----------+
    |  1 |   18 | 2018-09-30 | 小明      |
    +----+------+------------+-----------+
       
     order:
    +----+------+------------+-----------+
    | id | age  | date       | last_name |
    +----+------+------------+-----------+
    |  1 |   18 | 2018-09-30 | 小明      |
    +----+------+------------+-----------+

分析:

两个对象，由于多个Order关联一个Customer，两个对象，可以先保存Customer,得到Customer保存在数据库中的对象的时候再保存Order，使相关联。
    如果先保存Order,那么Order相关联的字段首先设置为null,再保存Customer,保存完之后得到对应的customer的id，再更新之前保存的order，设置对应关联的列的值为这个id，这样比上一个多执行了几条sql

查询：

@Test 
    public void manyToOne1() {
         
        Order order = entityManager.find(Order.class, 1);
        System.out.println(order);
    }

执行的sql

ibernate: 
        select
            order0_.id as id1_2_1_,
            order0_.customer_id as customer3_2_1_,
            order0_.order_name as order_na2_2_1_,
            customer1_.id as id1_1_0_,
            customer1_.age as age2_1_0_,
            customer1_.date as date3_1_0_,
            customer1_.last_name as last_nam4_1_0_ 
        from
            tb_order order0_ 
        left outer join
            tb_customer customer1_ 
                on order0_.customer_id=customer1_.id 
        where
            order0_.id=?

修改：

@ManyToOne(fetch = FetchType.LAZY) // 设置为懒加载

@Test 
    public void manyToOne1() {
         
        Order order = entityManager.find(Order.class, 1);
        System.out.println("----------");
        System.out.println(order);
    }

执行的SQL:

Hibernate: 
        select
            order0_.id as id1_2_0_,
            order0_.customer_id as customer3_2_0_,
            order0_.order_name as order_na2_2_0_ 
        from
            tb_order order0_ 
        where
            order0_.id=?
    ----------  执行了两条Sql，在数据使用时再去查询 
    Hibernate: 
        select
            customer0_.id as id1_1_0_,
            customer0_.age as age2_1_0_,
            customer0_.date as date3_1_0_,
            customer0_.last_name as last_nam4_1_0_ 
        from
            tb_customer customer0_ 
        where
            customer0_.id=?

删除：

@Test
    public void manyToOne2() {
         
        Customer customer = entityManager.find(Customer.class, 1);
        // 执行删除会报错，因为这个数据下面有关联的order
        entityManager.remove(customer);
    }

执行的sql:

ibernate: 
        select
            customer0_.id as id1_1_0_,
            customer0_.age as age2_1_0_,
            customer0_.date as date3_1_0_,
            customer0_.last_name as last_nam4_1_0_ 
        from
            tb_customer customer0_ 
        where
            customer0_.id=?
    Hibernate: 
        delete 
        from
            tb_customer 
        where
            id=?

修改：

@Test
    public void manyToOne3() {
         
        Order order = entityManager.find(Order.class, 1);
        // 修改属性
        order.getCustomer().setLastName("小草");
    }

执行的Sql：

Hibernate: 
        select
            order0_.id as id1_2_0_,
            order0_.customer_id as customer3_2_0_,
            order0_.order_name as order_na2_2_0_ 
        from
            tb_order order0_ 
        where
            order0_.id=?
    Hibernate: 
        select
            customer0_.id as id1_1_0_,
            customer0_.age as age2_1_0_,
            customer0_.date as date3_1_0_,
            customer0_.last_name as last_nam4_1_0_ 
        from
            tb_customer customer0_ 
        where
            customer0_.id=?
    Hibernate: 
        update
            tb_customer 
        set
            age=?,
            date=?,
            last_name=? 
        where
            id=?

#### 2.多对一关联 ####

需求：一个轮子类wheel，一个车类car，一个车关联多个轮子

@Entity
    @Table(name = "tb_wheel")
    public class Wheel {
         
    	
    	@Id
    	@GeneratedValue
    	private Integer id;
    	@Column(name = "name")
    	private String name;
        // 省略getter/setter/constructor/toString
    }

@Entity
    @Table( name = "tb_car")
    public class Car {
         
    	
    	@Id
    	@GeneratedValue
    	private Integer id;
    	private String name;
        // 指定对应的列名，会在wheel表中新增一个car_id字段 
    	@JoinColumn(name = "car_id") 
    	@OneToMany // 指定关系为一对多
    	private Set<Wheel> wheels = new HashSet<>();
        // 省略getter/setter/constructor/toString
    }

***当前Entity实体写好后要加入到persistence.xml文件中***

public class RelationTest {
         
    	// 测试类
    	private EntityManagerFactory entityManagerFactory = null;
    	private EntityManager entityManager = null;
    	private EntityTransaction entityTransaction = null;
    	
    	@Before // @Before 执行@Test方法之前执行
    	public void before() {
         
    		String persistenceUnitName = "jpapro";
    		entityManagerFactory = Persistence.createEntityManagerFactory(persistenceUnitName);
    		entityManager = entityManagerFactory.createEntityManager();
    		entityTransaction = entityManager.getTransaction();
    		entityTransaction.begin();
    	}
    	
    	@After // @After 执行@Test方法之后执行
    	public void after() {
         
    		entityTransaction.commit();
    		entityManager.close();
    		entityManagerFactory.close();
    		
    	}
    
    }

// 测试方法
    @Test
    public void oneToMany() {
         
        Wheel lf = new Wheel("左前方");
        Wheel rf = new Wheel("右前方");
        Wheel lb = new Wheel("左后方");
        Wheel rb = new Wheel("右后方");
    
        Car car = new Car();
        car.setName("audi");
        car.getWheels().add(lf);
        car.getWheels().add(lb);
        car.getWheels().add(rb);
        car.getWheels().add(rf);
    
        entityManager.persist(car);
        entityManager.persist(lf);
        entityManager.persist(lb);
        entityManager.persist(rf);
        entityManager.persist(rb);
    }

执行的sql:分别执行insert，再update关联
    Hibernate: 
        insert 
        into
            tb_car
            (name) 
        values
            (?)
    Hibernate: 
        insert 
        into
            tb_wheel
            (name) 
        values
            (?)
    Hibernate: 
        insert 
        into
            tb_wheel
            (name) 
        values
            (?)
    Hibernate: 
        insert 
        into
            tb_wheel
            (name) 
        values
            (?)
    Hibernate: 
        insert 
        into
            tb_wheel
            (name) 
        values
            (?)
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=? 
        where
            id=?
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=? 
        where
            id=?
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=? 
        where
            id=?
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=? 
        where
            id=?

查询：

find():

@Test
    public void oneToManyFind() {
         
        Car car = entityManager.find(Car.class, 1);
        System.out.println("---------------------");
        System.out.println(car);
    }

执行sql：
    Hibernate: 
        select
            car0_.id as id1_1_0_,
            car0_.name as name2_1_0_ 
        from
            tb_car car0_ 
        where
            car0_.id=?
    --------------------- 在使用时，懒加载 
    Hibernate: 
        select
            wheels0_.car_id as car_id3_1_1_,
            wheels0_.id as id1_4_1_,
            wheels0_.id as id1_4_0_,
            wheels0_.name as name2_4_0_ 
        from
            tb_wheel wheels0_ 
        where
            wheels0_.car_id=?

@OneToMany(fetch = FetchType.EAGER) //设置为非懒加载

getRefrence():

@Test
    public void onToManyGetRefrence() {
         
        Car car = entityManager.getReference(Car.class, 1);
        System.out.println("-------");
        System.out.println(car);
    }

------ 懒加载，全部sql懒加载，上面find()只会是懒加载关联表 
    Hibernate: 
        select
            car0_.id as id1_1_0_,
            car0_.name as name2_1_0_ 
        from
            tb_car car0_ 
        where
            car0_.id=?
    Hibernate: 
        select
            wheels0_.car_id as car_id3_1_1_,
            wheels0_.id as id1_4_1_,
            wheels0_.id as id1_4_0_,
            wheels0_.name as name2_4_0_ 
        from
            tb_wheel wheels0_ 
        where
            wheels0_.car_id=?

修改：

@Test
    public void oneToManyUpdate() {
         
        Car car = entityManager.find(Car.class, 1);
        // 修改属性
        car.getWheels().iterator().next().setName("正前方");
    }

执行的sql
    ibernate: 
        select
            car0_.id as id1_1_0_,
            car0_.name as name2_1_0_ 
        from
            tb_car car0_ 
        where
            car0_.id=?
    Hibernate: 
        select
            wheels0_.car_id as car_id3_1_1_,
            wheels0_.id as id1_4_1_,
            wheels0_.id as id1_4_0_,
            wheels0_.name as name2_4_0_ 
        from
            tb_wheel wheels0_ 
        where
            wheels0_.car_id=?
    Hibernate: 
        update
            tb_wheel 
        set
            name=? 
        where
            id=?

删除：

@Test 
    public void oneToManyRemove() {
         
        Car car = entityManager.find(Car.class, 1);
        entityManager.remove(car);
    }

执行的sql：
    Hibernate: 
        select
            car0_.id as id1_1_0_,
            car0_.name as name2_1_0_ 
        from
            tb_car car0_ 
        where
            car0_.id=?
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=null 
        where
            car_id=?  # 把关联的表的关联属性置为null，之后中再删除
    Hibernate: 
        delete 
        from
            tb_car 
        where
            id=?

级连删除：

@Test 
    public void oneToManyRemove() {
         
        Car car = entityManager.find(Car.class, 2);
        entityManager.remove(car);
    }

Hibernate: 
        select
            car0_.id as id1_1_0_,
            car0_.name as name2_1_0_ 
        from
            tb_car car0_ 
        where
            car0_.id=?
    Hibernate: 
        select
            wheels0_.car_id as car_id3_1_1_,
            wheels0_.id as id1_4_1_,
            wheels0_.id as id1_4_0_,
            wheels0_.name as name2_4_0_ 
        from
            tb_wheel wheels0_ 
        where
            wheels0_.car_id=?
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=null 
        where
            car_id=?
    Hibernate: 
        delete 
        from
            tb_wheel 
        where
            id=?
    Hibernate: 
        delete 
        from
            tb_wheel 
        where
            id=?
    Hibernate: 
        delete 
        from
            tb_wheel 
        where
            id=?
    Hibernate: 
        delete 
        from
            tb_wheel 
        where
            id=?
    Hibernate: 
        delete 
        from
            tb_car 
        where
            id=?

--------------------

// 设置@OneToMany的cascade属性为remove就能完成级连删除
    @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.REMOVE)

#### 3.双向一对多/多对一关联 ####

@Entity
    @Table( name = "tb_car")
    public class Car {
         
    	
    	@Id
    	@GeneratedValue
    	private Integer id;
    	private String name;
    	@JoinColumn(name = "car_id")
    	@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.REMOVE)
    	private Set<Wheel> wheels = new HashSet<>();
    	// 省略getter/setter/constructor/toString
    }

**注意两个类中的关联关系**

@Test
    public void test01() {
         
        Car car = new Car();
        car.setName("audi");
    
        Wheel l = new Wheel("left");
        Wheel r = new Wheel("right");
    
        car.getWheels().add(l);
        car.getWheels().add(r);
    
        l.setCar(car);
        r.setCar(car);
    
        entityManager.persist(car);
        entityManager.persist(r);
        entityManager.persist(l);
    
    }

ibernate: 
        insert 
        into
            tb_car
            (name) 
        values
            (?)
    Hibernate: 
        insert 
        into
            tb_wheel
            (car_id, name) 
        values
            (?, ?)
    Hibernate: 
        insert 
        into
            tb_wheel
            (car_id, name) 
        values
            (?, ?)
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=? 
        where
            id=?
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=? 
        where
            id=?
    # 先插入所有数据后更新

更改保存数据的顺序：

@Test
    public void test01() {
         
        Car car = new Car();
        car.setName("audi");
    
        Wheel l = new Wheel("left");
        Wheel r = new Wheel("right");
    
        car.getWheels().add(l);
        car.getWheels().add(r);
    
        l.setCar(car);
        r.setCar(car);
    
    	// '多' 先插入
        entityManager.persist(r);
        entityManager.persist(l);
        // '一' 后插入
        entityManager.persist(car);
    
    }

执行的sql:
    ibernate: 插入whell
        insert 
        into
            tb_wheel
            (car_id, name) 
        values
            (?, ?)
    Hibernate: 插入whell
        insert 
        into
            tb_wheel
            (car_id, name) 
        values
            (?, ?)
    Hibernate: 插入car
        insert 
        into
            tb_car
            (name) 
        values
            (?)
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=?,
            name=? 
        where
            id=?
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=?,
            name=? 
        where
            id=?
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=? 
        where
            id=?
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=? 
        where
            id=?

分析：

当先插入「一」后插入「多」的时候：
    	插入有三条insert语句，然后两条update语句分别从car角度/wheel角度更新外键关联关系
    当先插入[多]后插入[一]的时候
    	插入有三条insert语句，然后从wheel角度、和car角度执行分别执行两update语句

总结：

先插入[一]的数据，再插入[多]的数据

由于【多】的一方和【一】的一方都维护了关联关系，所以会出现上述情况，此时，可以指定只由一方来维护关联关系，不维护关联关系就是没有外键

@Entity
    @Table( name = "tb_car")
    public class Car {
         
    	
    	@Id
    	@GeneratedValue
    	private Integer id;
    	private String name;
    	// @JoinColumn(name = "car_id") 注释@JoinColumn
        // 在@OneToMany属性中指定mapperdBy 关联对象的关联的属性名，指定由谁来维护关联关系
    	@OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.REMOVE, mappedBy = "car")
    	private Set<Wheel> wheels = new HashSet<>();
        // ...
    }

bernate: 
        insert 
        into
            tb_wheel
            (car_id, name) 
        values
            (?, ?)
    Hibernate: 
        insert 
        into
            tb_wheel
            (car_id, name) 
        values
            (?, ?)
    Hibernate: 
        insert 
        into
            tb_car
            (name) 
        values
            (?)
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=?,
            name=? 
        where
            id=?
    Hibernate: 
        update
            tb_wheel 
        set
            car_id=?,
            name=? 
        where
            id=?

由于只由wheel方，来维护关联关系，所以插入的两条wheel数据会产生两个update语句

#### 3.双向一对一 ####

需求：一个部门一个经理，一个经理管理一个部门

@Table(name = "tb_manager")
    @Entity
    public class Manager {
         
    	
    	@Id
    	@GeneratedValue
    	private Integer id;
    	private String name;
        // @OneToOne 设置为一对一关系，指定为对应的manager属性
    	@OneToOne(mappedBy = "manager")
    	private Dept dept;
        // ...
    }

@Table(name = "tb_dept")
    @Entity
    public class Dept {
         
    	
    	@Id
    	@GeneratedValue
    	private Integer id;
    	private String name;
        // unique属性 指定是否是唯一
    	@JoinColumn(name= "dept", unique = true)
        // 指定为一对一关联关系
    	@OneToOne
    	private Manager manager;
        // ...
    }

@Test
    public void oneToOne() {
         
        Dept dept = new Dept();
        dept.setName("dept1");
        Manager manager = new Manager();
        manager.setName("manager1");
        dept.setManager(manager);
        manager.setDept(dept);
        entityManager.persist(dept);
        entityManager.persist(manager);
    }

Hibernate: 
        insert 
        into
            tb_dept
            (dept, name) 
        values
            (?, ?)
    Hibernate: 
        insert 
        into
            tb_manager
            (name) 
        values
            (?)
    Hibernate: 
        update
            tb_dept 
        set
            dept=?,
            name=? 
        where
            id=?

find()查找：

@Test
    public void oneToOneFind() {
         
        Dept dept = entityManager.find(Dept.class, 1);
        System.out.println(dept);
    }

Hibernate: 
        select
            dept0_.id as id1_3_1_,
            dept0_.dept as dept3_3_1_,
            dept0_.name as name2_3_1_,
            manager1_.id as id1_4_0_,
            manager1_.name as name2_4_0_ 
        from
            tb_dept dept0_ 
        left outer join
            tb_manager manager1_ 
                on dept0_.dept=manager1_.id 
        where
            dept0_.id=?
    Hibernate: 
        select
            dept0_.id as id1_3_1_,
            dept0_.dept as dept3_3_1_,
            dept0_.name as name2_3_1_,
            manager1_.id as id1_4_0_,
            manager1_.name as name2_4_0_ 
        from
            tb_dept dept0_ 
        left outer join
            tb_manager manager1_ 
                on dept0_.dept=manager1_.id 
        where
            dept0_.dept=?

默认使用左外连接查找

修改dept对象

@OneToOne(fetch = FetchType.LAZY)

两次执行上述方法：

Hibernate: 
        select
            dept0_.id as id1_3_0_,
            dept0_.dept as dept3_3_0_,
            dept0_.name as name2_3_0_ 
        from
            tb_dept dept0_ 
        where
            dept0_.id=?
    Hibernate: 
        select
            manager0_.id as id1_4_1_,
            manager0_.name as name2_4_1_,
            dept1_.id as id1_3_0_,
            dept1_.dept as dept3_3_0_,
            dept1_.name as name2_3_0_ 
        from
            tb_manager manager0_ 
        left outer join
            tb_dept dept1_ 
                on manager0_.id=dept1_.dept 
        where
            manager0_.id=?
    Hibernate: 
        select
            dept0_.id as id1_3_0_,
            dept0_.dept as dept3_3_0_,
            dept0_.name as name2_3_0_ 
        from
            tb_dept dept0_ 
        where
            dept0_.dept=?

#### 4.双向多对多 ####

需求：一个商品可以属于多个类别，一个类别可以有多个商品

@Table(name = "tb_type")
    @Entity
    public class Type {
         
    	@Id
    	@GeneratedValue
    	private Integer id;
    	private String name;
    	@ManyToMany(mappedBy = "types") //指定关联关系
    	private Set<Item> items = new HashSet<>();
        //....
    }

@Entity
    @Table(name = "tb_item")
    public class Item {
         
    	@Id
    	@GeneratedValue
    	private Integer id;
    	private String name;
    	@JoinTable(name="item_type", // 指定中间表表名 
    	   joinColumns = {
         
               	// 指定关联当前表的表的列名和对应的当前表的字段名
    			@JoinColumn(name = "item_id", referencedColumnName = "id")
    	}, inverseJoinColumns = {
         
               // 指定关联另一张表的表的列名和对应的另一张表的字段名
    			@JoinColumn(name = "type_id", referencedColumnName = "id")
    	})
    	@ManyToMany
    	private Set<Type> types = new HashSet<>();
        // ...
    }

@Test
    public void manyToMany() {
         
    
        Type type = new Type();
        type.setName("电子产品");
        Type type1 = new Type();
        type1.setName("数码产品");
    
        Item item = new Item();
        item.setName("iphone");
        Item item1 = new Item();
        item1.setName("huawei");
    
        type.getItems().add(item1);
        type.getItems().add(item);
        item.getTypes().add(type1);
        item.getTypes().add(type);
    
        entityManager.persist(type);
        entityManager.persist(type1);
        entityManager.persist(item1);
        entityManager.persist(item);
    
    
    }

Hibernate: 
        insert 
        into
            tb_type
            (name) 
        values
            (?)
    Hibernate: 
        insert 
        into
            tb_type
            (name) 
        values
            (?)
    Hibernate: 
        insert 
        into
            tb_item
            (name) 
        values
            (?)
    Hibernate: 
        insert 
        into
            tb_item
            (name) 
        values
            (?)
    Hibernate: 
        insert 
        into
            item_type
            (item_id, type_id) 
        values
            (?, ?)
    Hibernate: 
        insert 
        into
            item_type
            (item_id, type_id) 
        values
            (?, ?)

### 5.缓存 ###

###### 一级缓存： ######

@Test
    public void cache() {
         
        // 从数据库中获取同样一条数据，发现只发送了一条sql语句，原因是第一次查询已经存在了缓存中，
        // 第二次查询只需要从缓存中获取就行了
        Item item = entityManager.find(Item.class, 1);
        System.out.println(item);
        Item item1 = entityManager.find(Item.class, 1);
        System.out.println(item1);
    }

@Test
    public void cache() {
         
        Item item = entityManager.find(Item.class, 1);
        System.out.println(item);
    
        // 关闭entityManger,重新开启，缓存中的数据被清空
        entityTransaction.commit();
        entityManager.close();
        entityManager = entityManagerFactory.createEntityManager();
        entityTransaction = entityManager.getTransaction();
        entityTransaction.begin();
    
        Item item1 = entityManager.find(Item.class, 1);
        System.out.println(item1);
    }

### 六.JPQL ###

#### 1.Hello World ####

@Test
    public void testQuery() {
         
        // form 对象，？占位符 , 默认查询全部属性，返回查询 的对象
        String jpql = "from Customer c where c.id > ?";
        Query query = entityManager.createQuery(jpql);
        // 设置占位符的值
        query.setParameter(1, 1);
        // 获取查询结果 
        List<Customer> res = query.getResultList();
        System.out.println(res);
    }

#### 2.不查全部属性，返回的是一个数组 ####

@Test
    public void testQuery01() {
         
        String jpql = "select c.lastName , c.age from Customer c where c.id > ?";
        Query query = entityManager.createQuery(jpql);
        query.setParameter(1, 1);
        List list = query.getResultList();
        System.out.println(list);
    }

#### 3.指定查询列 ####

@Test
    public void testQuery02() {
         
        // new Customer(c.lastName, c.age) ，必须要有对应的构造器
        String jpql = "select new Customer(c.lastName, c.age) from Customer c where c.id > ?";
        Query query = entityManager.createQuery(jpql);
        query.setParameter(1,  1);
        List list = query.getResultList();
        System.out.println(list);
    }

#### 4.NamedQuery ####

// 这里eclipse编译器会报错，无视即可
    // query里面写jpql表达式 FROM Customer c WHERE c.id = ?
    @NamedQuery(name = "testNamedQuery", query = "SELECT c FROM Customer c WHERE c.id = ?")
    @Entity
    @Table(name = "tb_customer")
    public class Customer {
         
    	
    	@Id
    	@GeneratedValue
    	private Integer id;
    	@Column(name = "last_name")
    	private String lastName;
    	@Column
    	private Integer age;
    	@Column
    	@Temporal(TemporalType.DATE)
    	private Date date;
        //...
    }

@Test
    public void testNamedQuery03() {
         
        Query query = entityManager.createNamedQuery("testNamedQuery").setParameter(1, 1);
        Customer customer = (Customer) query.getSingleResult();
        System.out.println(customer);
    }

#### 4.NativeQuery ####

@Test
    public void testNativeQuery() {
         
        // 写sql查询 
        String sql = "select age from tb_customer where id = ?";
        Query query = entityManager.createNativeQuery(sql);
        query.setParameter(1, 1);
        Object res = query.getSingleResult();
        System.out.println(res);
    }

#### 5.ORDER BY 和 GROUP BY ####

@Test
    public void orderByTest() {
         
        // order by  排序 
        String jpql = "from Customer c where c.id > 1 order by c.id desc";
        Query query = entityManager.createQuery(jpql);
        List resultList = query.getResultList();
        System.out.println(resultList);
    }

@Test
    public void groupByTest() {
         
        // group by 分组 
        String jpql = "select count(*) from Customer c group by c.date";
        Query query = entityManager.createQuery(jpql);
        List result = query.getResultList();
        System.out.println(result);
    }

#### 6.关联查询 ####

@Test
    public void test01() {
         
        String jpql = "from Order o  where o.id = 2";
        List list = entityManager.createQuery(jpql).getResultList();
        System.out.println(list);
    }

不使用关联查询时：
    Hibernate: 
        select
            order0_.id as id1_7_,
            order0_.customer_id as customer3_7_,
            order0_.order_name as order_na2_7_ 
        from
            tb_order order0_ 
        where
            order0_.id=2
    Hibernate: 
        select
            customer0_.id as id1_3_0_,
            customer0_.age as age2_3_0_,
            customer0_.date as date3_3_0_,
            customer0_.last_name as last_nam4_3_0_ 
        from
            tb_customer customer0_ 
        where
            customer0_.id=?

@Test
    public void test01() {
         
        // 设置关联查询, 语句中加了fetch,会组合成一个对象，不加fetch则返回一个数组
        String jpql = "from Order o left outer join fetch o.customer  where o.id = 2";
        List list = entityManager.createQuery(jpql).getResultList();
        System.out.println(list);
    }

# 关联查询只有一条sql
    Hibernate: 
        select
            order0_.id as id1_7_0_,
            customer1_.id as id1_3_1_,
            order0_.customer_id as customer3_7_0_,
            order0_.order_name as order_na2_7_0_,
            customer1_.age as age2_3_1_,
            customer1_.date as date3_3_1_,
            customer1_.last_name as last_nam4_3_1_ 
        from
            tb_order order0_ 
        left outer join
            tb_customer customer1_ 
                on order0_.customer_id=customer1_.id 
        where
            order0_.id=2

#### 4.更新 ####

@Test
    public void test02() {
         
        String jpql = "update Customer c set c.lastName = ?  where c.id = ?";
        Query query = entityManager.createQuery(jpql).setParameter(1, "哈哈").setParameter(2, 2);
        // 执行更新
        int i = query.executeUpdate();
        System.out.println(i);
    }

### 七.Spring整合JPA ###

#### 1.环境整合 ####

新建一个Maven工程

**pom.xml文件**

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.spring.jpa</groupId>
        <artifactId>spring_jpa</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>5.0.5.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.0.5.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>5.0.5.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>com.mchange</groupId>
                <artifactId>c3p0</artifactId>
                <version>0.9.5.2</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.11</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-core</artifactId>
                <version>5.3.3.Final</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate</groupId>
                <artifactId>hibernate-entitymanager</artifactId>
                <version>5.3.3.Final</version>
            </dependency>
            <dependency>
                <groupId>org.hibernate.javax.persistence</groupId>
                <artifactId>hibernate-jpa-2.1-api</artifactId>
                <version>1.0.0.Final</version>
            </dependency>
            <dependency>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
                <version>1.2</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-jpa</artifactId>
                <version>2.0.8.RELEASE</version>
            </dependency>
    
        </dependencies>
    
    
    </project>

**spring配置文件application.xml**

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
    
        
        <context:component-scan base-package="com.spring.jpa"></context:component-scan>
        
        <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
    
        
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
            <property name="user" value="${jdbc.username}"></property>
            <property name="password"  value="${jdbc.password}"></property>
            <property name="driverClass" value="${jdbc.driverClass}"></property>
            <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
        </bean>
    
        
        <bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" id="entityManagerFactory">
            
            <property name="dataSource" ref="dataSource"></property>
            
            <property name="jpaVendorAdapter">
                <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"></bean>
            </property>
            
            <property name="jpaProperties">
                <props>
                    <prop key="hibernate.show_sql">true</prop>
                    <prop key="hibernate.format_sql">true</prop>
                    <prop key="hibernate.hbm2ddl.auto">update</prop>
                </props>
            </property>
            
            <property name="packagesToScan" value="com.spring.jpa.entity"></property>
        </bean>
        <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
            <property name="entityManagerFactory" ref="entityManagerFactory"></property>
        </bean>
    
        
        <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>
    
    </beans>

新建一个实体类**Person**，放在实体类所在的包的下面：

@Entity
    @Table(name = "tb_person")
    public class Person {
         
    
        @Id
        @GeneratedValue(strategy = GenerationType.AUTO)
        private Integer id;
        @Column(name= "last_name")
        private String lastName;
        @Column(name = "birthday")
        @Temporal(TemporalType.DATE)
        private Date birth;
    	// 省略了getter/setter
    }

测试：

@Test
    public void test () {
         
        // 通过属性配置文件加载spring容器，生成对应的bean对象，同时会在数据库中生成对应的数据库表
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        System.out.println(applicationContext);
    }

控制台打印Sql:

Hibernate: 
        
        create table hibernate_sequence (
           next_val bigint
        ) engine=InnoDB
    Hibernate: 
        
        insert into hibernate_sequence values ( 1 )
    Hibernate: 
        
        create table tb_person (
           id integer not null,
            birthday date,
            last_name varchar(255),
            primary key (id)
        ) engine=InnoDB

数据库中生成的表：

+-----------+--------------+------+-----+---------+-------+
    | Field     | Type         | Null | Key | Default | Extra |
    +-----------+--------------+------+-----+---------+-------+
    | id        | int(11)      | NO   | PRI | NULL    |       |
    | birthday  | date         | YES  |     | NULL    |       |
    | last_name | varchar(255) | YES  |     | NULL    |       |
    +-----------+--------------+------+-----+---------+-------+
    3 rows in set (0.01 sec)

#### 2.功能测试 ####

**在repository包中新建一个PersonRepository类**

@Repository
    public class PersonRepository {
         
    
        @PersistenceContext
        private EntityManager entityManager;
    
        public void save(Person p) {
         
            entityManager.persist(p);
        }
    
    }

**在service包中新建一个PersonService类**

@Service
    public class PersonService {
         
    
        @Autowired
        private PersonRepository personRepository;
    
        @Transactional
        public void save(Person p1, Person p2) {
         
            personRepository.save(p1);
            personRepository.save(p2);
        }
    
    }

**在测试类中测试**

@Test
    public void test01() {
         
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
        PersonService personService = applicationContext.getBean(PersonService.class);
        Person p1 = new Person();
        p1.setLastName("张三");
        p1.setBirth(new Date());
        Person p2 = new Person();
        p2.setLastName("李四");
        p2.setBirth(new Date());
        personService.save(p1, p2);
    }

控制台打印sql:

Hibernate: 
        select
            next_val as id_val 
        from
            hibernate_sequence for update
                
    Hibernate: 
        update
            hibernate_sequence 
        set
            next_val= ? 
        where
            next_val=?
    Hibernate: 
        select
            next_val as id_val 
        from
            hibernate_sequence for update
                
    Hibernate: 
        update
            hibernate_sequence 
        set
            next_val= ? 
        where
            next_val=?
    Hibernate: 
        insert 
        into
            tb_person
            (birthday, last_name, id) 
        values
            (?, ?, ?)
    Hibernate: 
        insert 
        into
            tb_person
            (birthday, last_name, id) 
        values
            (?, ?, ?)

整合项目的gitHub地址：[https://github.com/xiefeif/spring\_jpa.git][https_github.com_xiefeif_spring_jpa.git]

[https_github.com_xiefeif_spring_jpa.git]: https://github.com/xiefeif/spring_jpa.git