在业务成的域模型中，类和类之间最普遍的关系就是关联关系，而关联也是有方向的。
就以例子来说明：一个人对应一张身份证。对其进行增删改。
对于人在数据创建表的时候，我们就给他两个字段，一个是id号，一个就是名字。
那么对于身份证也就是两个字段，一个对应于一个人相同的id号，一个就是身份证码。
1 那么来创建数据库表：
人为主表，身份证为从表。
create table person(
id bigint primary key auto_increment,
userName varchar(20)
); create table card(
id bigint primary key,
cardNo varchar(18)
);
创建实体类的时候，人要引用身份证卡的信息，同样身份证卡也要引用人这个类。
2 那么来创建实体类：
人：
package com.cy.beans;
import java.io.Serializable;
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private long id;
private String userName;
private Card card;// 卡 一对一关联
public void person() {
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Card getCard() {
return card;
}
public void setCard(Card card) {
this.card = card;
}
@Override
public String toString() {
return "Person [id=" + id + ", userName=" + userName + ", card=" + card
+ "]";
}
}
身份证：
package com.cy.beans;
import java.io.Serializable;
public class Card implements Serializable{
private static final long serialVersionUID = 1L;
private long id;
private String cardNo;
private Person person;//人 一对一关联
public Card(){
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getCardNo() {
return cardNo;
}
public void setCardNo(String cardNo) {
this.cardNo = cardNo;
}
public Person getPerson() {
return person;
}
public void setPerson(Person person) {
this.person = person;
}
@Override
public String toString() {
return "Card [id=" + id + ", cardNo=" + cardNo + ", person=" + person
+ "]";
}
}
现在创建映射文件
Person.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.cy.beans.Person" table="person" catalog="j2ee"> <!-- catalog数据库 --> <id name="id" type="java.lang.Long"><!-- 此行的ID，为对象的属性ID -->
<column name="id"></column><!-- 此行的ID，为表字段ID -->
<generator class="increment"></generator><!-- 给id指定生成策略 -->
</id> <property name="userName" type="java.lang.String">
<column name="userName"></column>
</property> <!--站在主对象的一方来设置级联关系 -->
<!-- cascade定义的是关系两端对象到对象的级联关系,cascade有四個取值，all，none，save-update，delete
all : 所有情况下均进行关联操作。
none：所有情况下均不进行关联操作。这是默认值。
save-update:在执行save/update/saveOrUpdate时进行关联操作。
delete：在执行delete时进行关联操作。 -->
<one-to-one name="card" class="com.cy.beans.Card" cascade="all"></one-to-one> </class> </hibernate-mapping>
Card.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping>
<class name="com.cy.beans.Card" table="card" catalog="j2ee"> <!-- catalog数据库 -->
<id name="id" type="java.lang.Long"><!-- 此行的ID，为对象的属性ID -->
<column name="id"></column><!-- 此行的ID，为表字段ID -->
<generator class="foreign"><!-- foreign主键生成器 -->
<param name="property">person</param><!--类属性 -->
</generator>
</id> <property name="cardNo" type="java.lang.String">
<column name="cardNo"></column>
</property>
<!--站在从对象的一方来设置交出约束 -->
<!-- name:一对一节点 ，constrained： 约束（必须为true） -->
<one-to-one name="person" class="com.cy.beans.Person" constrained="true"></one-to-one> </class>
</hibernate-mapping>
在hibernate.cfg.xml里添加对象xml文件：
1 <mapping resource="com/cy/xmls/Person.hbm.xml"/>
<mapping resource="com/cy/xmls/Card.hbm.xml"/>
工具类：
package com.cy.tools; import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry; /**
* session工厂的工具类
* @author acer
*
*/ public class HibernateUtils { private static Configuration cfg;
private static SessionFactory sessionFactory;
private static ServiceRegistry serviceRegistry; static{ cfg = new Configuration().configure();
serviceRegistry = new StandardServiceRegistryBuilder().applySettings(cfg.getProperties()).build();
sessionFactory = cfg.buildSessionFactory(serviceRegistry); } public static SessionFactory getSessionFactory(){
return sessionFactory;
} }
IPersonDao.java接口，定义方法：
package com.cy.dao;
import java.io.Serializable;
import com.cy.beans.Person;
public interface IPersonDao {
/**
* 添加
* @param p
*/
public void savePerson(Person p);
/**
* 修改
* @param p
*/
public void updatePerson(Person p);
/**
* 刪除
* @param p
*/
public void deletePerson(Person p);
/**
* 根据id查询数据
* @param cls
* @param pk
* @return
*/
public Person getPerson(Class<?> cls,Serializable pk);
public void findPerson(Person p);
}
写接口实现：PersonDaoImpl.java
package com.cy.dao.impl; import java.io.Serializable; import org.hibernate.Session;
import org.hibernate.Transaction; import com.cy.beans.Person;
import com.cy.dao.IPersonDao;
import com.cy.tools.HibernateUtils; public class PersonDaoImpl implements IPersonDao { @Override
public void savePerson(Person p) {
//获得Session
Session session=null;
Transaction transaction=null; try {
session=HibernateUtils.getSessionFactory().openSession();//
transaction=session.beginTransaction();//开启事务
session.save(p);//添加
transaction.commit();//提交事务
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();//回滚事务
}finally{
session.close();//关闭session
} } @Override
public void updatePerson(Person p) {
Session session=null;
Transaction transaction=null; try {
session=HibernateUtils.getSessionFactory().openSession();
transaction=session.beginTransaction();
session.update(p);//修改
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}finally{
session.close();
} } @Override
public Person getPerson(Class<?> cls, Serializable pk) {
Session session=null;
Transaction transaction=null;
Person person=null;
try {
session=HibernateUtils.getSessionFactory().openSession();
transaction=session.beginTransaction();
person=(Person) session.get(cls, pk);//根据id查询。pk这里指的就是id
transaction.commit(); } catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}finally{
session.close();
} return person;
}
@Override
public void deletePerson(Person p) {
Session session=null;
Transaction transaction=null; try {
session=HibernateUtils.getSessionFactory().openSession();
transaction=session.beginTransaction();
session.delete(p);//删除
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}finally{
session.close();
} } @Override
public void findPerson(Person p) { } }
写IPersonServer.java接口
package com.cy.server;
import java.io.Serializable;
import com.cy.beans.Person;
public interface IPersonServer {
/**
* 添加
* @param p
*/
public void savePerson(Person p);
/**
* 修改
* @param p
*/
public void updatePerson(Person p);
/**
* 刪除
* @param p
*/
public void deletePerson(Long id);
/**
* 根据id查询
* @param cls
* @param pk
* @return
*/
public Person getPerson(Class<?> cls,Serializable pk);
public void findPerson(Person p);
}
写PersonServerImpl.java实现；
package com.cy.server.impl; import java.io.Serializable; import com.cy.beans.Person;
import com.cy.dao.IPersonDao;
import com.cy.dao.impl.PersonDaoImpl;
import com.cy.server.IPersonServer; public class PersonServerImpl implements IPersonServer {
IPersonDao dao = new PersonDaoImpl(); @Override
public void savePerson(Person p) {
dao.savePerson(p); } @Override
public void updatePerson(Person p) {
dao.updatePerson(p);
} @Override
public void deletePerson(Long id) {
Person p = dao.getPerson(Person.class, id);
if (p != null) {
dao.deletePerson(p);
} } @Override
public Person getPerson(Class<?> cls, Serializable pk) { return dao.getPerson(cls, pk);
} @Override
public void findPerson(Person p) { } }
写个PersonAction测试；
package com.cy.action; import com.cy.beans.Card;
import com.cy.beans.Person;
import com.cy.server.IPersonServer;
import com.cy.server.impl.PersonServerImpl; public class PersonAction {
public static void main(String[] args) { // savePerson();
// updatePerson();
deletePerson();
} private static void deletePerson() {
IPersonServer ps=new PersonServerImpl();
ps.deletePerson(Long.valueOf(1)); } private static void updatePerson() {
IPersonServer ps=new PersonServerImpl();
Person p=ps.getPerson(Person.class, Long.valueOf(1));
p.setUserName("小紅");
ps.updatePerson(p);
/*Hibernate: //这些hibernate所执行语句 修查询 后修改
select
person0_.id as id1_1_0_,
person0_.userName as userName2_1_0_,
card1_.id as id1_0_1_,
card1_.cardNo as cardNo2_0_1_
from
j2ee.person person0_
left outer join
j2ee.card card1_
on person0_.id=card1_.id
where
person0_.id=?
Hibernate:
update
j2ee.person
set
userName=?
where
id=?
Hibernate:
update
j2ee.card
set
cardNo=?
where
id=?
*/ } private static void savePerson() {
IPersonServer ps=new PersonServerImpl();
Person p=new Person();
p.setUserName("小明");
Card c=new Card();
c.setCardNo("511123************");
//設置相互
p.setCard(c);
c.setPerson(p);
ps.savePerson(p);
/*Hibernate: 添加时 先查询主表的最大的id，先添加主表，在添加从表。 删除时则是先删除从表，在删除主表。
select
max(id)
from
person
Hibernate:
insert
into
j2ee.person
(userName, id)
values
(?, ?)
Hibernate:
insert
into
j2ee.card
(cardNo, id)
values
(?, ?) */ }
}