• Hibernate：最流行的ORM框架，通过对象—关系映射配置，可以完全脱离底层SQL。
• JPA：Java Persistence API. JPA通过JDK5.0注解或XML描述对象关系表的映射关系。（只有接口规范）
• MyBatis：本是Apache的一个开源项目iBatis，支持普通的SQL查询，存储过程和高级映射的优秀持久层框架。
• Apache DBUtils 、Spring JDBCTemplate

• 用于整合其他日志系统（在企业中常用的日志记录：log4J）
• 是具体的日志记录方案

• 开发阶段的调试信息
• 运行时的日志记录（日志代码占代码总量的4%）

• 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文件中。

• org.apache.log4j.ConsoleAppender（控制台）
• org.apache.log4j.FileAppender（文件）
• org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
• org.apache.log4j.RollingFileAppender（文件到达指定大小时产生一个新文件）
• org.apache.log4j.WriterAppender（将日志信息以流方式发送到任何地方）

• org.apache.log4j.HTMLLayout（以HTML表格形式布局）
• org.apache.log4j.PatternLayout（可以灵活的自己指定布局模式）
• org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串）
• org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等信息）

• %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 —>org.apache.xyz.SomeClass    %C{2}—>xyz.SomeClass

• %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

• %l —> MyClass.main(MyClass.java:129)

package org.javaresearch.log4j;
import org.apache.log4j.*;
public class TestLog4J {   
static Logger log = Logger.getLogger(TestLog4J.class.getName());  
 public static void main(String args[]) {	    // logging的各种方法	  
  log.debug("Start of main()");  
 }
}

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{2}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=d\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change ‘info‘ to ‘debug‘ ###

log4j.rootLogger=info, stdout ,file

package cn.test.log4j;

import org.apache.log4j.Logger;
import org.junit.Test;

/**
 * 日志记录的类:
 *
 */
public class Log4JTest {
	
	private Logger logger = Logger.getLogger(Log4JTest.class);
	
	@Test
	public void demo1(){
		logger.fatal("致命错误");
		logger.error("普通错误");
		logger.warn("警告信息");
		logger.info("普通信息");
		logger.debug("调试信息");
		logger.trace("堆栈信息");
	}
}

输出到日志文件

<?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="cn.itcast.domain.Customer" table="customer" select-before-update="true">
		 <!-- 配置哪个属性 关联数据表主键 -->
		 <id name="id" column="id" type="integer">
		 	<!-- 主键生成策略 -->
		 	<generator class="identity"></generator>
		 </id>
		 <!-- 普通属性 -->
		 <property name="name" column="name" type="string"></property>
		 <!-- 如果属性名和列名相同 可以省略 column -->
		 <property name="age" type="integer" ></property>
		 <!-- 类型也可以使用默认生成规则，省略type -->
		 <property name="city"></property>
		 <property name="info"></property>
	</class>
</hibernate-mapping>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
	<!-- 会话连接工厂，建立数据库连接需要SessionFactory -->
	<session-factory>
		<!-- JDBC连接基本参数 -->
		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql:///hibernatetest</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">123</property>
		<!-- 配置数据库方言，便于生成一些与数据库相关SQL方言 -->
		<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
		<!-- 可以根据需要自动创建数据表 -->
		<property name="hibernate.hbm2ddl.auto">update</property>
		<!-- 将SQL语句 输出到控制台 -->
		<property name="hibernate.show_sql">true</property>
		<property name="hibernate.format_sql">true</property>
		
		<!-- JavaEE6 使用BeanValidator校验，需要设置校验模式-->
<!-- 		<property name="javax.persistence.validation.mode">none</property> -->
		
		<mapping resource="cn/itcast/domain/Customer.hbm.xml"></mapping>
	</session-factory>
</hibernate-configuration>

第七步：编程操作hibernate框架

• Object    get(Class clazz,  Serializable  id)
• Object  load(Class clazz,  Serializable  id )

• Query  createQuery(String   queryString)  接受HQL
• SQLQuery  createSQLQuery(String queryString)  接受SQL

• Query query=session.createQuery("from Customer");
• 这里的Customer是类名

• Query query = session.createSQLQuery("select * from customer");  
• 这里参数就是普通SQL语句 

• Hibernate的持久化方案，将用户从原始的JDBC底层SQL访问中解放出来。
• 用户无须关注底层数据库的操作，只要通过操作映射到数据表的Java对象，就可以对数据库进行增删改查。
• Hibernate框架支持哦两种Hibernate属性配置方式：hibernate.properties和hibernate.cfg.xml。
• 采用properties方式必须手动编程加载hbm文件或者持久化类
• 采用xml配置方式，可以配置添加hbm文件

• 加载hibernate.properties 和hibernate.cfg.xml
• 持久化类与数据表的映射关系( *.hbm.xml)

• Configuration configuration=new Configuration().configure();
• SessionFactory sessionFactory = configuration.buildSessionFactory();

• Session  session = sessionFactory.openSession();

• commit()：提交相关联的session实例。
• rollback()：撤销事务操作。
• wasCommitted()：检查事务是否提交。

• 获得Hibernate  Session对象。
• 编写HQL语句。
• 调用session.createQuery 创建查询对象。
• 如果HQL语句包含参数，则调用Query的setXXX设置参数。
• 调用Query对象的list() 或uniqueResult() 方法执行查询。

• setFirstResult(int  firstResult)：设置返回结果从第几条开始
• setMaxResults(int maxResults)：设置本次返回结果的记录条数

• from Customer 查询customer表所有数据

• select name from Customer  返回List<String>
• select name,age from Customer 返回 List<Object[] >
• select c.name from Customer as c 为Customer实例起别名

• 获得Hibernate的Session对象
• 通过Session获得Criteria对象
• 通过Restrictions的静态方法创建Criterion条件对象
• 向Criteria对象中添加Criterion查询条件
• 执行Criteria的list() 或 uniqueResult() 获得结果

• 提供一个无参数public访问控制符的构造器（无参构造函数，因为Hibernate要使用反射进行操作）
• 提供一个标识属性，映射数据表主键字段。（Java区分两个对象是否是同一个使用地址，数据库区分两条记录是否一致使用主键，Hibernate中区分持久化对象是否是同一个则根据唯一标识）
• 所有属性提供public访问控制符的set / get方法。（框架存取值的时候使用）
• 标识属性应尽量使用基本数据类型的包装类型。
• 不要使用final修饰（将无法生成代理对象进行优化）

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

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

• class：指定使用标识符生成器全限定 类名或其缩写名。

• 由于increment生存标识符机制不依赖于底层数据库系统，因此它是适用于所有的数据库系统。
• 适用于只有单个Hibernate应用进程访问同一个数据库的场合。因为会产生多线程问题，在集群下不要使用。
• OID必须为long，int，或short类型，如果把OID定义为byte类型，在运行时就会抛出异常。

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

• 由于sequence生成标识符的机制依赖于底层数据库系统的序列，因此，要求底层数据库系统必须支持序列。支持序列的数据库包括DB2、Oracle等。
• OID必须为long、int、或short类型，如果把OID定义为byte类型，在运行时也会抛出异常。

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

package cn.itcast.hibernate3.demo1;
/**
 * 实体类对象
 *
 */
public final class Customer {
	private Integer id;
	//private String id;
	private String name;
	private int age;

	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Customer [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	
}

package cn.itcast.hibernate3.demo1;

import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

/**
 * Hibernate入门案例的测试:
 *
 *
 */
public class HibernateTest1 {
	
	@Test
	// 查询所有记录:SQL
	public void demo7(){
		// 1.加载核心配置文件
		Configuration configuration = new Configuration().configure();
		// 2.构建Session工厂
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		// 3.通过工厂创建Session
		Session session = sessionFactory.openSession();
		// 4.开启事务
		Transaction tx = session.beginTransaction();
		
		// 5.操作
		// 查询所有:SQL
		/*SQLQuery query = session.createSQLQuery("select * from customer");
		List<Object[]> list = query.list();
		
		for (Object[] objs : list) {
			System.out.println(Arrays.toString(objs));
		}*/
		SQLQuery query = session.createSQLQuery("select * from customer");
		query.addEntity(Customer.class);
		List<Customer> list = query.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		// 6.事务提交
		tx.commit();
		// 7.释放资源
		session.close();
		sessionFactory.close();
		
	}
	
	@Test
	// 查询所有:QBC
	public void demo6(){
		// 1.加载核心配置文件
		Configuration configuration = new Configuration().configure();
		// 2.构建Session工厂
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		// 3.通过工厂创建Session
		Session session = sessionFactory.openSession();
		// 4.开启事务
		Transaction tx = session.beginTransaction();
		
		// 5.操作:
		// 查询所有 :QBC.
		/*Criteria criteria = session.createCriteria(Customer.class);
		List<Customer> list = criteria.list();*/
		Criteria criteria = session.createCriteria(Customer.class);
		criteria.add(Restrictions.eq("name", "凤姐"));
		List<Customer> list = criteria.list();
		
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		// 6.事务提交
		tx.commit();
		// 7.释放资源
		session.close();
		sessionFactory.close();
	}
	
	@Test
	// 查询所有:HQL.
	// HQL:Hibernate Query Language.Hibernate查询语言.面向对象的查询.
	public void demo5(){
		// 1.加载核心配置文件
		Configuration configuration = new Configuration().configure();
		// 手动编码加载映射文件:
		// configuration.addResource("cn/itcast/hibernate3/demo1/Customer.hbm.xml");
		// configuration.addClass(Customer.class);
		// 2.构建Session工厂
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		// 3.通过工厂创建Session
		Session session = sessionFactory.openSession();
		// 4.开启事务
		Transaction tx = session.beginTransaction();	
		
		// 5.操作
		// 1.查询所有的客户
		/*Query query = session.createQuery("from Customer");
		List<Customer> list = query.list();*/
		// 2.按名称查询
		/*Query query = session.createQuery("from Customer where name = ?");
		query.setParameter(0, "苍老师");*/
		Query query = session.createQuery("from Customer where name = :aaa");
		query.setParameter("aaa", "苍老师");
		List<Customer> list = query.list();
		
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		// 6.事务提交
		tx.commit();
		// 7.释放资源
		session.close();
		sessionFactory.close();
	}
	
	@Test
	// 删除记录
	public void demo4(){
		// 1.加载核心配置文件
		Configuration configuration = new Configuration().configure();
		// 2.构建Session工厂
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		// 3.通过工厂创建Session
		Session session = sessionFactory.openSession();
		// 4.开启事务
		Transaction tx = session.beginTransaction();	
		
		// 5.操作
		// 删除记录有两种方式:
		// 5.1手动创建对象的方式
		/*Customer customer = new Customer();
		customer.setId(2);
		
		session.delete(customer);*/
		
		// 5.2先查询在删除的方式
		Customer customer = (Customer)session.get(Customer.class, 1);
		session.delete(customer);
		
		// 6.事务提交
		tx.commit();
		// 7.释放资源
		session.close();
		sessionFactory.close();
	}
	
	@Test
	// 修改记录
	public void demo3(){
		// 1.加载核心配置文件
		Configuration configuration = new Configuration().configure();
		// 2.构建Session工厂
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		// 3.通过工厂创建Session
		Session session = sessionFactory.openSession();
		// 4.开启事务
		Transaction tx = session.beginTransaction();	
		
		// 5.操作:
		// 修改记录:两种方式可以进行修改.
		// 5.1手动创建对象的方式
		/*Customer customer = new Customer();
		customer.setId(2);
		customer.setName("苍老师");
		
		session.update(customer);*/
		
		// 5.2先查询在修改的方式
		Customer customer = (Customer) session.get(Customer.class, 1);
		customer.setName("凤姐");
		
		session.update(customer);
		
		// 6.事务提交
		tx.commit();
		// 7.释放资源
		session.close();
		sessionFactory.close();
	}
	
	@Test
	// 按id进行查询
	// (*****面试题)get和load方法区别
	public void demo2(){
		// 1.加载核心配置文件
		Configuration configuration = new Configuration().configure();
		// 2.构建Session工厂
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		// 3.通过工厂创建Session
		Session session = sessionFactory.openSession();
		// 4.开启事务
		Transaction tx = session.beginTransaction();
		// 5.操作
		// 根据id进行查询:
		// get方法进行查询
		Customer customer = (Customer) session.get(Customer.class, 100); // 马上发生一条SQL进行查询
		
		System.out.println(customer);
		
		// load方法进行查询
		//Customer customer = (Customer) session.load(Customer.class, 100); // 没有发送SQL
		
		//System.out.println(customer);// 发送SQL.
		
		// 6.事务提交
		tx.commit();
		// 7.释放资源
		session.close();
		sessionFactory.close();
		
	}
	
	@Test
	// 保存记录
	public void demo1(){
		// 1.Hiberante框架加载核心配置文件(有数据库连接信息)
		Configuration configuration = new Configuration().configure();
		// 2.创建一个SessionFactory.(获得Session--相当连接对象)
		SessionFactory sessionFactory = configuration.buildSessionFactory();
		// 3.获得Session对象.
		Session session = sessionFactory.openSession();
		// 4.默认的情况下,事务是不自动提交.
		Transaction tx = session.beginTransaction();
		// 5.业务逻辑操作
		
		// 向数据库中插入一条记录:
		Customer customer = new Customer();
		customer.setName("苍老师");
		customer.setAge(38);
		
		session.save(customer);
		
		// 6.事务提交
		tx.commit();
		// 7.释放资源
		session.close();
		sessionFactory.close();
	}
}

<?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 :类的全路径  table:表名称 -->
	<class name="cn.itcast.hibernate3.demo1.Customer" table="customer">
		<!-- 建立类中属性与表中的字段映射 -->
		<!-- 唯一标识 -->
		<!-- 使用id的标签 配置唯一属性 -->
		<!-- 在<id>标签中配置一个主键的生成策略. -->
		<id name="id" column="id">
			<generator class="assigned"/>
		</id>
		
		<!-- 普通属性 -->
		<!-- property标签:映射类中的普通属性 name:类中的属性名称, column:表中字段名称 -->
		<!-- 
			type:三种写法
				* Java类型		:java.lang.String
				* Hibernate类型	:string
				* SQL类型		:不能直接使用type属性,需要子标签<column>
					* <column name="name" sql-type="varchar(20)"/>
		 -->
		<property name="name" column="name" type="string" length="20"/>
		<property name="age" column="age"/>
		
		
	</class>
	

</hibernate-mapping>

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>
	<!-- 必须去配置的属性 -->
	<!-- 配置数据库连接的基本信息: -->
	<property name="hibernate.connection.driver_class">
		com.mysql.jdbc.Driver
	</property>
	<property name="hibernate.connection.url">
		jdbc:mysql:///hibernate3_day01
	</property>
	<property name="hibernate.connection.username">root</property>
	<property name="hibernate.connection.password">123</property>
	<!-- Hibernate的方言 -->
	<!-- 生成底层SQL不同的 -->
	<property name="hibernate.dialect">
		org.hibernate.dialect.MySQLDialect
	</property>

	<!-- 可选的属性 -->
	<!-- 显示SQL -->
	<property name="hibernate.show_sql">true</property>
	<!-- 格式化SQL -->
	<property name="hibernate.format_sql">true</property>
	
	<property name="hibernate.connection.autocommit">false</property>
	<!-- hbm:映射 to DDL: create drop alter -->
	<property name="hibernate.hbm2ddl.auto">update</property>

	<!-- 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加载那些映射文件 -->
	<mapping resource="cn/itcast/hibernate3/demo1/Customer.hbm.xml" />

</session-factory>
</hibernate-configuration>

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{2}:%L - %m%n

### direct messages to file mylog.log ###
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=d\:mylog.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change ‘info‘ to ‘debug‘ ###

log4j.rootLogger=info, stdout ,file

package cn.itcast.utils;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

/**
 * Hibernate抽取工具类
 * 
 *
 */
public class HibernateUtils {
	private static Configuration configuration;
	private static SessionFactory sessionFactory;
	
	static{
		configuration = new Configuration().configure();
		sessionFactory = configuration.buildSessionFactory();
	}
	
	public static Session openSession(){
		return sessionFactory.openSession();
	}
	
	public static void main(String[] args) {
		openSession();
	}
}

package cn.itcast.hibernate3.demo1;

import java.io.Serializable;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.criterion.Restrictions;
import org.junit.Test;

import cn.itcast.utils.HibernateUtils;

/**
 * 抽取了Hibernate的工具类的使用
 *
 */
public class HibernateTest2 {
	@Test
	// 保存数据
	public void demo1(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer = new Customer();
		customer.setName("芙蓉");
		customer.setAge(26);
		
		session.save(customer);
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 保存或更新()
	public void demo2(){
		// 获得SEssion
		Session session = HibernateUtils.openSession();
		// 开启事务
		Transaction tx = session.beginTransaction();
		
		/*Customer customer = new Customer();
		customer.setName("冠希");
		customer.setAge(34);
		
		session.saveOrUpdate(customer);*/
		
		Customer customer = new Customer();
		customer.setName("冠希");
		customer.setAge(34);
		
		session.saveOrUpdate(customer);
		
		System.out.println(tx.wasCommitted());
		
		// 事务提交
		tx.commit();
		
		System.out.println(tx.wasCommitted());
		// session关闭
		session.close();
	}
	
	@Test
	// 保存数据
	public void demo3(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer = new Customer();
		customer.setName("芙蓉");
		customer.setAge(26);
		
		Serializable id = session.save(customer);
		
		// session.get(Customer.class, id);
		
		session.update(customer);
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 测试程序
	public void demo4(){
		Session session = HibernateUtils.openSession();
		
		Customer customer = new Customer();
		customer.setName("关羽");
		customer.setAge(26);
		
		session.save(customer);
		
		int d = 10 / 0;
		
		Customer customer2 = new Customer();
		customer2.setName("张飞");
		customer2.setAge(26);
		
		session.save(customer2);
		
		session.close();
	}
	
	@Test
	// HQL:
	public void demo5(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		// 1.简单查询
		// List<Customer> list = session.createQuery("from Customer").list();
		
		// 2.条件查询:
		// List<Customer> list = session.createQuery("from Customer where name = ?").setParameter(0, "芙蓉").list();
		
		// 3.分页查询:select * from customer limit a,b; a:从哪开始  b:每页显示记录数.
		Query query = session.createQuery("from Customer");
		query.setFirstResult(3);
		query.setMaxResults(3);
		
		List<Customer> list = query.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		tx.commit();
		session.close();
	}
	
	@Test
	// QBC:
	public void demo6(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		// 1.简单查询
		//List<Customer> list = session.createCriteria(Customer.class).list();
		
		// 2.条件查询:
		/*Criteria criteria = session.createCriteria(Customer.class);
		criteria.add(Restrictions.eq("name","芙蓉"));
		List<Customer> list = criteria.list();*/
		
		// 3.分页查询:
		Criteria criteria = session.createCriteria(Customer.class);
		criteria.setFirstResult(3);
		criteria.setMaxResults(3);
		List<Customer> list = criteria.list();
		for (Customer customer : list) {
			System.out.println(customer);
		}
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 演示错误:(注意:)
	public void demo7(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer = (Customer) session.get(Customer.class, 10);
		
		Customer customer2 = new Customer();
		customer.setId(10);
		customer.setName("张飞");
		session.update(customer2);
		
		tx.commit();
		session.close();
	}
	
	@SuppressWarnings("unused")
	@Test
	// 演示持久化类为final情况
	public void demo8(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer = (Customer) session.load(Customer.class, 10);
		
		tx.commit();
		session.close();
	}
}

package cn.itcast.hibernate3.demo1;

import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;

import cn.itcast.utils.HibernateUtils;

/**
 * 主键生成策略
 *
 */
public class HibernateTest3 {
	
	@Test
	// 演示increment的问题:
	public void demo1(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer = new Customer();
		customer.setName("芙蓉");
		customer.setAge(26);
		
		session.save(customer);
		
		tx.commit();
		session.close();
	}
	
	@Test
	// 演示increment的问题:
	public void demo2(){
		Session session = HibernateUtils.openSession();
		Transaction tx = session.beginTransaction();
		
		Customer customer = new Customer();
		// customer.setId(100);
		customer.setName("凤姐");
		customer.setAge(26);
		
		session.save(customer);
		
		tx.commit();
		session.close();
	}
}

package cn.itcast.log4j;

import org.apache.log4j.Logger;
import org.junit.Test;

/**
 * 日志记录的类:
 */
public class Log4JTest {
	
	private Logger logger = Logger.getLogger(Log4JTest.class);
	
	@Test
	public void demo1(){
		logger.fatal("致命错误");
		logger.error("普通错误");
		logger.warn("警告信息");
		logger.info("普通信息");
		logger.debug("调试信息");
		logger.trace("堆栈信息");
	}
}