IDEA+MAVEN 实现hiberate 一对一，一对多，多对多 操作（代码笔记）

直接上步骤：

1.修改pom.xml,添加hibernate相关包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.htt.hibernate</groupId>
    <artifactId>Hibernate_Test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>5.3.6.Final</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.0</version>
        </dependency>

    </dependencies>
</project>

2.在resources里面添加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>
        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/javaweb?serverTimezone=UTC</property>
        <property name="connection.username">...</property>
        <property name="connection.password">...</property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <!--指定映射文件路径-->
        <!--<mapping class="UserMod" />-->
        <mapping resource="Grade.hbm.xml"/>
        <mapping resource="Student.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

3.一对多(班级和和学生)(一对一可看成特殊的一对多)

3.1 创建班级和学生的对应持久化类(//在一方定义一个多方的集合),对于构造函数，根据测试类中的需求进行构造，不过无参构造函数和包含全部参数的构造函数最好都写上

//Grade.java
package com.entity;

import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

public class Grade implements Serializable{
    private int gid;
    private String gname;
    private String gdesc;
    //一对多时，在一方定义一个多方的集合
    private Set<Student> students = new HashSet<Student>();

    public Set<Student> getStudents() {
        return students;
    }

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

    public int getGid() {

        return gid;
    }

    public void setGid(int gid) {
        this.gid = gid;
    }

    public String getGname() {
        return gname;
    }

    public void setGname(String gname) {
        this.gname = gname;
    }

    public String getGdesc() {
        return gdesc;
    }

    public void setGdesc(String gdesc) {

        this.gdesc = gdesc;
    }

    public Grade() {
    }

    public Grade(int gid, String gname, String gdesc,Set<Student> students) {
        this.gid = gid;
        this.gname = gname;
        this.gdesc = gdesc;
        this.students = students;
    }

    public Grade(String gname, String gdesc) {
        this.gname = gname;
        this.gdesc = gdesc;
    }
}

//Student.java
package com.entity;

import java.io.Serializable;

public class Student implements Serializable{
    private int sid;
    private String sname;
    private String sex;

    //多对一时，在多方定义一个一方的引用
    private Grade grade;

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Student() {
    }

    public Student(String sname, String sex) {
        this.sname = sname;
        this.sex = sex;
    }
}

3.2.创建Hibrnate对应的映射类

//HibernateUtils.java
package com.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtils {
    // 1.创建工厂对象;
    private static SessionFactory sessionFactory;

    // 2.初始化工厂对象;
    static {
        sessionFactory = new Configuration().configure().buildSessionFactory();
    }

    //4.获取sessionFactory
    public static SessionFactory getSessionFactory(){
        return sessionFactory;
    }

    // 3.获得Session;
    public static Session getSession() {
        return sessionFactory.openSession();
    }

    //4.关闭session
    public static void closeSession(Session session){
        if (session!= null){
            session.close();
        }
    }
}

3.3 3.创建持久化类对应的映射文件

//Grade.hbm.xml
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.entity.Grade" table="grade">
        <id name="gid" column="gid" type="java.lang.Integer">
            <!--设置主键为自增模式-->
            <generator class="increment"></generator>
        </id>
        <property name="gname" type="java.lang.String">
            <column name="gname" length="20" not-null="true"></column>
        </property>
        <property name="gdesc">
            <column name="gdesc"></column>
        </property>
        <!--配置单向的一对多关联关系 , inverse为false表示由一方进行关联关系的维护，设置为true表示由多方进行关联关系的维护-->
        <!--cascade代表级联，设置为all代表对于所有操作都可以进行级联操作。例，在班级表中添加一个班级后，该班级对应的所有学生也会添加到相应的数据库中-->
        <set name="students" table="student" inverse="false" cascade="all">
            <key column="gid"></key>
            <one-to-many class="com.entity.Student"/>
        </set>
    </class>
</hibernate-mapping>

//Student.hbm.xml
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="com.entity.Student" table="student">
        <id name="sid" column="sid" type="java.lang.Integer">
            <!--设置主键为自增模式-->
            <generator class="increment"></generator>
        </id>
        <property name="sname" type="java.lang.String">
            <column name="sname" length="20" not-null="true"></column>
        </property>
        <property name="sex">
            <column name="sex"></column>
        </property>
        <many-to-one name="grade" class="com.entity.Grade" column="gid"></many-to-one>
    </class>
</hibernate-mapping>

3.4 创建测试类测试

//test.java
package com.entity;

import com.util.HibernateUtils;
import org.hibernate.Session;
import org.hibernate.Transaction;

import java.util.Set;

/*单向一对多关系（班级--->学生）
* 建立关联关系后，可以方便的从一个对象导航到另一个对象
* 当建立了双向一对多关系后，既可以方便的由学生查找到对应的班级信息，也可以方便的由班级查找到其所包含的学生信息
* */
public class test {
    public static void main(String[] args){
//        add();
//        findStudentsByGrade();
        update();
    }

    //将学生添加到班级
    public static void add(){
        Grade g = new Grade("Java一班","Java软件开发一班");
        Student stu1 = new Student("张三","男");
        Student stu2 = new Student("王兰","女");

        //如果希望在学生表中添加对应的班级编号，需要在班级中添加学生，建立关联关系
        g.getStudents().add(stu1);
        g.getStudents().add(stu2);

        Session session = HibernateUtils.getSession();
        Transaction tx = session.beginTransaction();
        session.save(g);
        session.save(stu1);
        session.save(stu2);
        tx.commit();
        HibernateUtils.closeSession(session);
    }

    //查询班级中包含的学生
    public static void findStudentsByGrade(){
        Session session = HibernateUtils.getSession();
        Grade grade = (Grade)session.get(Grade.class,1);
        System.out.println(grade.getGname()+","+grade.getGdesc());

        Set<Student> students = grade.getStudents();
        for (Student stu:students){
            System.out.println(stu.getSname()+","+stu.getSex());
        }
    }

    //修改学生信息
    public static void update(){
        Grade g = new Grade("Java二班","Java软件开发二班");//新建一个班级

        Session session = HibernateUtils.getSession();
        Transaction tx = session.beginTransaction();
        Student stu = (Student) session.get(Student.class,1);//获取id为1的学生信息，将他保存起来
        g.getStudents().add(stu);//在新建的班级中加入该学生
        session.save(g);
        tx.commit();
        HibernateUtils.closeSession(session);
    }

    //删除学生信息
    public static void delete(){
        Session session = HibernateUtils.getSession();
        Transaction tx = session.beginTransaction();
        Student stu = (Student)session.get(Student.class,2);
        session.delete(stu);
        tx.commit();
        HibernateUtils.closeSession(session);
    }
}

4.多对多 与一对多类似，后面看情况再写吧。。