Hibernate基于注解annotation的配置

最新推荐文章于 2024-11-03 11:01:20 发布

awv94517

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量242

点赞数

文章标签： java 数据库 php

原文链接：http://www.cnblogs.com/Joke-Jay/p/8920504.html

版权

Annotation在框架中是越来越受欢迎了，因为annotation的配置比起XML的配置来说方便了很多，不需要大量的XML来书写，方便简单了很多，只要几个annotation的配置，就可以完成我们以前需要书写的大量的XML文件。当然annotation的配置也有缺陷的，那就是annotation一般都是配置在代码中的，如果要修改的话，需要动源代码，丧失了灵活性，违背了OCP（增加开放，修改关闭）原则，但是在真实的项目开发中，我们只是动配置文件，而不修改源代码的情况实在是太少见了，所以现在annotation已经被广泛的运用到了编程中，各种框架都提供了基于annotation的配置。

hibernate的注解配置和Jpa中的注解使用基本上都差不多。

参考博客：

https://blog.csdn.net/ervinbao/article/details/52861000

https://www.cnblogs.com/liangxinxinbo/p/6092664.html

http://www.ilt.me/dmfx/89.html

导入jar包：

还有mysql的驱动

----------------------

简单的插入测试小案例：

实体：User

package org.model;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

@Entity
// @Table(name="t_user")//表名 默认不写的话 就是类名
public class User {
    private int id;
    private String username;
    private String password;
    private String nickname;
    private Date bornDate;

    public User() {
    }

    public User(int id, String username, String password, String nickname, Date bornDate) {
        super();
        this.id = id;
        this.username = username;
        this.password = password;
        this.nickname = nickname;
        this.bornDate = bornDate;
    }

    public User(String username, String password, String nickname, Date bornDate) {
        super();
        this.username = username;
        this.password = password;
        this.nickname = nickname;
        this.bornDate = bornDate;
    }

    @Id
    @GeneratedValue()//默认native @GeneratedValue()
    //@GeneratedValue(generator = "x") //  使用uuid id的类型必须是String类型
    //@GenericGenerator(name = "x", strategy = "uuid") // 使用hibernate的uuid策略
    public int getId() {
        return id;
    }

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

    @Column(length = 5, nullable = false)
    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Column(length = 10, nullable = false)//nullable属性：默认是true  允许空值
    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Column(length = 5, nullable = true)
    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    @Column(name = "born_date")
    public Date getBornDate() {
        return bornDate;
    }

    public void setBornDate(Date bornDate) {
        this.bornDate = bornDate;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", password=" + password + ", nickname=" + nickname
                + ", bornDate=" + bornDate + "]";
    }

}

测试类：

package org.execute;

import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
import org.model.User;

public class Exe {
    static Configuration config = null;
    static SessionFactory sessionFactory = null;

    // 初始化
    static {
        // 加载核心配置文件 默认加载类路径下的hibernate.cfg.xml
        config = new Configuration();
        config.configure();
        // 创建工厂
        sessionFactory = config.buildSessionFactory();
    }

    // 返回session
    public Session rtn() {
        return sessionFactory.openSession();
    }

    // 保存测试
    @Test
    public void insert() {
        Session session = rtn();
        session.getTransaction().begin();
        User u = new User("laomu", "123", "老孙", new Date());
        session.save(u);
        session.getTransaction().commit();
    }

}

我们发现在对实体进行注解配置的时候导入的包和JPA配置时一样

在测试类中进行插入时，使用的不是JPA中的EntityManager对象，

EntityManagerFactory factory=Persistence.createEntityManagerFactory("simple");
EntityManager em = factory.createEntityManager();

而还是hibernate中的session对象。

配置文件：类路径下的hibernate.cfg.xml文件默认会去找该文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>

    <session-factory>
        <property name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <property name="hibernate.hbm2ddl.auto">update</property>
            <!--控制台打印sql语句-->
        <property name="connection.url">
            jdbc:mysql://localhost:3308/annotationhibernate
        </property>
        <property name="connection.username">root</property>
        <property name="connection.password">jay571018</property>
        <property name="connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
    
        <property name="show_sql">true</property>
        <!--     
        <mapping resource="org/model/Course.hbm.xml" />
        <mapping resource="org/model/Student.hbm.xml" /> 
        -->
        
        <mapping class="org.model.User"/>
    </session-factory>

</hibernate-configuration>

View Code

下面观察数据库：

插入的数据：

-------------------------------------------------

annotation配置many-to-one双向

先看有问题的代码：(明明配置了级联但是却没有进行级联保存的问题)

多方：Student

package org.model;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

//多方  由该方维护外键
@Entity
@Table(name = "t_student")
public class Student {
    private int id;
    private String name;
    private String stuNo;
    // 一方的属性
    private ClassRoom room;

    @Id
    @GeneratedValue()
    public int getId() {
        return id;
    }

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

    @Column(length = 5, nullable = false)
    public String getName() {
        return name;
    }

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

    @Column(length = 10, nullable = false)
    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    // optional=false 外键字段不能为空 即每个学生都必须有对应的班级 默认为true
    // ManyToOne 查询student 默认使用即时加载
    @ManyToOne(cascade = { CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH })
    // 在维护端 指定外键字段名 也可以不写 默认属性_id
    @JoinColumn(name = "r_id")
    public ClassRoom getRoom() {
        return room;
    }

    public void setRoom(ClassRoom room) {
        this.room = room;
    }

    public Student() {
    }

    // 互相关联的方法
    public Student(String name, String stuNo) {
        this.name = name;
        this.stuNo = stuNo;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", stuNo=" + stuNo + ", classRoom=" + room.toString() + "]";
    }

}

一方：ClassRoom

package org.model;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;

//一方  被维护端
@Entity
@Table(name = "t_classroom")
public class ClassRoom {
    private int id;
    private String name;
    // 多方的集合属性
    private Set<Student> students = new HashSet<Student>();

    @Id
    @GeneratedValue()
    public int getId() {
        return id;
    }

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

    @Column(length = 10, nullable = false)
    public String getName() {
        return name;
    }

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

    // mappedBy属性：由集合中对应的实体Student中的classroom属性来维护外键 声明mappedBy的实体为被维护方
    // 抓取方式 onetoMany 默认为lazy加载
    @OneToMany(cascade = { CascadeType.MERGE, CascadeType.PERSIST, CascadeType.REFRESH }, mappedBy = "room")
    public Set<Student> getStudents() {
        return students;
    }

    public void setStudents(Set<Student> students) {
        this.students = students;
    }

    public ClassRoom(String name) {
        this.name = name;
    }
    
    public ClassRoom() {}
    /*
     * public ClassRoom(int id,String name) { this.id=id; this.name = name; }
     */

    
    // 互相关联的方法
    public void addStudent(Student student) {
        student.setRoom(this);
        this.students.add(student);
    }

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

}

测试类：

    //一对多插入测试
    @Test
    public void oneToManyInsert() {
        Session session=rtn();
        session.getTransaction().begin();
        //创建对象
        Student s1=new Student("乔克","A01010");
        Student s2=new Student("小明","A01012");
        ClassRoom classRoom=new ClassRoom("就业班");
        //进行互相关联
        classRoom.addStudent(s1);
        classRoom.addStudent(s2);//在addStudent（）中进行了互相关联   这里直接调用这个方法即完成了互相关联
        //进行持久化操作
        session.save(classRoom);
        session.getTransaction().commit();
    }

然后查看数据库：

可以看到只对classRoom表进行了数据的插入可以我们在实体中明明配置了级联保存的操作啊同时也进行了互相的关联为啥会出现这种情况呢？

还记得学习JPA时级联操作触发的时机吗？----》如果使用javax.persistence.*里面的注解，只有调用相应的方法才生效，如PERSIST，只有调用persist方法才生效

所以这里当然不能实现级联了

https://blog.csdn.net/l1028386804/article/details/17686229

https://blog.csdn.net/z69183787/article/details/22327725

第一种测试：

根据网上说的情况我了试试如果把ClassRoom中的级联属性配置为以下的情况：

CascadeType.PESIST,CascadeType.REMOVE,CascadeType.MERGE,CascadeType.REFRESH

也不能进行级联保存，但是，如果配置为CascadeType.All则可以级联保存成功，说明

JPA中的CascadeType.ALL并不等于{CascadeType.PESIST,CascadeType.REMOVE,CascadeType.MERGE,CascadeType.REFRESH}

第二种测试：

然后我把级联属性设置成了上面说的那种方式save_update 注意导入的是hibernate.annotation中的包而不再是jpa中的级联包了

roomClass中的级联方式修改为：

测试结果：

级联保存成功，所以这里需要明白，hibernate注解开发设置级联时不能使用jpa规范中的级联方式，而只能是使用自己提供的级联方式，如下：

---------------------------------------

上面进行了插入测试，下面我们进行查询测试：

可见只查询了一次数据库，在查询student对象(多方) 立即查询一方数据

因为我们在student中是这样配置的

抓取方式在ManyToOne情况下默认直接加载了一方属性如果改为下面的配置方式：

执行查询观察打印的sql

可以看到是发送了两次sql查询同样在执行查询一方属性时不指定查询方式时默认是懒加载多方属性的这里就不再执行了

需要注意的一点是：在查询某个实体的时候需要在该实体中配置一个无参数的构造方法比如我把student实体中的无参构造删除掉然后执行查询

所以因为框架中好多地方都会用到无参构造在我们创建有参构造的时候记得把无参构造也写出来。

---------------------------------------------------------------

annotation配置many-to-one单向

student

package org.model.om.danxiang;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name = "danxiang_student")
public class Student {
    private int id;
    private String name;
    private String stuNo;
    // 一方的属性
    private ClassRoom room;

    @Id
    @GeneratedValue()
    public int getId() {
        return id;
    }

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

    @Column(length = 5, nullable = false)
    public String getName() {
        return name;
    }

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

    @Column(length = 10, nullable = false)
    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    // optional=false 外键字段不能为空 即每个学生都必须有对应的班级 默认为true
    // ManyToOne 查询student 默认使用即时加载
    //使用hibernate自己的级联方式
    @ManyToOne()
    //@Cascade({CascadeType.PERSIST,CascadeType.MERGE,CascadeType.REFRESH})
    // 在维护端 指定外键字段名 也可以不写 默认属性_id
    @JoinColumn(name = "cid")
    public ClassRoom getRoom() {
        return room;
    }

    public void setRoom(ClassRoom classRoom) {
        this.room = classRoom;
    }
    
    public Student() {
    }

    // 互相关联的方法
    public Student(String name, String stuNo) {
        this.name = name;
        this.stuNo = stuNo;
    }

    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", stuNo=" + stuNo + ", classRoom=" + room.toString() + "]";
    }

}

classRoom

package org.model.om.danxiang;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

//一方  被维护端
@Entity
@Table(name = "danxiang_classroom")
public class ClassRoom {
    private int id;
    private String name;
    /*
    // 多方的集合属性
    private Set<Student> students = new HashSet<Student>();*/

    @Id
    @GeneratedValue()
    public int getId() {
        return id;
    }

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

    @Column(length = 10, nullable = false)
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    /*
    // mappedBy属性：由集合中对应的实体Student中的classroom属性来维护外键 声明mappedBy的实体为被维护方
    // 抓取方式 onetoMany 默认为lazy加载
    //使用hibernate自己的级联方式
    @OneToMany(mappedBy = "room")
    @Cascade({CascadeType.PERSIST,CascadeType.MERGE,CascadeType.REFRESH})
    public Set<Student> getStudents() {
        return students;
    }

    public void setStudents(Set<Student> students) {
        this.students = students;
    }*/

    public ClassRoom(String name) {
        this.name = name;
    }
    
    public ClassRoom() {}
    /*
     * public ClassRoom(int id,String name) { this.id=id; this.name = name; }
     */

    /*
    // 互相关联的方法
    public void addStudent(Student student) {
        student.setRoom(this);
        this.students.add(student);
    }*/

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

}

测试：

    //单向  一方classroom中不创建集合   只在多方student中创建一方对象 ---》 测试成功
    //所以  单向方式操作时  只能是：在多方对象中创建一方对象属性   在一方中省略创建多方的集合属性    反之则不行  比如测试2
    @Test
    public void oneToManyInsertDanXiang() {
        Session session=rtn();
        session.getTransaction().begin();
        //创建对象
        org.model.om.danxiang.Student s1=new org.model.om.danxiang.Student("乔克","A01010");
        org.model.om.danxiang.Student s2=new org.model.om.danxiang.Student("乔克2","A01012");
        
        org.model.om.danxiang.ClassRoom classRoom=new org.model.om.danxiang.ClassRoom("就业班");
        //进行互相关联
        s1.setRoom(classRoom);
        s2.setRoom(classRoom);
        //保存
        session.save(classRoom);//保存的顺序无关
        session.save(s1);
        session.save(s2);
        
        //classRoom.addStudent(s1);
        //classRoom.addStudent(s2);//在addStudent（）中进行了互相关联   这里直接调用这个方法即完成了互相关联
        //进行持久化操作
        session.save(classRoom);
        session.getTransaction().commit();
    }

查询测试：

    //单向查询
    @Test
    public void oneToManyInsertDanXiangQuery() {
        Session session=rtn();
        //查询多方   观察是否同时查询一方数据
        org.model.om.danxiang.Student student = session.get(org.model.om.danxiang.Student.class,67);
        System.out.println(student);
    }

单向关系，查询多方的时候，可以顺带查询一方的数据但是不能通过查询一方同时获得多方的数据但是双向关系就可以查询ClassRoom时可以选择即使加载或者懒加载多方属性然后通过ClassRoom中的students属性就可以得到多方集合数据

-----------------------------------------------

openSession和getCurrentSession的区别：

使用getCurrentSession时出现下面错误是因为没有开启事务

开启事务就可以解决该问题

---------------------------------------------------

annotation配置many-to-one双向

Person

package org.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;

//一对一双向实体  person作为维护方
@Entity
@Table(name = "t_person")
public class Person {
    private int id;// 主键
    private String name;// 姓名
    private IDCard idCard;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

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

    // 这里暂时不配置 数据库默认字段为name 可以为空 长度255
    public String getName() {
        return name;
    }

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

    @OneToOne
    @JoinColumn(name = "cardid")
    @Cascade(value = { CascadeType.ALL })
    public IDCard getIdCard() {
        return idCard;
    }

    public void setIdCard(IDCard idCard) {
        this.idCard = idCard;
    }

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

}

IDCard

package org.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;

//一对一双向实体
@Entity
@Table(name = "t_card")
public class IDCard {
    private int id;// 主键
    private String no;// 编号
    private Person person;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

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

    public String getNo() {
        return no;
    }

    public void setNo(String no) {
        this.no = no;
    }

    @OneToOne(mappedBy = "idCard")
    @Cascade(value = { CascadeType.ALL })
    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

    @Override
    public String toString() {
        return "IDCard [id=" + id + ", no=" + no + ", person=" + person + "]";
    }

}

测试

//一对一双向关联
    @Test
    public void oneToOne() {
        Session session=rtn();
        session.getTransaction().begin();
        //创建person对象
        Person p=new Person();
        p.setName("张三");
        //创建IDCard对象
        IDCard idCard=new IDCard();
        idCard.setNo("xx1");
        //进行相互关联
        /**
         * 如果没有配置级联保存的话  那么需要相互关联  并且还要分别保存
        p.setIdCard(idCard);
        idCard.setPerson(p);
        session.save(idCard);
        session.save(p);
        */
        //配置级联之后 
        p.setIdCard(idCard);
        session.save(p);
        session.getTransaction().commit();
        session.close();
    }

数据库:

-------------------------------------

annotation配置many-to-many

user

package org.model.mm.shuangxiang;

import java.util.Date;
import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
@Entity
@Table(name="mm_user")
//规定该实体为外键维护方
public class User {
    private int id;
    private String username;
    private String password;
    private String nickname;
    private Date bornDate;
    private Set<Role> roles;
    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(length=10,nullable=false)
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    @Column(length=10,nullable=false)
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Column(length=10,nullable=false)
    public String getNickname() {
        return nickname;
    }
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
    @Temporal(TemporalType.TIMESTAMP)//日期 时间 yyyy-dd-mm HH:MM:SS
    public Date getBornDate() {
        return bornDate;
    }
    public void setBornDate(Date bornDate) {
        this.bornDate = bornDate;
    }
    //以m打头   默认加载方式为lazy
    @ManyToMany()
    @Cascade(value= {CascadeType.ALL})
    /**
    @JoinTable(
    name="u_r",//中间表名称
    joinColumns=@JoinColumn(name="uid"),//本实体在中间表中创建的字段名
    inverseJoinColumns= @JoinColumn(name="rid"))//关联实体在中间表中创建的字段名 
    //以上内容可以省略不写  有默认值
    */
    public Set<Role> getRoles() {
        return roles;
    }
    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }
    public User(String username, String password, String nickname, Date bornDate) {
        super();
        this.username = username;
        this.password = password;
        this.nickname = nickname;
        this.bornDate = bornDate;
    }
    public User() {}
    
}

role

package org.model.mm.shuangxiang;

import java.util.Set;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;

@Entity
@Table(name = "mm_role")
public class Role {
    private int id;
    private String name;
    private Set<User> users;
    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
    @Column(length=10,nullable=false)
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    @ManyToMany(mappedBy="roles")
    @Cascade(value= {CascadeType.ALL})
    public Set<User> getUsers() {
        return users;
    }

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

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

    public Role(String name) {
        super();
        this.name = name;
    }
    public Role() {}
    

}

测试：

//多对多不拆分
    @Test
    public void manyToMany() {
        Session session=rtn();
        session.getTransaction().begin();
        //创建user对象
        org.model.mm.shuangxiang.User user1=new org.model.mm.shuangxiang.User("zhang","123","小张",new Date());
        //org.model.mm.shuangxiang.User user2=new org.model.mm.shuangxiang.User("wang","123","小王",new Date());
        //org.model.mm.shuangxiang.User user3=new org.model.mm.shuangxiang.User("sun","123","小孙",new Date());
    
        //创建role对象
        Role role1=new Role("总监");
        Role role2=new Role("保安");
        Role role3=new Role("菜鸟");
        //创建集合
        Set<Role> roles=new HashSet<Role>();
        roles.add(role1);
        roles.add(role2);
        roles.add(role3);
        //进行关联  
        user1.setRoles(roles);
        //保存user对象
        session.save(user1);
        session.getTransaction().commit();
        session.close();
    }

数据库：

-----------------------------------------

annotation配置many-to-many变种拆分为两个一对多

Student

package org.model.mm.shuangxiang2;

import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;

@Entity
@Table(name = "mm_student")
public class Student {
    private int id;
    private String name;
    private String stuNo;
    private Set<StudentCourse> tcs;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

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

    @Column(length = 10, nullable = false)
    public String getName() {
        return name;
    }

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

    @Column(length = 10, nullable = false)
    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    // 与中间表相比 是一方 被维护端
    @OneToMany(mappedBy = "student")
    @Cascade(value = { CascadeType.ALL })
    public Set<StudentCourse> getTcs() {
        return tcs;
    }

    public void setTcs(Set<StudentCourse> tcs) {
        this.tcs = tcs;
    }

    public Student() {
    }

    public Student(String name, String stuNo) {
        this.name = name;
        this.stuNo = stuNo;
    }
}

Course

package org.model.mm.shuangxiang2;

import java.util.Set;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;

@Entity
@Table(name = "mm_course")
public class Course {
    private int id;
    private String name;
    private Set<StudentCourse> tcs;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

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

    @Column(length = 10, nullable = false)
    public String getName() {
        return name;
    }

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

    // 是一方 被维护端
    @OneToMany(mappedBy = "course")
    @Cascade(value = { CascadeType.ALL })
    public Set<StudentCourse> getTcs() {
        return tcs;
    }

    public void setTcs(Set<StudentCourse> tcs) {
        this.tcs = tcs;
    }

    public Course() {
    }

    public Course(String name) {
        this.name = name;
    }

}

中间实体 StudentCourse

package org.model.mm.shuangxiang2;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;

@Entity
@Table(name = "mm_SC") // 指定中间表名称
public class StudentCourse {
    private int id;
    private double score;
    private Student student;
    private Course course;

    @Id
    @GeneratedValue
    public int getId() {
        return id;
    }

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

    @Column(length = 5, nullable = false)
    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    // 多方维护外键 指定中间表外键名称为student_ID
    @ManyToOne()
    @Cascade(value = { CascadeType.ALL })
    @JoinColumn(name = "student_ID")
    public Student getStudent() {
        return student;
    }

    public void setStudent(Student student) {
        this.student = student;
    }

    // 多方维护外键 指定中间表外键名称为course_ID
    @ManyToOne()
    @Cascade(value = { CascadeType.ALL })
    @JoinColumn(name = "course_ID") // 多方作为维护端
    public Course getCourse() {
        return course;
    }

    public void setCourse(Course course) {
        this.course = course;
    }

    public StudentCourse(double score, Student student, Course course) {
        super();
        this.score = score;
        this.student = student;
        this.course = course;
    }

    public StudentCourse() {
    }

}

配置文件中引入：

测试：

//多对多  拆分为两个一对多
    @Test
    public void manyToMany2() {
        Session session=rtn();
        session.getTransaction().begin();
        //创建2个student对象
        org.model.mm.shuangxiang2.Student student1=new org.model.mm.shuangxiang2.Student("zhang","141164000");
        org.model.mm.shuangxiang2.Student student2=new org.model.mm.shuangxiang2.Student("wang","141164888");
        //创建2个course对象
        Course course1=new Course("java");
        Course course2=new Course("php");
        //创建studentCourse对象  把创建的student course加入进去
        //学生1的两门课成绩
        StudentCourse sc1=new StudentCourse(88.5,student1,course1);
        StudentCourse sc2=new StudentCourse(99.5,student1,course2);
        //学生2的两门课成绩
        StudentCourse sc3=new StudentCourse(66.5,student2,course1);
        StudentCourse sc4=new StudentCourse(49.5,student2,course2);
        //保存维护端对象  studentcourse
        session.save(sc1);
        session.save(sc2);
        session.save(sc3);
        session.save(sc4);
        session.getTransaction().commit();
        session.close();
    }