hibernate 双向多对多 注解

其实它的和 一对多 差不多，但是按照网上写法出现了一个问题，使得 双向的关系变成了单向的。

Person类

package cn.lzg;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

@Entity
@Table(name = "person_lzg")
public class Person {

	@Id
	@SequenceGenerator(name = "person_lzg", sequenceName = "p_seq", allocationSize = 1)
	@GeneratedValue(generator = "person_lzg", strategy = GenerationType.SEQUENCE)
	private Long p_id;

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

	@ManyToMany(targetEntity = cn.lzg.Book.class, fetch = FetchType.LAZY)
	@JoinTable(name = "lzgp_lzgb", joinColumns = { @JoinColumn(name = "p_id") }, inverseJoinColumns = { @JoinColumn(name = "b_id") })
	// name中间表的名字,第一个自己的主键，第二个关联的主键
	private List<Book> books = new ArrayList<Book>();

	public Long getP_id() {
		return p_id;
	}

	public void setP_id(Long p_id) {
		this.p_id = p_id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public List<Book> getBooks() {
		return books;
	}

	public void setBooks(List<Book> books) {
		this.books = books;
	}

}

Book类

package cn.lzg;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

@Entity
@Table(name = "book_lzg")
public class Book {
	@Id
	@SequenceGenerator(name = "book_lzg", sequenceName = "b_seq", allocationSize = 1)
	@GeneratedValue(generator = "book_lzg", strategy = GenerationType.SEQUENCE)
	private Long b_id;

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

	@ManyToMany(targetEntity = cn.lzg.Person.class, fetch = FetchType.LAZY)
	<span style="color:#FF0000;">// 如果在上面使用mappedBy后,就成单向的了.也就是mappedBy出现的位置所在的类,这个类是被维护端,它只能被别人级联,不能去保存别人.
	// 这个问题搞了好久才发现，开始一直是单向的.</span>
	@JoinTable(name = "lzgp_lzgb", joinColumns = { @JoinColumn(name = "b_id") }, inverseJoinColumns = { @JoinColumn(name = "p_id") })
	private List<Person> persons = new ArrayList<Person>();

	public Long getB_id() {
		return b_id;
	}

	public void setB_id(Long b_id) {
		this.b_id = b_id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public List<Person> getPersons() {
		return persons;
	}

	public void setPersons(List<Person> persons) {
		this.persons = persons;
	}

}

注意

<span style="color:#FF0000;">如果在上面ManyToMany注解中使用mappedBy,就成单向的了.因为mappedBy出现的位置所在的类,这个类是被维护端,它只能被别人级联,不能去保存别人

<span style="color:#330033;">测试类
</span></span><pre name="code" class="java">package cn.lzg;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.Test;

public class TestHibernate {
	private static Configuration configuration = null;
	private static SessionFactory sessionFactory = null;
	private static ServiceRegistry serviceRegistry = null;
	private static Session session = null;

	static {
		/**
		 * hibernate 4 貌失要这样获得sessionFactory 以前的configuration.buildSessionFactory();方法 过时了
		 */
		configuration = new Configuration().configure();

		serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties())
				.buildServiceRegistry();

		sessionFactory = configuration.buildSessionFactory(serviceRegistry);
		session = sessionFactory.openSession();
	}



	@Test
	// 测试manytomany
	public void testM2M() {
		Person p1 = new Person();
		p1.setName("张三");
		Person p2 = new Person();
		p2.setName("李四");
		Person p3 = new Person();
		p3.setName("王五");
		List<Person> persons = new ArrayList<Person>();
		persons.add(p1);
		persons.add(p2);
		persons.add(p3);

		Book b1 = new Book();
		b1.setName("书本1");
		Book b2 = new Book();
		b2.setName("书本2");
		Book b3 = new Book();
		b3.setName("书本3");
		List<Book> books = new ArrayList<Book>();
		books.add(b1);
		books.add(b2);
		books.add(b3);

		p1.setBooks(books);
		b3.setPersons(persons);

		Transaction tx = session.beginTransaction();
		session.save(p1);
		session.save(p2);
		session.save(p3);
		session.save(b1);
		session.save(b2);
		session.save(b3);
		tx.commit();
		session.close();
	}
}

结果生成了中间表

lzgp_lzgb 里面的关系p1 有三本书， p1,p2,p3都有b3