孙卫琴Hibernate第四章对象-关系映射基础

最新推荐文章于 2024-04-06 19:53:40 发布
最新推荐文章于 2024-04-06 19:53:40 发布
阅读量1.3k 收藏
点赞数
分类专栏： hibernate 文章标签： hibernate dictionary exception string session class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangtian_84fighting/article/details/1955828
版权
 
单个持久化类与单个数据库表之间进行映射的技巧：
主要解决以下问题：
       持久化类的属性没有相关的setXXX()和getXXX()方法；
持久化类的属性在数据库中没有对应的字段，或者数据库中的字段在持久化类中没有对应的属性；
控制Hibernate生成的insert和update语句；
设置从持久化类映射到数据库表，以及持久化类的属性映射到数据库表的字段的命名策略；
一．持久化类的属性及访问方法
 
1 、getXXX() setXXX() 的产生是为了控制属性的读权限和改权限；
2 、java中的基本类型和包装类型对应着相同的Hibernate映射类型；
3 、在持久化类中，java基本类型和包装类型比较：基本类型操作方便，可以直接进行运算，包装类不行；基本数据类型不能表达NULL值。（java包装类型与sql数据类型有更直接的对应关系）
二．Hibernate访问持久化类属性的策略
1．在对象--关系映射文件中,<property>元素的access属性用于指定访问持久化类的属性的方法。
      （1）property 默认值。表示Hibernate通过相应的setXXX() 和 getXXX()方法访问属性。
      （2）field 表明Hibernate运用java反射机制直接访问类的属性。（类中没有提供属性的setXXX() 和 getXXX()方法）
2． 在Customer类的setSex（）方法中加入数据验证逻辑。
 
public void setSex( char sex){
       if (sex!= 'F' && sex!= 'M' ){
           throw new IllegalArgumentException( "Invalid Sex" );
       }
       this .sex=sex;
}
setSex( char sex) 有两个调用者： java 应用程序和 Hibernate 。 Java 应用程序调用时，参数可能来自用户界面输入的数据，需要验证；而 hibernate 调用时，参数值来自数据库读出的数据，通常是合法的，不需要验证。 解决这一个矛盾的方法是：
  把映射文件中的 sex 属性的 <property> 元素的 access 属性设为 ”field”
这样 hinernate 就会直接访问 Customer 实例的 sex 属性，而不调用 set 和 get 方法
 
一个例子：
1 数据库部分：
drop database if exists SAMPLEDB;
create database SAMPLEDB;
use SAMPLEDB;
 
create table DICTIONARIES (
   ID bigint not null ,
   TYPE varchar (15),
   TYPE_KEY varchar (15),
   VALUE varchar (128),
   primary key (ID)
);
create table ORDERS (
   ID bigint not null ,
   ORDER_NUMBER varchar (15),
   PRICE double precision ,
   CUSTOMER_ID bigint not null ,
   primary key (ID)
);
create table CUSTOMERS (
   ID bigint not null ,
   NAME varchar (15),
   SEX char (1),
   `CUSTOMER DESCRIPTION` text,
   primary key (id)
);
alter table ORDERS add index IDX_CUSTOMER (CUSTOMER_ID), add constraint FK_CUSTOMER foreign key (CUSTOMER_ID) references CUSTOMERS (id);
 
注意： `CUSTOMER DESCRIPTION` sql 引用标识符 （ 数据库中的字段含有空格）
2 java类：
 
Customer.java
 
package mypack;
 
import java.io.Serializable;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.StringTokenizer;
 
public class Customer implements Serializable {
 
    private Long id ;
 
    private String firstName ;
 
    private String lastName ;
 
    private char sex ;
 
    private Set orders = new HashSet();
 
    private double avgPrice ;
 
    private double totalPrice ;
 
    private String description ;
 
    public Customer() {
       // TODO Auto-generated constructor stub
    }
 
    public Customer(String lastName, String firstName, char sex,
           HashSet orders, String description) {
       // TODO Auto-generated constructor stub
 
       this . lastName = lastName;
       this . firstName = firstName;
       this . sex = sex;
       this . orders = orders;
       this . description = description;
 
    }
 
    public double getAvgPrice() {
       return avgPrice ;
    }
 
    public String getDescription() {
       return description ;
    }
 
    public void setDescription(String description) {
       this . description = description;
    }
 
    public String getFirstName() {
       return firstName ;
    }
 
    public Long getId() {
       return id ;
    }
 
    public void setId(Long id) {
       this . id = id;
    }
 
    public String getLastName() {
       return lastName ;
    }
 
    public Set getOrders() {
       return orders ;
    }
 
    public void setOrders(Set orders) {
       this . orders = orders;
    }
 
    public char getSex() {
       return sex ;
    }
 
    public void setSex( char sex) {
 
       if (sex != 'F' && sex != 'M' ) {
           throw new IllegalArgumentException( "Invalid Sex" );
       }
       this . sex = sex;
    }
 
    public double getTotalPrice() {
       return totalPrice ;
    }
 
    public void setTotalPrice( double totalPrice) {
       this . totalPrice = totalPrice;
    }
 
    public String getName() {
       return firstName + " " + lastName ;
    }
 
    public void setName(String name) {
       StringTokenizer t = new StringTokenizer(name);
       firstName = t.nextToken();
       lastName = t.nextToken();
    }
 
    public void caculatePrice() {
 
       double avgPrice = 0.0;
       double totalPrice = 0.0;
       int count = 0;
       Iterator it = getOrders().iterator();
       while (it.hasNext()) {
 
           Order order = (Order) it.next();
           totalPrice += order.getOrderPrice();
           count++;
       }
       avgPrice = totalPrice / count;
       setAvgPrice(avgPrice);
    }
 
    public void setAvgPrice( double avgPrice) {
       this . avgPrice = avgPrice;
    }
}
 
Order.java 类
 
package mypack;
 
import java.io.Serializable;
 
public class Order implements Serializable {
 
    private Long id ;
 
    private double orderPrice ;
 
    private String order_number ;
 
    private double price ;
 
    private Customer customer ;
 
    public Order(String order_number, double price, Customer customer) {
       // TODO Auto-generated constructor stub
       this . order_number = order_number;
       this . price = price;
       this . customer = customer;
    }
 
    public Customer getCustomer() {
       return customer ;
    }
 
    public void setCustomer(Customer customer) {
       this . customer = customer;
    }
 
    public String getOrder_number() {
       return order_number ;
    }
 
    public void setOrder_number(String order_number) {
       this . order_number = order_number;
    }
 
    public double getPrice() {
       return price ;
    }
 
    public void setPrice( double price) {
       this . price = price;
    }
 
    public double getOrderPrice() {
       return orderPrice ;
    }
 
    public void setOrderPrice( double orderPrice) {
       this . orderPrice = orderPrice;
    }
 
    public Long getId() {
       return id ;
    }
 
    private void setId(Long id) {
       this . id = id;
    }
}
 
Dictionary.java
 
package mypack;
 
import java.io.Serializable;
 
public class Dictionary implements Serializable {
 
    private Long id ;
 
    private String type ;
 
    private String type_key ;
 
    private String value ;
 
    public Dictionary() {
 
    }
 
    public Dictionary(String type, String type_key, String value) {
       this . type = type;
       this . type_key = type_key;
       this . value = value;
    }
 
    public Long getId() {
       return id ;
    }
 
    private void setId(Long id) {
       this . id = id;
    }
 
    public String getType() {
       return type ;
    }
 
    public void setType(String type) {
       this . type = type;
    }
 
    public String getType_key() {
       return type_key ;
    }
 
    public void setType_key(String type_key) {
       this . type_key = type_key;
    }
 
    public String getValue() {
       return value ;
    }
 
    public void setValue(String value) {
       this . value = value;
    }
}
 
3 映射文件部分
 
Customer.hbm.xml
 
<? xml version = "1.0" encoding = "utf-8" ?>
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<!--
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
< hibernate-mapping >
    < class name = "mypack.Customer" table = "customers"
       catalog = "sampledb" dynamic-insert="true" dynamic-update="true" lazy = "false" >
       <!-- dynamic-insert="true" dynamic-update="true" 分别表示 insert 语句中仅包含所有取值不为空的字段 和 只有字段发生变化时才会包含到 update 语句中 -->
       < id name = "id" type = "long" >
           < column name = "ID" />
           < generator class = "increment" />
       </ id >
       < property name = "name" type = "string" >
           < column name = "NAME" />
       </ property >
       < property name = "sex" type = "character" access="field" > <!-- 直接取设属性值 -->
           < column name = "SEX" length = "1" />
       </ property >
       < property name = "description" type = "text" >
           < column name = " `CUSTOMER DESCRIPTION` " />
 
       </ property >
       < property name = "totalPrice"
           formula="(select sum(o.PRICE) from ORDERS o where o.CUSTOMER_ID=ID)" > <!— 数据库中不含有次字段，它对应一个 sql 语句的结果 -->
       </ property >
       < set name = "orders" inverse = "true" cascade = "save-update" >
           < key column = "CUSTOMER_ID" ></ key >
           < one-to-many class = "mypack.Order" />
       </ set >
 
    </ class >
</ hibernate-mapping >
 
Order.hbm.xml
<? xml version = "1.0" encoding = "utf-8" ?>
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<!--
    Mapping file autogenerated by MyEclipse Persistence Tools
-->
< hibernate-mapping >
    < class name = "mypack.Order" table = "ORDERS" catalog = "sampledb" dynamic-insert = "true" dynamic-update = "true" >
       < id name = "id" type = "long" >
           < column name = "ID" />
           < generator class = "increment" />
       </ id >
       < property name = "order_number" >
       </ property >
       < property name = "price" ></ property >
       < many-to-one name = "customer" column = "CUSTOMER_ID"
           class = "mypack.Customer" >
       </ many-to-one >
    </ class >
</ hibernate-mapping >
 
Dictionary.hbm.xml
 
<? xml version = "1.0" encoding = "utf-8" ?>
<! DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
< hibernate-mapping >
    < class name = "mypack.Dictionary" table = "DICTIONARIES"
       catalog = "sampledb" mutable = "false" lazy = "false" > <!--  整个实例不能被更新 -->
       < id name = "id" type = "long" >
           < column name = "ID" />
           < generator class = "increment" />
       </ id >
       < property name = "type" type = "string" access = "field" ></ property >
       < property name = "type_key" type = "string" access = "field" ></ property >
       < property name = "value" type = "string" access = "field" ></ property >
    </ class >
</ hibernate-mapping >
4 测试类
 
package mypack;
 
import java.util.HashSet;
 
import org.hibernate.Session;
import org.hibernate.Transaction;
 
import sessionFactory.HibernateSessionFactory;
 
public class BusinessService {
 
    public Customer loadCustomer(Long customer_id) throws Exception {
       Session session = HibernateSessionFactory.getSession();
       Transaction tr = null ;
 
       try {
 
           tr = session.beginTransaction();
           Customer customer = (Customer) session.load(Customer. class ,
                  customer_id);
           tr.commit();
           return customer;
       } catch (Exception e) {
           // TODO : handle exception
           if (tr != null ) {
              tr.rollback();
           }
           throw e;
       } finally {
           session.close();
       }
 
    }
 
    public void saveCustomer(Customer customer) throws Exception {
       Session session = HibernateSessionFactory.getSession();
       Transaction tr = null ;
       try {
           tr = session.beginTransaction();
           session.save(customer);
           tr.commit();
       } catch (Exception e) {
           // TODO : handle exception
           if (tr != null ) {
              tr.rollback();
           }
           throw e;
       } finally {
           session.close();
       }
    }
 
    public void loadAndUpdateCustomer(Long customerId) throws Exception {
       Session session = HibernateSessionFactory.getSession();
       Transaction tr = null ;
       try {
           tr = session.beginTransaction();
           Customer customer = (Customer) session.load(Customer. class ,
                  customerId);
           customer.setDescription( "A lovely customer!" );
           tr.commit();
       } catch (Exception e) {
           // TODO : handle exception
           if (tr != null ) {
              tr.rollback();
           }
           throw e;
       } finally {
           session.close();
       }
 
    }
 
    public void updateCustomer(Customer customer) throws Exception {
 
       Session session = HibernateSessionFactory.getSession();
       Transaction tr = null ;
       try {
           tr = session.beginTransaction();
           session.update(customer);
           tr.commit();
       } catch (Exception e) {
           // TODO : handle exception
           if (tr != null ) {
              tr.rollback();
           }
           throw e;
       } finally {
           session.close();
       }
    }
 
    public void saveDictionary(Dictionary dictionary) throws Exception {
 
       Session session = HibernateSessionFactory.getSession();
       Transaction tr = null ;
       try {
           tr = session.beginTransaction();
           session.save(dictionary);
           tr.commit();
       } catch (Exception e) {
           // TODO : handle exception
           if (tr != null ) {
              tr.rollback();
           }
           throw e;
       } finally {
           session.close();
       }
    }
 
    public void updateDictionary(Dictionary dictionary) throws Exception {
       Session session = HibernateSessionFactory.getSession();
       Transaction tr = null ;
       try {
           tr = session.beginTransaction();
           session.update(dictionary);
           tr.commit();
       } catch (Exception e) {
           // TODO : handle exception
           if (tr != null ) {
              tr.rollback();
           }
           throw e;
       } finally {
           session.close();
       }
    }
 
    public Dictionary loadDictionary(Long dictionary_id) throws Exception {
       Session session = HibernateSessionFactory.getSession();
       Transaction tr = null ;
 
       try {
 
           tr = session.beginTransaction();
           Dictionary dictionary = (Dictionary) session.load(Dictionary. class ,
                  dictionary_id);
           tr.commit();
           return dictionary;
       } catch (Exception e) {
           // TODO : handle exception
           if (tr != null ) {
              tr.rollback();
           }
           throw e;
       } finally {
           session.close();
       }
    }
 
    public void printCustomer(Customer customer) {
       System. out .println( "name:" + customer.getName());
       System. out .println( "sex:" + customer.getSex());
       System. out .println( "description:" + customer.getDescription());
       System. out .println( "avgPrice:" + customer.getAvgPrice());
       System. out .println( "totalPrice:" + customer.getTotalPrice());
    }
 
    public void printDictionary(Dictionary dictionary) {
       System. out .println( "type:" + dictionary.getType());
       System. out .println( "key:" + dictionary.getType_key());
       System. out .println( "value:" + dictionary.getValue());
    }
 
    public void test() throws Exception {
       // Customer customer = new Customer("Laosan", "Zhang", 'M', new
       // HashSet(),
       // "A good citizen!");
       // Order order1 = new Order("Order001", 100, customer);
       // Order order2 = new Order("Order002", 200, customer);
       // customer.getOrders().add(order1);
       // customer.getOrders().add(order2);
       //
       // saveCustomer(customer);
       //
       // customer = new Customer("Laowu", "Wang", 'M', new HashSet(), null);
       // saveCustomer(customer);
       //
       // customer = loadCustomer(new Long(1));
       //
       // customer.setDescription("An honest customer!");
       // updateCustomer(customer);
       //
       // printCustomer(customer);
       //    
       // loadAndUpdateCustomer(new Long(1));
 
       Dictionary dictionary = new Dictionary( "SEX" , "M" , "MALE" );
       saveDictionary(dictionary);
       printDictionary(dictionary);
 
       dictionary = loadDictionary( new Long(1));
       dictionary.setValue( "MAN" );
       updateDictionary(dictionary);
      
      
        dictionary = loadDictionary( new Long(1));
        printDictionary(dictionary);
 
    }
 
    public static void main(String[] args) throws Exception {
 
       BusinessService b = new BusinessService();
       b.test();
    }
}
 
5 问题：
在测试 Customer 和 Dictionary的load 方法时报错：
could not initialize proxy - the owning Session was closed
 
解决办法：把对应类的映射文件中加入 lazy= "false" 限制（ class 元素中）
 
zhangtian_84Fighting
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
精通Hibernate(孙卫琴)
11-30
Hibernate是非常流程的对象关系映射工具。本书详细介绍了运用日常最成熟的Hibernate2.1版本进行java对象持久化的技术
孙卫琴hibernate实战第二版书及源码.part2.
01-17
hibernate
精通hibernate-孙卫琴
09-02
精通hibernate-孙卫琴,精通hibernate-孙卫琴,精通hibernate-孙卫琴,精通hibernate-孙卫琴
孙卫琴hibernate source code2
10-28
孙卫琴精通hibernate source code第二部分。
精通hibernate：对象持久化技术孙卫琴第二版part2
11-14
第5章 对象-关系映射基础 101 本章主要介绍单个持久化类与单个数据库表之间进行映射的方法，尤其是当持久化类的属性不和数据库表的字段一一对应时的映射技巧。 5.1 持久化类的属性及访问方法 101 5.1.1 基本类型...
孙卫琴-精通hibernate-源码-chapter1
06-04
孙卫琴 精通hibernate源码，由于源码太大，所以分次上传
孙卫琴hibernate实战第二版书及源码.part1
01-17
孙卫琴hibernate实战第二版书及源码
Java面向对象编程配套下PPT-孙卫琴.ppt
09-21
Java面向对象编程配套下PPT-孙卫琴.ppt
孙卫琴——缅怀张孝祥老师（原文）
04-05 5665
作为热爱软件开发的晚辈，对软件开发高手是敬佩的。虽然，我并没有去参加过java的培训。但是，我是通过java的视频来自学的。包括：王勇。马士兵老师。再就是 传智播客的了。自从听了张孝祥老师的视频以及看了张孝祥老师的书，感觉到：相见恨晚啊，给人一种通俗易懂的感觉，就像是喝了上品的就一般，陶醉其中爱不释手，感觉能把技术知识讲解的如此透彻，令我心生佩服。     而 孙卫琴 老师也是一位技术高人。
孙卫琴的《精通JPA与Hibernate》读书笔记：Hibernate的配置文件
csdnuserlala的博客
04-30 259
在Hibernate的配置文件中，需要指定连接数据库的信息，包括数据库URL，用户名和口令，JDBC驱动程序等。 hibernate.cfg.xml <hibernate-configuration> <session-factory > <property name="dialect"> org.hibernate.dialect.MySQL8Dialect </property> <property name
孙卫琴.精通Hibernate：Java对象持久化技术详解_触发器使缓存与数据库不一致
五谷杂粮
12-14 127
     p198  
孙卫琴Hibernate06映射一对多单向关联关系
天使
12-23 1630
  映射一对多关联关系以Customer和Order为例：一对多：每个Customer可以有一个或者多个Order，因此Customer中应该有一个集合类型的属性，来引用所有关联的Order对象。多对一：Order到Customer的关联为多对一关联，每个Order对象都要有一个Customer对象。在Order中要有一个Customer类型的属性。如果仅包含Custo
孙卫琴Hibernate第二章（hello 例子）
天使
12-17 1609
第二章 Hibernate入门 一 Hello例子：1、 创建数据库： create table CUSTOMERS( ID bigint not null primary key, NAME varchar(15) not null, EMAIL varchar(128)not null, PASSWORD varchar(8)not null, PHONE
05映射自然主键(不推荐使用自然主键)
天使
12-23 1110
 一般不提倡用自然主键，而是用代理主键。当无法避免时：look 1 映射单个自然主键 假定在Customer表中没有ID 代理主键，而是以name作为主键。那么Customer类中不必定义id属性，Customer类的OID为name属性。映射文件为：hibernate-mapping>    class name="mypack.Customer" table="cu
孙卫琴hibernate05映射对象标识符
天使
12-23 999
Hibernate 的内置标识符生成器 1 increment 适用于代理主键，由Hibernate自动一递增的方式生成标识符，每次增加1 2 indentity 适用于代理主键。由底层数据库生成标识符。前提是底层数据库支持自动增长字段类型。 3 sequence 适用于代理主键。Hibernate根据底层数据库的序列来生成标识符。前提条件是底层数据库支持序列。 4 hilo 适用于代理主键。Hi
web安全学习笔记（6）
最新发布
m0_58875569的博客
04-06 762
记一下第十节课的内容。
孙卫琴《精通spring》
01-28
《精通Spring》是由孙卫琴所著的一本Java编程书籍，深入介绍了Spring框架的各种应用和使用技巧。本书内容全面且系统，对于想要学习和掌握Spring框架的开发人员来说是一本很好的指南。 首先，本书详细介绍了Spring...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值