过一下hibernate4-6（含Log4J）

Posted 2022-09-30

一. Hibernate 检索策略

1. 检索策略属性 Lazy

Lazy取值	说明
true	(默认) 延迟检索 ；set 端 一对多
false	立即检索；set 端 一对多
extra	增强延迟检索； set 端 一对多
proxy	(默认) 延迟检索；many-to-one 多对一
no-proxy	无代理延迟检索；many-to-one 多对一 (需要编译时字节码增强)

2. 检索策略属性 batch-size

• 批量延迟检索；
• 批量立即检索；

3. 检索策略属性 Fetch

• Fetch:select(默认) 查询方式；
• Fetch:subselect 子查询方式；
• Fetch:join 迫切左外连接查询方式；

4. 配置例子

• Student.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.bee.model">

  <class name="Student" table="t_student">
    <id name="id" column="stuId">
      <generator class="native"></generator>
    </id>
    
    <property name="name" column="stuName"></property>
    
    <many-to-one name="c" column="classId" class="com.bee.model.Class" cascade="save-update" lazy="no-proxy"></many-to-one>
  </class>

</hibernate-mapping>

• Class.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.bee.model">

  <class name="Class" table="t_class">
    <id name="id" column="classId">
      <generator class="native"></generator>
    </id>
    
    <property name="name" column="className"></property>
    
    <set name="students" cascade="delete" inverse="true" lazy="false" batch-size="3" fetch="join" >
      <key column="classId"></key>
      <one-to-many class="com.bee.model.Student"/>
    </set>
  </class>

</hibernate-mapping>

二. 查询

1. SQL查询

import org.hibernate.Query;
...
@Test
public void testSQLQuery() 
  String sql="select * from t_student";
  Query query=session.createSQLQuery(sql).addEntity(Student.class);
  List studentList=query.list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
      


@Test
public void testSQLQuery2() 
  String sql="select * from t_student where stuName like :stuName and stuAge=:stuAge";
  Query query=session.createSQLQuery(sql).addEntity(Student.class);
  query.setString("stuName", "张%");
  query.setInteger("stuAge", 10);
  List studentList=query.list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
      

2. HQL查询

@Test
public void testHQLQuery() 
  String hql="from Student";
  Query query=session.createQuery(hql);
  List<Student> studentList=(List<Student>)query.list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
      


@Test
public void testHQLQuery2() 
  String hql="from Student where name like :stuName and age=:stuAge";
  Query query=session.createQuery(hql);
  query.setString("stuName", "张%");
  query.setInteger("stuAge", 10);
  List<Student> studentList=(List<Student>)query.list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
      


@Test
public void testHQLQuery3() 
  String hql="from Student as s where s.name like :stuName and s.age=:stuAge";
  Query query=session.createQuery(hql);
  query.setString("stuName", "张%");
  query.setInteger("stuAge", 10);
  List<Student> studentList=(List<Student>)query.list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
      


@Test
public void testHQLQuery4() 
  String hql="from Student order by age desc";
  Query query=session.createQuery(hql);
  List<Student> studentList=(List<Student>)query.list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
      


@Test
public void testHQLQuery5() 
  String hql="from Student";
  Query query=session.createQuery(hql);
  query.setFirstResult(1);
  query.setMaxResults(2);
  List<Student> studentList=(List<Student>)query.list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
      


@Test
public void testHQLQuery6() 
  String hql="from Student";
  Query query=session.createQuery(hql);
  query.setFirstResult(1);
  query.setMaxResults(1);
  Student student=(Student)query.uniqueResult();
  System.out.println(student);  


@Test
public void testHQLQuery7() 
  String hql="from Student as s where s.name like :stuName and s.age=:stuAge";
  Query query=session.createQuery(hql);
  List<Student> studentList=(List<Student>)query
      .setString("stuName", "张%")
      .setInteger("stuAge", 10)
      .list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
      

3. QBC查询

@Test
public void testQBCQuery1()
  Criteria criteria=session.createCriteria(Student.class);
  List<Student> studentList=criteria.list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
    


@Test
public void testQBCQuery2()
  Criteria criteria=session.createCriteria(Student.class);
  Criterion c1=Restrictions.like("name", "张%");
  Criterion c2=Restrictions.eq("age", 10);
  criteria.add(c1);
  criteria.add(c2);
  List<Student> studentList=criteria.list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
    


@Test
public void testQBCQuery3()
  Criteria criteria=session.createCriteria(Student.class);
  criteria.addOrder(Order.desc("age"));
  List<Student> studentList=criteria.list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
    


@Test
public void testQBCQuery4()
  Criteria criteria=session.createCriteria(Student.class);
  criteria.setFirstResult(2);
  criteria.setMaxResults(2);
  List<Student> studentList=criteria.list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
    


@Test
public void testQBCQuery5()
  Criteria criteria=session.createCriteria(Student.class);
  criteria.setFirstResult(2);
  criteria.setMaxResults(1);
  Student student=(Student)criteria.uniqueResult();
  System.out.println(student);


@Test
public void testQBCQuery6()
  Criteria criteria=session.createCriteria(Student.class);
  List<Student> studentList=criteria
      .setFirstResult(0)
      .setMaxResults(2)
      .list();
  Iterator it=studentList.iterator();
  while(it.hasNext())
    Student s=(Student)it.next();
    System.out.println(s);
    

三. 高级配置

1. 连接池
   Hibernate4一般推荐使用C3P0连接池组件。

• C3P0连接池组件jar包

c3p0-0.9.2.1.jar
hibernate-c3p0-4.3.5.Final.jar
mchange-commons-java-0.2.3.4.jar

• 主配置文件
  hibernate.cfg.xml

<?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="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
        <property name="connection.username">root</property>
        <property name="connection.password">123456</property>

       
        <!-- 方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
    
        <!-- 控制台显示SQL -->
        <property name="show_sql">true</property>

        <!-- 自动更新表结构 -->
        <property name="hbm2ddl.auto">update</property>
        
        <!-- 最小连接数 --> 
        <property name="c3p0.min_size">7</property> 
        <!-- 最大连接数 -->   
        <property name="c3p0.max_size">42</property> 
        <!-- 获得连接的超时时间,如果超过这个时间,会抛出异常，单位毫秒 -->  
        <property name="c3p0.timeout">1800</property> 
        <!-- 最大的PreparedStatement的数量 -->   
        <property name="c3p0.max_statements">50</property> 
        
        <mapping resource="com/bee/model/Student.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

2. 日志框架
   Hibernate一般使用Log4J日志框架。

• jar包

log4j-1.2.17.jar

• 常用配置
  src/log4j.properties

# info为当前的告警级别，而appender1和appender2是定义了两个输出对象。
log4j.rootLogger=info,appender1,appender2

log4j.appender.appender1=org.apache.log4j.ConsoleAppender 

# 文件大小到达指定尺寸的时候产生一个新的文件（与下边FileAppender互斥）
# log4j.appender.appender2=org.apache.log4j.RollingFileAppender
# log4j.appender.appender2.Append=true
# log4j.appender.appender2.ImmediateFlush=true
# log4j.appender.appender2.MaxFileSize=50MB
# 后缀可以是KB, MB 或者GB。
# log4j.appender.appender2.MaxBackupIndex=50
# 除了定义的log文件（Bee.log），最多50个日志备份文件，且备份扩展名如：Bee.log.1，Bee.log.2，...

log4j.appender.appender2=org.apache.log4j.FileAppender 
log4j.appender.appender2.File=E:/tmp/Bee.log

# 日志输出采用预定义格式
log4j.appender.appender1.layout=org.apache.log4j.TTCCLayout
log4j.appender.appender2.layout=org.apache.log4j.TTCCLayout  

# 自定义日志输出格式
# log4j.appender.appender2.layout=org.apache.log4j.PatternLayout
# log4j.appender.appender2.layout.ConversionPattern=[ProjectName %dyyyy-MM-dd HH:mm:ss] %p [%t]%C.%M(%L)=>%m%n
# %d 日期；%p 告警级别；%t 线程；%C 类；%M 方法；%L 行；%m 输出的信息；%n 回车换行

详细可参考​​这里​​

• 输出等级（告警级别）



• Log4J的Maven坐标

<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.17</version>
</dependency>

• Java代码中的使用

public class StudentTest 

  private SessionFactory sessionFactory=HibernateUtil.getSessionFactory();
  private Session session;
  //生成logger
  private Logger logger=Logger.getLogger(StudentTest.class);
  
  @Before
  public void setUp() throws Exception 
    session=sessionFactory.openSession(); // 生成一个session
      session.beginTransaction(); // 开启事务
  

  @After
  public void tearDown() throws Exception 
     session.getTransaction().commit(); // 提交事务
     session.close(); // 关闭session
  

  @Test
  public void testSQLQuery() 
    String sql="select * from t_student";
    Query query=session.createSQLQuery(sql).addEntity(Student.class);
    List studentList=query.list();
    Iterator it=studentList.iterator();
    while(it.hasNext())
      Student s=(Student)it.next();
      System.out.println(s);
      
    //输出log
    logger.debug("这是一个debug信息");
    logger.info("这是一个info信息");
    logger.error("这是一个错误信息");
  

四. Hibernate的缓存

1. 缓存的概念：
   缓存是介于物理数据源与应用程序之间，是对数据库中的数据复制一份临时放在内存或者硬盘中的容器，其作用是为了减少应用程序对物理数据源访问的次数，从而提高了应用程序的运行性能。Hibernate 在进行读取数据的时候，根据缓存机制在相应的缓存中查询，如果在缓存中找到了需要的数据(我们把这称做“缓存命 中")，则就直接把命中的数据作为结果加以利用，避免了大量发送 SQL 语句到数据库查询的性能损耗。
2. Hibernate 缓存的分类：

• Session 缓存（又称作事务缓存）：Hibernate 内置的，不能卸除。
  缓存范围：缓存只能被当前 Session 对象访问。缓存的生命周期依赖于 Session 的生命周期，当 Session 被关闭后，缓存也就结束生命周期。
• SessionFactory 缓存（又称作应用缓存）：使用第三方插件，可插拔。
  缓存范围：缓存被应用范围内的所有 session 共享,不同的 Session 可以共享。这些 session 有可能是并发访问缓存，因此必须对缓存进行更新。缓存的生命周期依赖于应用的生命周期，应用结束时，缓存也就结束了生命周期，二级缓存存在于应用程序范围。
• 二级缓存策略提供商：
  提供了 HashTable 缓存，EHCache，OSCache，SwarmCache，jBoss Cathe2，这些缓存机制，其中 EHCache，OSCache 是不能用于集群环境（Cluster Safe）的，而 warmCache，jBoss Cathe2 是可以的。HashTable 缓存主要是用来测试的，只能把对象放在内存中，EHCache，OSCache 可以把对象放在内存（memory）中，也可以把对象放在硬盘（disk）上（为什么放到硬盘上？上面解释了）。

3. 什么数据适合放二级缓存中：

（1）经常被访问
（2）改动不大
（3）数量有限
（4）不是很重要的数据，允许出现偶尔并发的数据。
比如组织机构代码，列表信息等；

五. EHCache配置

1. jar包

ehcache-core-2.4.3.jar
hibernate-ehcache-4.3.5.Final.jar
slf4j-api-1.6.1.jar

2. 配置文件

• src/ehcache.xml

<ehcache>
   
    <!-- 指定一个文件目录，当EHCache把数据写到硬盘上时，将把数据写到这个目录下 -->
    <diskStore path="c:\\\\ehcache"/>
    
    <!--  
        设置缓存的默认数据过期策略 
    -->    
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />

    <!-- 
        name 设置缓存的名字，他的取值为类的完整名字或者类的集合的名字；
        maxElementsInMemory 设置基于内存的缓存可存放的对象的最大数目
        eternal 如果为true，表示对象永远不会过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds，默认为false;
        timeToIdleSeconds 设定允许对象处于空闲状态的最长时间，以秒为单位；
        timeToLiveSeconds 设定对象允许存在于缓存中的最长时间，以秒为单位；
        overflowToDisk 如果为true,表示当基于内存的缓存中的对象数目达到maxElementsInMemory界限，会把溢出的对象写到基于硬盘的缓存中；
     -->

    <!-- 设定具体的第二级缓存的数据过期策略 -->
    <cache name="com.bee.model.Class"
        maxElementsInMemory="1"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />
</ehcache>

• src/hibernate.cfg.xml

<?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="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
        <property name="connection.username">root</property>
        <property name="connection.password">123456</property>

       
        <!-- 方言 -->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
    
        <!-- 控制台显示SQL -->
        <property name="show_sql">true</property>

        <!-- 自动更新表结构 -->
        <property name="hbm2ddl.auto">update</property>
        
         <!-- 启用二级缓存 -->
        <property name="cache.use_second_level_cache">true</property>
        
        <!-- 配置使用的二级缓存的产品 -->
        <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
        
        <!-- 配置启用查询缓存 -->
        <property name="cache.use_query_cache">true</property>
        
        <mapping resource="com/bee/model/Student.hbm.xml"/>
        
        <mapping resource="com/bee/model/Class.hbm.xml"/>

    </session-factory>

</hibernate-configuration>

• src\\com\\bee\\model\\Class.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.bee.model">

  <class name="Class" table="t_class"以上是关于过一下hibernate4-6（含Log4J）的主要内容，如果未能解决你的问题，请参考以下文章
 
 log4j学习
 冰河连夜复现了Log4j最新史诗级重大漏洞，含视频和完整案例代码，全网最全，赶快收藏吧
 log4j日志不输出的问题
 log4j日志不输出的问题
 如何在kafka server.log文件名中包含当前日期和小时？
 log4j按照日期分割