Hiberate的基本使用

最新推荐文章于 2023-06-16 16:41:59 发布
最新推荐文章于 2023-06-16 16:41:59 发布
阅读量359 收藏 1
点赞数
分类专栏： 服务开发 文章标签： hibernate spring 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/goodmentc/article/details/125850508
版权

一、概述

掌握Hiberate的基本配置——即搭建Hiberate开发环境
掌握Hiberate常用API——即如何使用Hiberate框架进行开发
掌握Hiberate的关联映射——解决表与表之间存在的关系问题，有1n(一对多)、 11(一对一)、mn(多对多)关系
掌握Hiberate的检索方式——即掌握Hiberate的查询
掌握Hiberate的优化方式——即提高Hiberate的效率

二、介绍

2.1 hibernate执行过程：
1）应用程序先调用Configuration类，该类读取Hibernate的配置文件及映射文件中的信息，并用这些信息生成一个SessionFactory对象

2）利用SessionFactory对象得到session对象，两种方式：getCurrentSession与 openSession()。

区别：

1）getCurrentSession创建的session会和绑定到当前线程,而openSession不会。

2） getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭（session.close）。

3） openSession()打开的是新的session，getCurrentSession会先从上下文找，有session就拿过来用，没有就创造新的session

3）session对象开启事务，得到一个事务对象：

Transaction tx= session.beginTransaction();

4）利用session对象的方法get load save delete操作pojo实体类

5）事务提交+session.close()+sessionfactory.close()

2.2 hibernate配置核心
1.配置SessionFactory
2.配置事务容器
3.配置事务规则
4.配置事务入口

三、 搭建Hibernate开发环境

3.1创建java web工程，数据库和表
新建全局配置文件：

jdbc_url=jdbc\:oracle\:thin\:@192.168.23.15\:1521\:ORCL
jdbc_username=test
jdbc_password=test
dbType=oracle

hibernate.dialect=org.hibernate.dialect.Oracle9Dialect
driverClassName=oracle.jdbc.driver.OracleDriver
validationQuery=SELECT 1 from dual

hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=false
hibernate.use_sql_comments=true

3.2 引入hibernate相关依赖
3.3 配置hibernate
配置连接池druid：
引入相关配置;
创建spring-druid.xml配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:c="http://www.springframework.org/schema/c" xmlns:cache="http://www.springframework.org/schema/cache" xmlns:context="http://www.springframework.org/schema/context" xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:lang="http://www.springframework.org/schema/lang" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:p="http://www.springframework.org/schema/p" xmlns:task="http://www.springframework.org/schema/task" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:util="http://www.springframework.org/schema/util"
   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
      http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
      http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
      http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
      http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd
      http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
      http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
      http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

   <!-- 配置druid监控spring jdbc -->
   <bean id="druid-stat-interceptor" class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor" />

   <bean id="druid-stat-pointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut" scope="prototype">
      <property name="patterns">
         <list>
            <value>org.tc.*.service.*</value> 
         </list>
      </property>
   </bean>
   <aop:config>
      <aop:advisor advice-ref="druid-stat-interceptor" pointcut-ref="druid-stat-pointcut" />
   </aop:config>

</beans>

在web.xml中增加：

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
        classpath:spring.xml,classpath:spring-hibernate.xml,classpath:spring-druid.xml,classpath:spring-tasks.xml
    </param-value>
</context-param>

Web方式监控druid:

<servlet> 
2.	     <servlet-name>DruidStatView</servlet-name> 
3.	     <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class> 
4.	 </servlet> 
5.	 <servlet-mapping> 
6.	     <servlet-name>DruidStatView</servlet-name> 
7.	     <url-pattern>/druid/*</url-pattern> 
8.	 </servlet-mapping> 
9.	 <filter> 
10.	  <filter-name>druidWebStatFilter</filter-name> 
11.	  <filter-class>com.alibaba.druid.support.http.WebStatFilter</filter-class> 
12.	  <init-param> 
13.	   <param-name>exclusions</param-name> 
14.	   <param-value>/public/*,*.js,*.css,/druid*,*.jsp,*.swf</param-value> 
15.	  </init-param> 
16.	  <init-param> 
17.	   <param-name>principalSessionName</param-name> 
18.	   <param-value>sessionInfo</param-value> 
19.	  </init-param> 
20.	  <init-param> 
21.	   <param-name>profileEnable</param-name> 
22.	   <param-value>true</param-value> 
23.	  </init-param> 
24.	 </filter> 
25.	 <filter-mapping> 
26.	  <filter-name>druidWebStatFilter</filter-name> 
27.	  <url-pattern>/*</url-pattern> 
28.	 </filter-mapping>

运行Tomcat，浏览器输入 http://IP:PROT/druid就可以打开Druid的监控页面了:

配置数据源：

<bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
 <property name="url" value="${jdbc_url}" />
 <property name="username" value="${jdbc_username}" />
 <property name="password" value="${jdbc_password}" />

 <!-- 初始化连接大小 -->
 <property name="initialSize" value="1" />
 <!-- 连接池最大使用连接数量 -->
 <property name="maxActive" value="10" />
 <!-- 连接池最小空闲 -->
 <property name="minIdle" value="1" />
 <!-- 获取连接最大等待时间 -->
 <property name="maxWait" value="60000" />

 <!-- <property name="poolPreparedStatements" value="true" /> <property name="maxPoolPreparedStatementPerConnectionSize" value="33" /> -->

 <property name="validationQuery" value="${validationQuery}" />
 <property name="testOnBorrow" value="false" />
 <property name="testOnReturn" value="false" />
 <property name="testWhileIdle" value="true" />

 <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
 <property name="timeBetweenEvictionRunsMillis" value="60000" />
 <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
 <property name="minEvictableIdleTimeMillis" value="300000" />

 <!-- 打开removeAbandoned功能 -->
 <property name="removeAbandoned" value="true" />
 <!-- 1800秒，也就是30分钟 -->
 <property name="removeAbandonedTimeout" value="1800" />
 <!-- 关闭abanded连接时输出错误日志 -->
 <property name="logAbandoned" value="true" />

 <!-- 监控数据库 -->
 <!-- <property name="filters" value="mergeStat" /> -->
 <property name="filters" value="stat" />
</bean>

配置sessionFactory：

<!-- 配置hibernate session工厂 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
   <property name="dataSource" ref="dataSource" />
   <property name="hibernateProperties">
      <props>
                 <prop key="hibernate.dialect">${hibernate.dialect}</prop>
         <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
         <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
         <prop key="hibernate.use_sql_comments">${hibernate.use_sql_comments}</prop>
         <prop key="hibernate.connection.release_mode">after_transaction</prop>
      </props>
   </property>

   <!-- 自动扫描注解方式配置的hibernate类文件 -->
   <property name="packagesToScan">
      <list>          
       <value>org.tc.api.model</value>
      </list>
   </property>

   </bean>

配置事务管理器：

<bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
   <property name="sessionFactory" ref="sessionFactory"></property>
</bean>

配置事务：

<!—声明方式配置事物 -->
<tx:advice id="transactionAdvice" transaction-manager="transactionManager">
   <tx:attributes>
      <tx:method name="add*" propagation="REQUIRED" />
      <tx:method name="append*" propagation="REQUIRED" />
      <tx:method name="save*" propagation="REQUIRED" />
      <tx:method name="update*" propagation="REQUIRED" />
      <tx:method name="modify*" propagation="REQUIRED" />
      <tx:method name="edit*" propagation="REQUIRED" />
      <tx:method name="delete*" propagation="REQUIRED" />
      <tx:method name="remove*" propagation="REQUIRED" />
      <tx:method name="init" propagation="REQUIRED" />
      <tx:method name="delAndInit" propagation="REQUIRED" />

      <tx:method name="get*" propagation="REQUIRED" read-only="true" />
      <tx:method name="find*" propagation="REQUIRED" read-only="true" />
      <tx:method name="load*" propagation="REQUIRED" read-only="true" />
      <tx:method name="search*" propagation="REQUIRED" read-only="true" />
      <tx:method name="datagrid*" propagation="REQUIRED" read-only="true" />

      <tx:method name="*" propagation="REQUIRED" />
   </tx:attributes>
</tx:advice>

<!—入口-->
<aop:config> 
   <aop:pointcut id="transactionPointcut" expression="execution(* org.tc.*.service.impl.*Impl.*(..))" />
   <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />     
</aop:config>
<aop:config >
   <aop:pointcut id="transactionPointcut1" expression="execution(* org.tc.*.*.service.impl.*Impl.*(..))" />
   <aop:advisor pointcut-ref="transactionPointcut1" advice-ref="transactionAdvice" />    
</aop:config>

3.4创建实体类
实体类用@Table（name=“表名”） 标注，字段用@Column标识
3.5 创建dao类

 @Repository
public class UserDao {

   @Resource
   SessionFactory sessionFactory;
   
   public void save(User user){
       Session session = sessionFactory.openSession();
       session.save(user);
       
   }
}

3.6 创建service类

@Service
public class UserService {
    @Resource
    UserDao userDao;

    @Transactional
    public void save(User user){
        userDao.save(user);
    }
    
}

3.7 创建控制类

@Controller
public class SaveUser {

    @Resource
    UserService userService;
    
    @RequestMapping(value="/saveUser")
    public String saveUser(User user){
        userService.save(user);
        return "saveSucess";
    }
}

四、 hibernate配置项

4.1 hibernate.hbm2ddl.auto：会帮助我们根据定义好的实体，自动创建，更新，验证数据库表
none(默认)
在Hiberante启动时，不会执行任何操作。
create-only
在Hibernate启动时，对实体仅会执行建表语句，即使实体对应的表已经存在了，也会重复执行建表语句。
drop
在Hiberante启动时，对实体对应的表执行删除语句，即使实体不存在对应的表，都会执行表删除语句。
create
在Hiberante启动时，对实体对应的表执行删除语句，然后再执行建表语句。
create-drop
在Hibernate启动时，对实体对应的表执行删除语句，然后执行建表语句。在Hibernate关闭时，实体对应的表执行删除语句。
validate
对实体和对应的表进行校验。
update
实体对应的表如果不存在则会创建。如果实体中新增加了字段，会在相应的表中增加一列。
总结
create, create-drop选项要谨慎使用，因为其会执行删表语句。
validate 一般适用于线上环境，用于校验实体与数据库中的字段是否对应
update 一般用于本地快速开发，定义好实体后，Hibernate会自动创建和更新表，省去了手动更新数据库表的麻烦.

4.2 什么是validationQuery
validationQuery是用来验证数据库连接的查询语句，这个查询语句必须是至少返回一条数据的SELECT语句。每种数据库都有各自的验证语句，下表中收集了几种常见数据库的validationQuery。

DataBase validationQuery
hsqldb select 1 from INFORMATION_SCHEMA.SYSTEM_USERS
Oracle select 1 from dual
DB2 select 1 from sysibm.sysdummy1
MySql select 1
Microsoft SqlServer select1
postgresql select version()
ingres select 1
derby values 1
H2 select 1

4.3 dual
第一点
dual不是缩写词而是完整的单词。dual名词意思是对数，做形容词时是指二重的，二元的。
第二点
Oracle中的dual表是一个单行单列的虚拟表。
第三点
Dual表是oracle与数据字典一起自动创建的一个表，这个表只有1列DUMMY，数据类型为VERCHAR2(1)，dual表中只有一个数据’X’, Oracle有内部逻辑保证dual表中永远只有一条数据。
第四点
Dual表主要用来选择系统变量或求一个表达式的值。
第五点
最常见的一个简单的例子SELECT sysdate FROM daul
Oracle的SELECT语法的限制为 SELECT * | [column1 [AS alias1], column2 [AS alias2]] FROM table
所以没有表名就没有办法查询，而时间日期并不存放在任何表中，于是这个dual虚拟表的概念就被引入了。
DUAL表的用途
dual是Oracle中的一个实际存在的表，任何用户均可读取，常用在没有目标表的Select语句块中。
查看当前连接用户
select user from dual;
SYSTEM
查看当前日期、时间
select sysdate from dual;
2012-1-24 1
需要保证在DUAL表内有且仅有一条记录，不能把DUAL表的UPDATE，INSERT，DELETE权限随意释放出去，这样对于系统是很危险的。

4.4 dialect
dialect就是“方言”，因为hibernate是要把Java对象转换成关系数据库来描述的，而关系数据库虽然有一些统一的标准，如SQL-92等，但是实际上各数据库如Oracle, MySQL, MS SQL Server等等为了提高性能或增加功能都提供了一些额外的标准或语法，因此，hibernate为了更好适配各种关系数据库，针对每种数据库都指定了一个方言dialect。就是告诉Hibernate，将你写的那些HQL、QBC、、、、等等。翻译成哪种数据库的SQL。

五、 事务配置方式

事务一般有两种：编程式事务和声明式事务；编程式事务就是将事务处理放在程序中，而声明式事务则是通过配置文件或者注解进行操作。
其实配置Hibernate事务的核心就四种：
（1）、配置SessionFactory；
（2）、配置事务容器；
（3）、配置事务规则；
（4）、配置事务入口；

5.1 声明式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:c="http://www.springframework.org/schema/c" xmlns:cache="http://www.springframework.org/schema/cache" xmlns:context="http://www.springframework.org/schema/context" xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:jee="http://www.springframework.org/schema/jee" xmlns:lang="http://www.springframework.org/schema/lang" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:p="http://www.springframework.org/schema/p" xmlns:task="http://www.springframework.org/schema/task" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:util="http://www.springframework.org/schema/util"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
     http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
     http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
     http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd
     http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
     http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

  
  <!-- 配置数据源 -->
  <bean name="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
     <property name="url" value="${jdbc_url}" />
     <property name="username" value="${jdbc_username}" />
     <property name="password" value="${jdbc_password}" />

     <!-- 初始化连接大小 -->
     <property name="initialSize" value="1" />
     <!-- 连接池最大使用连接数量 -->
     <property name="maxActive" value="10" />
     <!-- 连接池最小空闲 -->
     <property name="minIdle" value="1" />
     <!-- 获取连接最大等待时间 -->
     <property name="maxWait" value="60000" />

    
     <property name="validationQuery" value="${validationQuery}" />
     <property name="testOnBorrow" value="false" />
     <property name="testOnReturn" value="false" />
     <property name="testWhileIdle" value="true" />

  <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
     <property name="timeBetweenEvictionRunsMillis" value="60000" />
     <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
     <property name="minEvictableIdleTimeMillis" value="300000" />

     <!-- 打开removeAbandoned功能 -->
     <property name="removeAbandoned" value="true" />
     <!-- 1800秒，也就是30分钟 -->
     <property name="removeAbandonedTimeout" value="1800" />
     <!-- 关闭abanded连接时输出错误日志 -->
     <property name="logAbandoned" value="true" />

     <!-- 监控数据库 -->
     <!-- <property name="filters" value="mergeStat" /> -->
     <property name="filters" value="stat" />
  </bean>

  <!-- 配置hibernate session工厂 -->
  <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
     <property name="dataSource" ref="dataSource" />
     <property name="hibernateProperties">
        <props>
                       <prop key="hibernate.dialect">${hibernate.dialect}</prop>
           <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
           <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>
           <prop key="hibernate.use_sql_comments">${hibernate.use_sql_comments}</prop>
           <prop key="hibernate.connection.release_mode">after_transaction</prop>
        </props>
     </property>

     <!-- 自动扫描注解方式配置的hibernate类文件 -->
     <property name="packagesToScan">
        <list>          
         <value>org.tc.api.model</value>
        </list>
     </property>

        </bean>

  <!-- 配置事务管理器 -->
  <bean name="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
     <property name="sessionFactory" ref="sessionFactory"></property>
  </bean>

      <!—声明方式配置事物 定义事务规则-->
  <tx:advice id="transactionAdvice" transaction-manager="transactionManager">
     <tx:attributes>
        <tx:method name="add*" propagation="REQUIRED" />
        <tx:method name="append*" propagation="REQUIRED" />
        <tx:method name="save*" propagation="REQUIRED" />
        <tx:method name="update*" propagation="REQUIRED" />
        <tx:method name="modify*" propagation="REQUIRED" />
        <tx:method name="edit*" propagation="REQUIRED" />
        <tx:method name="delete*" propagation="REQUIRED" />
        <tx:method name="remove*" propagation="REQUIRED" />
        <tx:method name="init" propagation="REQUIRED" />
        <tx:method name="delAndInit" propagation="REQUIRED" />

        <tx:method name="get*" propagation="REQUIRED" read-only="true" />
        <tx:method name="find*" propagation="REQUIRED" read-only="true" />
        <tx:method name="load*" propagation="REQUIRED" read-only="true" />
        <tx:method name="search*" propagation="REQUIRED" read-only="true" />
        <tx:method name="datagrid*" propagation="REQUIRED" read-only="true" />

        <tx:method name="*" propagation="REQUIRED" />
     </tx:attributes>
  </tx:advice>
  <aop:config> 
     <aop:pointcut id="transactionPointcut" expression="execution(* org.tc.*.service.impl.*Impl.*(..))" />
     <aop:advisor pointcut-ref="transactionPointcut" advice-ref="transactionAdvice" />     
  </aop:config>
  <aop:config >
     <aop:pointcut id="transactionPointcut1" expression="execution(* org.tc.*.*.service.impl.*Impl.*(..))" />
     <aop:advisor pointcut-ref="transactionPointcut1" advice-ref="transactionAdvice" />    
  </aop:config>

</beans>

5.2 拦截器方式

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
      http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
 
    <!--引入配置文件属性-->
    <!--<context:property-placeholder location="classpath:datasource.properties" />-->
 
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:datasource.properties" />
    </bean>
 
    <!--配置数据源-->
    <bean id="myDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
        <property name="driverClassName" value="${jdbc.driver_class}"/>
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
 
    <!--整合hibernate中sessionFactory 交给spring 容器管理-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" >
        <property name="dataSource" ref="myDataSource" />
        <property name="packagesToScan" value="com.aop.transaction.pay" />
        <!--配置hibernate额外属性-->
        <property name="hibernateProperties">
            <props>
                <!--设置hibernate方言-->
                <!--<prop key="hibernate.dialect">org.hibernate.dialect.MySQL57Dialect</prop>-->
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>
 
    <!--配置事物管理-->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
 
    <!-- 配置声明性事务管理(事务应用一般放在业务层) -->
    <!-- 事务传播行为类型 说明 PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
        PROPAGATION_SUPPORTS 支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGATION_MANDATORY 使用当前的事务，如果当前没有事务，就抛出异常。
        PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。 PROPAGATION_NOT_SUPPORTED
        以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 PROPAGATION_NEVER 以非事务方式执行，如果当前存在事务，则抛出异常。
        PROPAGATION_NESTED 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类
        似的操作。 -->
    <!-- aop代理 -->
    <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
        <!-- 设置事务管理其 -->
        <property name="transactionManager" ref="transactionManager" />
        <!--设置事物属性-->
        <property name="transactionAttributes">
            <props>
                <!-- 设置拦截方法，可以使用通配符 -->
                <!-- 可以设置事务的传播行为，隔离级别，多个值用逗号隔开 -->
                <prop key="transfer*">PROPAGATION_REQUIRED,ISOLATION_REPEATABLE_READ</prop>
                <prop key="add*">PROPAGATION_REQUIRED,ISOLATION_REPEATABLE_READ</prop>
                <prop key="insert*">PROPAGATION_REQUIRED,ISOLATION_REPEATABLE_READ</prop>
            </props>
        </property>
    </bean>
 
    <!-- 定义BeanNameAutoProxyCreatorf进行Spring的事务处理 -->
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <!-- 针对指定的bean自动生成业务代理 -->
        <property name="beanNames" value="*Service" />
        <!-- 这个属性为true时，表示被代理的是目标类本身而不是目标类的接口[cglib] -->
        <property name="proxyTargetClass">
            <value>true</value>
        </property>
        <!-- 依赖注入上面定义的事务拦截器transactionInterceptor -->
        <property name="interceptorNames">
            <list>
                <value>transactionInterceptor</value>
            </list>
        </property>
    </bean>
 
    <!--配置包扫描-->
    <context:component-scan base-package="com.aop.transaction.pay" />
 
</beans>

5.3 注解方式

  <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:aop="http://www.springframework.org/schema/aop"
      xmlns:context="http://www.springframework.org/schema/context"
      xmlns:tx="http://www.springframework.org/schema/tx"
      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

   <!--引入配置文件属性-->
   <!--<context:property-placeholder location="classpath:datasource.properties" />-->

   <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
       <property name="location" value="classpath:datasource.properties" />
   </bean>

   <!--配置数据源-->
   <bean id="myDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" >
       <property name="driverClassName" value="${jdbc.driver_class}"/>
       <property name="url" value="${jdbc.url}" />
       <property name="username" value="${jdbc.username}" />
       <property name="password" value="${jdbc.password}" />
   </bean>

   <!--整合hibernate中sessionFactory 交给spring 容器管理-->
   <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" >
       <property name="dataSource" ref="myDataSource" />
       <property name="packagesToScan" value="com.aop.transaction.pay" />
       <!--配置hibernate额外属性-->
       <property name="hibernateProperties">
           <props>
               <!--设置hibernate方言-->
               <prop key="hibernate.dialect">org.hibernate.dialect.MySQL57Dialect</prop>
               <prop key="hibernate.show_sql">true</prop>
               <prop key="hibernate.format_sql">true</prop>
               <prop key="hibernate.hbm2ddl.auto">update</prop>
           </props>
       </property>
   </bean>

   <!--配置事物管理-->
   <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
       <property name="sessionFactory" ref="sessionFactory" />
   </bean>

   <!-- 配置注解方式管理事务 -->
   <tx:annotation-driven transaction-manager="transactionManager" />

   <!--配置包扫描-->
   <context:component-scan base-package="com.aop.transaction.pay" />

</beans>

使用：在需要加事务的类上加上@Transactional

5.4代理方式

  <!-- 配置事务容器 -->
<beanid="transactionManager"
    class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <propertyname="sessionFactory"ref="sessionFactory"/>
</bean>
<!-- 定义事务规则 -->
<beanid="transactionProxy"
    class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
    abstract="true">
    <propertyname="transactionManager"ref="transactionManager"/>
    <propertyname="transactionAttributes">
        <props>
            <!-- ，回滚为-，不回滚为+ -->
            <propkey="add*">PROPAGATION_REQUIRED,-Exception</prop>
            <propkey="modify*">PROPAGATION_REQUIRED,+MyException</prop>
            <propkey="del*">PROPAGATION_REQUIRED</prop>
            <propkey="*">READONLY</prop>
        </props>
    </property>
</bean>
<!-- 定义事务入口 -->
<beanid="userDaoProxy"parent="transactionProxy">
    <propertyname="target"ref="userDao"></property>
</bean>
————————————————

六、 检索方式HQL

String hql="from RegisterOperator a where a.optLoginName=? and a.optPwd=?";

RegisterOperator是一个类名，不是表名。

6.2 分页查询

public List<Map> findBySql(String sql, int page, int rows) {
      String dbType = ConfigUtil.getSysDbType();
      List<Map> list = null;
      
  	if (page == 0) page = 1;
  	SQLQuery q = getCurrentSession().createSQLQuery(sql);
  	list = q.setFirstResult((page - 1) * rows).setMaxResults(rows).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP).list();

      
      //统一转为小写
      List<Map> rtnList = new ArrayList<Map>();
      for (int i = 0; i < list.size(); i++) {
          Map map = (Map) list.get(i);
          Set set = map.keySet();
          String key = "";
          Object value = null;
          Map rtnMap = new HashMap();
          for (Iterator iter = set.iterator(); iter.hasNext(); ) {
              key = (String) iter.next();
              value = map.get(key);
              rtnMap.put(key.toLowerCase(), value);
          }
          rtnList.add(rtnMap);
      }
      return rtnList;
  }

七、 优化方式

oyezitan
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
hibernate基本jar包
06-02
hibernate基本jar包，非常方便，学习SSH框架，只要在项目里将这些jar包复制上就可以了。
hiberate核心API/配置文件/一级缓存详解
空山新雨后，天气晚来秋
06-23 98
一次搞定hiberate核心API/配置文件/1级缓存
hibernate环境配置
a604435713的博客
10-18 217
hibernate介绍 Hibernate是轻量级JavaEE应用的持久层框架，它用于实现DAO，它是一个关系型数据库ORM框架。 用于实现DAO：使用hibernate实现数据访问层。 ORM框架：Object Relational Mapping 对象关系映射 Object：对象，java对象 Relational：关系，关系型数据库中二维表。 Mapping：映射，通过操作java对象去操作...
Hibernate简介（入门）
不自律不成魔 静心 精进
06-14 288
什么是Hibernate Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可...
Hibernate简单讲解
最新发布
weixin_42694511的博客
06-16 2556
所谓的ORM就是利用描述对象和数据库表之间映射的元数据，自动把java应用程序中的对象持久化到关系型数据库的表中。通过操作java对象，就可以完成对数据库表的操作。可以把ORM理解为关系型数据和对象的一个纽带，开发人员只需关注纽带一段映射的对象即可。Hibernate框架使用ORM思想对数据库进行crud操作在web阶段学习的javabean，更准确的叫法应该是实体类ORM：Object Relational Mapping，对象关系映射。让实体类和数据库表对应，让实体类属性和表中字段对应。
Hibernate快速入门详细讲解
Yang_Hui_Liang的博客
03-19 617
Hibernate框架介绍 什么是Hibernate Hibernate是一种ORM框架，全称为 Object_Relative DateBase-Mapping，在Java对象与关系数据库之间建立某种映射，以实现直接存取Java对象！ Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，...
hiberate架构介绍及环境搭建(非常详细)
空山新雨后，天气晚来秋
06-23 451
hiberate架构介绍及环境搭建-一次搞定
Hibernate
Sunshine521114的博客
08-16 236
Hibernate概述与配置 一、Hibernate hibernate是对JDBC进行的轻量级封装，位于数据持久层 作用： 和数据库做增、删、改、查 它是一个ORM的实现是面向对象编程与关系型 数据库之间的桥梁，是以对象的形式操作数据库的 hibernate是跨数据库的 优缺点：开发效率高，执行效率低 核心思想:Hibernate是基于对象来操作数据库的，但它最终还是被转换成SQL进行操作 ORM（Object Relation Mapping）：对象关系型的映
Hibernate基本使用
qq_45429856的博客
04-13 5453
hibernate4基本配置方式详解
08-29
给大家带来了hibernate4基本配置方式，非常不错，具有参考借鉴价值，需要的额朋友参考下吧
hibernate基本架构
02-01
文档阐述了hibernate基本架构的使用，可以作为hibernate学习的基础知识
Hibernate基本实现
04-08
Hibernate的基本实现，基础实现步骤及有关基本笔记，里面包含下载jar包方法
什么是Hibernate
weixin_49307896的博客
08-18 320
什么是Hiberate hibernate优点： 1、封装了jdbc，简化了很多重复性代码。 2、简化了DAO层编码工作，使开发更对象化了。 3、移植性好，支持各种数据库，如果换个数据库只要在配置文件中变换配置就可以了，不用改变hibernate代码。 4、支持透明持久化，因为hibernate操作的是纯粹的（pojo）java类，没有实现任何接口，没有侵入性。所以说它是一个轻量级框架。Hiberate框架学习目标： 1、掌握Hiberate的基本配置——即搭建Hiberate开发环境； 2、掌握Hibe
Hiberate框架入门
a807570702的博客
02-18 151
Hiberate框架 1.什么是框架 提高我们的开发效率,可以理解成是一个半成品项目. 2.hibernate框架 (1)dao层框架 (2)操作数据库 (3)以面向对象的方式操作数据库 ORM思想,对象关系映射,通过映射文件配置对象与数据库中表的关系。 3.hibernate框架搭建 1&amp;gt;导包 required+驱动包 2&amp;gt;准备实体类 以及 orm元数据 3&amp;gt;创建主配置文件 4...
hibernate的使用
thunder-1
03-25 3119
一、Hibernate定义 是一个ORM对象关系映射框架，对JDBC进行了封装，将java实体类映射到数据库表中，将java实体类成员变量数据类型映射到数据库表字段数据类型中，开发人员直接操作对象，避免大量数据编程（SQL编写），提升了开发效率。 二、Hibernate使用过程 1、根据配置信息，创建配置对象. 2、通过配置对象创建sessionFactory 对象，来配置hibernate。 3、通过sessionFactory 对象用来创建Session 对象，进行数据库物理连接，与数据库进行交互。
springmvc的hibernate的配置操作
mll999888的专栏
05-16 473
#hibernate配置 hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect hibernate.hbm2ddl.auto=update hibernate.show_sql=false hibernate.format_sql=true hibernate.use_sql_comments=true validati
常用数据库validationQuery语句
码农自留地
04-21 3367
在配置数据库连接池的时候，有一个选项validationQuery，该
Hibernate的基本使用
qq_45888932的博客
06-10 1082
大致描述Hibernate的使用，能够快速入门
SqlServer日期格式
goodmentc的专栏
01-18 6669
一、概述 二、常用格式 Select CONVERT(varchar(45), GETDATE(), 0): 01 18 2020 4:36PM Select CONVERT(varchar(45), GETDATE(), 1): 01/18/20 Select CONVERT(varchar(45), GETDATE(), 2): 20.01.18 Select CONVERT(varc...
hibernate如何使用jdbc5.1.7连接 mysql8.0
04-19
对于这个问题，我可以给你一些简要的步骤。 首先，在pom.xml文件中添加以下依赖项： ...这些就是使用jdbc5.1.7连接mysql8.0的基本步骤。如果你需要更多细节和帮助，可以参考Hibernate和MySQL的官方文档。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

oyezitan

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值