Hibernate One-to-One Mappings 一对一关系映射
Hibernate One-to-One Mappings 一对一关系映射
关键:一对一关系映射和多对一关系映射非常像。仅仅是unique 属性值为 true
样例:一个员工仅仅能有一个地址。
1、创建Hibernate的配置文件(hibernate.cfg.xml)
2、创建持久化类,即事实上例须要保存到数据库中的类(Employee.java)
3、创建对象-关系映射文件(Employee.hbm.xml)4、通过Hibernate API编写訪问数据库的代码
-------------------------------------------------------------------------------------------------------------
一、创建Hibernate的配置文件(hibernate.cfg.xml)
<?xml version="1.0" encoding="utf-8"?
>
<!DOCTYPE hibernate-configuration SYSTEM
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- Assume testone is the database name -->
<property name="hibernate.connection.url">jdbc:mysql://localhost/testOne2One</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.show_sql">true</property>
<!-- List of XML mapping files -->
<mapping resource="resource/Employee.hbm.xml" />
</session-factory>
</hibernate-configuration>
二、创建持久化类,即事实上例须要保存到数据库中的类(Employee.java)
package com.jiangge.hblearn;
/**
* @author jiangge
* @version 2014-7-4 下午12:51:30
*/
public class Employee
{
private int id;
private String firstName;
private String lastName;
private int salary;
private Address address;
public Employee()
{
}
public Employee(String fname, String lname, int salary, Address address)
{
this.firstName = fname;
this.lastName = lname;
this.salary = salary;
this.address = address;
}
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public String getFirstName()
{
return firstName;
}
public void setFirstName(String first_name)
{
this.firstName = first_name;
}
public String getLastName()
{
return lastName;
}
public void setLastName(String last_name)
{
this.lastName = last_name;
}
public int getSalary()
{
return salary;
}
public void setSalary(int salary)
{
this.salary = salary;
}
public Address getAddress()
{
return address;
}
public void setAddress(Address address)
{
this.address = address;
}
}
Address.java 文件:
package com.jiangge.hblearn;
/**
* @author jiangge
* @version 2014-7-4 下午12:51:50
*
*/
public class Address
{
private int id;
private String street;
private String city;
private String state;
private String zipcode;
public Address()
{
}
public Address(String street, String city, String state, String zipcode)
{
this.street = street;
this.city = city;
this.state = state;
this.zipcode = zipcode;
}
public int getId()
{
return id;
}
public void setId(int id)
{
this.id = id;
}
public String getStreet()
{
return street;
}
public void setStreet(String street)
{
this.street = street;
}
public String getCity()
{
return city;
}
public void setCity(String city)
{
this.city = city;
}
public String getState()
{
return state;
}
public void setState(String state)
{
this.state = state;
}
public String getZipcode()
{
return zipcode;
}
public void setZipcode(String zipcode)
{
this.zipcode = zipcode;
}
}
创建MySQL数据库中相应的表:
create table EMPLOYEE (
id INT NOT NULL auto_increment,
first_name VARCHAR(20) default NULL,
last_name VARCHAR(20) default NULL,
salary INT default NULL,
address INT NOT NULL,
PRIMARY KEY (id)
);
create table ADDRESS (
id INT NOT NULL auto_increment,
street_name VARCHAR(40) default NULL,
city_name VARCHAR(40) default NULL,
state_name VARCHAR(40) default NULL,
zipcode VARCHAR(10) default NULL,
PRIMARY KEY (id)
);
三、创建对象-关系映射文件(Employee.hbm.xml)
<?xml version="1.0" encoding="utf-8"?
>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<!--
A one-to-one association is similar to many-to-one association with a difference that the column will be set as unique.
The <many-to-one> element is used to set the relationship between EMPLOYEE and ADDRESS entities.
The name attribute is set to the defined variable in the parent class, in our case it is address.
The column attribute is used to set the column name in the parent table EMPLOYEE
which is set to unique so that only one Employee object can be associated with an address object
-->
<hibernate-mapping>
<class name="com.jiangge.hblearn.Employee" table="EMPLOYEE">
<meta attribute="class-description">
This class contains the employee detail.
</meta>
<id name="id" type="int" column="id">
<generator class="native" />
</id>
<property name="firstName" column="first_name" type="string" />
<property name="lastName" column="last_name" type="string" />
<property name="salary" column="salary" type="int" />
<many-to-one name="address" column="address" unique="true" class="com.jiangge.hblearn.Address" not-null="true" />
</class>
<class name="com.jiangge.hblearn.Address" table="ADDRESS">
<meta attribute="class-description">
This class contains the address detail.
</meta>
<id name="id" type="int" column="id">
<generator class="native" />
</id>
<property name="street" column="street_name" type="string" />
<property name="city" column="city_name" type="string" />
<property name="state" column="state_name" type="string" />
<property name="zipcode" column="zipcode" type="string" />
</class>
</hibernate-mapping>
四、通过Hibernate API编写訪问数据库的代码:
一对一关系的測试类。CURD操作
package test;
/**
* @author jiangge
* @version 2014-7-4 下午12:57:56
*/
import java.util.Iterator;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import com.jiangge.hblearn.Address;
import com.jiangge.hblearn.Employee;
/**
* 一对一关系測试类:
* CRUD操作
* @author jiangge
*
*/
public class ManageEmployee
{
private static SessionFactory factory;
public static void main(String[] args)
{
try
{
factory = new Configuration().configure().buildSessionFactory();
} catch (Throwable ex)
{
System.err.println("Failed to create sessionFactory object." + ex);
throw new ExceptionInInitializerError(ex);
}
ManageEmployee ME = new ManageEmployee();
/* Let us have one address object */
Address address1 = ME.addAddress("Kondapur", "Hyderabad", "AP", "532");
/* Add employee records in the database */
Integer empID1 = ME.addEmployee("Manoj", "Kumar", 4000, address1);
/* Let us have another address object */
Address address2 = ME.addAddress("Saharanpur", "Ambehta", "UP", "111");
/* Add another employee record in the database */
Integer empID2 = ME.addEmployee("Dilip", "Kumar", 3000, address2);
/* List down all the employees */
ME.listEmployees();
/* Update employee's salary records */
ME.updateEmployee(empID1, 5000);
/* List down all the employees */
ME.listEmployees();
}
/* Method to add an address record in the database */
public Address addAddress(String street, String city, String state, String zipcode)
{
Session session = factory.openSession();
Transaction tx = null;
Integer addressID = null;
Address address = null;
try
{
tx = session.beginTransaction();
address = new Address(street, city, state, zipcode);
addressID = (Integer) session.save(address);
tx.commit();
}
catch (HibernateException e)
{
if (tx != null)
tx.rollback();
e.printStackTrace();
}
finally
{
session.close();
}
return address;
}
/* Method to add an employee record in the database */
public Integer addEmployee(String fname, String lname, int salary, Address address)
{
Session session = factory.openSession();
Transaction tx = null;
Integer employeeID = null;
try
{
tx = session.beginTransaction();
Employee employee = new Employee(fname, lname, salary, address);
employeeID = (Integer) session.save(employee);
tx.commit();
}
catch (HibernateException e)
{
if (tx != null)
tx.rollback();
e.printStackTrace();
}
finally
{
session.close();
}
return employeeID;
}
/* Method to list all the employees detail */
public void listEmployees()
{
Session session = factory.openSession();
Transaction tx = null;
try
{
tx = session.beginTransaction();
List employees = session.createQuery("FROM Employee").list();
for (Iterator iterator = employees.iterator(); iterator.hasNext();)
{
Employee employee = (Employee) iterator.next();
System.out.print("First Name: " + employee.getFirstName());
System.out.print(" Last Name: " + employee.getLastName());
System.out.println(" Salary: " + employee.getSalary());
Address add = employee.getAddress();
System.out.println("Address ");
System.out.println("\tStreet: " + add.getStreet());
System.out.println("\tCity: " + add.getCity());
System.out.println("\tState: " + add.getState());
System.out.println("\tZipcode: " + add.getZipcode());
}
tx.commit();
}
catch (HibernateException e)
{
if (tx != null)
tx.rollback();
e.printStackTrace();
}
finally
{
session.close();
}
}
/* Method to update salary for an employee */
public void updateEmployee(Integer EmployeeID, int salary)
{
Session session = factory.openSession();
Transaction tx = null;
try
{
tx = session.beginTransaction();
Employee employee = (Employee) session.get(Employee.class, EmployeeID);
employee.setSalary(salary);
session.update(employee);
tx.commit();
}
catch (HibernateException e)
{
if (tx != null)
tx.rollback();
e.printStackTrace();
}
finally
{
session.close();
}
}
}
五、执行结果:
数据库中
watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveGlhb3dhbmdnZWRlZ2U=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />
參考文献:
英文 http://www.tutorialspoint.com/hibernate/hibernate_one_to_one_mapping.htm
Hibernate One-to-One Mappings 一对一关系映射的更多相关文章
- Hibernate学习笔记(五) — 多对多关系映射
多对多关系映射 多对多建立关系相当于在第三张表中插入一行数据 多对多解除关系相当于在第三张表中删除一行数据 多对多改动关系相当于在第三张表中先删除后添加 多对多谁维护效率都一样.看需求 在实际开发过程 ...
- 问题记录:EntityFramework 一对一关系映射
EntityFramework 一对一关系映射有很多种,比如主键作为关联,配置比较简单,示例代码: public class Teacher { public int Id { get; set; } ...
- JavaEE之Hibernate(开放源代码的对象关系映射框架)
Hibernate(开放源代码的对象关系映射框架) 1.简介 Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全 ...
- mybatis中一对一关系映射
一对一关系中普通的配置方式 一.多表连接查询语句: <select id="selectStudentWithAddress" parameterType="int ...
- hibernate(五) hibernate一对一关系映射详解
序言 之前讲解了一对多(单向.双向).多对多(双向),今天就讲解一下最后一个关系,一对一. 心情不错.状态也挺好的,赶紧写一篇博文造福一下大家把. --WH 一.一对一关系的概述 一对一关系看起来简单 ...
- Hibernate一对一关系映射
Hibernate提供了两种一对一映射关联关系的方式: 1)按照外键映射 2)按照主键映射 下面以员工账号表和员工档案表(员工账号和档案表之间是一对一的关系)为例,介绍这两种映射关系,并使用这两种 映 ...
- Hibernate学习笔记(四)关系映射之一对一关联映射
一. 一对一关联映射 ² 两个对象之间是一对一的关系,如Person-IdCard(人—身份证号) ² 有两种策略可以实现一对一的关联映射 Ø 主键关联:即让 ...
- Hibernate 、多表关联映射 - 一对一关系映射(one- to-one)
hibernate.cfg.xml: <hibernate-configuration> <session-factory name="sessionFactory&quo ...
- Hibernate学习笔记三:对象关系映射(一对一,一对多,多对一,多对多)
如需转载,请说明出处:http://www.cnblogs.com/gudu1/p/6895610.html Hibernate通过关系映射来表示数据库中表与表之间的关系,关系映射可以通过两种方式:配 ...
随机推荐
- 关于hugepages 3.txt
关于hugepages 3.txt --//有一段时间我一直强调安装oracle一定要配置hugepage,因为现在的服务器内存越来越大,如果还使用4K的页面表,如果内存表占用内存巨大, --//特别 ...
- hdu3544找规律
如果x>1&&y>1,可以简化到其中一个为1的情况,这是等价的,当其中一个为1(假设为x),另一个一定能执行y-1次, 这是一个贪心问题,把所有的执行次数加起来比较就能得到 ...
- 第五天 Linux基本命令
tty控制台终端 tty1~tty6? ctrl + alt + F2~F6 切换控制台 alt + F1 返回 但是使用 在图形化界面,使用init 3后,不能使用alt + F1返回,因为两者 ...
- Graphviz(转载)
简述 原文: http://www.tuicool.com/articles/vy2Ajyu 本文翻译自 Drawing Graphs using Dot and Graphviz 1. 许可 Cop ...
- HDU 2795 线段树单点更新
Billboard Time Limit: 20000/8000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total ...
- Day11 - Python操作memcache、redis缓存、rabbitMQ队列
本周课前必备: 1. Memcached 2. Python操作Memcached模块: https://pypi.python.org/pypi/python-memcached 3. Redis ...
- 013——数组(十三) array_push array_rand array_reverse
<?php /* 数组 array_push array_rand array_reverse */ //array_push()在数组的末端,增加一个或多个元素,入栈 /*$array = a ...
- ASP.NET MVC 路由系统类
RouteData public class RouteData { private RouteValueDictionary _dataTokens; private IRouteHandler _ ...
- nginx的编译,和简单的配置问题
反向代理常见的lvs.haproxy. 缓存服务常见的.squid.vanish.常见的前端缓存.Apache是多进程的web服务器,Nginx是多线程的web服务器. Nginx的特点,对静态能力强 ...
- MySQL Batched Key Access
Batched Key Access是MySQL 5.6 版本中的新特性,是一种用户提高表join性能的算法.[Batched Key Access] 对于多表join语句,当MySQL使 ...