JPA-映射双向多对多关联关系

不维护关联关系的一端

@Entity
@Table(name="item")
public class Item {
    
    private Integer id;
    private String itemname;
    private Set<Category> items=new HashSet<>();
    
    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getItemname() {
        return itemname;
    }
    public void setItemname(String itemname) {
        this.itemname = itemname;
    }
    
    @ManyToMany(mappedBy="categories")
    public Set<Category> getItems() {
        return items;
    }
    public void setItems(Set<Category> items) {
        this.items = items;
    } 
}

维护关联关系的一端

@Entity
@Table(name="category")
public class Category {
    
    private Integer id;
    private String categoryname;
    private Set<Item> categories=new HashSet<>();
    
    @Id
    @GeneratedValue
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getCategoryname() {
        return categoryname;
    }
    public void setCategoryname(String categoryname) {
        this.categoryname = categoryname;
    }
    
    //使用@ManyToMany 来映射多对多关联关系
    //使用@JoinTable 来映射中间表
    //1.name 指向中间表的名字
    //2.joinColumns 映射当前类所在的表在中间表的外键
    //2.1 name指定外键列的列名
    //2.2 referencedColumnName指定外键列关联当前表的哪一列
    //3.inverseJoinColumns 映射关联的类在中间表的外键
    @ManyToMany
    @JoinTable(name="category_item",
    joinColumns={@JoinColumn(name="category_id",referencedColumnName="id")},
    inverseJoinColumns={@JoinColumn(name="item_id",referencedColumnName="id")})
    public Set<Item> getCategories() {
        return categories;
    }
    public void setCategories(Set<Item> categories) {
        this.categories = categories;
    }
}

@Tset

public class JPATest {

    private EntityManager entityManager;
    private EntityTransaction transaction;
    private EntityManagerFactory entityManagerFactory;

    @Before
    public void setUp() throws Exception {
        entityManagerFactory = Persistence.createEntityManagerFactory("jpa-1");
        entityManager = entityManagerFactory.createEntityManager();
        transaction = entityManager.getTransaction();
        transaction.begin();
    }

    @After
    public void destroy() {
        transaction.commit();
        entityManager.close();
        entityManagerFactory.close();
    }
    
    //对于关联的集合对象,默认使用懒加载策略
    //获取维护关联关系的一端还是不维护关联关系的一端,SQL语句相同
    @Test
    public void testManyToManyFind(){
        Item item = entityManager.find(Item.class, 1);
        System.out.println(item.getItemname());
        System.out.println(item.getItems().size());
        
        Category category = entityManager.find(Category.class, 1);
        System.out.println(category.getCategoryname());
        System.out.println(category.getCategories().size());
    }
    
    //多对多的保存
    @Test
    public void testManyToManyPersist(){
        Item i1 = new Item();
        Item i2 = new Item();
        i1.setItemname("i1");
        i2.setItemname("i2");
        Category c1 = new Category();
        Category c2 = new Category();
        c1.setCategoryname("c1");
        c2.setCategoryname("c2");
        //设置关联关系
        i1.getItems().add(c1);
        i1.getItems().add(c2);
        i2.getItems().add(c1);
        i2.getItems().add(c2);
        c1.getCategories().add(i1);
        c1.getCategories().add(i2);
        c2.getCategories().add(i1);
        c2.getCategories().add(i2);
        //执行保存操作
        entityManager.persist(i1);
        entityManager.persist(i2);
        entityManager.persist(c1);
        entityManager.persist(c2);
    }
}