1.学生与身份证一对一关联
IdCard.java
package com.oto.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.annotations.Parameter;
@Entity
@Table(name="card")
public class IdCard {
@Id
@GeneratedValue(generator="aa")
@GenericGenerator(name="aa",strategy="foreign",
parameters={@Parameter(name="property",value="person")})
private Integer id;
private String cardNo;
@OneToOne(mappedBy="card")
private Student student;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getCardNo() {
return cardNo;
}
public void setCardNo(String cardNo) {
this.cardNo = cardNo;
}
public Student getStudent() {
return student;
}
public void setStudent(Student student) {
this.student = student;
}
@Override
public String toString() {
return "IdCard [id=" + id + ", cardNo=" + cardNo + ", student=" + student + "]";
}
}
Student.java
package com.oto.entity;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;
import com.oto.entity.IdCard;
@Entity
@Table(name="student")
public class Student {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private Integer id;
private String name;
@OneToOne(cascade=CascadeType.ALL)
@PrimaryKeyJoinColumn(name="id")
private IdCard card;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public IdCard getCard() {
return card;
}
public void setCard(IdCard card) {
this.card = card;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", card=" + card + "]";
}
}
IdCard.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.oto.entity">
<class name="IdCard" table="card" >
<id name="id" column="id" >
<generator class="foreign">
<param name="property">student</param>
</generator>
</id>
<property name="cardNo" column="cardNo" />
<one-to-one name="student" class="Student" constrained="true"/>
</class>
</hibernate-mapping>
Student.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.oto.entity">
<class name="Student" table="student_card" >
<id name="id" column="id" >
<generator class="native">
</generator>
</id>
<property name="name" column="name" />
<one-to-one name="card" cascade="all"></one-to-one>
</class>
</hibernate-mapping>
TestOto.java
package com.oto.ui;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import com.oto.entity.IdCard;
import com.oto.entity.Student;
import com.lye.util.HibernateUtil;
public class TestOto {
/**
* 12.12 测试类(主键关联)--->主要测试程序功能实现情况
* 注意：<顺序>
* constrained="true"--->添加时先添加主表后添加从表，删除时反之。
*/
public TestOto() {
}
public static void main(String[] args) {
// save();
update();
// delete();
}
/*
*
* 实现添加功能
*/
public static void save() {
Configuration cfg=new Configuration().configure();
SessionFactory factory=cfg.buildSessionFactory();
Session session=factory.openSession();
Transaction tran=session.beginTransaction();
Student s=new Student();
s.setName("张三");
IdCard card=new IdCard();
card.setCardNo("0001");
card.setStudent(s);
s.setCard(card);
session.save(s);
session.save(card);
tran.commit();//提交
session.close();
factory.close();
}
/*
*
* 实现删除功能
*/
public static void delete() {
Session session = null;
Transaction tran = null;
try {
session = HibernateUtil.openSession();
tran = session.beginTransaction();
// ---------------------------------
// 查找Person对象
Student s = session.load(Student.class, 5);
System.out.println(s.getCard().getCardNo());
session.delete(s);
// ---------------------------------
tran.commit();
} catch (Exception e) {
e.printStackTrace();
tran.rollback();
} finally {
if (null != session) {
session.close();
}
}
}
/*
* 实现修改功能
*/
public static void update() {
Session session = null;
Transaction tran = null;
try {
session = HibernateUtil.openSession();
tran = session.beginTransaction();
// ---------------------------------
// 查找Person对象
Student s = session.load(Student.class, 1);
s.setName("李四");//级联更新，在修改name的同时修改idcard；
IdCard card=s.getCard();
card.setCardNo("0002");
s.setCard(card);
session.update(s);
// ---------------------------------
tran.commit();
} catch (Exception e) {
e.printStackTrace();
tran.rollback();
} finally {
if (null != session) {
session.close();
}
}
}
}
HibernateUtil.java
package com.lye.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;
/**
* 3.27
* 初始化Hibernate过程
* Configuration、SessionFactory、Session对象
*/
public class HibernateUtil {
public HibernateUtil() {
// TODO Auto-generated constructor stub
}
// SessionFactory实例（会话工厂）
private static SessionFactory sessionFactory = null;
//Configuration configuration = new Configuration();
/**
* 静态初始化 Hibernate
*/
static {
// 1 创建 StandardServiceRegistry 实例（标准注册服务）
// 1.1 创建 StandardServiceRegistryBuilder 实例（标准注册服务生成器）
// 1.2 从 hibernate.cfg.xml 配置文件中读取配置信息
// 1.3 构建 StandardServiceRegistry实例（标准注册服务）
StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();
try {
// 2 创建 SessionFactory 实例（会话工厂）
// 2.1 根据标准注册服务创建一个 MetadataSources 实例（元数据资源集）
// 2.2 构建元数据
// 2.3 生成应用一般唯一的 SessionFactory 实例（会话工厂）
sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
} catch (Exception e) {
// 2.4 创建失败手动释放 StandardServiceRegistry 实例
StandardServiceRegistryBuilder.destroy(registry);
e.printStackTrace();
}
}
/**
* 打开一个 Session 会话
* @return Session
*/
public static Session openSession() {
return sessionFactory.openSession();
}
}
hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--表明解析本XML文件的DTD文档位置，DTD是Document Type Definition 的缩写,即文档类型的定义,
XML解析器使用DTD文档来检查XML文件的合法性。hibernate.sourceforge.net/hibernate-configuration-3.0dtd可以在Hibernate3.1.3软件包中的src\org\hibernate目录中找到此文件-->
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<!--Hibernate配置文件的根元素,其他文件要包含在其中-->
<hibernate-configuration>
<!--SessionFactory是Hibernate中的一个类，这个类主要负责保存Hibernate的配置信息，以及对session的操作-->
<session-factory>
<!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
<!--配置数据库的驱动程序，Hibernate在连接数据库时，需要用到数据库的驱动程序-->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!--设置数据库的连接url:jdbc:mysql://localhost：3306/dbname,其中localhost表示mysql服务器名称，此处为本机， dbname是数据库名-->
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernatestu?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC</property>
<!-- 连接数据库时数据的传输字符集编码方式 -->
<property name="hibernate.connection.characterEncoding">UTF-8</property>
<!--连接数据库时的用户名-->
<property name="hibernate.connection.username">root</property>
<!--连接数据库时的密码-->
<property name="hibernate.connection.password">123456</property>
<!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于差错，
程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。项目部署后可以设置为false，提高运行效率-->
<property name="hibernate.show_sql">true</property>
<!-- 格式化输出的Sql语句 -->
<property name="hibernate.format_sql">true</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<!--指定映射文件，可映射多个映射文件-->
<!-- <mapping class="com.oto.entity.Student"/>
<mapping class="com.oto.entity.IdCard"/>
-->
<mapping resource="com/oto/entity/Student.hbm.xml"/>
<mapping resource="com/oto/entity/IdCard.hbm.xml"/>
</session-factory>
</hibernate-configuration>
2.学生与角色一对多关联
Role.java
package com.otm.entity;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.hibernate.annotations.Cascade;
@Entity
@Table(name="role")
public class Role {
private Integer id;//代理主键
private String name;
private Set<Student> students=new HashSet<Student>();//对应的员工的对象
public Role(){
}
public Role(Integer id, String name) {
this.id = id;
this.name = name;
}
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name="name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@OneToMany(targetEntity=Student.class,mappedBy="role",cascade=CascadeType.ALL)
public Set<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
}
@Override
public String toString() {
return "Role [id=" + id + ", name=" + name + "]";
}
}
Student.java
package com.otm.entity;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
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.Fetch;
import org.hibernate.annotations.Proxy;
//@Proxy(lazy=false)
@Entity
@Table(name="student")
public class Student {
private Integer id;
private String name;
private String telephone;
private Role role;
public Student(){
}
public Student(String name, String telephone) {
super();
this.name = name;
this.telephone = telephone;
}
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name="name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Column(name="telephone")
public String getTelephone() {
return telephone;
}
public void setTelephone(String telephone) {
this.telephone = telephone;
}
@ManyToOne
@JoinColumn(name="rid")
public Role getRole() {
return role;
}
public void setRole(Role role) {
this.role = role;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", telephone=" + telephone
+ "]";
}
}
Role.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.otm.entity">
<class name="Role" table="role" >
<id name="id" column="id" >
<generator class="identity">
</generator>
</id>
<property name="name" column="name" >
<!-- <column name="" sql-type=""></column> -->
</property>
<!-- inverse="true" lazy="true" outer-join="true" fetch="subselect" -->
<set name="students" cascade="all" inverse="true">
<!--inverse属性是谁维护外键（关联关系），是否放弃维护权，false：当前方维护外键，true：由对方维护外键，inverse="true"意思是让多方维护外键 -->
<key column="rid"></key>
<one-to-many class="Student"/>
</set>
</class>
</hibernate-mapping>
Student.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.otm.entity">
<class name="Student" table="student" >
<id name="id" column="id" >
<generator class="identity">
</generator>
</id>
<property name="name" column="name" />
<property name="telephone" column="telephone"></property>
<many-to-one name="role" column="rid" class="Role" outer-join="false" fetch="join"></many-to-one>
<!-- many-to-one不提供inverse属性，默认是false；不能设置 -->
</class>
</hibernate-mapping>
TestOtm.java
package com.otm.ui;
import java.util.List;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.query.Query;
import com.otm.entity.Role;
import com.otm.entity.Student;
import com.lye.util.HibernateUtil;
public class TestOtm {
/**
* 12.19 测试类--->使用基本对象查询
*/
public static void main(String[] args) {
save();
// delete();
// find();
// findZq();
}
public static void findZq() {
Session session = null;
Transaction tran = null;
try {
session = HibernateUtil.openSession();
tran = session.beginTransaction();
// ---------------------------------
Query query=session.createQuery("from Student");
List<Student> list = query.list();
for (Student s : list) {
System.out.println(s.getRole().getName());
}
tran.commit();
} catch (Exception e) {
e.printStackTrace();
tran.rollback();
} finally {
if (null != session) {
session.close();
}
}
}
public static void find() {
Session session = null;
Transaction tran = null;
try {
session = HibernateUtil.openSession();
tran = session.beginTransaction();
// ---------------------------------
//查询学生对象
Student student=session.load(Student.class, 6);
System.out.println(student.getName());
System.out.println(student.getRole().getName());
// ---------------------------------
tran.commit();
} catch (Exception e) {
e.printStackTrace();
tran.rollback();
} finally {
if (null != session) {
session.close();
}
}
}
/*
*
* 实现添加部门功能
*/
public static void save() {
Configuration cfg=new Configuration().configure();
SessionFactory factory=cfg.buildSessionFactory();
Session session=factory.openSession();
Transaction tran=session.beginTransaction();//这四种方法要记住，产生session的方法
Role role=new Role();
role.setName("超级管理员");
Student student1=new Student();
student1.setName("李四");
student1.setTelephone("1111111111");
// Student student2=new Student();
// student2.setName("小明");
// student2.setTelephone("3364");
student1.setRole(role);
// student2.setRole(role);
//员工为多方，由员工维护关联关系
/*
* 测试保存时的几种情况（不考虑级联）
* #.每个对象都需要save（），否则会报异常java.lang.IllegalStateException
* ##.双方关联一方，多方先后保存有什么不同？
* ###.双方维护外键，但多方不关联一方，save（全部）成功
* ###.双方维护外键，但多方不关联一方，save（一方）失败，保存瞬时对象
* ###.双方维护外键，但多方不关联一方，save（多方）成功
* <一方放弃维护权，使用inverse=true>
* 多方关联一方，只save（多方），这样由于保存多方时，会去维护外键，而用来维护外键的一方对象为瞬时态对象，所以一定保存失败
* 多方关联一方，只save（一方），会是什么结果？
*/
// session.save(department);
//在员工的映射文件设置级联的话就可以不用保存部门，保存员工的时候会同时保存部门
// session.save(employee1);//执行添加操作
// session.save(employee2);//在部门的配置文件设置了级联的情况下，可以只保存部门不用保存员工，在保存部门的同时会保存员工
//对象少的时候可以不使用级联，对象多时用
session.save(role);//注意先保存一方与多方的顺序问题
session.save(student1);
tran.commit();
session.close();
factory.close();
}
/*
*
* 实现部门删除功能
*/
public static void delete() {
Session session = null;
Transaction tran = null;
try {
session = HibernateUtil.openSession();
tran = session.beginTransaction();
// ---------------------------------
// 查找Department对象
Role role = session.load(Role.class, 1);
System.out.println(role.getName());
session.delete(role);
// ---------------------------------
tran.commit();
} catch (Exception e) {
e.printStackTrace();
tran.rollback();
} finally {
if (null != session) {
session.close();
}
}
}
}
/*
*
* 实现删除功能
*/
public static void delete() {
Session session = null;
Transaction tran = null;
try {
session = HibernateUtil.openSession();
tran = session.beginTransaction();
// ---------------------------------
// 查找Person对象
Student student = session.load(Student.class, 2);
System.out.println(student.getName());
session.delete(student);
// ---------------------------------
tran.commit();
} catch (Exception e) {
e.printStackTrace();
tran.rollback();
} finally {
if (null != session) {
session.close();
}
}
}
/*
* 实现修改功能
*/
public static void update() {
Session session = null;
Transaction tran = null;
try {
session = HibernateUtil.openSession();
tran = session.beginTransaction();
// ---------------------------------
// 查找Person对象
Student student = session.load(Student.class, 5);
student.setName("靓靓靓");
session.update(student);
// ---------------------------------
tran.commit();
} catch (Exception e) {
e.printStackTrace();
tran.rollback();
} finally {
if (null != session) {
session.close();
}
}
}
}
HibernateUtil.java
package com.lye.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;
/**
* 3.27
* 初始化Hibernate过程
* Configuration、SessionFactory、Session对象
*/
public class HibernateUtil {
public HibernateUtil() {
// TODO Auto-generated constructor stub
}
// SessionFactory实例（会话工厂）
private static SessionFactory sessionFactory = null;
//Configuration configuration = new Configuration();
/**
* 静态初始化 Hibernate
*/
static {
// 1 创建 StandardServiceRegistry 实例（标准注册服务）
// 1.1 创建 StandardServiceRegistryBuilder 实例（标准注册服务生成器）
// 1.2 从 hibernate.cfg.xml 配置文件中读取配置信息
// 1.3 构建 StandardServiceRegistry实例（标准注册服务）
StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();
try {
// 2 创建 SessionFactory 实例（会话工厂）
// 2.1 根据标准注册服务创建一个 MetadataSources 实例（元数据资源集）
// 2.2 构建元数据
// 2.3 生成应用一般唯一的 SessionFactory 实例（会话工厂）
sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
} catch (Exception e) {
// 2.4 创建失败手动释放 StandardServiceRegistry 实例
StandardServiceRegistryBuilder.destroy(registry);
e.printStackTrace();
}
}
/**
* 打开一个 Session 会话
* @return Session
*/
public static Session openSession() {
return sessionFactory.openSession();
}
}
hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--表明解析本XML文件的DTD文档位置，DTD是Document Type Definition 的缩写,即文档类型的定义,
XML解析器使用DTD文档来检查XML文件的合法性。hibernate.sourceforge.net/hibernate-configuration-3.0dtd可以在Hibernate3.1.3软件包中的src\org\hibernate目录中找到此文件-->
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<!--Hibernate配置文件的根元素,其他文件要包含在其中-->
<hibernate-configuration>
<!--SessionFactory是Hibernate中的一个类，这个类主要负责保存Hibernate的配置信息，以及对session的操作-->
<session-factory>
<!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
<!--配置数据库的驱动程序，Hibernate在连接数据库时，需要用到数据库的驱动程序-->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!--设置数据库的连接url:jdbc:mysql://localhost：3306/dbname,其中localhost表示mysql服务器名称，此处为本机， dbname是数据库名-->
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernatestu?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC</property>
<!-- 连接数据库时数据的传输字符集编码方式 -->
<property name="hibernate.connection.characterEncoding">UTF-8</property>
<!--连接数据库时的用户名-->
<property name="hibernate.connection.username">root</property>
<!--连接数据库时的密码-->
<property name="hibernate.connection.password">123456</property>
<!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于差错，
程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。项目部署后可以设置为false，提高运行效率-->
<property name="hibernate.show_sql">true</property>
<!-- 格式化输出的Sql语句 -->
<property name="hibernate.format_sql">true</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<!--指定映射文件，可映射多个映射文件-->
<!-- <mapping class="com.oto.entity.Student"/>
<mapping class="com.oto.entity.IdCard"/>
-->
<!-- <mapping resource="com/oto/entity/Student.hbm.xml"/>
<mapping resource="com/oto/entity/IdCard.hbm.xml"/> -->
<mapping resource="com/otm/entity/Student.hbm.xml"/>
<mapping resource="com/otm/entity/Role.hbm.xml"/>
</session-factory>
</hibernate-configuration>
3.学生与课程多对多关联
Course.java
package com.mtm.entity;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
@Entity
@Table(name="courses")
public class Course {
private Integer id;
private String name;
private Set<Student> students=new HashSet<Student>();
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@ManyToMany(mappedBy="courses")
public Set<Student> getStudents() {
return students;
}
public void setStudents(Set<Student> students) {
this.students = students;
}
@Override
public String toString() {
return "Course [id=" + id + ", name=" + name + ", students=" + students + "]";
}
}
Student.java
package com.mtm.entity;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;
@Entity
@Table(name="students")
public class Student {
private Integer id;
private String name;
private Set<Course> courses=new HashSet<Course>();
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@ManyToMany
@JoinTable(name="students_course",joinColumns=@JoinColumn(name="sid")
,inverseJoinColumns=@JoinColumn(name="cid"))
public Set<Course> getCourses() {
return courses;
}
public void setCourses(Set<Course> courses) {
this.courses = courses;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + ", courses=" + courses + "]";
}
}
Course.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.mtm.entity">
<class name="Course" table="m_course" >
<id name="id" column="id" >
<generator class="increment" />
</id>
<property name="name" column="name" />
<set name="students" table="m_student_course" inverse="true">
<key column="cid"></key>
<many-to-many class="Student" column="sid" ></many-to-many>
</set>
</class>
</hibernate-mapping>
Student.hbm.xml
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.mtm.entity">
<class name="Student" table="m_student" >
<id name="id" column="id" >
<generator class="increment" />
</id>
<property name="name" column="name" />
<set name="courses" table="m_student_course" cascade="all">
<key column="sid"></key>
<many-to-many class="Course" column="cid" ></many-to-many>
</set>
</class>
</hibernate-mapping>
TestMtm.java
package com.mtm.ui;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import com.lye.util.HibernateUtil;
import com.mtm.entity.Course;
import com.mtm.entity.Student;
public class TestMtm {
/**
* 12.14 测试类--->主要测试程序功能实现情况
*
*/
public TestMtm() {
}
public static void main(String[] args) {
save();
//update();
// delete();
//find();
}
public static void find() {
Configuration cfg=new Configuration().configure();
SessionFactory factory=cfg.buildSessionFactory();
Session session=factory.openSession();
Transaction tran=session.beginTransaction();
Student student=session.get(Student.class, 1);
System.out.println("当前用户是"+student.getName());
Set<Course> courses=student.getCourses();
for(Course course:courses){
System.out.println(course.getName());
}
tran.commit();
session.close();
factory.close();
}
/*
*
* 实现添加功能
*/
public static void save() {
Configuration cfg=new Configuration().configure();
SessionFactory factory=cfg.buildSessionFactory();
Session session=factory.openSession();
Transaction tran=session.beginTransaction();
Student student1=new Student();
student1.setName("小明");
Student student2=new Student();
student2.setName("小红");
Course course1=new Course();
course1.setName("JAVA");
Course course2=new Course();
course2.setName("C++");
//建立关联
student1.getCourses().add(course1);//由用户来维护关联，所以用户在前面
student1.getCourses().add(course2);
// role1.getStudent().add(student1);
// role2.getStudent().add(student1);
student2.getCourses().add(course1);
// role1.getStudent().add(student2);
session.save(student1);
session.save(student2);
session.save(course1);
session.save(course1);
tran.commit();
session.close();
factory.close();
}
/*
*
* 实现删除功能
*/
public static void delete() {
Session session = null;
Transaction tran = null;
try {
session = HibernateUtil.openSession();
tran = session.beginTransaction();
// ---------------------------------
// 查找Person对象
Student student = session.load(Student.class, 2);
System.out.println(student.getName());
session.delete(student);
// ---------------------------------
tran.commit();
} catch (Exception e) {
e.printStackTrace();
tran.rollback();
} finally {
if (null != session) {
session.close();
}
}
}
/*
* 实现修改功能
*/
public static void update() {
Session session = null;
Transaction tran = null;
try {
session = HibernateUtil.openSession();
tran = session.beginTransaction();
// ---------------------------------
// 查找Person对象
Student student = session.load(Student.class, 5);
student.setName("zhangsan");
session.update(student);
// ---------------------------------
tran.commit();
} catch (Exception e) {
e.printStackTrace();
tran.rollback();
} finally {
if (null != session) {
session.close();
}
}
}
}
HibernateUtil.java
package com.lye.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;
/**
* 3.27
* 初始化Hibernate过程
* Configuration、SessionFactory、Session对象
*/
public class HibernateUtil {
public HibernateUtil() {
// TODO Auto-generated constructor stub
}
// SessionFactory实例（会话工厂）
private static SessionFactory sessionFactory = null;
//Configuration configuration = new Configuration();
/**
* 静态初始化 Hibernate
*/
static {
// 1 创建 StandardServiceRegistry 实例（标准注册服务）
// 1.1 创建 StandardServiceRegistryBuilder 实例（标准注册服务生成器）
// 1.2 从 hibernate.cfg.xml 配置文件中读取配置信息
// 1.3 构建 StandardServiceRegistry实例（标准注册服务）
StandardServiceRegistry registry = new StandardServiceRegistryBuilder().configure().build();
try {
// 2 创建 SessionFactory 实例（会话工厂）
// 2.1 根据标准注册服务创建一个 MetadataSources 实例（元数据资源集）
// 2.2 构建元数据
// 2.3 生成应用一般唯一的 SessionFactory 实例（会话工厂）
sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
} catch (Exception e) {
// 2.4 创建失败手动释放 StandardServiceRegistry 实例
StandardServiceRegistryBuilder.destroy(registry);
e.printStackTrace();
}
}
/**
* 打开一个 Session 会话
* @return Session
*/
public static Session openSession() {
return sessionFactory.openSession();
}
}
hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!--表明解析本XML文件的DTD文档位置，DTD是Document Type Definition 的缩写,即文档类型的定义,
XML解析器使用DTD文档来检查XML文件的合法性。hibernate.sourceforge.net/hibernate-configuration-3.0dtd可以在Hibernate3.1.3软件包中的src\org\hibernate目录中找到此文件-->
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<!--Hibernate配置文件的根元素,其他文件要包含在其中-->
<hibernate-configuration>
<!--SessionFactory是Hibernate中的一个类，这个类主要负责保存Hibernate的配置信息，以及对session的操作-->
<session-factory>
<!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
<!--配置数据库的驱动程序，Hibernate在连接数据库时，需要用到数据库的驱动程序-->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!--设置数据库的连接url:jdbc:mysql://localhost：3306/dbname,其中localhost表示mysql服务器名称，此处为本机， dbname是数据库名-->
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernatestu?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC</property>
<!-- 连接数据库时数据的传输字符集编码方式 -->
<property name="hibernate.connection.characterEncoding">UTF-8</property>
<!--连接数据库时的用户名-->
<property name="hibernate.connection.username">root</property>
<!--连接数据库时的密码-->
<property name="hibernate.connection.password">123456</property>
<!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于差错，
程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。项目部署后可以设置为false，提高运行效率-->
<property name="hibernate.show_sql">true</property>
<!-- 格式化输出的Sql语句 -->
<property name="hibernate.format_sql">true</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<!--指定映射文件，可映射多个映射文件-->
<!-- <mapping class="com.oto.entity.Student"/>
<mapping class="com.oto.entity.IdCard"/>
-->
<!-- <mapping resource="com/oto/entity/Student.hbm.xml"/>
<mapping resource="com/oto/entity/IdCard.hbm.xml"/> -->
<!-- <mapping resource="com/mtm/entity/Student.hbm.xml"/>
<mapping resource="com/mtm/entity/Course.hbm.xml"/> -->
<mapping resource="com/otm/entity/Student.hbm.xml"/>
<mapping resource="com/otm/entity/Role.hbm.xml"/>
</session-factory>
</hibernate-configuration>
1572
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
