一对一双向注解方式

需求：

1. 通过hibernate 1对1双向映射关系，使用注解方式，在数据库中，自动创建一个观众表(t_viewer),和一个电影票表(t_ticket)

2. 观众表字段如下:id(观众号),name(观众姓名)

3. 电影票表字段如下:id(票号),name(座位名)

4. 在观众表中插入小组同学的数据

5. 在电影票表中插入电影票数据

要求:

1.每个小组同学一张票

把以上的数据以及数据间1对1关系编程实现.

具体实现：

项目结构：

编写model类

Ticket类

package com.model;

import java.io.Serializable;

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.OneToOne;

import javax.persistence.Table;

@Entity

@Table(name="t_ticket")

public classTicket implements Serializable {

private int tid;

private String tname;

private Viewer viewer;

@Id

@GeneratedValue(strategy=GenerationType.IDENTITY)

@Column(name="tid")

public int getTid() {

return tid;

}

public void setTid(int tid) {

this.tid = tid;

}

@Column(name="tname",length=20)

public String getTname() {

return tname;

}

public void setTname(String tname) {

this.tname = tname;

}

//一对一viewer类中ticket属性映射到ticket类，故save viewer的时候就能save ticket，

@OneToOne(mappedBy="ticket",cascade=CascadeType.ALL)

public Viewer getViewer() {

return viewer;

}

public void setViewer(Viewer viewer) {

this.viewer = viewer;

}

Viewer类

package com.model;

import java.io.Serializable;

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.JoinColumn;

import javax.persistence.OneToOne;

import javax.persistence.Table;

@Entity

@Table(name="t_viewer")

public classViewer implements Serializable {

private int vid;

private String vname;

private Ticket ticket;

@Id

@GeneratedValue(strategy=GenerationType.IDENTITY)

@Column(name="vid")

public int getVid() {

return vid;

}

public void setVid(int vid) {

this.vid = vid;

}

@Column(name="vname")

public String getVname() {

return vname;

}

public void setVname(String vname) {

this.vname = vname;

}

//一对一关系，连接的列名是ticket的tid属性

@OneToOne(cascade=CascadeType.ALL)

@JoinColumn(name="tid")

public Ticket getTicket() {

return ticket;

}

public void setTicket(Ticket ticket) {

this.ticket = ticket;

}

配置hibernate.cfg.xml

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPE hibernate-configurationPUBLIC

"-//Hibernate/HibernateConfiguration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

<property name="hibernate.connection.url">jdbc:mysql://127.0.0.1:3306/hiber?useUnicode=true&characterEncoding=UTF-8</property>

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

<property name="hbm2ddl.auto">create</property>

</session-factory>

</hibernate-configuration>

测试类

package com.Test;

import org.hibernate.Session;

import org.hibernate.Transaction;

import com.db.util.HiberDBUtil;

import com.model.Ticket;

import com.model.Viewer;

public class TestForOtO {

public static void main(String[] args) {

Session session=HiberDBUtil.getSession();

Ticket ticket1=new Ticket();

ticket1.setTname("票1");

Viewer viewer1=new Viewer();

viewer1.setVname("小静");

viewer1.setTicket(ticket1);

Ticket ticket2=new Ticket();

ticket2.setTname("票2");

Viewer viewer2=new Viewer();

viewer2.setVname("小珊");

viewer2.setTicket(ticket2);

Transaction tr = session.beginTransaction();

try {

session.save(viewer1);

session.save(viewer2);

tr.commit();

} catch (Exception e) {

tr.rollback();

}finally{

HiberDBUtil.closeSession();

}

结果截图：

双向多对多注解方式

需求：

6. 通过hibernate多对多双向映射关系，使用XML文件配置方式，在数据库中，自动创建一个权限表(t_role),和一个组表(t_group)

7. 权限表字段如下:id(权限号),name(权限名称)

8. 组表字段如下:id(组号),name(组名)

9. 在权限表中插入如下数据:

读文件权限

写文件权限

服务器管理权限

管理用户权限

10. 在组表在权限表中插入如下数据:

系统管理员

一般用户

访问者

11. 要求实现下面关系:

(1) 访问者只可以读文件

(2) 一般用户拥有读,写文件权限

(3) 系统管理员拥有以上所有权限.

把以上的数据以及多对多关系编程实现.

组表中添加权限

具体实现：

项目结构：

编写model类

Role类

package com.model;

import java.io.Serializable;

import java.util.HashSet;

import java.util.Set;

import javax.persistence.CascadeType;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.ManyToMany;

import javax.persistence.Table;

@Entity

@Table(name="t_role")

public classRole implements Serializable {

private int rid;

private String rname;

private Set<Group> group=new HashSet<Group>();

@Id

@Column(name="rid")

public int getRid() {

return rid;

}

public void setRid(int rid) {

this.rid = rid;

}

@Column(name="rname")

public String getRname() {

return rname;

}

public void setRname(String rname) {

this.rname = rname;

}

//Group类中的role属性映射到Role类中，故save group的时候就能save role表

@ManyToMany(mappedBy="role",cascade=CascadeType.ALL)

public Set<Group>getGroup() {

return group;

}

public voidsetGroup(Set<Group> group) {

this.group = group;

}

Group类

package com.model;

import java.io.Serializable;

import java.util.HashSet;

import java.util.Set;

import javax.persistence.CascadeType;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.JoinTable;

import javax.persistence.ManyToMany;

import javax.persistence.Table;

import javax.persistence.JoinColumn;;

@Entity

@Table(name="t_group")

public classGroup implements Serializable {

private int gid;

private String gname;

private Set<Role> role=new HashSet<Role>();

@Id

@Column(name="gid")

public int getGid() {

return gid;

}

public void setGid(int gid) {

this.gid = gid;

}

@Column(name="gname")

public String getGname() {

return gname;

}

public void setGname(String gname) {

this.gname = gname;

}

//产生中间表，定义中间表的表名和列的属性

@ManyToMany(cascade=CascadeType.ALL)

@JoinTable(

name="t_role_group",

joinColumns=@JoinColumn(name="gid"),

inverseJoinColumns=@JoinColumn(name="rid")

)

public Set<Role>getRole() {

return role;

}

public void setRole(Set<Role>role){

this.role = role;

}

配置hibernate.cfg.xml

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/HibernateConfiguration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

<property name="hibernate.connection.url">jdbc:mysql://127.0.0.1:3306/hiber?useUnicode=true&characterEncoding=UTF-8</property>

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

<property name="hbm2ddl.auto">create</property>

</session-factory>

</hibernate-configuration>

测试类

package com.Test;

import org.hibernate.Session;

import org.hibernate.Transaction;

import com.db.util.HiberDBUtil;

import com.model.Group;

import com.model.Role;

public classTestForMtM {

public static void main(String[] args) {

Sessionsession=HiberDBUtil.getSession();

Rolerole1=new Role();

role1.setRid(1);

role1.setRname("读文件权限");

Rolerole2=new Role();

role2.setRid(2);

role2.setRname("写文件权限");

Rolerole3=new Role();

role3.setRid(3);

role3.setRname("服务器管理权限");

Rolerole4=new Role();

role4.setRid(4);

role4.setRname("管理用户权限");

Groupgroup1=new Group();

group1.setGid(11);

group1.setGname("系统管理员");

group1.getRole().add(role1);

group1.getRole().add(role2);

group1.getRole().add(role3);

group1.getRole().add(role4);

Groupgroup2=new Group();

group2.setGid(12);

group2.setGname("一般用户");

group2.getRole().add(role1);

group2.getRole().add(role2);

Groupgroup3=new Group();

group3.setGid(13);

group3.setGname("访问者");

group3.getRole().add(role1);

Transactiontr = session.beginTransaction();

try {

session.save(group1);

session.save(group2);

session.save(group3);

session.save(role1);

session.save(role2);

session.save(role3);

session.save(role4);

tr.commit();

} catch (Exception e) {

tr.rollback();

}finally{

HiberDBUtil.closeSession();

}

结果截图

双向一对多注解方式

需求：

1.通过hibernate一对多双向映射关系，使用XML文件配置方式，在数据库中，自动创建商品表(g_item),和商品种类表(g_type)

2.创建商品表(goods_item)的字段如下：

商品ID(goodsId)

商品名称(goodsName)

商品价格(goodsPrice)

商品产地(prcPlace)

商品种类ID(tId)

3.商品种类表(goods_type)的字段如下：

商品种类ID(tId)

商品种类名称ID(tName)

商品种类描述(tDebe)

4.使用add方法,在商品种类表，插入如下的数据：

商品种类ID 商品种类名称商品种类描述

1001 日常用品人们每天使用的物品

1002 食品包括熟食品，方便食品等

1003 电器各种通过电力工作的电子产品

在商品表，插入如下的数据：

商品ID 商品名称商品价格商品产地商品种类ID

10001 牙刷7.85 广州市 1001

10002 火腿肠9.6 浙江金华 1002

10003 方便面 15.8 天津 1002

10004电水壶 213 深圳市 1003

10005 电冰箱 3618 青岛 1004

具体实现：

项目结构：

编写model类

CopyGoods_type类

package com.model;

import java.util.HashSet;

import java.util.Set;

importjavax.persistence.CascadeType;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.OneToMany;

import javax.persistence.Table;

@Entity

@Table(name="copy_type")

public class CopyGoods_type {

/*商品种类ID(tId)

商品种类名称ID(tName)

商品种类描述(tDebe)*/

privateint tid;

privateString tname;

privateString tdebe;

privateSet<CopyGoods_item> items=new HashSet<CopyGoods_item>();

@Id

@Column(name="tid")

publicint getTid() {

returntid;

}

publicvoid setTid(int tid) {

this.tid= tid;

}

@Column(name="tname")

publicString getTname() {

returntname;

}

publicvoid setTname(String tname) {

this.tname= tname;

}

@Column(name="tdebe")

publicString getTdebe() {

returntdebe;

}

publicvoid setTdebe(String tdebe) {

this.tdebe= tdebe;

}

//item类中的type映射到type类中，保存item类的时候就能保存type

@OneToMany(cascade=CascadeType.ALL,mappedBy="type")

public Set<CopyGoods_item> getItems() {

returnitems;

}

publicvoid setItems(Set<CopyGoods_item> items) {

this.items= items;

}

CopyGoods_item类

package com.model;

importjavax.persistence.CascadeType;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.Id;

import javax.persistence.JoinColumn;

import javax.persistence.ManyToOne;

import javax.persistence.Table;

@Entity

@Table(name="copy_item")

public class CopyGoods_item {

privateint goodsId;

privateString goodsName;

privatedouble goodsPrice;

privateString prcPlace;

privateCopyGoods_type type;

@Id

@Column(name="goodsId")

publicint getGoodsId() {

returngoodsId;

}

publicvoid setGoodsId(int goodsId) {

this.goodsId= goodsId;

}

@Column(name="goodsName")

publicString getGoodsName() {

returngoodsName;

}

publicvoid setGoodsName(String goodsName) {

this.goodsName= goodsName;

}

@Column(name="goodsPrice")

publicdouble getGoodsPrice() {

returngoodsPrice;

}

publicvoid setGoodsPrice(double goodsPrice) {

this.goodsPrice= goodsPrice;

}

@Column(name="prcPlace")

publicString getPrcPlace() {

returnprcPlace;

}

publicvoid setPrcPlace(String prcPlace) {

this.prcPlace= prcPlace;

}

//多对一关系，设置连接的列是 type类中的tId

@ManyToOne(cascade=CascadeType.ALL)

@JoinColumn(name="tId")

publicCopyGoods_type getType() {

returntype;

}

publicvoid setType(CopyGoods_type type) {

this.type= type;

}

配置hibernate.cfg.xml

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/HibernateConfiguration DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

<property name="hibernate.connection.url">jdbc:mysql://127.0.0.1:3306/hiber?useUnicode=true&characterEncoding=UTF-8</property>

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

<property name="hbm2ddl.auto">create</property>

</session-factory>

</hibernate-configuration>

测试类

package com.Test;

import org.hibernate.Session;

import org.hibernate.Transaction;

import com.db.util.HiberDBUtil;

import com.model.CopyGoods_item;

import com.model.CopyGoods_type;

import com.model.CopyGoods_item;

import com.model.CopyGoods_type;

public class TestOne {

publicstatic void main(String[] args) {

Session session=HiberDBUtil.getSession();

CopyGoods_typetype1=new CopyGoods_type();

type1.setTid(1001);

type1.setTname("日常用品");

type1.setTdebe("人们每天使用的物品");

CopyGoods_typetype2=new CopyGoods_type();

type2.setTid(1002);

type2.setTname("食品");

type2.setTdebe("包括熟食品，方便食品等");

CopyGoods_typetype3=new CopyGoods_type();

type3.setTid(1003);

type3.setTname("电器");

type3.setTdebe("各种通过电力工作的电子产品");

CopyGoods_itemitem1=new CopyGoods_item();

item1.setGoodsId(10001);

item1.setGoodsName("牙刷");

item1.setGoodsPrice(7.85);

item1.setPrcPlace("广州市");

CopyGoods_itemitem2=new CopyGoods_item();

item2.setGoodsId(10002);

item2.setGoodsName("火腿肠");

item2.setGoodsPrice(7.85);

item2.setPrcPlace("广州市");

CopyGoods_itemitem3=new CopyGoods_item();

item3.setGoodsId(10003);

item3.setGoodsName("方便面 ");

item3.setGoodsPrice(15.8);

item3.setPrcPlace("天津 ");

CopyGoods_itemitem4=new CopyGoods_item();

item4.setGoodsId(10004);

item4.setGoodsName("电水壶 ");

item4.setGoodsPrice(213);

item4.setPrcPlace("深圳市");

CopyGoods_itemitem5=new CopyGoods_item();

item5.setGoodsId(10005);

item5.setGoodsName("电冰箱 ");

item5.setGoodsPrice(3618);

item5.setPrcPlace("青岛 ");

item1.setType(type1);

item2.setType(type2);

item3.setType(type2);

item4.setType(type3);

item5.setType(type3);

Transactiontr = session.beginTransaction();

try {

session.save(item1);

session.save(item2);

session.save(item3);

session.save(item4);

session.save(item5);

tr.commit();

} catch (Exception e) {

tr.rollback();

}finally{

HiberDBUtil.closeSession();

}

结果截图：

附加=HiberDBUtil类

packagecom.db.util;

import org.hibernate.Session;

importorg.hibernate.SessionFactory;

importorg.hibernate.cfg.Configuration;

public classHiberDBUtil {

private static StringCONFIG_FILE_LOCATION="/com/cfg/hibernate.cfg.xml";

private static Configuration config=new Configuration();

private static SessionFactory sessionFac;

private static ThreadLocal<Session>tdlocal=new ThreadLocal<Session>();

private static Stringconfigfile=CONFIG_FILE_LOCATION;

//静态数据块加载配置文件，生成sessionFactory

static{

try{

//加载配置文件

config.configure(configfile);

//通过配置文件加载sessionFactory

sessionFac=config.buildSessionFactory();

}catch(Exception e){

e.printStackTrace();

}

private HiberDBUtil(){

}

public static Session getSession(){

Session session=(Session)tdlocal.get();

if(null==session||!session.isOpen()){

if(sessionFac==null){

reBuildSessonFac();

}

session=(sessionFac!=null)?sessionFac.openSession():null;

tdlocal.set(session);

}

return session;

}

public static void reBuildSessonFac(){

try{

//加载配置文件

config.configure(configfile);

//通过配置文件加载sessionFactory

sessionFac=config.buildSessionFactory();

}catch(Exception e){

e.printStackTrace();

}

public static void closeSession(){

Session session=tdlocal.get();

tdlocal.set(null);

if(session!=null){

session.close();

}

public static SessionFactorygetSessionFactory(){

return sessionFac;

}

hibernate关系注解方式

一对一双向注解方式

需求：

具体实现：

编写model类

配置hibernate.cfg.xml

测试类

结果截图：

双向多对多注解方式

需求：

具体实现：

编写model类

配置hibernate.cfg.xml

测试类

结果截图

双向一对多注解方式

需求：

具体实现：

编写model类

配置hibernate.cfg.xml

测试类

结果截图：

猜你喜欢