程序博客网 > 淘宝扣了48分如何申诉

JAVAWEB开发之Hibernate详解（一）——Hibernate的框架概述、开发流程、CURD操作和核心配置与API以及Hibernate日志的使用

来源：互联网 发布：淘宝扣了48分如何申诉 编辑：程序博客网 时间：2024/04/30 04:28


目录(?)[+]

Hibernate框架概述

什么是Hibernate？

 框架：软件的半成品，完成部分代码的功能。
Hibernate：Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思想来操作数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序中使用，也可以在Servlet/JSP的web应用程序中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

为何要学习Hibernate？

Hibernate对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
Hibernate是一个基于jdbc的主流持久化框架，是一个优秀的ORM实现，它很大程度的简化了dao层编码工作。
HIbernate使用Java的反射机制，而不是字节码增强程序类实现透明性。
Hibernate的性能非常好，因为它是一个轻量级框架。映射的灵活性很出色。它支持很多关系型数据库，从一对一到多对多的各种复杂关系。
ORM：Object Relational Mapping 对象关系映射
 传统方式开发:
  •  持久层:
  •  编写SQL.执行SQL. String sql = “insert into 表 values (?,?,?...)”;
  •  开发语言Java:面向对象.
  •  数据库:MySQL(关系型的数据库.)
  •  将Java中的实体类与数据库的关系表建立一个映射.就可以操作Java中对象,从而操作数据库.
Hibernate就是一个持久层的ORM的框架。
常见的持久层框架：
  • Hibernate：最流行的ORM框架，通过对象—关系映射配置，可以完全脱离底层SQL。
  • JPA：Java Persistence API. JPA通过JDK5.0注解或XML描述对象关系表的映射关系。（只有接口规范）
  • MyBatis：本是Apache的一个开源项目iBatis，支持普通的SQL查询，存储过程和高级映射的优秀持久层框架。
  • Apache DBUtils 、Spring JDBCTemplate
企业开发两种架构：
SSH：Struts2+Spring+Hibernate
SSI：SpringMVC+Spring+Ibatis

Hibernate版本：

Hibernate3.x版本和Hibernate4.x
企业中常用的还是Hibernate3.x

Hibernate日志记录

日志: 程序开发中的一些信息
常用信息输出：System.out.println(" ");
这种方式不好，原因如下：
如果输出的内容比较多，项目已经开发完毕，不想使用输出，需要输出每个类，将输出的代码注释。
日志：Hibernate中使用slf4j技术
slf4j：SLF4J，即简单门面（Simple Logging Facade for Java），不是具体的日志解决方案，它只服务于各种各样的日志系统。
  • 用于整合其他日志系统（在企业中常用的日志记录：log4J）
  • 是具体的日志记录方案

Log4J技术

开发中的日志操作
  • 开发阶段的调试信息
  • 运行时的日志记录（日志代码占代码总量的4%）
if (someCondition) {   
   System.out.println("some information.");
}
Hibernate中使用Log4J的步骤：
（1）导入Log4J的jar包apache-log4j-1.2.16（在Hibernate中使用时还需要导入slf4J的jar包）
在Hibernate中使用时需要单独下载SLF4J的jar包


（2）编写Property文件（log4J的配置信息）参考模板在如下位置
Hibernate_HOME/project/etc 示例中可以将log4j.properties文件拷贝出来进行修改放在项目中的classPath即src下

（3）在程序中获得logger对象，通过下列方法输出日志信息
  • public void debug(Object message);
  • public void info(Object message);
  • public void warn(Object message);
  • public void error(Object message);
利用信息级别确保日志信息在内容上和反映问题的严重程度上，是非常重要的。
  • fatal：非常严重的错误，导致系统终止。期望这类信息能立即显示在状态控制台上。
  • error：即普通错误，其它运行期错误或不是预期条件。期望这类信息能立即显示在状态控制台上。
  • warn：警告，使用了不赞成使用的API、非常拙劣的使用API，几乎就是错误，其它运行时不合需要和不合预期的状态但还没必要称为错误。期望这类信息能立即显示在状态控制台上。
  • info：普通信息。运行时产生有意义的事件。期望这类事件能立即显示在状态控制台上。
  • debug：系统流程中的细节信息。期望这类信息仅被写入log文件中。
  • trace：堆栈信息。期望这类信息仅被写入log文件中。
（4）配置文件（log4j.properties）
Log4J有三个主要部件：记录器（Loggers）、输出源（Appenders）、布局（Layouts）
组件简介：
记录器（loggers）：用来配置日志输出级别，使用哪些输出源
  * 格式：记录器=级别，输出源1，输出源2...   
    如  log4j.rootLogger=info,stdout  info是日志级别，stdout是输出源名称
  * log4j提供日志级别 由高到低：fatal(致命错误)、error(普通错误)、warn(警告)、debug(调试)、trace(堆栈)
  * log4j记录日志时只会记录 配置级别以及更高级别的信息
输出源（appenders）:在log4j中可以定义多个输出源（控制台、日志文件、邮件、数据库）
  * log4j.appender.输出源名称=实现类
  * log4j.appender.stdout=org.apache.log4j.ConsoleAppender  ：控制台进行输出
  * log4j.appender.file=org.apache.log4j.FileAppender  ：向文件进行输出
布局（Layouts） ：在日志中都记录哪些信息
  * log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  ：自定义布局
  * log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n  ：自定义布局格式

示例如下：
log4j.rootLogger=DEBUG, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern= %-4r [%t] %-5p %c %x - %m%n

配置时的注意事项：
注意1、log4j.properties被放置到ClassPath所指定的目录下。
注意2、log4j的日志记录的优先级分为FATAL、ERROR、WARN、INFO、DEBUG、TRACE或者您定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了INFO级别，则应用程序中所有DEBUG级别的日志信息将不被打印出来。

Log4J提供的输出源：
  • org.apache.log4j.ConsoleAppender（控制台）
  • org.apache.log4j.FileAppender（文件）
  • org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
  • org.apache.log4j.RollingFileAppender（文件到达指定大小时产生一个新文件）
  • org.apache.log4j.WriterAppender（将日志信息以流方式发送到任何地方）
Log4J提供的layout：
  • org.apache.log4j.HTMLLayout（以HTML表格形式布局）
  • org.apache.log4j.PatternLayout（可以灵活的自己指定布局模式）
  • org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串）
  • org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等信息）
自定义布局的layout中的格式符：
%c：列出logger名字空间的全称，如果加上{<层数>}表示列出从最内层算起的指定层数的名称空间。假设当前logger的名字空间是"a.b.c"
  • %c  —> a.b.c
  • %c{2} —>b.c
  • %c{1} —>c
  • %20c（若名字空间长度小于20，则左边用空格填充）
  • %-20c（若名字空间小于20，则右边用空格填充）
  • %.30c（若名字空间长度超过30，截取多余字符）
  • %20.30c（若名字空间长度小于20，则左边用空格填充；若名字空间长度超过30，截取多余字符）
  • %-20.30c（若名字空间长度小于20，则右边用空格填充；若名字空间超过30，截取多余字符）
%C：列出调用logger的类的全名（包含包路径），假设当前类是"org.apache.xyz.SomeClass"
  • %C —>org.apache.xyz.SomeClass    %C{2}—>xyz.SomeClass
%d：显示日志记录时间，{<日期格式>}  使用ISO8601定义的日期格式
  • %d{yyyy/MM/dd HH:mm:ss,sss} —> 2005/10/12 22:23:30,117
  • %d{ABSOLUTE} —> 22:23:30,117
  • %d{DATE} —> 12 Oct 2005 22:23:30,117
  • %d{ISO8601} —> 2005-10-12 22:23:30,117
%F：显示调用logger的源文件名  %F —> MyClass.java
%l：输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数
  • %l —> MyClass.main(MyClass.java:129)
%L：显示调用logger的代码行   %L—> 129
%m：显示输出消息  %m —> This is a message for debug
%M：显示调用logger的方法名  %M —> main
%n：当前平台下的换行符 Windows平台下表示rn   UNIX平台下表示n
%p：显示该条日志的优先级  %p —> INFO
%r：显示从程序启动到记录该条日志已经过去的毫秒数  %r —> 1215
%t：输出产生该日志事件的线程名  %t —> MyClass
%x：按NDC(Nested Diagnostic Context，线程堆栈)  假设某程序调用顺序是MyApp调用com.foo.Bar
       %c %x - %m%n   —>   MyApp - Call com.foo.Bar.
            com.foo.Bar - Log in Bar
              MyApp - Return to MyApp.
%X：按MDC(Mapped  Diagnostic  Context，线程映射表)输出日志。通常用于多个客户端连接同一台服务器，方便服务器区分是哪个客户端访问留下的日志    %X{5}  —> (记录代号为5的客户端记录)
%%：显示一个百分号   %% —> %

在Tomcat6下配置log4j的步骤
首先需要准备的文件为：
1.log4j.jar , 下载地址 ：
http://www.apache.org/dist/logging/log4j/1.2.15/apache-log4j-1.2.15.zip
2.log4j配置文件：log4j.properties
注意：日志级别不能太低，如果配置为debug的话，输出的日志信息太多，导致tomcat启动非常的慢。 

获得logger 范例代码
[java] view plain copy
  1. <span style="font-size:18px;">package org.javaresearch.log4j;   
  2. import org.apache.log4j.*;   
  3. public class TestLog4J {      
  4. static Logger log = Logger.getLogger(TestLog4J.class.getName());     
  5.  public static void main(String args[]) {       // logging的各种方法         
  6.   log.debug("Start of main()");     
  7.  }  
  8. }  
  9. </span>  
关于Log4J比较全面的配置
#应用于文件
log4j.appender.FILE=org.apache.log4j.FileAppender 
log4j.appender.FILE.File=C:\file.log 
log4j.appender.FILE.Append=false 
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout log4j.appender.FILE.layout.ConversionPattern= [framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n
#应用于控制台
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender 
log4j.appender.CONSOLE.Target=System.out 
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout log4j.appender.CONSOLE.layout.ConversionPattern=[framework] %d - %c -%-4r [%t] %-5p %c %x - %m%n

示例代码如下：
log4j.properties
[plain] view plain copy
  1. <span style="font-size:18px;">### direct log messages to stdout ###  
  2. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
  3. log4j.appender.stdout.Target=System.err  
  4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
  5. log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{2}:%L - %m%n  
  6.   
  7. ### direct messages to file mylog.log ###  
  8. log4j.appender.file=org.apache.log4j.FileAppender  
  9. log4j.appender.file.File=d\:mylog.log  
  10. log4j.appender.file.layout=org.apache.log4j.PatternLayout  
  11. log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n  
  12.   
  13. ### set log levels - for more verbose logging change 'info' to 'debug' ###  
  14.   
  15. log4j.rootLogger=info, stdout ,file  
  16. </span>  
Log4JTest
[java] view plain copy
  1. <span style="font-size:18px;">package cn.test.log4j;  
  2.   
  3. import org.apache.log4j.Logger;  
  4. import org.junit.Test;  
  5.   
  6. /** 
  7.  * 日志记录的类: 
  8.  * 
  9.  */  
  10. public class Log4JTest {  
  11.       
  12.     private Logger logger = Logger.getLogger(Log4JTest.class);  
  13.       
  14.     @Test  
  15.     public void demo1(){  
  16.         logger.fatal("致命错误");  
  17.         logger.error("普通错误");  
  18.         logger.warn("警告信息");  
  19.         logger.info("普通信息");  
  20.         logger.debug("调试信息");  
  21.         logger.trace("堆栈信息");  
  22.     }  
  23. }  
  24. </span>  

输出到日志文件


Hibernate快速入门

第一步：下载Hibernate3.x的开发包（3.6.10）

http://sourceforge.net/projects/hibernate/files/hibernate3/

slf4j与其他日志框架的关系



第二步：Hibernate框架目录结构


目录说明如下：
documentation ：Hibernate文档
lib                     ：Hibernate开发的jar包
     * bytecode  ：操作字节码的jar包
     * jpa            ：Hibernate的实现JPA规范
     * optional    ：Hibernate的可选jar包
     * required   ：Hibernate必须导入的jar包
project             ：Hibernate提供的工程

第三步：创建一个工程：（Java工程）

导入相应的jar包：
*  hibernate3.jar
*  HIBERNATE_HOME / lib / required/*.jar
*  HIBERNATE_HOME/lib/jpa/hibernate-jpa-2.0-api-1.0.1.Final.jar
* 导入日志记录的包:
* log4j-1.2.16.jar
* slf4j-log4j12-1.7.2.jar
* 导入数据库驱动:

第四步：搭建环境（创建一个customer表与对应的持久化类）



第五步：在Customer.class所在的目录创建映射文件

Customer.hbm.xml（类名.hbm.xml）
配置规则参考 hibernate2.jar org/hibernate/hibernate-mappong-3.0.dtd
查找位置如下：

配置Customer.hbm.xml内容如下：

[html] view plain copy
  1. <span style="font-size:18px;"><?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE hibernate-mapping PUBLIC   
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  4.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6.     <!-- 配置类 和数据表 对应关系 -->  
  7.     <class name="cn.itcast.domain.Customer" table="customer" select-before-update="true">  
  8.          <!-- 配置哪个属性 关联数据表主键 -->  
  9.          <id name="id" column="id" type="integer">  
  10.             <!-- 主键生成策略 -->  
  11.             <generator class="identity"></generator>  
  12.          </id>  
  13.          <!-- 普通属性 -->  
  14.          <property name="name" column="name" type="string"></property>  
  15.          <!-- 如果属性名和列名相同 可以省略 column -->  
  16.          <property name="age" type="integer" ></property>  
  17.          <!-- 类型也可以使用默认生成规则，省略type -->  
  18.          <property name="city"></property>  
  19.          <property name="info"></property>  
  20.     </class>  
  21. </hibernate-mapping>  
  22. </span>  

java、hibernate、sql类型对应关系


第六步：配置JDBC连接数据库基本属性

在src下创建hibernate.cfg.xml
规则参考hibernate3.jar  /org/hibernate/hibernate-configuration-3.0.dtd
hibernate.cfg.xml内容配置如下：

[html] view plain copy
  1. <span style="font-size:18px;"><?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE hibernate-configuration PUBLIC  
  3.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  4.     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">  
  5. <hibernate-configuration>  
  6.     <!-- 会话连接工厂，建立数据库连接需要SessionFactory -->  
  7.     <session-factory>  
  8.         <!-- JDBC连接基本参数 -->  
  9.         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>  
  10.         <property name="hibernate.connection.url">jdbc:mysql:///hibernatetest</property>  
  11.         <property name="hibernate.connection.username">root</property>  
  12.         <property name="hibernate.connection.password">123</property>  
  13.         <!-- 配置数据库方言，便于生成一些与数据库相关SQL方言 -->  
  14.         <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>  
  15.         <!-- 可以根据需要自动创建数据表 -->  
  16.         <property name="hibernate.hbm2ddl.auto">update</property>  
  17.         <!-- 将SQL语句 输出到控制台 -->  
  18.         <property name="hibernate.show_sql">true</property>  
  19.         <property name="hibernate.format_sql">true</property>  
  20.           
  21.         <!-- JavaEE6 使用BeanValidator校验，需要设置校验模式-->  
  22. <!--         <property name="javax.persistence.validation.mode">none</property> -->  
  23.           
  24.         <mapping resource="cn/itcast/domain/Customer.hbm.xml"></mapping>  
  25.     </session-factory>  
  26. </hibernate-configuration>  
  27. </span>  

第七步：编程操作hibernate框架

// 实例化配置对象，加载配置文件 hibernate.cfg.xml
Configuration configuration = new Configuration().configure();
// 创建会话连接工厂
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 创建会话
Session session = sessionFactory.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
...  这里可以编写hibernate操作代码逻辑
// 提交事务，释放资源
transaction.commit();
session.close();
sessionFactory.close();

Hibernate的CRUD操作

Hibernate操作一（插入数据）

插入数据 通过Session对象的save方法  Serializable save(Object  object)

Hibernate操作二（修改数据）

修改数据  通过Session的update方法   void  update(Object object)

注意—修改有两种方式
方式一：手动创建对象的方式如下所示：
Customer customer = new Customer();
customer.setId(2);
customer.setName("苍老师");
session.update(customer);
使用这种方式，如果手动创建的对象中 只对一部分属性赋值，那么剩余的属性将以默认值存入（不建议使用）
方式二：先查询再进行修改的方式（推荐使用）
Customer customer = (Customer) session.get(Customer.class, 1);
customer.setName("凤姐");
session.update(customer);

Hibernate常用操作三（删除数据）

删除数据  通过Session的delete方法   void  delete(Object  object)

注意—删除记录也有两种方式
删除方式一：手动创建对象的方式
// 手动创建对象的方式
Customer customer = new Customer();
customer.setId(2);
session.delete(customer);
方式二：先查询再删除的方式
Customer customer = (Customer)session.get(Customer.class, 1);
session.delete(customer);
两种方式的区别：当只涉及到一个表时，没有明显的区别，但当涉及到多个有关系的表时就有区别了 手动创建对象的删除方式是不能配置级联删除的，而先查询再删除的方式是可以配置级联删除的

Hibernate常用操作四（根据主键查询数据）

根据主键查询  通过Session的get或load方法
  • Object    get(Class clazz,  Serializable  id)
  • Object  load(Class clazz,  Serializable  id )

* Customer customer = (Customer)session.get(Customer.class ,1);
* Customer customer = (Customer)session.load(Customer.class,1);
get和load的区别(重点+面试题)
1、发送SQL的时机不同
*  load这个方法采用了一个技术叫lazy延迟加载（懒加载）只有真正使用这个对象的数据的时候才发送SQL（对象的数据不包括主键  也就是说只查询主键时是不会发送SQL的）
*  get方法是立即检索，当执行session.get()方法的时候，马上发送SQL语句进行查询。
2、返回的对象不同
*  load方法返回的是代理对象。
*  get方法返回的是真实的对象。
3、查询一个不存在的数据时抛出的异常不同
*  load方法抛出异常：ObjectNotFoundException
*    get方法抛出异常：NullPointException

Hibernate常用操作五（查询所有数据）

 Hibernate框架查询数据  可以通过Query对象完成
Session对象提供了两个方法可以获得Query对象
  • Query  createQuery(String   queryString)  接受HQL
  • SQLQuery  createSQLQuery(String queryString)  接受SQL
HQL—Hibernate  Query Language  描写对象操作的一种查询语言
  • Query query=session.createQuery("from Customer");
  • 这里的Customer是类名
SQL—Structured Query Language  面向数据库查询语言
  • Query query = session.createSQLQuery("select * from customer");  
  • 这里参数就是普通SQL语句 
HQL查询结果会自动封装为Java对象

SQLQuery会将查询结果每条数据封装为一个Object[]

示例如下：
HQL:
HQL:Hibernate Query Language.
面向对象的写法:
Query query = session.createQuery("from Customer where name = ?");
query.setParameter(0, "苍老师");
query.list();
QBC:
Query By Criteria.(条件查询)
Criteria criteria = session.createCriteria(Customer.class);
criteria.add(Restrictions.eq("name", "凤姐"));
List<Customer> list = criteria.list();
SQL:
SQLQuery query = session.createSQLQuery("select * from customer");
List<Object[]> list = query.list();
SQLQuery query = session.createSQLQuery("select * from customer");
query.addEntity(Customer.class);
List<Customer> list = query.list();

Hibernate运行的流程图如下：

Hibernate常见配置及核心API

Hibernate体系结构及常见配置


  • Hibernate的持久化方案，将用户从原始的JDBC底层SQL访问中解放出来。
  • 用户无须关注底层数据库的操作，只要通过操作映射到数据表的Java对象，就可以对数据库进行增删改查。
  • Hibernate框架支持哦两种Hibernate属性配置方式：hibernate.properties和hibernate.cfg.xml。
  • 采用properties方式必须手动编程加载hbm文件或者持久化类
  • 采用xml配置方式，可以配置添加hbm文件
   核心配置的两种方式进行配置:
         * 属性文件的配置:
                * hibernate.properties
                * 格式: key=value
                         * hibernate.connection.driver_class=com.mysql.jdbc.Driver
                ***** 注意:没有办法在核心配置文件中加载映射文件.(必须手动编码的方式进行加载.)
        * XML格式文件配置:
                * hibernate.cfg.xml
                * 格式:
                         <property name="hibernate.connection.username">root</property>

Hibernate核心配置常用属性

在project/etc/hibernate.properties中配置了hibernate常用的一些属性信息

核心配置中：

   1、必须的配置
         *连接数据库的4个基本参数：
               hibernate.connection.driver_class  连接数据库驱动程序
               hibernate.connection.url   连接数据库的URL
               hibernate.connection.username   数据库用户名
               hibernate.connection.password    数据库密码         
         *hibernate的方言
               hibernate.dialect   操作数据的方言

   2、可选的配置
          hibernate.show_sql   true   在控制台上输出SQL语句
          hibernate.format_sql   true  格式化控制台输出的SQL语句
          hibernate.connection.autocommit   true   事务是否自动提交
          hibernate.hbm2ddl.auto  create/create-drop/update/validate
          *  create  ：每次执行的时候，创建一个新的表（如果以前有该表，将该表删除重新创建）一般测试的时候使用.
          *  create-drop：每次执行的时候，创建一个新的表，程序执行结束后将这个表删除掉了。一般测试的时候使用。
          *  update：如果数据库中没有表，创建一个新的表，如果有了，直接使用这个表。可以更新表的结构.
          *  validate：会使用原有的表，完成校验，校验映射文件与表中配置的字段是否一致，不一致报错
  3、映射的配置
         在核心配置文件中加载映射文件
             * <mapping resource="cn/itcast/hibernate3/demo1/Customer.hbm.xml" />
             * 使用手动编码的方式进行加载hbm.xml映射文件
                 configuration.addResource("cn/itcast/hibernate3/demo1/Customer.hbm.xml");
                 或 configuration.addClass(Customer.class);
          注意：在核心配置文件中加载映射文件时有一个小技巧

             映射文件的配置

ORM：对象关系映射。需要在映射文件（命名格式：持久化类名.hbm.xml）中配置Java对象与表的映射。
*  配置类与表的映射：
         * name：类的全路径
         * table：表的名称（可以省略，若不写表名则使用类的名称作为表名）
          <class name="cn.itcast.hibernate3.demo1.Order" table=”orders”></class>
*  配置普通属性与字段映射：
         <property  name="name"  column="name"  type="string"  length="20" />
         type：三种写法
                *  Java类型：java.lang.String
                *  Hibernate类型：string
                *  SQL类型：不能直接使用type属性，需要子标签<column>
                         *  <column  name="name" sql-type="varchar(20)" />
*  配置唯一标识与主键映射：
         *  一个表中只有一个主键的形式
             <id name="id"  column="id">
                  <generator class="assigned"/>  <!-- 生成策略 -->
             </id>
         *  一个表对应多个主键形式：(复合主键)
             <composite-id>
                 <key-property name="firstname" column="firstname"  type="string" />
                          <key-property name="lastname" column="lastname"  type="string" />
             </composite-id>
*  关联关系
*  命名SQL
       <query  name="findAll">  from Customer  </query>
       <sql-query  name="sqlFindAll" >  select * from customer </sql-query>

Hibernate的核心API

Hibernate体系结构

Hibernate  API简介 — Configuration类

Configuration类负责管理Hibernate的配置信息。包括如下内容：
  • 加载hibernate.properties 和hibernate.cfg.xml
  • 持久化类与数据表的映射关系( *.hbm.xml)
1、加载核心配置文件 
      创建Configuration的两种方式
          方式一：加载属性文件（hibernate.properties）
                Configuration  cfg = new Configuration();  // 手动加载hbm
          方式二：加载xml文件（hibernate.cfg.xml）
                Configuration configuration = new Configuration().configure();
2、手动加载映射文件
      第一种写法：通过Configuration对象的addResource方法添加hbm文件映射
           //  加载位于cn.itcast.domain包下面Customer.hbm.xml文件
           configuration.addResource("cn/itcast/domain/Customer.hbm.xml");
      第二种写法：通过addClass添加持久化类，Hibernate会在类所在包自动搜索hbm映射文件
           要求：映射文件名称要规范，类与映射文件在同一个包下
          configuration.addClass(Customer.class);

Hibernate API简介—SessionFactory接口

Configuration对象根据当前的配置信息生成SessionFactory对象。
SessionFactory对象中保存了当前的数据库配置信息和所有映射关系以及预定义的SQL语句。
SessionFactory 对象是线程安全的。
SessionFactory还负责维护Hibernate的二级缓存。
  • Configuration configuration=new Configuration().configure();
  • SessionFactory sessionFactory = configuration.buildSessionFactory();
SessionFactory对象根据数据库信息，维护连接池，创建Session(相当于Connection)对象
  • Session  session = sessionFactory.openSession();
构造SessionFactory很消耗资源，一般情况下一个应用只初始化一个
抽取HibernateUtils类用来提供Session对象

使用C3P0连接池
引入c3p0-0.9.1.jar
在hibernate.cfg.xml文件中增加如下配置：
<!-- C3P0连接池设定-->
<!-- 使用c3po连接池  配置连接池提供的供应商-->
<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider </property>
<!--在连接池中可用的数据库连接的最少数目 -->
<property name="c3p0.min_size">5</property>
<!--在连接池中所有数据库连接的最大数目  -->
<property name="c3p0.max_size">20</property>
<!--设定数据库连接的过期时间,以秒为单位,
如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->
<property name="c3p0.timeout">120</property>
 <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->
<property name="c3p0.idle_test_period">3000</property>

Hibernate API简介—Session接口

相当于JDBC的Connection
Session是应用程序与数据库之间交互操作的一个单线程对象，是Hibernate运作的中心。
Session是线程不安全的。
所有持久化对象必须在session的管理下才可以进行持久化操作。
Session对象有一个一级缓存，显式执行flush之前，所有持久化操作的数据都缓存在session对象处。
持久化类与Session关联起来后就具有了持久化的能力。
Session维护了Hibernate的一级缓存。
常用方法如下：
save() / persist()   ：添加。
update                  ：修改。
saveOrUpdate      ：增加和修改对象。
delete                    ：删除对象。
get() / load()          ：根据主键查询。
createQuery()       ：创建一个Query接口，编写HQL语句。
createSQLQuery()：创建一个SQLQuery接口，编写SQL语句  数据库操作对象。
createCriteria()     ：返回一个Criteria接口，条件查询。

Hibernate API简介—Transaction接口

代表数据库操作的事务对象
  Transaction transaction = session.beginTransaction();
提供事务管理的方法：
  • commit()：提交相关联的session实例。
  • rollback()：撤销事务操作。
  • wasCommitted()：检查事务是否提交。
如果没有开启事务，那么每个session的操作，都相当于一个独立的事务。注意：默认情况下这些独立的事务是不会提交的，都会进行回滚。
思考题：关羽和张飞的信息能否插入数据库。

如果在Hibernate的核心配置文件中配置了事务自动提交，则会将关羽的信息插入数据库，张飞的信息不会被插入数据库。如果在核心配置文件中没有配置事务自动提交，则张飞和关羽的信息都不会被插入数据库。

Hibernate API简介— Query接口

Query代表面向对象的一个Hibernate查询操作。
session.createQuery  接受一个HQL语句。
HQL是Hibernate  Query  Language缩写，语法很像SQL语法，但它是完全面向对象的。
使用Query对象的步骤：
  • 获得Hibernate  Session对象。
  • 编写HQL语句。
  • 调用session.createQuery 创建查询对象。
  • 如果HQL语句包含参数，则调用Query的setXXX设置参数。
  • 调用Query对象的list() 或uniqueResult() 方法执行查询。
Query还包含两个方法，用于控制返回结果。
  • setFirstResult(int  firstResult)：设置返回结果从第几条开始
  • setMaxResults(int maxResults)：设置本次返回结果的记录条数

HQL入门举例：

以from开始HQL语句，调用list方法返回 List<Customer>     
  • from Customer 查询customer表所有数据
使用select 关键字 （查询部分对象属性）
  • select name from Customer  返回List<String>
  • select name,age from Customer 返回 List<Object[] >
  • select c.name from Customer as c 为Customer实例起别名
使用where添加条件
from Customer as c where c.age > :age 其中:age是参数

 from Customer as c where c.age > ? 其中?是参数

Hibernate API简介—Criteria接口

Criteria是Hibernate提供的用于条件查询接口
Criteria criteria = session.createCriteria(Customer.class);
使用Criteria对象的步骤：
  • 获得Hibernate的Session对象
  • 通过Session获得Criteria对象
  • 通过Restrictions的静态方法创建Criterion条件对象
  • 向Criteria对象中添加Criterion查询条件
  • 执行Criteria的list() 或 uniqueResult() 获得结果

Hibernate持久化配置和操作

Hibernate中的持久化类

Hibernate采用普通、传统的Java对象（POJO），作为持久化类，与数据表进行映射。
编写规则：
  • 提供一个无参数public访问控制符的构造器（无参构造函数，因为Hibernate要使用反射进行操作）
  • 提供一个标识属性，映射数据表主键字段。（Java区分两个对象是否是同一个使用地址，数据库区分两条记录是否一致使用主键，Hibernate中区分持久化对象是否是同一个则根据唯一标识）
  • 所有属性提供public访问控制符的set / get方法。（框架存取值的时候使用）
  • 标识属性应尽量使用基本数据类型的包装类型。
  • 不要使用final修饰（将无法生成代理对象进行优化）
注意：用final修饰的类是不能被继承的，无法生成代理对象（延迟加载的时候返回代理对象，延迟加载就会失效）

持久化对象的唯一标识OID

  • Java按地址区分同一个类的不同对象。
  • 关系数据库用主键区分同一条记录。
  • Hibernate使用OID来建立内存中的对象和数据库中记录的对应关系。
  • 对象的OID和数据库的表的主键对应。为保证OID的唯一性，应该让Hibernate来为OID进行赋值。

区分自然主键与代理主键




持久化类属性用基本类型还是包装类型？

基本数据类型和包装类型对应hibernate的映射类型相同。
<property  name="price" type="double"  column="PRICE"  />
基本类型可直接运算、无法表达null、数字类型的默认值是0.
包装类型默认值是null。当对于默认值有业务意义的时候需要使用包装类。
例如:Student类有一个int类型的scope属性,表示学生的考试分数.int类型的scope属性无法表达这样的业务需求:
   * 如果scope的属性为null,表示该学生的成绩是未知的,有可能得了100分，也有可能得了0分,只是暂时还不知道成绩
   * 如果scope属性为0,表示学生考试成绩为0分.
   * 在上面的情况中必须使用包装类型

详解对象—关系映射 hbm文件


ID和generator属性说明

id：设定持久化类的OID和表的主键的映射。id标签有以下属性：
  • name：表示持久化类OID的属性名。
  • column：设置标识属性所映射的数据列的列名（主键字段的名称）。
  • unsaved-value：若设定了该属性，Hibernate会通过比较持久化类的OID和该属性值来区分当前持久化类的对象是否是临时对象，Hibernate3中几乎不再需要。
  • type:指定 Hibernate 映射类型. Hibernate 映射类型是 Java 类型与 SQL 类型的桥梁. 如果没有为某个属性显式设定映射类型, Hibernate 会运用反射机制先识别出持久化类的特定属性的 Java 类型, 然后自动使用与之对应的默认的 Hibernate 映射类型
  • Java 的基本数据类型和包装类型对应相同的 Hibernate 映射类型. 基本数据类型无法表达 null, 所以对于持久化类的 OID 推荐使用包装类型（integer，long，string等）
generator：设置持久化类指定标识符生成器。
  • class：指定使用标识符生成器全限定 类名或其缩写名。

主键生成策略

常用的几种标识符生成器以及相关描述如下：
increment ：适用于代理主键。由Hibernate自动以递增的方式生成标识符，每次增量为1.
identity     ：适合代理主键。由底层数据库生成标识符。条件是数据库支持自动增长数据类型。
sequence ：适用于代理主键。Hibernate根据底层数据库序列生成标识符。条件是数据库支持序列。
native       ：适用于代理主键。根据底层数据库对自动生成标识符的能力来选择identity、sequence、hilo。
uuid          ：适用于代理主键。Hibernate采用128位的UUID算法来生成标识符。该算法能够在网络环境中生成唯一的字符串标识符，这种策略并不流行，因为字符串类型的主键比整数类型的主键占用更多的数据库空间。
assigned  ：适用于自然主键。由Java程序员负责生成标识符。不能把setId()声明为private类型。尽量避免使用自然主键。
主键生成策略increment
increment标识符生成器
increment 标识符生成器由Hibernate以递增的方式为代理主键赋值。

Hibernate会先读取NEWS表中的主键的最大值，而接下来向NEWS表中插入记录时，就在max(id)的基础之上递增，增量为1（带走+1）
适用范围：
  • 由于increment生存标识符机制不依赖于底层数据库系统，因此它是适用于所有的数据库系统。
  • 适用于只有单个Hibernate应用进程访问同一个数据库的场合。因为会产生多线程问题，在集群下不要使用。
  • OID必须为long，int，或short类型，如果把OID定义为byte类型，在运行时就会抛出异常。
主键生成策略 identity
identity标识符生成器由底层数据库负责生成标识符，它要求底层数据库把主键定义为自动增长字段类型（加1带走）

适用范围：
  • 由于identity生成标识符的机制依赖于底层数据库系统，因此要求底层数据库系统必须支持自动增长字段类型。支持自动增长字段类型的数据库包括：DB2，MySQL，MSSQLServer，Sybase等。
  • OID必须为long，int或short类型，如果把OID定义为byte类型，在运行时也会抛出异常。
主键生成策略 sequence
sequence标识符生成器利用底层数据库提供的序列来生成标识符。

Hibernate在持久化一个NEWS对象时，先从底层数据库的news_seq序列中获得一个唯一的标识号，再把它作为主键值。
适用范围：
  • 由于sequence生成标识符的机制依赖于底层数据库系统的序列，因此，要求底层数据库系统必须支持序列。支持序列的数据库包括DB2、Oracle等。
  • OID必须为long、int、或short类型，如果把OID定义为byte类型，在运行时也会抛出异常。
主键生成策略 native
native标识符生成器依赖底层数据库对自动生成标识符的支持能力，来选择identity，sequence或hilo标识符生成器

适用范围：
  • 由于native能根据底层数据库系统的类型，自动选择合适的标识符生成器，因此很适合用于跨数据库平台开发。
  • OID必须为long、int、或short类型，如果把OID定义为byte类型，在运行时也会抛出异常。
主键生成策略 uuid
uuid 32位标识符生成器


Hibernate会产生不重复的32位字符作为主键。
主键生成策略 assigned
assigned标识符生成器— 用于映射单个自然主键。
假如CUSTOMER表没有定义ID代理主键，而是以NAME字段作为主键，那么相应的，在Customer类中不必定义id属性，Customer类的OID为name属性，它的映射代码如下：

映射复合主键


具体代码示例演示Hibernate：
项目如下：
   

Customer
[java] view plain copy
  1. <span style="font-size:18px;">package cn.itcast.hibernate3.demo1;  
  2. /** 
  3.  * 实体类对象 
  4.  * 
  5.  */  
  6. public final class Customer {  
  7.     private Integer id;  
  8.     //private String id;  
  9.     private String name;  
  10.     private int age;  
  11.   
  12.     public Integer getId() {  
  13.         return id;  
  14.     }  
  15.     public void setId(Integer id) {  
  16.         this.id = id;  
  17.     }  
  18.     public String getName() {  
  19.         return name;  
  20.     }  
  21.     public void setName(String name) {  
  22.         this.name = name;  
  23.     }  
  24.     public int getAge() {  
  25.         return age;  
  26.     }  
  27.     public void setAge(int age) {  
  28.         this.age = age;  
  29.     }  
  30.     @Override  
  31.     public String toString() {  
  32.         return "Customer [id=" + id + ", name=" + name + ", age=" + age + "]";  
  33.     }  
  34.       
  35. }  
  36. </span>  
HibernateTest1
[java] view plain copy
  1. <span style="font-size:18px;">package cn.itcast.hibernate3.demo1;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.hibernate.Criteria;  
  6. import org.hibernate.Query;  
  7. import org.hibernate.SQLQuery;  
  8. import org.hibernate.Session;  
  9. import org.hibernate.SessionFactory;  
  10. import org.hibernate.Transaction;  
  11. import org.hibernate.cfg.Configuration;  
  12. import org.hibernate.criterion.Restrictions;  
  13. import org.junit.Test;  
  14.   
  15. /** 
  16.  * Hibernate入门案例的测试: 
  17.  * 
  18.  * 
  19.  */  
  20. public class HibernateTest1 {  
  21.       
  22.     @Test  
  23.     // 查询所有记录:SQL  
  24.     public void demo7(){  
  25.         // 1.加载核心配置文件  
  26.         Configuration configuration = new Configuration().configure();  
  27.         // 2.构建Session工厂  
  28.         SessionFactory sessionFactory = configuration.buildSessionFactory();  
  29.         // 3.通过工厂创建Session  
  30.         Session session = sessionFactory.openSession();  
  31.         // 4.开启事务  
  32.         Transaction tx = session.beginTransaction();  
  33.           
  34.         // 5.操作  
  35.         // 查询所有:SQL  
  36.         /*SQLQuery query = session.createSQLQuery("select * from customer"); 
  37.         List<Object[]> list = query.list(); 
  38.          
  39.         for (Object[] objs : list) { 
  40.             System.out.println(Arrays.toString(objs)); 
  41.         }*/  
  42.         SQLQuery query = session.createSQLQuery("select * from customer");  
  43.         query.addEntity(Customer.class);  
  44.         List<Customer> list = query.list();  
  45.         for (Customer customer : list) {  
  46.             System.out.println(customer);  
  47.         }  
  48.           
  49.         // 6.事务提交  
  50.         tx.commit();  
  51.         // 7.释放资源  
  52.         session.close();  
  53.         sessionFactory.close();  
  54.           
  55.     }  
  56.       
  57.     @Test  
  58.     // 查询所有:QBC  
  59.     public void demo6(){  
  60.         // 1.加载核心配置文件  
  61.         Configuration configuration = new Configuration().configure();  
  62.         // 2.构建Session工厂  
  63.         SessionFactory sessionFactory = configuration.buildSessionFactory();  
  64.         // 3.通过工厂创建Session  
  65.         Session session = sessionFactory.openSession();  
  66.         // 4.开启事务  
  67.         Transaction tx = session.beginTransaction();  
  68.           
  69.         // 5.操作:  
  70.         // 查询所有 :QBC.  
  71.         /*Criteria criteria = session.createCriteria(Customer.class); 
  72.         List<Customer> list = criteria.list();*/  
  73.         Criteria criteria = session.createCriteria(Customer.class);  
  74.         criteria.add(Restrictions.eq("name", "凤姐"));  
  75.         List<Customer> list = criteria.list();  
  76.           
  77.         for (Customer customer : list) {  
  78.             System.out.println(customer);  
  79.         }  
  80.           
  81.         // 6.事务提交  
  82.         tx.commit();  
  83.         // 7.释放资源  
  84.         session.close();  
  85.         sessionFactory.close();  
  86.     }  
  87.       
  88.     @Test  
  89.     // 查询所有:HQL.  
  90.     // HQL:Hibernate Query Language.Hibernate查询语言.面向对象的查询.  
  91.     public void demo5(){  
  92.         // 1.加载核心配置文件  
  93.         Configuration configuration = new Configuration().configure();  
  94.         // 手动编码加载映射文件:  
  95.         // configuration.addResource("cn/itcast/hibernate3/demo1/Customer.hbm.xml");  
  96.         // configuration.addClass(Customer.class);  
  97.         // 2.构建Session工厂  
  98.         SessionFactory sessionFactory = configuration.buildSessionFactory();  
  99.         // 3.通过工厂创建Session  
  100.         Session session = sessionFactory.openSession();  
  101.         // 4.开启事务  
  102.         Transaction tx = session.beginTransaction();      
  103.           
  104.         // 5.操作  
  105.         // 1.查询所有的客户  
  106.         /*Query query = session.createQuery("from Customer"); 
  107.         List<Customer> list = query.list();*/  
  108.         // 2.按名称查询  
  109.         /*Query query = session.createQuery("from Customer where name = ?"); 
  110.         query.setParameter(0, "苍老师");*/  
  111.         Query query = session.createQuery("from Customer where name = :aaa");  
  112.         query.setParameter("aaa", "苍老师");  
  113.         List<Customer> list = query.list();  
  114.           
  115.         for (Customer customer : list) {  
  116.             System.out.println(customer);  
  117.         }  
  118.           
  119.         // 6.事务提交  
  120.         tx.commit();  
  121.         // 7.释放资源  
  122.         session.close();  
  123.         sessionFactory.close();  
  124.     }  
  125.       
  126.     @Test  
  127.     // 删除记录  
  128.     public void demo4(){  
  129.         // 1.加载核心配置文件  
  130.         Configuration configuration = new Configuration().configure();  
  131.         // 2.构建Session工厂  
  132.         SessionFactory sessionFactory = configuration.buildSessionFactory();  
  133.         // 3.通过工厂创建Session  
  134.         Session session = sessionFactory.openSession();  
  135.         // 4.开启事务  
  136.         Transaction tx = session.beginTransaction();      
  137.           
  138.         // 5.操作  
  139.         // 删除记录有两种方式:  
  140.         // 5.1手动创建对象的方式  
  141.         /*Customer customer = new Customer(); 
  142.         customer.setId(2); 
  143.          
  144.         session.delete(customer);*/  
  145.           
  146.         // 5.2先查询在删除的方式  
  147.         Customer customer = (Customer)session.get(Customer.class, 1);  
  148.         session.delete(customer);  
  149.           
  150.         // 6.事务提交  
  151.         tx.commit();  
  152.         // 7.释放资源  
  153.         session.close();  
  154.         sessionFactory.close();  
  155.     }  
  156.       
  157.     @Test  
  158.     // 修改记录  
  159.     public void demo3(){  
  160.         // 1.加载核心配置文件  
  161.         Configuration configuration = new Configuration().configure();  
  162.         // 2.构建Session工厂  
  163.         SessionFactory sessionFactory = configuration.buildSessionFactory();  
  164.         // 3.通过工厂创建Session  
  165.         Session session = sessionFactory.openSession();  
  166.         // 4.开启事务  
  167.         Transaction tx = session.beginTransaction();      
  168.           
  169.         // 5.操作:  
  170.         // 修改记录:两种方式可以进行修改.  
  171.         // 5.1手动创建对象的方式  
  172.         /*Customer customer = new Customer(); 
  173.         customer.setId(2); 
  174.         customer.setName("苍老师"); 
  175.          
  176.         session.update(customer);*/  
  177.           
  178.         // 5.2先查询在修改的方式  
  179.         Customer customer = (Customer) session.get(Customer.class, 1);  
  180.         customer.setName("凤姐");  
  181.           
  182.         session.update(customer);  
  183.           
  184.         // 6.事务提交  
  185.         tx.commit();  
  186.         // 7.释放资源  
  187.         session.close();  
  188.         sessionFactory.close();  
  189.     }  
  190.       
  191.     @Test  
  192.     // 按id进行查询  
  193.     // (*****面试题)get和load方法区别  
  194.     public void demo2(){  
  195.         // 1.加载核心配置文件  
  196.         Configuration configuration = new Configuration().configure();  
  197.         // 2.构建Session工厂  
  198.         SessionFactory sessionFactory = configuration.buildSessionFactory();  
  199.         // 3.通过工厂创建Session  
  200.         Session session = sessionFactory.openSession();  
  201.         // 4.开启事务  
  202.         Transaction tx = session.beginTransaction();  
  203.         // 5.操作  
  204.         // 根据id进行查询:  
  205.         // get方法进行查询  
  206.         Customer customer = (Customer) session.get(Customer.class, 100); // 马上发生一条SQL进行查询  
  207.           
  208.         System.out.println(customer);  
  209.           
  210.         // load方法进行查询  
  211.         //Customer customer = (Customer) session.load(Customer.class, 100); // 没有发送SQL  
  212.           
  213.         //System.out.println(customer);// 发送SQL.  
  214.           
  215.         // 6.事务提交  
  216.         tx.commit();  
  217.         // 7.释放资源  
  218.         session.close();  
  219.         sessionFactory.close();  
  220.           
  221.     }  
  222.       
  223.     @Test  
  224.     // 保存记录  
  225.     public void demo1(){  
  226.         // 1.Hiberante框架加载核心配置文件(有数据库连接信息)  
  227.         Configuration configuration = new Configuration().configure();  
  228.         // 2.创建一个SessionFactory.(获得Session--相当连接对象)  
  229.         SessionFactory sessionFactory = configuration.buildSessionFactory();  
  230.         // 3.获得Session对象.  
  231.         Session session = sessionFactory.openSession();  
  232.         // 4.默认的情况下,事务是不自动提交.  
  233.         Transaction tx = session.beginTransaction();  
  234.         // 5.业务逻辑操作  
  235.           
  236.         // 向数据库中插入一条记录:  
  237.         Customer customer = new Customer();  
  238.         customer.setName("苍老师");  
  239.         customer.setAge(38);  
  240.           
  241.         session.save(customer);  
  242.           
  243.         // 6.事务提交  
  244.         tx.commit();  
  245.         // 7.释放资源  
  246.         session.close();  
  247.         sessionFactory.close();  
  248.     }  
  249. }  
  250. </span>  
Customer.hbm.xml
[html] view plain copy
  1. <span style="font-size:18px;"><?xml version="1.0" encoding="UTF-8"?>  
  2. <!-- 引入约束 -->  
  3. <!DOCTYPE hibernate-mapping PUBLIC   
  4.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  5.     "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">  
  6.       
  7. <hibernate-mapping>  
  8.     <!-- 建立类与表的映射 -->  
  9.     <!-- class标签:用于映射类与表的关系 name :类的全路径  table:表名称 -->  
  10.     <class name="cn.itcast.hibernate3.demo1.Customer" table="customer">  
  11.         <!-- 建立类中属性与表中的字段映射 -->  
  12.         <!-- 唯一标识 -->  
  13.         <!-- 使用id的标签 配置唯一属性 -->  
  14.         <!-- 在<id>标签中配置一个主键的生成策略. -->  
  15.         <id name="id" column="id">  
  16.             <generator class="assigned"/>  
  17.         </id>  
  18.           
  19.         <!-- 普通属性 -->  
  20.         <!-- property标签:映射类中的普通属性 name:类中的属性名称, column:表中字段名称 -->  
  21.         <!--   
  22.             type:三种写法  
  23.                 * Java类型        :java.lang.String  
  24.                 * Hibernate类型   :string  
  25.                 * SQL类型     :不能直接使用type属性,需要子标签<column>  
  26.                     * <column name="name" sql-type="varchar(20)"/>  
  27.          -->  
  28.         <property name="name" column="name" type="string" length="20"/>  
  29.         <property name="age" column="age"/>  
  30.           
  31.           
  32.     </class>  
  33.       
  34.   
  35. </hibernate-mapping>  
  36. </span>  
hibernate.cfg.xml
[html] view plain copy
  1. <span style="font-size:18px;"><?xml version="1.0" encoding="UTF-8"?>  
  2. <!DOCTYPE hibernate-configuration PUBLIC  
  3.     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  4.     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">  
  5.   
  6. <hibernate-configuration>  
  7. <session-factory>  
  8.     <!-- 必须去配置的属性 -->  
  9.     <!-- 配置数据库连接的基本信息: -->  
  10.     <property name="hibernate.connection.driver_class">  
  11.         com.mysql.jdbc.Driver  
  12.     </property>  
  13.     <property name="hibernate.connection.url">  
  14.         jdbc:mysql:///hibernate3_day01  
  15.     </property>  
  16.     <property name="hibernate.connection.username">root</property>  
  17.     <property name="hibernate.connection.password">123</property>  
  18.     <!-- Hibernate的方言 -->  
  19.     <!-- 生成底层SQL不同的 -->  
  20.     <property name="hibernate.dialect">  
  21.         org.hibernate.dialect.MySQLDialect  
  22.     </property>  
  23.   
  24.     <!-- 可选的属性 -->  
  25.     <!-- 显示SQL -->  
  26.     <property name="hibernate.show_sql">true</property>  
  27.     <!-- 格式化SQL -->  
  28.     <property name="hibernate.format_sql">true</property>  
  29.       
  30.     <property name="hibernate.connection.autocommit">false</property>  
  31.     <!-- hbm:映射 to DDL: create drop alter -->  
  32.     <property name="hibernate.hbm2ddl.auto">update</property>  
  33.   
  34.     <!-- C3P0连接池设定-->  
  35.     <!-- 使用c3po连接池  配置连接池提供的供应商-->  
  36.     <property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider                                                                                                                                                     </property>  
  37.       
  38.     <!--在连接池中可用的数据库连接的最少数目 -->  
  39.     <property name="c3p0.min_size">5</property>  
  40.     <!--在连接池中所有数据库连接的最大数目  -->  
  41.     <property name="c3p0.max_size">20</property>  
  42.     <!--设定数据库连接的过期时间,以秒为单位,  
  43.     如果连接池中的某个数据库连接处于空闲状态的时间超过了timeout时间,就会从连接池中清除 -->  
  44.     <property name="c3p0.timeout">120</property>  
  45.      <!--每3000秒检查所有连接池中的空闲连接 以秒为单位-->  
  46.     <property name="c3p0.idle_test_period">3000</property>  
  47.   
  48.     <!-- 通知Hibernate加载那些映射文件 -->  
  49.     <mapping resource="cn/itcast/hibernate3/demo1/Customer.hbm.xml" />  
  50.   
  51. </session-factory>  
  52. </hibernate-configuration></span>  
log4j.properties
[plain] view plain copy
  1. <span style="font-size:18px;">### direct log messages to stdout ###  
  2. log4j.appender.stdout=org.apache.log4j.ConsoleAppender  
  3. log4j.appender.stdout.Target=System.err  
  4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  
  5. log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{2}:%L - %m%n  
  6.   
  7. ### direct messages to file mylog.log ###  
  8. log4j.appender.file=org.apache.log4j.FileAppender  
  9. log4j.appender.file.File=d\:mylog.log  
  10. log4j.appender.file.layout=org.apache.log4j.PatternLayout  
  11. log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n  
  12.   
  13. ### set log levels - for more verbose logging change 'info' to 'debug' ###  
  14.   
  15. log4j.rootLogger=info, stdout ,file  
  16. </span>  

HibernateUtils
[java] view plain copy
  1. package cn.itcast.utils;  
  2.   
  3. import org.hibernate.Session;  
  4. import org.hibernate.SessionFactory;  
  5. import org.hibernate.cfg.Configuration;  
  6.   
  7. /** 
  8.  * Hibernate抽取工具类 
  9.  *  
  10.  * 
  11.  */  
  12. public class HibernateUtils {  
  13.     private static Configuration configuration;  
  14.     private static SessionFactory sessionFactory;  
  15.       
  16.     static{  
  17.         configuration = new Configuration().configure();  
  18.         sessionFactory = configuration.buildSessionFactory();  
  19.     }  
  20.       
  21.     public static Session openSession(){  
  22.         return sessionFactory.openSession();  
  23.     }  
  24.       
  25.     public static void main(String[] args) {  
  26.         openSession();  
  27.     }  
  28. }  

HibernateTest2
[java] view plain copy
  1. <span style="font-size:18px;">package cn.itcast.hibernate3.demo1;  
  2.   
  3. import java.io.Serializable;  
  4. import java.util.List;  
  5.   
  6. import org.hibernate.Criteria;  
  7. import org.hibernate.Query;  
  8. import org.hibernate.Session;  
  9. import org.hibernate.Transaction;  
  10. import org.hibernate.criterion.Restrictions;  
  11. import org.junit.Test;  
  12.   
  13. import cn.itcast.utils.HibernateUtils;  
  14.   
  15. /** 
  16.  * 抽取了Hibernate的工具类的使用 
  17.  * 
  18.  */  
  19. public class HibernateTest2 {  
  20.     @Test  
  21.     // 保存数据  
  22.     public void demo1(){  
  23.         Session session = HibernateUtils.openSession();  
  24.         Transaction tx = session.beginTransaction();  
  25.           
  26.         Customer customer = new Customer();  
  27.         customer.setName("芙蓉");  
  28.         customer.setAge(26);  
  29.           
  30.         session.save(customer);  
  31.           
  32.         tx.commit();  
  33.         session.close();  
  34.     }  
  35.       
  36.     @Test  
  37.     // 保存或更新()  
  38.     public void demo2(){  
  39.         // 获得SEssion  
  40.         Session session = HibernateUtils.openSession();  
  41.         // 开启事务  
  42.         Transaction tx = session.beginTransaction();  
  43.           
  44.         /*Customer customer = new Customer(); 
  45.         customer.setName("冠希"); 
  46.         customer.setAge(34); 
  47.          
  48.         session.saveOrUpdate(customer);*/  
  49.           
  50.         Customer customer = new Customer();  
  51.         customer.setName("冠希");  
  52.         customer.setAge(34);  
  53.           
  54.         session.saveOrUpdate(customer);  
  55.           
  56.         System.out.println(tx.wasCommitted());  
  57.           
  58.         // 事务提交  
  59.         tx.commit();  
  60.           
  61.         System.out.println(tx.wasCommitted());  
  62.         // session关闭  
  63.         session.close();  
  64.     }  
  65.       
  66.     @Test  
  67.     // 保存数据  
  68.     public void demo3(){  
  69.         Session session = HibernateUtils.openSession();  
  70.         Transaction tx = session.beginTransaction();  
  71.           
  72.         Customer customer = new Customer();  
  73.         customer.setName("芙蓉");  
  74.         customer.setAge(26);  
  75.           
  76.         Serializable id = session.save(customer);  
  77.           
  78.         // session.get(Customer.class, id);  
  79.           
  80.         session.update(customer);  
  81.           
  82.         tx.commit();  
  83.         session.close();  
  84.     }  
  85.       
  86.     @Test  
  87.     // 测试程序  
  88.     public void demo4(){  
  89.         Session session = HibernateUtils.openSession();  
  90.           
  91.         Customer customer = new Customer();  
  92.         customer.setName("关羽");  
  93.         customer.setAge(26);  
  94.           
  95.         session.save(customer);  
  96.           
  97.         int d = 10 / 0;  
  98.           
  99.         Customer customer2 = new Customer();  
  100.         customer2.setName("张飞");  
  101.         customer2.setAge(26);  
  102.           
  103.         session.save(customer2);  
  104.           
  105.         session.close();  
  106.     }  
  107.       
  108.     @Test  
  109.     // HQL:  
  110.     public void demo5(){  
  111.         Session session = HibernateUtils.openSession();  
  112.         Transaction tx = session.beginTransaction();  
  113.         // 1.简单查询  
  114.         // List<Customer> list = session.createQuery("from Customer").list();  
  115.           
  116.         // 2.条件查询:  
  117.         // List<Customer> list = session.createQuery("from Customer where name = ?").setParameter(0, "芙蓉").list();  
  118.           
  119.         // 3.分页查询:select * from customer limit a,b; a:从哪开始  b:每页显示记录数.  
  120.         Query query = session.createQuery("from Customer");  
  121.         query.setFirstResult(3);  
  122.         query.setMaxResults(3);  
  123.           
  124.         List<Customer> list = query.list();  
  125.         for (Customer customer : list) {  
  126.             System.out.println(customer);  
  127.         }  
  128.           
  129.         tx.commit();  
  130.         session.close();  
  131.     }  
  132.       
  133.     @Test  
  134.     // QBC:  
  135.     public void demo6(){  
  136.         Session session = HibernateUtils.openSession();  
  137.         Transaction tx = session.beginTransaction();  
  138.         // 1.简单查询  
  139.         //List<Customer> list = session.createCriteria(Customer.class).list();  
  140.           
  141.         // 2.条件查询:  
  142.         /*Criteria criteria = session.createCriteria(Customer.class); 
  143.         criteria.add(Restrictions.eq("name","芙蓉")); 
  144.         List<Customer> list = criteria.list();*/  
  145.           
  146.         // 3.分页查询:  
  147.         Criteria criteria = session.createCriteria(Customer.class);  
  148.         criteria.setFirstResult(3);  
  149.         criteria.setMaxResults(3);  
  150.         List<Customer> list = criteria.list();  
  151.         for (Customer customer : list) {  
  152.             System.out.println(customer);  
  153.         }  
  154.           
  155.         tx.commit();  
  156.         session.close();  
  157.     }  
  158.       
  159.     @Test  
  160.     // 演示错误:(注意:)  
  161.     public void demo7(){  
  162.         Session session = HibernateUtils.openSession();  
  163.         Transaction tx = session.beginTransaction();  
  164.           
  165.         Customer customer = (Customer) session.get(Customer.class, 10);  
  166.           
  167.         Customer customer2 = new Customer();  
  168.         customer.setId(10);  
  169.         customer.setName("张飞");  
  170.         session.update(customer2);  
  171.           
  172.         tx.commit();  
  173.         session.close();  
  174.     }  
  175.       
  176.     @SuppressWarnings("unused")  
  177.     @Test  
  178.     // 演示持久化类为final情况  
  179.     public void demo8(){  
  180.         Session session = HibernateUtils.openSession();  
  181.         Transaction tx = session.beginTransaction();  
  182.           
  183.         Customer customer = (Customer) session.load(Customer.class, 10);  
  184.           
  185.         tx.commit();  
  186.         session.close();  
  187.     }  
  188. }  
  189. </span>  
HibernateTest3
[java] view plain copy
  1. <span style="font-size:18px;">package cn.itcast.hibernate3.demo1;  
  2.   
  3. import org.hibernate.Session;  
  4. import org.hibernate.Transaction;  
  5. import org.junit.Test;  
  6.   
  7. import cn.itcast.utils.HibernateUtils;  
  8.   
  9. /** 
  10.  * 主键生成策略 
  11.  * 
  12.  */  
  13. public class HibernateTest3 {  
  14.       
  15.     @Test  
  16.     // 演示increment的问题:  
  17.     public void demo1(){  
  18.         Session session = HibernateUtils.openSession();  
  19.         Transaction tx = session.beginTransaction();  
  20.           
  21.         Customer customer = new Customer();  
  22.         customer.setName("芙蓉");  
  23.         customer.setAge(26);  
  24.           
  25.         session.save(customer);  
  26.           
  27.         tx.commit();  
  28.         session.close();  
  29.     }  
  30.       
  31.     @Test  
  32.     // 演示increment的问题:  
  33.     public void demo2(){  
  34.         Session session = HibernateUtils.openSession();  
  35.         Transaction tx = session.beginTransaction();  
  36.           
  37.         Customer customer = new Customer();  
  38.         // customer.setId(100);  
  39.         customer.setName("凤姐");  
  40.         customer.setAge(26);  
  41.           
  42.         session.save(customer);  
  43.           
  44.         tx.commit();  
  45.         session.close();  
  46.     }  
  47. }  
  48. </span>  
Log4JTest
[java] view plain copy
  1. <span style="font-size:18px;">package cn.itcast.log4j;  
  2.   
  3. import org.apache.log4j.Logger;  
  4. import org.junit.Test;  
  5.   
  6. /** 
  7.  * 日志记录的类: 
  8.  */  
  9. public class Log4JTest {  
  10.       
  11.     private Logger logger = Logger.getLogger(Log4JTest.class);  
  12.       
  13.     @Test  
  14.     public void demo1(){  
  15.         logger.fatal("致命错误");  
  16.         logger.error("普通错误");  
  17.         logger.warn("警告信息");  
  18.         logger.info("普通信息");  
  19.         logger.debug("调试信息");  
  20.         logger.trace("堆栈信息");  
  21.     }  
  22. }  
  23. </span>  
阅读全文
0 0
淘宝扣了48分如何申诉 淘宝扣了48分如何申诉
原创粉丝点击
热门IT博客
oppor9切换网络oppor9切换网络
知金教育集团知金教育集团
免费餐饮软件
杭州美工培训学校
太原理工软件算211吗
淘宝图片排序二个一排
查询域名的ip地址
手机体育直播软件
翻墙有哪些软件推荐
淘宝手机充值代付
淘宝橙路女生书包
js 遍历子节点
erp源码
mac播放wav格式
域控推送软件
淘宝卖家怎么找直播
机械装配动画制作软件
js给div添加id
mac appstore验证失败
h3c mac地址绑定ip
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 网络工程师月薪 薪资管理 待遇如何 月薪10万的工作 年薪 月薪一万的工作 it工程师待遇 找工作哪里找 月薪过万的工作 程序员待遇怎么样 什么工作月薪5万 测试工程师待遇 java工程师薪资 薪金 月薪3万的工作 月薪过万 什么工作月薪10万 如何月薪过万 软件工程师收入 什么是薪酬 月薪 薪酬福利 待遇怎么样 程序员薪资待遇 软件测试薪资待遇 社会 中级会计师月薪多少钱 月薪一万 月薪5000 年薪和月薪的区别 薪资系统 薪酬水平 薪酬管理系统 薪资计算 金融行业讲师工资多少 工伤休息期间工资怎么算 2018船员真实工资 老板拖欠员工工资怎么办 企业拖欠员工工资怎么办 北京什么工作工资高 杭州什么工作工资高

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里