hibernate搭建Log4j日志环境
搭建Log4j日志环境
1.将slf4j-nop.jar换成log4j.jar，并slf4j-log4j.jar
2.拷来log4j.properties文件
在hibernate-distribution-3.5.5-Final\project\etc中，把log4j.properties文件拷到工程下
其实里面有用的内容就是下面的7行
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
log4j.rootLogger=warn, stdout
log4j.logger.org.hibernate.tool.hbm2ddl=debug2011年3月 Java大版内专家分月排行榜第三
本帖子已过去太久远了，不再提供回复功能。框架 day31 Hibernater入门(log4j简介,核心配置,映射配置,核心api,OID映射)
1.1框架介绍
*传统使用JDBC开发
*使用工具包，DbUtils （commons-...）
1.3hibernate 介绍
*Hibernate是轻量级EE应用的持久层解决方案，是一个关系ORM框架
*轻量级：依赖其他内容较少，消耗资源成本少。
*持久层：与数据库进行数据交换。
*ORM ，对象关系映射（object relation mapping）
对象：java一切都是对象，一般情况使用JavaBean
关系：数据库中的表（二维表）
映射：配置文件
1.4流行框架
a、 JPA Java Persistence API 通过注解描述对象与数据表映射关系 （只有接口规范）
b、 Hibernate 最流行ORM框架，通过对象-关系映射配置，可以完全脱离底层SQL ， Hibernate实现JPA规范
c、 MyBatis 本是apache的一个开源项目 iBatis，支持普通 SQL查询，存储过程和高级映射的优秀持久层框架 （企业主流）
* MyBaits 并不是完全ORM ， 需要在xml中配置SQL语句
d、 Apache DBUtils 、Spring JDBCTemplate
SQL语句封装程度 Hibernate & MyBatis & Apache DBUtils 、Spring JDBCTemplate
2第一个案例
2.1编写步骤
*创建java项目
*导入jar包
*核心配置文件 hibernate.cfg.xml (configuration)
*JavaBean + 映射文件 （bean名称.hbm.xml）
注意：必须将映射文件，添加核心配置文件中
2.2导入jar包
*版本：3.6.10
hibernate 是 JBOSS框架，JBOSS是EJB服务器，JBOSS推出JBPM工作流
企业主流 Hibernate 版本: hibernate3.x
最新hibernate版本4.x测试版，hibernate4和hibernate3开发有很多不同
***** hibernate 还有很多扩展技术 search、validator ....
下载 hibernate-distribution-3.6.10.Final-dist.zip
*导入jar（n个）
%h%/hibernate3.jar核心
%h%/lib\required必须目录下的所有
%h%/lib\jpa java 规范（java persist api）java持久api，hibernate对其支持（一般注解开发）
注意：数据驱动
hibernate 3.x版本 默认采用日志技术 slf4j (即简单日志门面（SimpleLoggingFacadeforJava）) ,不是具体的日志解决方案，它只服务于各种各样的日志。
* 使用slf4j好处，很容易整合其他日志技术
企业java开发 最主流日志技术log4j
slf4j-api-1.6.1.jar 没有日志实现，只是接口，整合log4j
导入 slf4j-log4j12-1.7.2.jar （slf4j对log4j框架整合 ）
导入 log4j-1.2.16.jar （log4j的日志jar包 ）
============================================================================
2.2.1log4j简介
log4j 是企业主流日志技术 ，是Apache公司提供的
1） 什么是日志技术，开发中为什么要用日志技术
日志 ： 在系统运行过程中，记录关键信息，记录错误异常信息的技术
* 区分 System.out 和 日志技术
* System.out 向控制台输入信息，一定输出
* 日志技术 存在级别，通过级别控制日志是否输出，输出的详细程度， 输出的目的地（控制台、文件、发送邮件）
使用日志： 主要用于开发过程中调试 和 项目上线后的维护（记录bug）
2） 使用log4j 通过配置文件 ，配置日志框架使用
src/log4j.xml
src/log4j.properties (简单)
配置log4j.properties 有三个
组件一： 记录器（Loggers） 用来配置日志输出级别，使用哪些输出源 格式： 记录器名 = 级别, 输出源1 , 输出源2 ...
* 一个记录器 指定 多个输出源
log4j.rootLogger=info, stdout info是日志级别 ， stdout是输出源名称
* log4j提供日志级别 由高到低 ：fatal(致命错误), error(普通错误), warn(警告),info(信息), 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 自定义布局格式
3）、 在程序中使用log4j 记录日志
步骤一 ：定义记录器
private static final Logger LOG = Logger.getLogger(Log4jTest.class);
步骤二 ：使用 log4j提供每个级别方法 记录日志
LOG.fatal(&致命错误&);
LOG.error(&普通错误&);
LOG.warn(&警告信息&);
(&普通信息&);
LOG.debug(&调试信息&);
LOG.trace(&堆栈信息&);
* 常用 ： error、warn、info、debug
===========================================================================
2.3核心配置文件
*名称：hibernate.cfg.xml
*位置：src （classpath）
*内容：（driver、url、username、password、 方言）
*约束:可以在hibernate3.jar文件中查找到 org.hibernate包下有一个
/org/hibernate/hibernate-configuration-3.0.dtd
在hibernate的目录 中有一个project/ect目录 有一个hibernate.cfg.xml文件，可以直接copy它.
在hibernate/project/etc/hibernate.properties文件，在这个文件中定义了键值与value值
com..jdbc.Driver
jdbc:mysql://localhost:3306/h_day01_db
org.hibernate.dialect.MySQL5Dialect
注意：必须手动创建数据库
2.4javabean和映射文件
2.4.1javabean 字段
public class User {
private I//注意：必须是整形
2.4.2映射文件
*名称：User.hbm.xml
*位置：javabean同包
*内容：（配置javabean属性 和 表中字段 对应关系）
*约束:在hibernate3.jar文件中查找到 org.hibernate包下有一个
/org/hibernate/hibernate-mapping-3.0.dtd
注意：映射文件必须添加到核心配置文件中
错误:Unknown entity
*解决方案：hibernate.cfg.xml 中添加映射
错误:表不存在 Table xxxxx exist
方案1：数据库手动创建表（建议）
方案2：hibernate自动创建（学习调试选择）
// 实例化配置对象，加载配置文件 hibernate.cfg.xml
Configuration configuration = new Configuration().configure();
// 创建会话连接工厂
SessionFactory sessionFactory = configuration.buildSessionFactory();
// 创建会话
Session session = sessionFactory.openSession();
// 开启事务
Transaction transaction = session.beginTransaction();
//==&&这里可以编写hibernate操作代码逻辑 （********）
// 提交事务，释放资源
session.close();
sessionFactory.close();
----------------------------------------------------------
1.添加 save(Object对象).
2.修改 update(Object c)根据id修改的
3.删除 delete(Object c)根据id删除
4.根据id查询 get(CObject.class,id);
5.查询所有 hql
Query query=session.createQuery(String hql);
Listlist=query.list();
6.查询所有 sql
SQLQuery query=session.createSQLQuery(String sql);
List list=query.list();
query.addEntity(Object.class);
在查询时得到的就是
List list=query.list();
7.查询所有 Qbc
Criteria ct = session.createCriteria(Object.class);
List list = ct.list();
----------------------------------------------------------
public class TestCRUD {
public void demo04(){
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession();
session.beginTransaction();
//分页查询 ，提供hibernate提供的api分页
// * 回顾sql
select * from t_user limit startIndex,pageS
// ** startIndex 开始索引
// ** pageSize 每页显示个数
Query query = session.createQuery(&from User&);
query.setFirstResult(0);
query.setMaxResults(2);
query.setFirstResult(2);
//回顾算法： startIndex = (pageNum - 1 ) * pageS
query.setMaxResults(2);
List allUser = query.list();
for (User user : allUser) {
System.out.println(user);
session.getTransaction().commit();
//获得之前开启的事务
session.close();
sessionFactory.close();
public void demo03(){
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession();
session.beginTransaction();
//查询所有--使用hibernate 查询 query 语句 hql
// * hql hibernate提供面向对象的查询语句，类似与sql
// ** sql 格式： select 表中字段 from 表名 where ... ,例如： select * from t_user
// ** hql 格式：[select 对象属性] from 对象[ where ...] ，例如：from User
Query query = session.createQuery(&from User&);
List allUser =query.list();
for (User user : allUser) {
System.out.println(user);
session.getTransaction().commit();
//获得之前开启的事务
session.close();
sessionFactory.close();
public void demo02(){
Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession();
session.beginTransaction();
//通过id查询
User user = (User)session.get(User.class, 1);
System.out.println(user);
session.getTransaction().commit();
//获得之前开启的事务
session.close();
sessionFactory.close();
public void demo01(){
User user = new User();
user.setUid(1);
user.setUsername(&杰克&);
Configuration config = new Configuration().configure();
//config.addResource(&cn/itcast/domain/User.hbm.xml&);
//config.addClass(User.class);
SessionFactory factory = config.buildSessionFactory();
Session session = factory.openSession();
Transaction transaction = session.beginTransaction();
//更新 -- 通过id更新所有内容，如果没有设置null
session.update(user);
session.close();
factory.close();
PO persistent object 持久对象
Hibernate中持久化类
提供一个无参数 public访问控制符的构造器
提供一个标识属性，映射数据表主键字段
所有属性提供public访问控制符的 set get 方法
标识属性应尽量使用基本数据类型的包装类型
不要用final修饰 （将无法生成代理对象进行优化）
应用程序通过po类与hibernate进行交互。
4.2Configuration
*hibernate 提供用于加载配置文件的。
*核心配置文件种类：hibernate.properties 和 hibernate.cfg.xml
一般情况使用 hibernate.cfg.xml ，可以配置不同内容（基本信息，映射文件）
hibernate.properties 只能配置基本信息（key=value）
参考：%h%/project/etc/hibernate.properties
*构造方法，new Configuration() hibernate将加载 hibernate.properties 配置文件
*提供方法：configure() 加载hibernate.cfg.xml 配置文件
通过 configure(String ) 指定自定义的cfg.xml文件。
*加载映射文件 hbm.xml
addResource() 加载自定义的映射文件。例如：config.addResource(&cn/itcast/domain/User.hbm.xml&);
addClass() 加载自定义映射文件。例如：config.addClass(User.class);
建议：映射文件与Java通同名同包，且扩展名为hbm.xml
注意：如果重复添加JavaBean，提示错误
4.3SessionFactory
*Configuration对象根据当前的配置信息生成 SessionFactory对象
*SessionFactory 对象中保存了当前的数据库配置信息和所有映射关系以及预定义的SQL语句
*SessionFactory还负责维护Hibernate的二级缓存（例如： hibernate.cfg.xml / ...hbm.xml 配置内容）
*每一个应用程序只能有一个实例（单例），类似Jdbc时学习的连接池
*线程安全的，不同的线程都可以获得不同session。
*获得实例 configuration.buildSessionFactory()
*获得session
openSession() 创建一个回话，每执行一次，session都是新的。
getCurrentSession() 获得当前线程中绑定的session，(需配置才能使用)。
构造SessionFactory 很消耗资源，一般情况下一个应用只初始化一个
抽取HibernateUtils 用来提供Session对象
public class HibernateUtils {
private static C
private static SessionF
config=new Configuration().configure();
factory=config.buildSessionFactory();
public static Session openSession(){
return factory.openSession();
public static Session getCurrentSession(){
return factory.getCurrentSession();
4.4Session
*hibernate 提供 操作 PO类
Session相当于 JDBC的 Connection
Session 是应用程序与数据库之间交互操作的一个单线程对象，是 Hibernate 运作的中心
*线程不安全，及每一个用户必须独享自己的session。
所有持久化对象必须在 session 的管理下才可以进行持久化操作
Session 对象有一个一级缓存，显式执行 flush 之前，所有的持久层操作的数据都缓存在 session 对象处
持久化类与 Session 关联起来后就具有了持久化的能力
save()/persist() 、update() 、saveOrUpdate() 增加和修改对象
delete() 删除对象
get()/load() 根据主键查询
createQuery() / createSQLQuery() 数据库操作对象
createCriteria() 条件查询
如果没有开启事务，那么每个Session的操作，都相当于一个独立的事务
Transaction transaction = session.beginTransaction();
4.5事务操作
*获得当前事务:session.getTransaction()
*开启事务：beginTransaction()
*提交事务：commit()
*回滚事务：rollback()
*检查事务是否提交:wasCommitted():
*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) 设置本次返回结果记录条数
4.7HQL入门举例
以from开始HQL语句，调用list方法返回List
fromCustomer 查询customer表所有数据
使用select 关键字 （查询部分对象属性）
select name from Customer 返回List
select name,age from Customer 返回 List
select c.name from Customer as c 为Customer实例起别名
使用where添加条件
fromCustomer as c where c.age & :age 其中:age是参数
from Customer as c where c.age & ? 其中?是参数
4.8Criteria
Criteria 是Hibernate提供的用于条件查询接口
Criteriacriteria = session.createCriteria(Customer.class);
使用Criteria对象步骤
获得Hibernate的Session对象
通过Session获得Criteria对象
使用Restrictions的静态方法创建Criterion条件对象
向Criteria对象中添加Criterion 查询条件
执行Criterita的 list() 或uniqueResult() 获得结果是参数
5主配置文件详解
*名称：hibernate.cfg.xml
*位置：src (classpath) ---& WEB-INF/classes
*配置 BeanFactory异常
原因：java web 6.0项目，默认进行Bean校验，通常不使用。
解决方案：
方案1：删除此jar==&&libraryset\EE_6\bean-validator.jar
方案2：hibernate 配置取消(见5)
com.mysql.jdbc.Driver
jdbc:mysql:///h_day01_db
org.hibernate.dialect.MySQL5Dialect
*如果使用session.openSession() 可以通过执行多次 session.beginTransaction() 进行多次事务操作。
*但如果使用session.getCurrentSession() 只能使用一次，如果进行提交，默认情况下，将进行session.close()，
解决此问题，spring采用 OpenSessionInViewFilter 过滤器。
public void demo01(){
Configuration config = new Configuration().configure();
SessionFactory factory = config.buildSessionFactory();
Session session = factory.getCurrentSession();
//开启事务
Transaction transaction = session.beginTransaction();
//**** 操作
User user = new User();
user.setUsername(&rose2&);
user.setPassword(&1234&);
session.save(user);
Spring OpenSessionInViewFilter
Transaction transaction2 = session.beginTransaction();
//**** 操作
User user2 = new User();
user2.setUsername(&tom&);
user2.setPassword(&1234&);
session.save(user2);
session.close();
//7 关闭工厂
factory.close();
5.2配置c3p0连接池
引入c3p0-0.9.1.jar
* 在hibernate.cfg.xml文件中增加如下配置
org.hibernate.connection.C3P0ConnectionProvider
7映射文件详解
*文件名称： javabean名称.hbm.xml
*位置：javabean同包
7.2属性基本设置
name : 默认用于配置javabean属性名称
length : 配置长度，字符串默认255，mysql类型 varchar(255)
column : 当前属性对应表中字段(列)名称，默认name的值
方式1：column属性(attribute),
方式2：子标签
type: 数据字段类型
方式1：hibernate类型，例如：string
方式2：java类型，例如：java.lang.String
方法3：mysql类型，例如：varchar(50)
*日期时间类型
date , 日期 java.util.Date ， 对应jdbc类型：java.sql.Date
time , 时间 java.util.Date ， 对应jdbc类型：java.sql.Time
timestamp,时间戳 java.util.Date （注意：时间戳随着数据更改变化）， 对应jdbc类型：java.sql.Timestamp
项目使用：
1.字符串、long (date.getTime())、日期时间类型
2.使用数据的datetime 表示日期时间。
7.3属性和字段选择
access ，用于确定当前属性如何进行数据封装
property: 默认值，hibernate采用javabean属性 与 表字段进行对应。在javabean必须提供 getter/setter方法
field： hibernate采用 javabean 字段 与 表字段进行对应。 可以没有getter/setter方法
例如：private S
noop: 提供给hibernatehql使用，数据库没有对应字段。一般不使用。
precision 和 scale 给 oracle配置，在mysql没有作用。
precision配置数字位数
scale配置小数位数
例如：numeric(precision,scale) , 12.34numeric(4,2)
7.4优化hibernate生成sql
*添加insert 和更新update
可以设置，允许当前属性是否在sql语句中 。默认值：true
insert=&false& 表示生产insert语句，没有当前字段。
update=&false& 表示生产update语句，没有当前字段。
设置动态 insert和update，默认值：false
dynamic-insert=&true& 如果生产insert语句，属性内容为null，生产的sql语句中将没有该字段。
dynamic-update=&true& 只有内容被修改才进行更新。默认更新所有。
注意：如果使用动态更新，数据必须是查询获得的，此时修改的内容将被更新，其他内容不变。
处理sql引用表示符
在SQL语法中，表示符是指用于为数据库表、视图、字段或索引等名字的字符串，常规表示符不包括空格，也不包含特殊字符，
因此无需使用引用符号。如果数据库表名或列名包含特殊字符，可以使用引用表示符(键盘~下面的字符)。
类中增加(desc在数据库中为关键字,不加重音符会报错)
映射文件增加
&property name=&desc& column=&`desc`&
type=& text&=&&&
7.5派生属性
*利用元素的formula属性，用来设置一个sql表达式，hibernate将根据它来计算出派生属性的值。
*派生属性内容，一般情况都是从数据库另一个张表B查询获得。
聚合函数：count()/max()/min()/avg()/sum()等
*sql语句要求，如果使用字段，默认从当前表A（配置文件描述的表）获得字段，如果要从B表中获得字段，必须使用表的别名。
8.1什么是OID
*java区分对象：hashCode(地址值)
*数据库区分记录：主键primary key
*hibernate 通过OID确定是否相同。如果OID相同，对象就相同。OID取值为数据库主键的值。
new User().setUid(1) java是一个对象A，hibernate是一个PO对象C
new User().setUid(1) java是另一个对象B，hibernate是同一个PO对象C
*PO持久对象中的数据，对应 表中一条记录。
8.2配置OID
8.3基本设置
属性（attribute）配置
name: 标识持久化类 OID 的属性名
column: 设置标识属性所映射的数据列的列名(主键字段的名字).
unsaved-value:
若设定了该属性, Hibernate 会通过比较持久化类的 OID 值和该属性值来区分当前持久化类的对象是否为临时对象,在Hibernate3中几乎不再需要.
save或update方法使用依据String ,默认null，
如果使用unsaved-value=&abc& ，当执行save方法，设置&abc&
相当于之前的null
指定 Hibernate 映射类型. Hibernate 映射类型是 Java 类型与 SQL 类型的桥梁.
如果没有为某个属性显式设定映射类型, Hibernate 会运用反射机制先识别出持久化类的特定属性的 Java 类型,
然后自动使用与之对应的默认的 Hibernate 映射类型
Java 的基本数据类型和包装类型对应相同的 Hibernate 映射类型.
基本数据类型无法表达 null, 所以对于持久化类的 OID 推荐使用包装类型（integer，long，string等）
8.4主键生成策略
主键生成策略，hibernate根据设置生成OID的值方案
建议：native、uuid、assigned （identity、sequence）
9持久对象状态
*hibernate之后操作通过对象状态确定如何使用api
*状态分类（3种）：transient 瞬时态、persistent持久态、detached脱管态
瞬时态：session没有缓存数据(无持久化标识OID)，数据库没有对应的数据。例如：new 对象
持久态：session缓存数据(存在持久化标识OID)，数据库中最终将会有数据。例如：save(user)
脱管态：session没有缓存(存在持久化标识OID)，数据库中有数据。例如：session.close() / new User().setUid(1)
删除态：给delete专门定义一个状态。（未官方）
*状态之间的转换
瞬时态 --& 持久态
当执行save()
当执行saveOrUpdate() ,hibernate底层执行save
瞬时态 --& 脱管态
手动设置OID，如果OID对应的记录再数据不存在，之后操作将抛异常（欺骗）
持久态 --& 瞬时态
当指定delete() --（存放问题--删除态）
持久态 --& 脱管态
session.close() 关闭，session不存在，缓存不存在
session.clear() 清除所有缓存。
session.evict(PO) 将指定对象从缓存移除。
脱管态 --& 瞬时态
手动删除OID
脱管态 --& 持久态
执行update
执行saveOrUpdate
*所有的查询结果，对象都是 持久态，及查询结果保存session。
对象的状态总结
10一级缓存
*一级缓存为session级别的缓存，及将数据保存session中。
*一级缓存内置，不能删除，必须使用的。
*一级缓存提高性能
public void demo01(){
//证明：一级缓存
Session session = H3Utils.getCurrentSession();
session.beginTransaction();
// 1 执行select ，将结果缓存到一级缓存
Category category = (Category) session.get(Category.class, &&);
System.out.println(category);
//2 如果一级缓存有数据，将直接获取
Category category2 = (Category) session.get(Category.class, &&);
System.out.println(category2);
session.getTransaction().commit();
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'}