jpa关联映射

jpa的对象关联映射主要通过注解来实现，分为一对多，多对多，一对一，这里只列出我实际项目中用到的，不打算写一些花哨的了。前面定义好了一个User实体类，这里再定义个订单实体类Order，一个用户可以有多个订单，一个订单只属于一个客户。

1、单向多对一
User实体：

@Entity
@Table(name = "t_user")
public class User {

    @Id//必须指定主键
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;

    @Column(name="user_name")
    private String userName;

    private String password;

    private String telephone;

    private String email;

    @Column(name="create_time")
    @Temporal(TemporalType.DATE)
    private Date createTime;


    //映射必须定义个空构造器
    public User() {
    }

    public User(String userName, String password, String telephone, String email, Date createTime) {
        super();
        this.userName = userName;
        this.password = password;
        this.telephone = telephone;
        this.email = email;
        this.createTime = createTime;
    }
    public String getUserInfo(){
        return "username:"+this.userName+",email:"+this.email;
    }
    get、set、toString方法
}

Order实体：

@Entity
@Table(name = "t_order")
public class Order {
    @Id
    @GeneratedValue
    private Long id;
    //付款金额
    private Integer payment;
    //支付方式 0:支付宝 1:微信
    private Integer channel;
    //支付状态
    private Integer status=0;
    //创建时间
    @Column(name="create_time")
    @Temporal(TemporalType.DATE)
    private Date createTime;

    //单向多对1，
    @ManyToOne(targetEntity=User.class,fetch=FetchType.LAZY)
    private User user;

    public Order() {
    }
    public Order(Integer payment, Integer channel, Integer status, Date createTime) {
        this.payment = payment;
        this.channel = channel;
        this.status = status;
        this.createTime = createTime;
    }
    get、set、toString方法
}

这里用户没有关联订单，订单关联了用户，所以订单实体有属性
private User user以及get、set方法。
映射单向多对一，使用注解@ManyToOne，使用@JoinColumn(name=”user_id”)指定外键列名为”user_id”，如果不写该注解的话，默认是属性名_id,上面的示例就没有指定外键列名，那么数据库表t_order的外键字段为user_id,但是这时需要指定实体类为User.class,否则执行持久化操作会抛出异常。
（1）、测试单向多对一持久化操作

public class TestMapper1 {
    private EntityManager entityManager;
    private EntityManagerFactory entityManagerFactory;
    private EntityTransaction transaction;

    @Before
    public void init(){
        entityManagerFactory = Persistence.createEntityManagerFactory("jpa-2");
        entityManager = entityManagerFactory.createEntityManager();
        transaction = entityManager.getTransaction();
        transaction.begin();
    }
    @After
    public void destory(){
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }
    @Test
    //多对一持久化操作
    public void testManyToOne(){
        Order order = new Order(1000, 0, 0, new Date());
        User user = new User("Lucy", "123456", "13322222226", "[e-mail]",new Date());
        //订单关联用户
        order.setUser(user);
        entityManager.persist(user);
        entityManager.persist(order);
    }
}

执行方法，控制台能看到两条插入语句。
查看数据库：


添加了订单记录，关联的用户id为14。

（2）、测试单向多对一查询操作

@Test
    //多对一查询
    public void testManyToOne2(){
        Order order = entityManager.find(Order.class, 1l);
        System.out.println("创建时间:"+order.getCreateTime());
        System.out.println("-----------------------------");
        System.out.println("用户信息:"+order.getUser());
    }

控制台输出：
Hibernate: 
    select
        order0_.id as id1_0_1_,
        order0_.channel as channel2_0_1_,
        order0_.create_time as create_t3_0_1_,
        order0_.payment as payment4_0_1_,
        order0_.status as status5_0_1_,
        order0_.user_id as user_id6_0_1_,
        user1_.id as id1_1_0_,
        user1_.create_time as create_t2_1_0_,
        user1_.email as email3_1_0_,
        user1_.password as password4_1_0_,
        user1_.telephone as telephon5_1_0_,
        user1_.user_name as user_nam6_1_0_ 
    from
        t_order order0_ 
    left outer join
        t_user user1_ 
            on order0_.user_id=user1_.id 
    where
        order0_.id=?
创建时间:2017-08-28
-----------------------------
用户信息:User [id=14, userName=Lucy, password=123456, telephone=13322222226, [e-mail]]

从发生的sql语句能看到，使用一条sql语句使用外连接将order关联的user的信息全部查了出来，也就是使用了立即加载策略。而hibernate的默认加载是懒加载，在jpa中如果要使用懒加载，可以修改@ManyToOne的属性fetch
分为：
FetchType.EAGER：立即加载（默认）
FetchType.LAZY：延迟加载

@ManyToOne(targetEntity=User.class,fetch=FetchType.LAZY)
    private User user;

这时候再执行上面的查询语句

Hibernate: 
    select
        order0_.id as id1_0_0_,
        order0_.channel as channel2_0_0_,
        order0_.create_time as create_t3_0_0_,
        order0_.payment as payment4_0_0_,
        order0_.status as status5_0_0_,
        order0_.user_id as user_id6_0_0_ 
    from
        t_order order0_ 
    where
        order0_.id=?
创建时间:2017-08-28
-----------------------------
Hibernate: 
    select
        user0_.id as id1_1_0_,
        user0_.create_time as create_t2_1_0_,
        user0_.email as email3_1_0_,
        user0_.password as password4_1_0_,
        user0_.telephone as telephon5_1_0_,
        user0_.user_name as user_nam6_1_0_ 
    from
        t_user user0_ 
    where
        user0_.id=?
用户信息:User [id=14, userName=Lucy, password=123456, telephone=13322222226, [e-mail]]

可以发现发送了两条sql，只有需要用到user的时候才进行查询

（3）、测试单向多对一删除
单向多对一删除如果先删除多的一方再删除一的一方是没问题的，但是先删除一的一方肯定是不能执行的，因为一的一方的主键为多的一方的外键，但是可以通过修改@OneToMany的cascade来修改默认的删除策略（级联删除），在一对多的测试时候演示。

    @Test
    //多对1删除
    public void testManyToOne3(){
        Order order = entityManager.find(Order.class, 1l);
        entityManager.remove(order);
    }

（4）、测试单向多对1修改

@Test
    //多对1修改
    public void testManyToOne4(){
        Order order = entityManager.find(Order.class, 1l);
        order.getUser().setUserName("jackson");
    }

输出：三条sql语句，第一条查询订单信息，由于懒加载第二条查询用户信息，最后执行update操作更新用户名。

2、单向一对多

修改User实体类，关联订单，一个用户拥有多个订单，一对多
添加属性

    @JoinColumn(name="user_id")
    @OneToMany
    private Set<Order> orders = new HashSet<>();
    get，set方法

注：外键是唯一的，知道外键列名必须跟Order实体类一致。

（1）、测试单向一对多持久化操作

@Test
    public void testOneToMany(){
        Order order = new Order(1000, 0, 0, new Date());
        Order order2 = new Order(999, 1, 0, new Date());
        User user = new User("Hession", "123456", "15822222226", "[e-mail]",new Date());
        //用户关联订单
        user.getOrders().add(order);
        user.getOrders().add(order2);
        //持久化操作
        entityManager.persist(user);
        entityManager.persist(order);
        entityManager.persist(order2);
    }

查看控制台输出语句：
一共五条：前三条是插入用户信息和两条订单记录语句。后两条是修改订单信息，添加两条订单记录的user_id,因为这时候外键由一的一方维护，必须一的一方插入后才能拿到id，然后才能设置外键（user_id）。

三条插入语句（一个用户2个订单）
两条更新语句如下：
Hibernate: 
    update
        t_order 
    set
        user_id=? 
    where
        id=?
Hibernate: 
    update
        t_order 
    set
        user_id=? 
    where
        id=?

（2）、测试单向一对多查询

@Test
    public void testManyToOne0(){
        User user = entityManager.find(User.class, 16l);
        System.out.println(user);
        System.out.println("---------------");
        System.out.println(user.getOrders().size());
    }

控制台输出：
Hibernate: 
    select
        user0_.id as id1_1_0_,
        user0_.create_time as create_t2_1_0_,
        user0_.email as email3_1_0_,
        user0_.password as password4_1_0_,
        user0_.telephone as telephon5_1_0_,
        user0_.user_name as user_nam6_1_0_ 
    from
        t_user user0_ 
    where
        user0_.id=?
User [id=16, userName=Hession, password=123456, telephone=15822222226, [e-mail]]
---------------
Hibernate: 
    select
        orders0_.user_id as user_id6_1_1_,
        orders0_.id as id1_0_1_,
        orders0_.id as id1_0_0_,
        orders0_.channel as channel2_0_0_,
        orders0_.create_time as create_t3_0_0_,
        orders0_.payment as payment4_0_0_,
        orders0_.status as status5_0_0_,
        orders0_.user_id as user_id6_0_0_ 
    from
        t_order orders0_ 
    where
        orders0_.user_id=?
2

从输出能看到，存在懒加载问题，默认策略跟多对一是相反的，同样可以修改@OneToMany的fetch来修改加载策略。

（3）、测试单向一对多删除

单向一对多删除，可以直接对一的一端删除

@Test
    public void testOneToMany2(){
        User user = entityManager.find(User.class, 16l);
        entityManager.remove(user);
    }

控制台输出：
Hibernate: 
    select
        user0_.id as id1_1_0_,
        user0_.create_time as create_t2_1_0_,
        user0_.email as email3_1_0_,
        user0_.password as password4_1_0_,
        user0_.telephone as telephon5_1_0_,
        user0_.user_name as user_nam6_1_0_ 
    from
        t_user user0_ 
    where
        user0_.id=?
Hibernate: 
    update
        t_order 
    set
        user_id=null 
    where
        user_id=?
Hibernate: 
    delete 
    from
        t_user 
    where
        id=?

从输出显而易见，先会将t_order表中关联的记录的user_id设为null，这时就不再关联该用户了，接着删除该用户。
注：如果想将该用户下的订单也删除，那么可以通过casecade属性来设置级联删除

    @JoinColumn(name="user_id")
    @OneToMany(cascade=CascadeType.REMOVE)
    private Set<Order> orders = new HashSet<>();

（4）、测试单向一对多修改

    @Test
    public void testOneToMany3(){
        User user = entityManager.find(User.class, 18l);
        user.getOrders().iterator().next().setPayment(1111);
    }

获取持久化状态的对象之间设置属性即可。

3、双向多对一

双向多对一关系，需要留意的是最好让一方维护外键，而外键是在多的一方，一般由多的一方维护外键即可。操作的话跟一对多，多对一是一样。

可以在一的一方来设置，放弃外键维护。

//@JoinColumn(name="user_id")
@OneToMany(fetch=FetchType.LAZY,cascade={CascadeType.REMOVE},mappedBy="user")
private Set<Order> orders = new HashSet<>();

mappedBy=”user”可以理解为一的一方放弃维护外键，外键由多的一方维护，user表示的是多的一方所持有的一的一方的属性。
一旦用了mappedBy，那么便不能再使用@JoinColumn(name=”user_id”)注解。

4、单向一对一
还是用上面的订单作为一方实体类，在自动售货机上使用扫描支付，那么订单和商品就是一对一的关系，添加商品实体类Goods。
由商品实体类来维护关联关系（没必要两边都维护，@OneToOne注解在一边使用即可，包括前面的一对多多对一，通常注解在一边使用即可）。

@Entity
@Table(name="t_goods")
public class Goods {

    @Id
    @GeneratedValue
    private long id;
    private String name;
    private Integer price;

    @Column(name="create_time")
    @Temporal(TemporalType.DATE)
    private Date createTime;

    //一对一关联
    @OneToOne
    private Order order;

    public Goods(String name, Integer price, Date createTime) {
        this.name = name;
        this.price = price;
        this.createTime = createTime;
    }

    public Goods() {
    }
    get、set方法
}

（1）、测试持久化操作

public void testOneToOne(){
        Order order = new Order(2222, 1, 0, new Date());
        Goods goods = new Goods("健力宝", 250, new Date());
        //商品关联订单
        goods.setOrder(order);
        //持久化操作
        entityManager.persist(order);
        entityManager.persist(goods);
    }

控制台会打印两条插入到两个表t_order,t_goods记录的语句，查看数据库表


插入了数据且已经关联。

至于多对多也是类似，实际使用中建议注解@ManyToMany使用在一边即可（多对多跟hibernate一样必然有一方要放弃维护外键）。

总结：不管是一对多还是多对一，还是一对一还是多对多，或是单向双向。最后使用的时候一般都可以只用单向，即在一方使用注解，最后需要的数据都是能查询到的而不用像学习的时候整的过于繁琐。