一、单向多对一关系映射处理
演示案例列举了员工与部门的关系，一个部门下具有多个员工，相反的一个员工只隶属于一个部门下面
Maven依赖坐标：
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.20</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-agroal</artifactId>
<version>5.4.21.Final</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-c3p0 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-c3p0</artifactId>
<version>5.4.21.Final</version>
</dependency>
如果缺组件，就再补上这个：
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-envers</artifactId>
<version>5.4.21.Final</version>
</dependency>
部门类编写：
package cn.zeal4j.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @author Administrator
* @file IntelliJ IDEA Hibernate-Tutorial
* @create 2020 09 26 19:51
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Department implements Serializable {
private static final long serialVersionUID = -2834030425366265977L;
private Integer departmentId;
private String departmentName;
private String departmentLocation;
}
对应的部门Hibernate映射文件：
<?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 package="cn.zeal4j.domain" > <!-- 实体类包映射 -->
<class name="Department" table="department">
<id name="departmentId" column="department_id" type="java.lang.Integer" access="property" >
<generator class="increment" />
</id>
<property name="departmentName" column="department_name" type="java.lang.String" access="property"/>
<property name="departmentLocation" column="department_location" type="java.lang.String" access="property" />
</class>
</hibernate-mapping>
员工类编写：
package cn.zeal4j.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @author Administrator
* @file IntelliJ IDEA Hibernate-Tutorial
* @create 2020 09 26 19:59
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee implements Serializable {
private static final long serialVersionUID = -6524261539072181203L;
private Integer employeeNo;
private String employeeName;
private Department department;// 多个员工中的每一个员工对应一个部门
}
对应的员工Hibernate映射文件：
<?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 package="cn.zeal4j.domain" > <!-- 实体类包映射 -->
<class name="Employee" table="employee">
<id name="employeeNo" column="employee_no" type="java.lang.Integer" access="property" >
<generator class="increment" />
</id>
<property name="employeeName" column="employee_name" type="java.lang.String" access="property"/>
<many-to-one name="department" column="department_no" class="Department" />
</class>
</hibernate-mapping>
Hibernate核心配置文件编写：
注意数据库hibernate要存在！！！
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 基本链接参数 -->
<property name="connection.url">jdbc:mysql://localhost:3308/hibernate?serverTimezone=Asia/Shanghai</property>
<property name="connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<property name="connection.username">root</property>
<property name="connection.password">123456</property>
<!-- c3p0数据源配置 -->
<property name="hibernate.c3p0.max_size">10</property>
<property name="hibernate.c3p0.min_size">5</property>
<property name="hibernate.c3p0.idle_test_period">2000</property>
<property name="hibernate.c3p0.timeout">2000</property>
<property name="dialect">org.hibernate.dialect.MySQL57Dialect</property> <!-- 数据库版本方言 -->
<property name="show_sql">true</property> <!-- 是否让控制台输出SQL语句 -->
<property name="format_sql">true</property> <!-- 控制台输出的SQL格式化 -->
<property name="hbm2ddl.auto">update</property> <!-- 数据库表的生成策略 -->
<mapping resource="hibernate/mapping/Department.hbm.xml"/>
<mapping resource="hibernate/mapping/Employee.hbm.xml" />
</session-factory>
</hibernate-configuration>
工具类编写：
package cn.zeal4j.util;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
/**
* @author Administrator
* @file IntelliJ IDEA Hibernate-Tutorial
* @create 2020 09 26 18:43
*/
public class HibernateUtil {
static {
final StandardServiceRegistry registry = new StandardServiceRegistryBuilder().
configure("hibernate/hibernate.cfg.xml").build();
sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
}
private HibernateUtil() {}
private static final SessionFactory sessionFactory;
public static Session getSession() {
return sessionFactory.openSession();
}
public static void destroyFactory() {
sessionFactory.close();
}
}
测试类编写：
package cn.zeal4j.test;
import cn.zeal4j.domain.Department;
import cn.zeal4j.domain.Employee;
import cn.zeal4j.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import java.io.Serializable;
/**
* @author Administrator
* @file IntelliJ IDEA Hibernate-Tutorial
* @create 2020 09 26 20:30
*/
public class HibernateTest {
@Test
public void manyToOneTest() {
Session session = HibernateUtil.getSession();
Transaction transaction = session.beginTransaction();
Employee employee = new Employee(null, "李四", null);
Department department = new Department(null, "行政部", "地址位置");
employee.setDepartment(department);
Serializable save = session.save(department); // 注意，多对一的一要先存在，因为两表关系Hibernate会自动创建强制外键约束
Serializable save2 = session.save(employee); // 有一的一方存在，多的一方才能够成功绑定外键
System.out.println(save); // 返回的序列化对象是映射对象的主键值
System.out.println(save2);
transaction.commit(); // 若没发生异常，表示操作成功，提交事务
session.close(); // 资源释放
HibernateUtil.destroyFactory();
}
}
运行结果：
先是数据表的创建
Hibernate:
create table department (
department_id integer not null,
department_name varchar(255),
department_location varchar(255),
primary key (department_id)
) engine=InnoDB
Hibernate:
create table employee (
employee_no integer not null,
employee_name varchar(255),
department_no integer,
primary key (employee_no)
) engine=InnoDB
Hibernate:
alter table employee
add constraint FKawh85bpyoqubu0i27ud5ufld9
foreign key (department_no)
references department (department_id)
九月 26, 2020 8:38:38 下午 org.hibernate.engine.transaction.jta.platform.internal.JtaPlatformInitiator initiateService
INFO: HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
Hibernate:
select
max(employee_no)
from
employee
然后是记录的插入：
Hibernate:
select
max(department_id)
from
department
Hibernate:
select
max(employee_no)
from
employee
2
2
Hibernate:
insert
into
department
(department_name, department_location, department_id)
values
(?, ?, ?)
Hibernate:
insert
into
employee
(employee_name, department_no, employee_no)
values
(?, ?, ?)
两表的字段也是正常的：
查询方法：
@Test
public void manyToOneQuery() {
Session session = HibernateUtil.getSession();
Department department = new Department();
department.setDepartmentId(1);
final String HQL_QUERY = "FROM cn.zeal4j.domain.Employee AS emp WHERE emp.department = ?0 ";
Query<Employee> employeeQuery = session.createQuery(HQL_QUERY, Employee.class);
employeeQuery.setParameter(0, department);
Employee employee = employeeQuery.uniqueResult();
System.out.println(employee);
session.close();
HibernateUtil.destroyFactory();
}
在写SpringDataJPA的时候一样的问题，你也需要使用升级版的HQL语句
需要在参数占位符的后面指定该参数的索引值，虽然语法上被IDEA提示报错，但是运行时不会出现问题
二、双向一对多关系映射处理
在上述的基础上这样配置映射类：
package cn.zeal4j.domain; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.io.Serializable; import java.util.HashSet; import java.util.Set; /** * @author Administrator * @file IntelliJ IDEA Hibernate-Tutorial * @create 2020 09 26 19:51 */ @Data @AllArgsConstructor @NoArgsConstructor public class Department implements Serializable { private static final long serialVersionUID = -2834030425366265977L; private Integer departmentId; private String departmentName; private String departmentLocation; private Set<Employee> employeeSet = new HashSet<>(); // 建立双向一对多关系映射 }
部门Hibernate映射文件：
<?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 package="cn.zeal4j.domain" > <!-- 实体类包映射 --> <class name="Department" table="department"> <id name="departmentId" column="department_id" type="java.lang.Integer" access="property" > <generator class="increment" /> </id> <property name="departmentName" column="department_name" type="java.lang.String" access="property"/> <property name="departmentLocation" column="department_location" type="java.lang.String" access="property" /> <set name="employeeSet" cascade="all"> <key column="department_no" /> <one-to-many class="Employee" /> </set> <!-- cascade属性 ： 默认 none session操作当前对象时，忽略其他关联对象，例如不设置cascade或者设置为none值，这里的employeeSet就会忽略 插入与更新 save-update 级联相关的游离对象，在执行插入和更新的操作时 删除 delete 执行删除操作时，级联相关对象 全部级联 执行上述的操作时级联相关对象 --> </class> </hibernate-mapping>
测试插入：
首先因为更改了类的原因，之前的测试单元就会编译出错，直接注释掉，然后再清空之前的记录：
要注意外键的约束问题，不能直接情况部门表
TRUNCATE TABLE `employee`; SET FOREIGN_KEY_CHECKS = 0; TRUNCATE TABLE `department`;
或者删除表让Hibernate重建：
DROP TABLE `department`, `employee`
参考地址：
https://www.cnblogs.com/fu-yong/p/9889503.html
测试类编写：
@Test
public void two_wayManyToOneTest() {
Session session = HibernateUtil.getSession();
Transaction transaction = session.beginTransaction();
Department department = new Department();
department.setDepartmentLocation("xx省xx市xx区xx路xxx号xx栋xx单元");
department.setDepartmentName("开发部");
Employee employee1 = new Employee(null, "张三", null); // 如果注入了部门，插入将会造成堆溢出，指针嵌套了
Employee employee2 = new Employee(null, "李四", null);
Employee employee3 = new Employee(null, "王五", null);
department.getEmployeeSet().add(employee1);
department.getEmployeeSet().add(employee2);
department.getEmployeeSet().add(employee3);
session.save(department);
transaction.commit();
session.close();
HibernateUtil.destroyFactory();
}
测试结果:
Hibernate:
select
max(department_id)
from
department
Hibernate:
select
max(employee_no)
from
employee
Hibernate:
insert
into
department
(department_name, department_location, department_id)
values
(?, ?, ?)
Hibernate:
insert
into
employee
(employee_name, department_no, employee_no)
values
(?, ?, ?)
Hibernate:
insert
into
employee
(employee_name, department_no, employee_no)
values
(?, ?, ?)
Hibernate:
insert
into
employee
(employee_name, department_no, employee_no)
values
(?, ?, ?)
Hibernate:
update
employee
set
department_no=?
where
employee_no=?
Hibernate:
update
employee
set
department_no=?
where
employee_no=?
Hibernate:
update
employee
set
department_no=?
where
employee_no=?
效果：
级联删除操作：
测试类
@Test
public void two_wayManyToOneTest2() {
Session session = HibernateUtil.getSession();
Transaction transaction = session.beginTransaction();
// 要先从数据库中查询出来
Department department = session.get(Department.class, 1);
// 再来删除
session.delete(department);
transaction.commit();
session.close();
HibernateUtil.destroyFactory();
}
测试结果：
Hibernate:
select
department0_.department_id as departme1_0_0_,
department0_.department_name as departme2_0_0_,
department0_.department_location as departme3_0_0_
from
department department0_
where
department0_.department_id=?
Hibernate:
select
employeese0_.department_no as departme3_1_0_,
employeese0_.employee_no as employee1_1_0_,
employeese0_.employee_no as employee1_1_1_,
employeese0_.employee_name as employee2_1_1_,
employeese0_.department_no as departme3_1_1_
from
employee employeese0_
where
employeese0_.department_no=?
Hibernate:
update
employee
set
department_no=null
where
department_no=?
Hibernate:
delete
from
employee
where
employee_no=?
Hibernate:
delete
from
employee
where
employee_no=?
Hibernate:
delete
from
employee
where
employee_no=?
Hibernate:
delete
from
department
where
department_id=?
效果：
这里需要注意一些问题：
使用了Lombok不独立写出SET映射对象的方法，会导致Hibernate级联删除操作的时候指针嵌套，堆溢出错误
不使用查询出来的对象，而是随便new的一个对象，给定OID值取删除，并不会触发Hibernate级联删除操作
Hibernate根据给定的OID值删除部门记录本身之后不再级联下面的员工进行删除
Set关系维护：
<?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 package="cn.zeal4j.domain" > <!-- 实体类包映射 --> <class name="Department" table="department"> <id name="departmentId" column="department_id" type="java.lang.Integer" access="property" > <generator class="increment" /> </id> <property name="departmentName" column="department_name" type="java.lang.String" access="property"/> <property name="departmentLocation" column="department_location" type="java.lang.String" access="property" /> <set name="employeeSet" cascade="all" inverse="false" > <key column="department_no" /> <one-to-many class="Employee" /> </set> <!-- cascade属性 ： 默认 none session操作当前对象时，忽略其他关联对象，例如不设置cascade或者设置为none值，这里的employeeSet就会忽略 插入与更新 save-update 级联相关的游离对象，在执行插入和更新的操作时 删除 delete 执行删除操作时，级联相关对象 全部级联 执行上述的操作时级联相关对象 --> <!-- inverse属性： 该属性用以指定关联关系的方向 默认值false， 表示不反转，由本映射类作为主关系方，进行关系维护 true，表示反转，由被映射类作为主关系方，进行关系维护 --> </class> </hibernate-mapping>
三、单向多对多关系映射处理
演示案例的关系类是：项目类和员工类，一个项目由多个员工合作，一个员工同时也在开发多个项目
单向多对多只需要其中的任意一方维护外键关系即可
重新创建一个新的模块，并且删除之前的数据表：
项目类
package cn.zeal4j.domain; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.io.Serializable; import java.util.HashSet; import java.util.Set; /** * @author Administrator * @file IntelliJ IDEA Hibernate-Tutorial * @create 2020 09 26 22:08 */ @Data @AllArgsConstructor @NoArgsConstructor public class Project implements Serializable { private static final long serialVersionUID = -4867120608900517525L; private Integer projectId; private String projectName; private Set<Employee> employeeSet = new HashSet<>(); public Set<Employee> getEmployeeSet() { return employeeSet; } }
员工类：
package cn.zeal4j.domain; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.io.Serializable; /** * @author Administrator * @file IntelliJ IDEA Hibernate-Tutorial * @create 2020 09 26 22:08 */ @Data @AllArgsConstructor @NoArgsConstructor public class Employee implements Serializable { private static final long serialVersionUID = -6524261539072181203L; private Integer employeeId; private String employeeName; }
员工类的Hibernate映射文件就按照单表配置即可
重点是项目类的Hibernate映射文件配置
<?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 package="cn.zeal4j.domain" > <!-- 实体类包映射 -->
<class name="Project" table="project" >
<id name="projectId" column="project_id" type="java.lang.Integer" access="property">
<generator class="increment" />
</id>
<property name="projectName" column="project_name" type="java.lang.String" access="property"/>
<set name="employeeSet" cascade="all">
<key column="project_id"></key>
<many-to-many class="Employee" column="employee_id" />
</set>
</class>
</hibernate-mapping>
Hibernate配置文件：
和之前一样，只要绑好这个就行了
<mapping resource="hibernate/mapping/Project.hbm.xml"/> <mapping resource="hibernate/mapping/Employee.hbm.xml" />
要注意的一些问题：
多对多关系必然是需要一张中间表来维护关系，但是单向维护并没有指定第三张关系维护表的内容
测试单元：
@Test
public void getTest() {
Session session = HibernateUtil.getSession();
Transaction transaction = session.beginTransaction();
Employee employee1 = new Employee(null, "员工01");
Employee employee2 = new Employee(null, "员工02");
Project project1 = new Project();
project1.setProjectName("项目01");
Project project2 = new Project();
project2.setProjectName("项目02");
// 多对多对象处理
project1.getEmployeeSet().add(employee1);
project1.getEmployeeSet().add(employee2);
project2.getEmployeeSet().add(employee1);
project2.getEmployeeSet().add(employee2);
// 开始操作
session.save(project1);
session.save(project2);
transaction.commit();
session.close();
HibernateUtil.destroyFactory();
}
语句输出：
Hibernate:
create table employee (
employee_id integer not null,
employee_name varchar(255),
primary key (employee_id)
) engine=InnoDB
Hibernate:
create table project (
project_id integer not null,
project_name varchar(255),
primary key (project_id)
) engine=InnoDB
Hibernate:
create table Project_employeeSet (
project_id integer not null,
employee_id integer not null,
primary key (project_id, employee_id)
) engine=InnoDB
Hibernate:
alter table Project_employeeSet
add constraint FKl70mnietqkmll2ccdn4vtm58n
foreign key (employee_id)
references employee (employee_id)
Hibernate:
alter table Project_employeeSet
add constraint FKns1stqcwdxpogvyhauuj82xul
foreign key (project_id)
references project (project_id)
九月 26, 2020 10:35:19 下午 org.hibernate.engine.transaction.jta.platform.internal.JtaPlatformInitiator initiateService
INFO: HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
Hibernate:
select
max(project_id)
from
project
Hibernate:
select
max(employee_id)
from
employee
Hibernate:
insert
into
project
(project_name, project_id)
values
(?, ?)
Hibernate:
insert
into
employee
(employee_name, employee_id)
values
(?, ?)
Hibernate:
insert
into
employee
(employee_name, employee_id)
values
(?, ?)
Hibernate:
insert
into
project
(project_name, project_id)
values
(?, ?)
Hibernate:
insert
into
Project_employeeSet
(project_id, employee_id)
values
(?, ?)
Hibernate:
insert
into
Project_employeeSet
(project_id, employee_id)
values
(?, ?)
Hibernate:
insert
into
Project_employeeSet
(project_id, employee_id)
values
(?, ?)
Hibernate:
insert
into
Project_employeeSet
(project_id, employee_id)
values
(?, ?)
外键表的处理也是正确无误的
四、双向多对多关系映射处理
双向绑定，对应的员工类和Hibernate映射文件也是同样的赋予对应的对象
注意双方都不要使用Lombok，否则还是会造成堆溢出错误！！！
package cn.zeal4j.domain; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; import java.io.Serializable; import java.util.HashSet; import java.util.Set; /** * @author Administrator * @file IntelliJ IDEA Hibernate-Tutorial * @create 2020 09 26 22:08 */ @Data @AllArgsConstructor @NoArgsConstructor public class Employee implements Serializable { private static final long serialVersionUID = -6524261539072181203L; private Integer employeeId; private String employeeName; private Set<Project> projectSet = new HashSet<>(); public Set<Project> getProjectSet() { return projectSet; } }
映射文件：
注意这里，只能指定一个主方进行关系维护，不允许双方都是关系维护者
还有set标签，双方都指定table属性的为同一个表明，设置的字段也是正好相反的两个字段
<?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 package="cn.zeal4j.domain" > <!-- 实体类包映射 --> <class name="Employee" table="employee"> <id name="employeeId" column="employee_id" type="java.lang.Integer" access="property" > <generator class="increment" /> </id> <property name="employeeName" column="employee_name" type="java.lang.String" access="property"/> <set name="projectSet" cascade="all" table="project_employee_map" inverse="true" > <key column="employee_id" /> <many-to-many class="Project" column="project_id" /> </set> </class> </hibernate-mapping>
测试类
@Test public void eachOtherManyToMany() { Session session = HibernateUtil.getSession(); Transaction transaction = session.beginTransaction(); Employee employee1 = new Employee(); employee1.setEmployeeName("员工01"); Employee employee2 = new Employee(); employee2.setEmployeeName("员工02"); Project project1 = new Project(); project1.setProjectName("项目01"); Project project2 = new Project(); project2.setProjectName("项目02"); project1.getEmployeeSet().add(employee1); project1.getEmployeeSet().add(employee2); project2.getEmployeeSet().add(employee1); employee1.getProjectSet().add(project1); employee1.getProjectSet().add(project2); employee2.getProjectSet().add(project1); session.save(project1); session.save(project2); transaction.commit(); session.close(); HibernateUtil.destroyFactory(); }
打印的SQL语句：
Hibernate:
create table employee (
employee_id integer not null,
employee_name varchar(255),
primary key (employee_id)
) engine=InnoDB
Hibernate:
create table project (
project_id integer not null,
project_name varchar(255),
primary key (project_id)
) engine=InnoDB
Hibernate:
create table project_employee_map (
project_id integer not null,
employee_id integer not null,
primary key (project_id, employee_id)
) engine=InnoDB
Hibernate:
alter table project_employee_map
add constraint FKo9hw3isyxdis78q1kjx6dgsx4
foreign key (employee_id)
references employee (employee_id)
Hibernate:
alter table project_employee_map
add constraint FKlwh46ok6c1axys3ooh2e5rwfo
foreign key (project_id)
references project (project_id)
九月 26, 2020 11:06:31 下午 org.hibernate.engine.transaction.jta.platform.internal.JtaPlatformInitiator initiateService
INFO: HHH000490: Using JtaPlatform implementation: [org.hibernate.engine.transaction.jta.platform.internal.NoJtaPlatform]
Hibernate:
select
max(project_id)
from
project
Hibernate:
select
max(employee_id)
from
employee
Hibernate:
insert
into
project
(project_name, project_id)
values
(?, ?)
Hibernate:
insert
into
employee
(employee_name, employee_id)
values
(?, ?)
Hibernate:
insert
into
employee
(employee_name, employee_id)
values
(?, ?)
Hibernate:
insert
into
project
(project_name, project_id)
values
(?, ?)
Hibernate:
insert
into
project_employee_map
(project_id, employee_id)
values
(?, ?)
Hibernate:
insert
into
project_employee_map
(project_id, employee_id)
values
(?, ?)
Hibernate:
insert
into
project_employee_map
(project_id, employee_id)
values
(?, ?)是
还是不知道为什么Lombok堆溢出的错误，报错指向了@Data注解
可能单独写SetterGetter会有用吧