Hibernate的注解方式：多对多双向关系基于外键关联

我们将创建两个pojo类，User和Lesson类，还有一个测试类Test，以及Usert对应的数据库表user表，Lesson对应的数据库表lesson表，还有两个数据库表对应的桥表user_and_lesson表（起一个连接的作用），桥表中分别有两个外键，对应于User表和Lesson表的主键id。

//User类
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity //说明该类为一个实体bean
@Table(name="user")  //说明该类映射的表（若类名和表名一样，则可以不写name属性（忽略大小写））
public class User {

private Integer id;
private String name;
private Set<Lesson> lessons = new HashSet<Lesson>();
public User() {

}
public User(Integer id, String name, Set<Lesson> lessons) {
this.id = id;
this.name = name;
this.lessons = lessons;
}
@Id //声明id
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//声明多对多关系，下面的注解也可以写在另一个类中，相应的另一个类中的注解就要写在这个类中
@ManyToMany(cascade=CascadeType.ALL) //cascade说明所有级联，就是和这个类对应表有关的操作所关联的数据都会被相应的操作所影响（牵一发而动全身）
@JoinTable(name="lesson_and_user",joinColumns={@JoinColumn(name="user_id")},inverseJoinColumns={@JoinColumn(name="lesson_id")})
//JoinTable注解的name属性的值lesson_and_user为user表和lesson表的桥表，user_id为桥表对应user表的外键，lesson_id为桥表对应lesson表的外键
public Set<Lesson> getLessons() {
return lessons;
}
public void setLessons(Set<Lesson> lessons) {
this.lessons = lessons;
}
@Override
public String toString() {
return "User [id=" + id + ", name=" + name + ", lessons=" + lessons + "]";
}
}

//Lesson类
import java.util.HashSet;
import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name="lesson")
public class Lesson {
private Integer id;
private String name;
private Set<User> users = new HashSet<User>();

public Lesson(){

}

public Lesson(Integer id, String name, Set<User> users) {
this.id = id;
this.name = name;
this.users = users;
}

@Id
public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public String getName() {
return name;
}

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

@ManyToMany(mappedBy="lessons") //lessons为另一类User类中的lessons属性
public Set<User> getUsers() {
return users;
}

public void setUsers(Set<User> users) {
this.users = users;
}

@Override
public String toString() {
return "Lesson [id=" + id + ", name=" + name + "]";
}

}

user表

create table user(
id int(11) primary key,
name varchar(20) not null
);

lesson表

create table user(
id int(11) primary key,
name varchar(20) not null
);

桥表user_and_lesson

create table user(
id int(11) primary key,
name varchar(20) not null
);

在hibernate正确的配置中添加：
<mapping class="com.liukun.association.many2many.pojo.User"/>

<mapping class="com.liukun.association.many2many.pojo.Lesson"/>

即通知Hibernate映射的pojo类。

//Test测试类
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.liukun.association.many2many.pojo.Lesson;
import com.liukun.association.many2many.pojo.User;
import com.liukun.common.HibernateSessionFactory;

public class Test {

public static void main(String[] args) {
User u1 = new User();
u1.setId(1);
u1.setName("张三");

User u2 = new User();
u2.setId(2);
u2.setName("李四");

Lesson le1 = new Lesson();
le1.setId(1);
le1.setName("数据结构");

Lesson le2 = new Lesson();
le2.setId(2);
le2.setName("JAVA课");

u1.getLessons().add(le1);
u1.getLessons().add(le2);

u2.getLessons().add(le1);
u2.getLessons().add(le2);

le1.getUsers().add(u1);
le1.getUsers().add(u2);

le2.getUsers().add(u1);
le2.getUsers().add(u2);

Transaction trans = null;

try{
//这里HibernateSessionFactory.getSession()是我自己封装的获取Session的方法，你可以自己写
Session session = HibernateSessionFactory.getSession();
trans = session.beginTransaction();
//			User u = (User)session.get(User.class, 1);
//			System.out.println(u.getName()+":"+u.getLessons());
session.save(u1);
session.save(u2);

trans.commit();

}catch(Exception ex){
ex.printStackTrace();
trans.rollback();
}
}

}

//HibernateSessionFactory类
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class HibernateSessionFactory {
public static Configuration config;
public static SessionFactory factory;

static{
config= new Configuration().configure();
ServiceRegistryBuilder builder = new ServiceRegistryBuilder();
builder.applySettings(config.getProperties());
ServiceRegistry serviceRegistry = builder.buildServiceRegistry();
factory = config.buildSessionFactory(serviceRegistry);
}

public static Session getSession(){
//获得当前线程所绑定的session对象
Session session = factory.getCurrentSession();
return session;

}
}

这样我们就实现了hibernate注解的多对多双向关联关系。多对多无非就是在两个对应的类中添加一个对方类的集合，可以使set，list，map等。单向的多对多只是把一方的类中的对方类的集合属性去掉就行。