Hibernate中多对多的annotation的写法(中间表可以有多个字段)

本文介绍Hibernate中多对多关系的两种映射方式:一种仅用于关联,使用ManyToMany注解;另一种包含额外信息,需定义中间实体并采用一对多双向映射。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一般情况下,多对多的关联关系是需要中间表的;

情况一:如果中间表仅仅是做关联用的,它里面仅有2个外键做联合主键,则使用ManyToMany(不用写中间表的Model,只需要写出两张主表的model即可)

学生表


@Entity
@Table(name = "T_STUDENT")
@SequenceGenerator(name = "SEQ_STUDENT", sequenceName = "SEQ_STUDENT")
public class Student implements Serializable {
private static final long serialVersionUID = 2524659555729848644L;
private Long id;
private String name;
private Date birthday;
private int sex;
private String address;
private Set<Teacher> teacherList;
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_STUDENT")
@Column(name = "ID", nullable = false, precision = 22, scale = 0)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name = "NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Temporal(TemporalType.DATE)
@Column(name = "BIRTHDAY")
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Column(name = "sex")
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
@Column(name = "address")
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@ManyToMany(cascade = CascadeType.ALL)
@JoinTable(name = "T_TEACHER_STUDENT",
joinColumns = @JoinColumn(name = "student_id"),
inverseJoinColumns = @JoinColumn(name = "teacher_id"))
public Set<Teacher> getTeacherList() {
return teacherList;
}
public void setTeacherList(Set<Teacher> teacherList) {
this.teacherList = teacherList;
}
}
教师表

@Entity
@Table(name = "T_TEACHER")
@SequenceGenerator(name = "SEQ_TEACHER", sequenceName = "SEQ_TEACHER")
public class Teacher implements Serializable {
private static final long serialVersionUID = 2297316923535111793L;
private Long id;
private String name;
private int sex;
private Set<Student> studentList;
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_TEACHER")
@Column(name = "ID", nullable = false, precision = 22, scale = 0)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name = "sex")
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
@ManyToMany(mappedBy = "teacherList", cascade = CascadeType.ALL)
public Set<Student> getStudentList() {
return studentList;
}
public void setStudentList(Set<Student> studentList) {
this.studentList = studentList;
}
}

hibernate.cfg.xml配置2个class类

<mapping class="com.dvn.li.model.Student"/>
<mapping class="com.dvn.li.model.Teacher"/>

测试:

SessionFactory sessionFactory = null;
Session session = null;
try {
sessionFactory = HibernateUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
session.beginTransaction();
Student s = new Student();
s.setName("小猪");
Teacher t = new Teacher();
t.setName("小李");
Set<Teacher> t_set = new HashSet<Teacher>();
t_set.add(t);
s.setTeacherList(t_set);
session.save(s);

} catch (Exception e) {
if (session != null) {
session.getTransaction().rollback();
}
}

测试通过!!!

很简单吧!注意HibernateUtil.getSessionFactory()的实现如下:

public class HibernateUtil {
private static final SessionFactory sessionFactory;

static {
try {
// Create the SessionFactory from hibernate.cfg.xml
sessionFactory = new AnnotationConfiguration().configure()
.buildSessionFactory();
} catch (Throwable ex) {
// Make sure you log the exception, as it might be swallowed
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
}
}

public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}

如果自己做测试,可以通过SchemaExport导入表结构

SchemaExport export = new SchemaExport(new AnnotationConfiguration()
.configure());
export.create(true, true);

情况二:如果中间表不仅仅是做关联用的,它里面包含了其他字段信息,仅仅靠多对多的关系是搞不定的。

解决方案:多对多的关系拆分为两个一对多!这时候三张表的Model都需要写。

我们知道,一对多的关系,一般都是在多的一方做配置。具体代码如下:

学生表

@Entity
@Table(name = "T_STUDENT")
@SequenceGenerator(name = "SEQ_STUDENT", sequenceName = "SEQ_STUDENT")
public class Student2 implements Serializable {
private static final long serialVersionUID = 2524659555729848644L;
private Long id;
private String name;
private Date birthday;
private int sex;
private String address;
private Set<TeacherStudent> teacherStudentList;
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_STUDENT")
@Column(name = "ID", nullable = false, precision = 22, scale = 0)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name = "NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Temporal(TemporalType.DATE)
@Column(name = "BIRTHDAY")
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Column(name = "sex")
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
@Column(name = "address")
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@OneToMany(mappedBy="student",cascade=CascadeType.ALL)
public Set<TeacherStudent> getTeacherStudentList() {
return teacherStudentList;
}
public void setTeacherStudentList(Set<TeacherStudent> teacherStudentList) {
this.teacherStudentList = teacherStudentList;
}
}

教师表

@Entity
@Table(name = "T_TEACHER")
@SequenceGenerator(name = "SEQ_TEACHER", sequenceName = "SEQ_TEACHER")
public class Teacher2 implements Serializable {
private static final long serialVersionUID = 2297316923535111793L;
private Long id;
private String name;
private int sex;
private Set<TeacherStudent> teacherStudentList;
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_TEACHER")
@Column(name = "ID", nullable = false, precision = 22, scale = 0)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name = "name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name = "sex")
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
@OneToMany(mappedBy = "teacher",cascade=CascadeType.ALL)
public Set<TeacherStudent> getTeacherStudentList() {
return teacherStudentList;
}
public void setTeacherStudentList(Set<TeacherStudent> teacherStudentList) {
this.teacherStudentList = teacherStudentList;
}
}

中间表

@Entity
@Table(name = "T_TEACHERSTUDENT")
@SequenceGenerator(name = "SEQ_TEACHERSTUDENT", sequenceName = "SEQ_TEACHERSTUDENT")
public class TeacherStudent implements Serializable {
private Long id;
private Student2 student;
private Teacher2 teacher;
private String note1;
private String note2;
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_TEACHERSTUDENT")
@Column(name = "ID", nullable = false, precision = 22, scale = 0)
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name = "note1")
public String getNote1() {
return note1;
}
public void setNote1(String note1) {
this.note1 = note1;
}
@Column(name = "note2")
public String getNote2() {
return note2;
}
public void setNote2(String note2) {
this.note2 = note2;
}
@ManyToOne(cascade=CascadeType.ALL)
@JoinColumn(name = "student_id", unique = true)
public Student2 getStudent() {
return student;
}
public void setStudent(Student2 student) {
this.student = student;
}
@ManyToOne
@JoinColumn(name = "teacher_id", unique = true)
public Teacher2 getTeacher() {
return teacher;
}
public void setTeacher(Teacher2 teacher) {
this.teacher = teacher;
}
}

hibernate.cfg.xml 引入对象

<mapping class="com.dvn.li.model.Student2"/>
<mapping class="com.dvn.li.model.Teacher2"/>
<mapping class="com.dvn.li.model.TeacherStudent"/>

测试:

SessionFactory sessionFactory = null;
Session session = null;
try {
sessionFactory = HibernateUtil.getSessionFactory();
session = sessionFactory.getCurrentSession();
session.beginTransaction();
Student2 s = new Student2();
s.setName("小猪");
Teacher2 t = new Teacher2();
t.setName("小李");
TeacherStudent ts=new TeacherStudent();
ts.setStudent(s);
ts.setTeacher(t);
ts.setNote1("以呀呀!!!");
session.save(s);
session.save(t);
session.save(ts);
session.getTransaction().commit();
} catch (Exception e) {
if (session != null) {
session.getTransaction().rollback();
}
}


测试通过!
<think>好的,我现在需要解决用户关于Java多表联查并展示数据的问题。用户希望得到具体的示例和方法。首先,我需要回忆一下Java中进行多表查询的常见方式。 用户提供的引用中有提到使用JDBC直接操作、MyBatisPlus的多表联查,以及服务层和DAO层的代码结构。例如,引用[3]中的service包通过DAO层调用查询,而引用[4]则展示了MyBatisPlus的MPJBaseMapper进行左连接。还有引用[1]和[2]提到了JOIN语句的写法,比如INNER JOIN和FULL JOIN。 我应该先整理不同的方法,包括原生的JDBC、MyBatisPlus框架,以及可能提到的其他ORM框架,比如Hibernate。不过根据引用内容,用户可能更关注JDBC和MyBatisPlus。 首先,JDBC方式需要编写SQL语句,使用JOIN连接表,然后通过ResultSet获取数据。引用[1]中的示例使用了inner join,并通过getString方法展示数据,这可能是一个直接的方法。需要注意SQL注入的问题,但示例中可能没有使用预编译语句,需要指出。 其次,MyBatisPlus的MPJBaseMapper方法,如引用[4]所示,通过LambdaWrapper进行连接查询,自动映射到DTO对象,这样代码更简洁,适合现代框架使用。需要详细说明如何配置Mapper接口和Wrapper的使用。 另外,引用[3]中的service层调用了DAO层的方法,可能涉及多表查询后的结果处理,比如将结果集转换为对象列表。这里可能需要结合JOIN查询和结果映射。 在展示数据时,无论是JDBC还是框架,都需要处理结果集。比如,JDBC通过遍历ResultSet,而MyBatisPlus则自动映射。需要分别举例说明这两种方法的步骤,并提供代码示例。 同时,用户可能关心如何展示连接后的数据,比如将多个表的数据合并显示在前端或控制台。因此,示例应包括如何从结果集中提取不同表的字段,并组合成需要的格式。 还需要注意异常处理和资源释放,尤其是在JDBC示例中,确保关闭Connection、Statement和ResultSet,避免资源泄漏。而使用MyBatisPlus等框架时,这些通常由框架管理,但事务管理和异常处理仍需考虑。 最后,根据用户提供的引用,应正确标注引用来源,比如引用[1]关于inner join的使用,引用[4]关于MyBatisPlus的配置。确保每个示例都有对应的引用标注,保持回答的准确性。 总结步骤:1. JDBC原生方法示例;2. MyBatisPlus框架示例;3. 结果展示部分;4. 注意事项和最佳实践。每个部分都需要代码示例和引用标注,确保用户能够清晰理解不同方法的实现方式。</think>### Java多表联查并展示连接表数据的实现方法 在Java中实现多表联查并展示数据,主要可以通过原生JDBC操作或框架(如MyBatisPlus)实现。以下是具体方法和示例: --- #### **方法1:原生JDBC实现多表联查** 通过编写SQL语句直接操作数据库,使用`JOIN`关键字连接多表,并通过`ResultSet`遍历结果集展示数据。 **示例代码**: ```java // 1. 建立数据库连接 Connection conn = DriverManager.getConnection(url, user, password); // 2. 编写多表联查SQL(以INNER JOIN为例) String sql = "SELECT o.order_id, m.name, g.goods_name " + "FROM orders o " + "INNER JOIN member m ON o.member_id = m.id " + "INNER JOIN goods g ON o.goods_id = g.id"; // 3. 执行查询 Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery(sql); // 4. 遍历结果集并展示数据 while (rs.next()) { String orderId = rs.getString("order_id"); String memberName = rs.getString("name"); String goodsName = rs.getString("goods_name"); System.out.println("订单ID:" + orderId + ",会员名:" + memberName + ",商品名:" + goodsName); } // 5. 关闭资源 rs.close(); stmt.close(); conn.close(); ``` **说明**: - 使用`INNER JOIN`连接`orders`、`member`、`goods`三张表,查询订单关联的会员和商品信息[^1][^2]。 - `ResultSet`通过字段名或索引获取数据,适用于简单的联查场景[^3]。 **注意事项**: - 需手动处理异常和资源释放(如`try-with-resources`)。 - 建议使用预编译`PreparedStatement`防止SQL注入。 --- #### **方法2:使用MyBatisPlus实现多表联查** 通过MyBatisPlus的`MPJBaseMapper`和`LambdaWrapper`简化联查操作,并自动映射结果到DTO对象。 **步骤**: 1. **定义DTO类**接收联查结果: ```java public class OrderDetailDTO { private String orderId; private String memberName; private String goodsName; // Getter/Setter省略 } ``` 2. **Mapper接口继承MPJBaseMapper**: ```java public interface OrderMapper extends MPJBaseMapper<Order> {} ``` 3. **编写联查逻辑**: ```java List<OrderDetailDTO> results = orderMapper.selectJoinList( OrderDetailDTO.class, new MPJLambdaWrapper<Order>() .selectAll(Order.class) .selectAs(Member::getName, OrderDetailDTO::getMemberName) .selectAs(Goods::getGoodsName, OrderDetailDTO::getGoodsName) .leftJoin(Member.class, Member::getId, Order::getMemberId) .leftJoin(Goods.class, Goods::getId, Order::getGoodsId) ); ``` 4. **展示数据**: ```java results.forEach(dto -> System.out.println( "订单ID:" + dto.getOrderId() + ",会员名:" + dto.getMemberName() + ",商品名:" + dto.getGoodsName() )); ``` **说明**: - `MPJLambdaWrapper`支持链式调用,通过`selectAs`指定字段别名,自动映射到DTO[^4]。 - 联查类型支持`leftJoin`、`innerJoin`等[^4]。 --- #### **方法3:Service层处理联查结果** 在Service层调用DAO方法获取联查数据,并处理业务逻辑(如库存检查)。 **示例**: ```java // Service层方法 public List<OrderDetailDTO> getOrderDetails() throws SQLException { return orderDao.selectOrderDetails(); } // DAO层实现(结合JDBC或ORM框架) public List<OrderDetailDTO> selectOrderDetails() { // 执行SQL或框架查询,返回DTO列表 } ``` **应用场景**: - 需要业务逻辑校验(如引用[3]中的库存检查`isEnough()`方法)。 - 多表数据聚合后返回给前端展示。 --- ### **总结** | 方法 | 适用场景 | 优点 | 缺点 | |---------------|----------------------------|-------------------------------|---------------------| | 原生JDBC | 简单查询、学习原型开发 | 直接控制SQL,无需框架依赖 | 代码冗余,易出错 | | MyBatisPlus | 企业级应用、复杂联查 | 简化映射,支持链式调用 | 需学习框架配置 | | Service+DAO | 业务逻辑复杂的多层架构 | 分离关注点,易于维护 | 需要分层设计 | ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值