6、JPA_映射单向多对一的关联关系（n的一方有1的引用，1的一方没有n的集合属性）

 1 package com.magicode.jpa.many2one;
 2 
 3 import javax.persistence.Column;
 4 import javax.persistence.Entity;
 5 import javax.persistence.FetchType;
 6 import javax.persistence.GeneratedValue;
 7 import javax.persistence.GenerationType;
 8 import javax.persistence.Id;
 9 import javax.persistence.JoinColumn;
10 import javax.persistence.ManyToOne;
11 import javax.persistence.Table;
12 import javax.persistence.TableGenerator;
13 
14 import com.magicode.jpa.helloworld.Customer;
15 
16 @Table(name="t_order")
17 @Entity
18 public class Order {
19     
20     private Integer id;
21     private String orderName;
22     
23     private Customer customer;
24     
25     @TableGenerator(name="order_id_generator",
26             table="t_id_generator",
27             pkColumnName="PK_NAME",
28             pkColumnValue="seedId_t_order",
29             valueColumnName="PK_VALUE",
30             initialValue=0,
31             allocationSize=20)
32     @GeneratedValue(generator="order_id_generator", strategy=GenerationType.TABLE)
33     @Id
34     @Column(name="ID")
35     public Integer getId() {
36         return id;
37     }
38     
39     @Column(name="ORDER_NAME")
40     public String getOrderName() {
41         return orderName;
42     }
43     
44     /**
45      * 1、通过 @ManyToOne 来配置单向多对一的关联关系，同时可以配置fetch=FetchType.LAZY
46      * 来指定懒加载查询策略；
47      * 2、@JoinColumn来映射外键
48      */
49     @ManyToOne(fetch=FetchType.LAZY)
50     @JoinColumn(name="CUSTOMER_ID")
51     public Customer getCustomer() {
52         return customer;
53     }
54 
55     public void setCustomer(Customer customer) {
56         this.customer = customer;
57     }
58 
59     @SuppressWarnings("unused")
60     private void setId(Integer id) {
61         this.id = id;
62     }
63     
64     public void setOrderName(String orderName) {
65         this.orderName = orderName;
66     }
67 
68 }

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <persistence version="2.0"
 3     xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
 5 
 6     <!-- 注意这里的 persistence-unit标签的name属性值，main函数中会用到它 -->
 7     <persistence-unit name="jpa-1" transaction-type="RESOURCE_LOCAL">
 8 
 9         <!-- 配置使用什么样的ORM产品作为JPA的实现 
10             1、实际上配置的是 javax.persistence.spi.PersistenceProvider 接口的实现类 
11             2、若JPA项目中只有一个JPA的实现产品，则可以不配置provider节点
12         -->
13         <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
14 
15         <!-- 添加持久化类 -->
16         <class>com.magicode.jpa.helloworld.Customer</class>
17         <class>com.magicode.jpa.many2one.Order</class>
18 
19         <properties>
20             <!-- 连接数据库的基本信息 -->
21             <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
22             <property name="javax.persistence.jdbc.url" value="jdbc:mysql:///jpa" />
23             <property name="javax.persistence.jdbc.user" value="root" />
24             <property name="javax.persistence.jdbc.password" value="tiger123" />
25 
26             <!-- 配置JPA实现产品的基本属性：配置Hibernate的基本属性 -->
27             <property name="hibernate.format_sql" value="true" />
28             <property name="hibernate.show_sql" value="true" />
29             <property name="hibernate.hbm2ddl.auto" value="update" />
30             <!-- 
31                 Setting is relevant when using @GeneratedValue. 
32                 It indicates whether or not the new IdentifierGenerator implementations 
33                 are used for javax.persistence.GenerationType.AUTO, 
34                 javax.persistence.GenerationType.TABLE and 
35                 javax.persistence.GenerationType.SEQUENCE. 
36                 Default to false to keep backward compatibility.
37              -->
38             <property name="hibernate.id.new_generator_mappings" value="true"/>
39 
40         </properties>
41 
42     </persistence-unit>
43 </persistence>

  1 package com.magicode.jpa.many2one;
  2 
  3 import java.util.Date;
  4 
  5 import javax.persistence.EntityManager;
  6 import javax.persistence.EntityManagerFactory;
  7 import javax.persistence.EntityTransaction;
  8 import javax.persistence.Persistence;
  9 
 10 import org.junit.After;
 11 import org.junit.Before;
 12 import org.junit.Test;
 13 
 14 import com.magicode.jpa.helloworld.Customer;
 15 
 16 public class Many2OneTest {
 17     
 18     EntityManagerFactory emf = null;
 19     EntityManager em = null;
 20     EntityTransaction transaction = null;
 21     
 22     @Before
 23     public void before(){
 24         emf = Persistence.createEntityManagerFactory("jpa-1");
 25         em = emf.createEntityManager();
 26         transaction = em.getTransaction();
 27         transaction.begin();
 28     }
 29     
 30     @After
 31     public void after(){
 32         transaction.commit();
 33         em.close();
 34         emf.close();
 35     }
 36     
 37     /**
 38      * 先持久化 1 的一方，后持久化 n 的一方会少发送两条update SQL语句
 39      */
 40     @Test
 41     public void testPersist(){
 42         
 43         for(int i = 0; i < 3; i++){
 44             char c = (char) (‘A‘ + i);
 45             String strName = (" " + c + c).trim();
 46             int age = 25 + i;
 47             
 48             Customer customer = new Customer();
 49             customer.setAge(age);
 50             customer.setEmail(strName + "@163.com");
 51             customer.setLastName(strName);
 52             customer.setBirthday(new Date());
 53             customer.setCreatedTime(new Date());
 54             
 55             Order order1 = new Order();
 56             order1.setOrderName("O-" + strName + "-1");
 57             
 58             Order order2 = new Order();
 59             order2.setOrderName("O-" + strName + "-2");
 60             
 61             //设置关联关系
 62             order1.setCustomer(customer);
 63             order2.setCustomer(customer);
 64             
 65             //持久化操作
 66             em.persist(customer);
 67             em.persist(order1);
 68             em.persist(order2);
 69         }
 70     }
 71     
 72     /**
 73      * 查询单向多对一关联关系的时候，默认情况下采用的是left outer join策略。
 74      * 可以通过 @ManyToOne(fetch=FetchType.LAZY) 来配置为懒加载查询策略
 75      */
 76     @Test
 77     public void testFind(){
 78         Order order = em.find(Order.class, 1);
 79         
 80         System.out.println("-----1------");
 81         System.out.println("orderName: " + order.getOrderName());
 82         
 83         System.out.println("-----2------");
 84         System.out.println("order.customer.email: " + order.getCustomer().getEmail());
 85     }
 86     
 87     @Test
 88     public void testRemove(){
 89         //删除多的一端可以随便删除
 90 //        Order order = em.find(Order.class, 1);
 91 //        em.remove(order);
 92         
 93         //删除1的一端的时候，如果还有多的一端引用它，则会删除失败
 94         Customer customer = em.find(Customer.class, 11);
 95         em.remove(customer);
 96     }
 97     
 98     @Test
 99     public void testUpdate(){
100         Customer customer = em.find(Customer.class, 12);
101         customer.setAge(1000);
102         
103         Order order = em.find(Order.class, 5);
104         order.setOrderName("OOOO");
105         order.getCustomer().setAge(1000);
106     }
107 }