1)基于Annotation:
多方User:
package com.stark.hibernate.model;
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_user")
public class User {
private String id;
private String name;
private Group group;
/**
*
* 只需在多方User中添加一个Group同时添加注解@ManyToOne即可(Many代表User,One代表Group)
*/
@ManyToOne
@JoinColumn(name="groupId")
public Group getGroup() {
return group;
}
public void setGroup(Group group) {
this.group = group;
}
@Id
//@GeneratedValue
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
一方:
package com.stark.hibernate.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name="t_group")
public class Group {
private String id;
private String name;
@Id
//@GeneratedValue
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
利用一下代码
public class TestSchemaExport {
@Test
public void testSchemaExport() {
new SchemaExport(new AnnotationConfiguration().configure()).create(true, true);
}
}
将会生成如下DDL语句:
create table t_group (groupId varchar(255) not null, groupName varchar(255), primary key (groupId))
create table t_user (userId varchar(255) not null, userName varchar(255), groupId varchar(255), primary key (userId))
alter table t_user add index FKCB63CCB65F00FCD6 (groupId), add constraint FKCB63CCB65F00FCD6 foreign key (groupId) references t_group (groupId)
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import com.stark.hibernate.model.Group;
import com.stark.hibernate.model.User;
import com.stark.hibernate.util.HibernateUtil;
import com.stark.hibernate.util.Hibernate_AnnotationUtil;
public class UserTest {
private static SessionFactory sessionFactory;
@BeforeClass
public static void setUpBeforeClass() throws Exception {
sessionFactory=Hibernate_AnnotationUtil.getSessionFactory();
}
@Test
public void saveUser() {
Session session = sessionFactory.openSession();
session.beginTransaction();
Group g =new Group();
g.setGroupId(01);
g.setGroupName("software");
// 如果不添加session.save(g),则不能成功保存,抛出TransientObjectException异常
//因为Group为Transient状态,groupId没有分配值
//persistent状态的对象是不能引用transient状态的对象的
//采用cascade属性是解决TransientObjectException异常的一种手段
session.save(g);
User u= new User();
u.setUserId(01);
u.setUserName("ZhangSan");
u.setGroup(g);
session.save(u);
session.getTransaction().commit();
session.close();
}
@Test
public void getUser(){
Session session = sessionFactory.openSession();
session.beginTransaction();
User u=(User)session.get(User.class, 1);
System.out.println("UserId:"+u.getUserId());
System.out.println("UserName:"+u.getUserName());
System.out.println("GroupId:"+u.getGroup ().getGroupId());
System.out.println("GroupName:"+u.getGroup().getGroupName());
session.getTransaction().commit();
session.close();
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
sessionFactory.close();
}
}
查询结果如下:
UserId:1
UserName:ZhangSan
GroupId:1
GroupName:software
2)基于XML:
将以上User和Group 中所有@注解去掉
Group.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.stark.hibernate.model">
<class name="Group" table="t_group">
<id name="groupId" >
<generator class="native"/>
</id>
<property name="groupName"/>
</class>
</hibernate-mapping>
User.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.stark.hibernate.model">
<class name="User" table="t_user">
<id name="userId">
<generator class="native"/>
</id>
<property name="userName" />
<many-to-one name="group" column="groupId" ></many-to-one>
</class>
</hibernate-mapping>
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import com.stark.hibernate.model.Group;
import com.stark.hibernate.model.User;
import com.stark.hibernate.util.HibernateUtil;
import com.stark.hibernate.util.Hibernate_AnnotationUtil;
public class UserTest {
private static SessionFactory sessionFactory;
@BeforeClass
public static void setUpBeforeClass() throws Exception {
//sessionFactory=Hibernate_AnnotationUtil.getSessionFactory();
sessionFactory=HibernateUtil.getSessionFactory();
}
@Test
public void saveUser() {
Session session = sessionFactory.openSession();
session.beginTransaction();
Group g =new Group();
g.setGroupId(01);
g.setGroupName("software");
// 如果不添加session.save(g),则不能成功保存,抛出TransientObjectException异常
//因为Group为Transient状态,groupId没有分配值
//persistent状态的对象是不能引用transient状态的对象的
session.save(g);
User u= new User();
u.setUserId(01);
u.setUserName("ZhangSan");
u.setGroup(g);
session.save(u);
session.getTransaction().commit();
session.close();
}
@Test
public void getUser(){
Session session = sessionFactory.openSession();
session.beginTransaction();
User u=(User)session.get(User.class, 1);
System.out.println("UserId:"+u.getUserId());
System.out.println("UserName:"+u.getUserName());
System.out.println("GroupId:"+u.getGroup().getGroupId());
System.out.println("GroupName:"+u.getGroup().getGroupName());
session.getTransaction().commit();
session.close();
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
sessionFactory.close();
}
}
如在User.hbm.xml 中
添加:
<many-to-one name="group" column="groupId" cascade="all" ></many-to-one>
则在saveUser时就不用先saveGroup了,[size=xx-small][/size][align=center][/align]因为采用了cascade属性,所以它会先保存Group
分享到:
相关推荐
标题中的“基于连接表的单向一对多关联”指的是在一对多关联中,通过一个额外的连接表来维护两个表之间的关系。这种关联方式通常用于两个实体之间没有直接的外键关联,而是通过第三个表来建立联系。 具体实现步骤...
本篇文章将深入探讨如何使用Hibernate Annotation来实现基于外键的单向多对一关联。 在关系型数据库中,多对一关联是一种常见的关系类型,意味着一个实体(如表)可以与另一个实体有多条记录关联,而另一个实体只能...
以上就是使用Hibernate通过注解和XML配置实现多对一单向关联的详细步骤。在实际开发中,这种关联方式能够有效地简化数据操作,提高代码的可读性和可维护性。注意,根据项目需求,你可能还需要处理关联的懒加载或立即...
本篇将详细讲解如何使用Hibernate实现多对多单向关联,包括注解(Annotation)和XML配置方式。 一、多对多关联的基本概念 多对多关联意味着一个实体可以与多个其他实体关联,反之亦然。例如,学生和课程的关系,一...
在本教程中,我们将探讨如何使用注解和XML配置实现Hibernate的一对多单向关联。 首先,让我们理解一对多关联的概念。在数据库中,一对多关联意味着在一个表(父表)中的一个记录可以对应另一个表(子表)中的多个...
这篇博文"基于Annotation的Servlet配置"探讨了如何使用注解来配置Servlet,让我们深入理解这一现代Web应用开发中的重要概念。 首先,我们来看`@WebServlet`注解。这个注解是Java Servlet API的一部分,可以直接在...
在基于Annotation的实现中,我们可以使用`@Action`和`@Result`注解来声明Action类及其对应的结果,避免了在struts.xml中的繁琐配置。 2. **Spring**:Spring框架负责管理对象的生命周期和依赖注入。通过`@Component...
本篇将深入探讨Hibernate中的一对一单向外键关联,通过注解和XML配置两种方式进行实现。这种关联允许一个实体类与另一个实体类之间存在一对一的关系,并且只在其中一个实体类中维护这种关系。 首先,我们来理解一对...
本文将深入探讨这两种关联方式在使用Hibernate时的配置,包括基于注解(Annotation)和XML的方式。 1. **一对多关联**(Many-to-One) - 在这种关系中,一个实体可以对应多个其他实体。例如,一个班级可以有多个...
### XML与Annotation的优缺点对比分析 #### 一、引言 ...同时,合理地规划配置文件的组织结构,如对XML配置进行模块化分组,以及加强对注解使用的规范指导,都是提升开发效率和项目质量的有效手段。
在Spring中,我们可以使用XML配置或Annotation来声明切面。本文主要关注Annotation方式,因为它更直观、简洁。`@Aspect`是声明一个类为切面的Annotation,而`@Before`、`@After`、`@Around`、`@AfterReturning`和`@...
基于Annotation的s2sh整合配置实现分页功能基于Annotation的s2sh整合配置实现分页功能基于Annotation的s2sh整合配置实现分页功能基于Annotation的s2sh整合配置实现分页功能基于Annotation的s2sh整合配置实现分页功能
在Spring框架中,任务调度是实现应用程序后台处理和定时任务的关键...对于复杂的任务调度场景,XML配置或者Quartz提供了更多的灵活性和控制力。理解并熟练掌握这些工具,可以极大地提升Spring应用的健壮性和可扩展性。
综上所述,"ssh包(基于annotation)"代表的是Spring、Struts2和Hibernate三个框架在使用注解进行配置的应用方式。这种方式使得代码更具有表达力,降低了配置的复杂度,同时也提高了开发的灵活性和可维护性。在学习和...
在实现基于外键的一对多双向关联时,理解注解的含义和作用至关重要,同时还需要考虑性能优化和潜在的问题,确保数据的正确性和一致性。通过阅读源码和实践,我们可以更深入地掌握Hibernate的内在机制。
在本主题中,我们将深入探讨使用Hibernate注解来实现JPA的一对多、多对多和多对一的关系映射。 1. **一对多关系**: 在现实世界中,一个老师可以教多个学生,或者一个班级可以包含多个学生,这就是典型的一对多...
传统的SpringMVC配置往往依赖于XML文件,如web.xml和spring-servlet.xml等,但随着Spring框架的发展,出现了基于代码的配置方式,实现了零XML配置,提高了开发效率。本文将详细介绍如何在不使用web.xml的情况下,...