`

spring4.x 和 hibernate 4.x 相关配置和使用方式

 
阅读更多
spring4.x 和 hibernate 4.x 相关配置和使用方式
 
  1. 关于springhibernate的使用以及特征等等,在此不再啰嗦,相信大家也都知道,或者去搜索一下即可。
  2. 本篇博文的内容主要是我最近整理的关于spring4.x 和 hibernate 4.x 相关配置和使用方式,当然spring3.x以及hibernate4.x也可以借鉴。
  3. 首先是配置文件 web.xml 增加以下代码即可
  4. <!-- 加载spring相关的配置文件 -->
  5.     <context-param>
  6.         <param-name>contextConfigLocation</param-name>
  7.         <param-value>classpath*:/applicationContext.xml</param-value>
  8.     </context-param>
  9.     
  10.     <!-- 启用spring监听 -->
  11.     <listener>
  12.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  13.     </listener>
  14.     
  15. 然后建立 applicationContext.xml 文件 ,src下。 文件内容如下,注释我尽量写的很详细
  16. <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  17.     xmlns="http://www.springframework.org/schema/beans" xmlns:aop="http://www.springframework.org/schema/aop"
  18.     xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
  19.     xmlns:cache="http://www.springframework.org/schema/cache" xmlns:p="http://www.springframework.org/schema/p"
  20.     xsi:schemaLocation="http://www.springframework.org/schema/beans ;
  21.        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
  22.        http://www.springframework.org/schema/aop
  23.        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
  24.        http://www.springframework.org/schema/context
  25.        http://www.springframework.org/schema/context/spring-context-4.0.xsd
  26.        http://www.springframework.org/schema/tx
  27.        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
  28.        http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.0.xsd">
  29.     <!-- 引入properties文件 -->
  30.     <context:property-placeholder location="classpath*:/appConfig.properties" />
  31.     <!-- 定义数据库连接池数据源bean destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用 -->
  32.     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
  33.         destroy-method="close">
  34.         <!-- 设置JDBC驱动名称 -->
  35.         <property name="driverClass" value="${jdbc.driver}" />
  36.         <!-- 设置JDBC连接URL -->
  37.         <property name="jdbcUrl" value="${jdbc.url}" />
  38.         <!-- 设置数据库用户名 -->
  39.         <property name="user" value="${jdbc.username}" />
  40.         <!-- 设置数据库密码 -->
  41.         <property name="password" value="${jdbc.password}" />
  42.         <!-- 设置连接池初始值 -->
  43.         <property name="initialPoolSize" value="5" />
  44.     </bean>
  45.     <!-- 配置sessionFactory -->
  46.     <bean id="sessionFactory"
  47.         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
  48.         <!-- 数据源 -->
  49.         <property name="dataSource" ref="dataSource" />
  50.         <!-- hibernate的相关属性配置 -->
  51.         <property name="hibernateProperties">
  52.             <value>
  53.                 <!-- 设置数据库方言 -->
  54.                 hibernate.dialect=org.hibernate.dialect.MySQLDialect
  55.                 <!-- 设置自动创建|更新|验证数据库表结构 -->
  56.                 hibernate.hbm2ddl.auto=update
  57.                 <!-- 是否在控制台显示sql -->
  58.                 hibernate.show_sql=true
  59.                 <!-- 是否格式化sql,优化显示 -->
  60.                 hibernate.format_sql=true
  61.                 <!-- 是否开启二级缓存 -->
  62.                 hibernate.cache.use_second_level_cache=false
  63.                 <!-- 是否开启查询缓存 -->
  64.                 hibernate.cache.use_query_cache=false
  65.                 <!-- 数据库批量查询最大数 -->
  66.                 hibernate.jdbc.fetch_size=50
  67.                 <!-- 数据库批量更新、添加、删除操作最大数 -->
  68.                 hibernate.jdbc.batch_size=50
  69.                 <!-- 是否自动提交事务 -->
  70.                 hibernate.connection.autocommit=true
  71.                 <!-- 指定hibernate在何时释放JDBC连接 -->
  72.                 hibernate.connection.release_mode=auto
  73.                 <!-- 创建session方式 hibernate4.x 的方式 -->
  74.                 hibernate.current_session_context_class=org.springframework.orm.hibernate4.SpringSessionContext
  75.                 <!-- javax.persistence.validation.mode默认情况下是auto的,就是说如果不设置的话它是会自动去你的classpath下面找一个bean-validation**包 
  76.                     所以把它设置为none即可 -->
  77.                 javax.persistence.validation.mode=none
  78.             </value>
  79.         </property>
  80.         <!-- 自动扫描实体对象 tdxy.bean的包结构中存放实体类 -->
  81.         <property name="packagesToScan" value="tdxy.bean" />
  82.     </bean>
  83.     <!-- 定义事务管理 -->
  84.     <bean id="transactionManager"
  85.         class="org.springframework.orm.hibernate4.HibernateTransactionManager">
  86.         <property name="sessionFactory" ref="sessionFactory" />
  87.     </bean>
  88.     
  89.     <!-- 定义 Autowired  自动注入 bean -->
  90.     <bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/> 
  91.     
  92.     <!-- 扫描有注解的文件  base-package 包路径 -->
  93.     <context:component-scan base-package="tdxy"/>
  94.     
  95.     <tx:advice id="txAdvice" transaction-manager="transactionManager">
  96.         <tx:attributes>
  97.             <!-- 事务执行方式
  98.                 REQUIRED:指定当前方法必需在事务环境中运行,
  99.                 如果当前有事务环境就加入当前正在执行的事务环境,
  100.                 如果当前没有事务,就新建一个事务。
  101.                 这是默认值。 
  102.              -->
  103.             <tx:method name="create*" propagation="REQUIRED" />
  104.             <tx:method name="save*" propagation="REQUIRED" />
  105.             <tx:method name="add*" propagation="REQUIRED" />
  106.             <tx:method name="update*" propagation="REQUIRED" />
  107.             <tx:method name="remove*" propagation="REQUIRED" />
  108.             <tx:method name="del*" propagation="REQUIRED" />
  109.             <tx:method name="import*" propagation="REQUIRED" />
  110.             <!-- 
  111.                 指定当前方法以非事务方式执行操作,如果当前存在事务,就把当前事务挂起,等我以非事务的状态运行完,再继续原来的事务。 
  112.                 查询定义即可
  113.                 read-only="true"  表示只读
  114.              -->
  115.             <tx:method name="*" propagation="NOT_SUPPORTED" read-only="true" />
  116.         </tx:attributes>
  117.     </tx:advice>
  118.     <!-- 定义切面,在 * tdxy.*.service.*ServiceImpl.*(..) 中执行有关的hibernate session的事务操作 -->
  119.     <aop:config>
  120.         <aop:pointcut id="serviceOperation" expression="execution(* tdxy.*.service.*Service.*(..))" />
  121.         <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceOperation" />
  122.     </aop:config>
  123.     
  124. </beans>
  125. applicationContext.xml 文件引用了一个properties文件 ,该文件也在src下,appConfig.properties 内容可以自己定义
  126. 1
  127. 2
  128. 3
  129. 4
  130. 5
  131. ########################数据库连接信息#############
  132. jdbc.username = root
  133. jdbc.password = admin
  134. jdbc.url = jdbc:mysql://localhost:3306/tdxy?useUnicode=true&characterEncoding=UTF-8
  135. jdbc.driver = com.mysql.jdbc.Driver
  136. 自己写了一个test用的basedao 
  137. package tdxy.dao;
  138. import java.util.List;
  139. import org.hibernate.Session;
  140. import org.hibernate.SessionFactory;
  141. import org.springframework.beans.factory.annotation.Autowired;
  142. import org.springframework.stereotype.Repository;
  143. /**
  144. * @Title: BaseDao.java
  145. * @Package tdxy.dao
  146. * @Description: TODO(baseDao 数据库操作实现类)
  147. * @author dapeng
  148. * @date 2014年5月7日 下午5:09:22
  149. * @version V1.0
  150. */
  151. @Repository
  152. public class BaseDao {
  153.     /**
  154.      * Autowired 自动装配 相当于get() set()
  155.      */
  156.     @Autowired
  157.     protected SessionFactory sessionFactory;
  158.     /**
  159.      * gerCurrentSession 会自动关闭session,使用的是当前的session事务
  160.      * 
  161.      * @return
  162.      */
  163.     public Session getSession() {
  164.         return sessionFactory.getCurrentSession();
  165.     }
  166.     /**
  167.      * openSession 需要手动关闭session 意思是打开一个新的session
  168.      * 
  169.      * @return
  170.      */
  171.     public Session getNewSession() {
  172.         return sessionFactory.openSession();
  173.     }
  174.     public void flush() {
  175.         getSession().flush();
  176.     }
  177.     public void clear() {
  178.         getSession().clear();
  179.     }
  180.     /**
  181.      * 根据 id 查询信息
  182.      * 
  183.      * @param id
  184.      * @return
  185.      */
  186.     @SuppressWarnings("rawtypes")
  187.     public Object load(Class c, String id) {
  188.         Session session = getSession();
  189.         return session.get(c, id);
  190.     }
  191.     /**
  192.      * 获取所有信息
  193.      * 
  194.      * @param c 
  195.      *        
  196.      * @return
  197.      */
  198.     @SuppressWarnings({ "rawtypes" })
  199.     public List getAllList(Class c) {
  200.         String hql = "from " + c.getName();
  201.         Session session = getSession();
  202.         return session.createQuery(hql).list();
  203.     }
  204.     /**
  205.      * 获取总数量
  206.      * 
  207.      * @param c
  208.      * @return
  209.      */
  210.     @SuppressWarnings("rawtypes")
  211.     public Long getTotalCount(Class c) {
  212.         Session session = getNewSession();
  213.         String hql = "select count(*) from " + c.getName();
  214.         Long count = (Long) session.createQuery(hql).uniqueResult();
  215.         session.close();
  216.         return count != null ? count.longValue() : 0;
  217.     }
  218.     /**
  219.      * 保存
  220.      * 
  221.      * @param bean 
  222.      *            
  223.      */
  224.     public void save(Object bean) {
  225.         try {
  226.             Session session = getNewSession();
  227.             session.save(bean);
  228.             session.flush();
  229.             session.clear();
  230.             session.close();
  231.         } catch (Exception e) {
  232.             e.printStackTrace();
  233.         }
  234.     }
  235.     /**
  236.      * 更新
  237.      * 
  238.      * @param bean 
  239.      *            
  240.      */
  241.     public void update(Object bean) {
  242.         Session session = getNewSession();
  243.         session.update(bean);
  244.         session.flush();
  245.         session.clear();
  246.         session.close();
  247.     }
  248.     /**
  249.      * 删除
  250.      * 
  251.      * @param bean 
  252.      *            
  253.      */
  254.     public void delete(Object bean) {
  255.         Session session = getNewSession();
  256.         session.delete(bean);
  257.         session.flush();
  258.         session.clear();
  259.         session.close();
  260.     }
  261.     /**
  262.      * 根据ID删除
  263.      * 
  264.      * @param c 类
  265.      *            
  266.      * @param id ID
  267.      *            
  268.      */
  269.     @SuppressWarnings({ "rawtypes" })
  270.     public void delete(Class c, String id) {
  271.         Session session = getNewSession();
  272.         Object obj = session.get(c, id);
  273.         session.delete(obj);
  274.         flush();
  275.         clear();
  276.     }
  277.     /**
  278.      * 批量删除
  279.      * 
  280.      * @param c 类
  281.      *            
  282.      * @param ids ID 集合
  283.      *            
  284.      */
  285.     @SuppressWarnings({ "rawtypes" })
  286.     public void delete(Class c, String[] ids) {
  287.         for (String id : ids) {
  288.             Object obj = getSession().get(c, id);
  289.             if (obj != null) {
  290.                 getSession().delete(obj);
  291.             }
  292.         }
  293.     }
  294. }
  295. 不知大家有没有注意 applicationContext.xml 这样一句代码
  296. <!-- 设置自动创建|更新|验证数据库表结构 -->
  297.     hibernate.hbm2ddl.auto=update
  298. 这个意思是 只要在实体bean指定了entity,那么在数据库会自动创建对应的表和表结构
  299. test用的一个实体bean
  300. package tdxy.bean;
  301. import java.io.Serializable;
  302. import javax.persistence.Entity;
  303. import javax.persistence.Id;
  304. /**
  305. * @ClassName: UserInfoBean
  306. * @Description: TODO(用户信息类)
  307. * @author dapeng
  308. * @date 2014年5月7日 上午12:13:44
  309. * @version V1.0
  310. */
  311. @Entity
  312. public class UserInfoBean implements Serializable {
  313.     private static final long serialVersionUID = 7280747949998651159L;
  314.     @Id
  315.     private String id;
  316.     /**
  317.      * 昵称
  318.      */
  319.     private String nickName;
  320.     private String pwd;
  321.     /**
  322.      * 等级
  323.      * 
  324.      */
  325.     private String level;
  326.     /**
  327.      * 经验值
  328.      */
  329.     private String emValue;
  330.     /**
  331.      * 性别(0 男 1女)
  332.      */
  333.     private String sex;
  334.     private String birthday;
  335.     private String qq;
  336.     private String email;
  337.     /**
  338.      * 头像
  339.      */
  340.     private String img;
  341.     /**
  342.      * 所在地
  343.      */
  344.     private String address;
  345.     /**
  346.      * 签名
  347.      */
  348.     private String qmd;
  349.     public String getId() {
  350.         return id;
  351.     }
  352.     public void setId(String id) {
  353.         this.id = id;
  354.     }
  355.     public String getNickName() {
  356.         return nickName;
  357.     }
  358.     public void setNickName(String nickName) {
  359.         this.nickName = nickName;
  360.     }
  361.     public String getPwd() {
  362.         return pwd;
  363.     }
  364.     public void setPwd(String pwd) {
  365.         this.pwd = pwd;
  366.     }
  367.     public String getLevel() {
  368.         return level;
  369.     }
  370.     public void setLevel(String level) {
  371.         this.level = level;
  372.     }
  373.     public String getEmValue() {
  374.         return emValue;
  375.     }
  376.     public void setEmValue(String emValue) {
  377.         this.emValue = emValue;
  378.     }
  379.     public String getSex() {
  380.         return sex;
  381.     }
  382.     public void setSex(String sex) {
  383.         this.sex = sex;
  384.     }
  385.     public String getBirthday() {
  386.         return birthday;
  387.     }
  388.     public void setBirthday(String birthday) {
  389.         this.birthday = birthday;
  390.     }
  391.     public String getQq() {
  392.         return qq;
  393.     }
  394.     public void setQq(String qq) {
  395.         this.qq = qq;
  396.     }
  397.     public String getEmail() {
  398.         return email;
  399.     }
  400.     public void setEmail(String email) {
  401.         this.email = email;
  402.     }
  403.     public String getImg() {
  404.         return img;
  405.     }
  406.     public void setImg(String img) {
  407.         this.img = img;
  408.     }
  409.     public String getAddress() {
  410.         return address;
  411.     }
  412.     public void setAddress(String address) {
  413.         this.address = address;
  414.     }
  415.     public String getQmd() {
  416.         return qmd;
  417.     }
  418.     public void setQmd(String qmd) {
  419.         this.qmd = qmd;
  420.     }
  421. }
  422. 当应用成功启动之后,数据库会出现表和结构,即刚才定义的bean是一样的,大家可以自己查看一下即可。
  423. 以下是test的Service
  424. package tdxy.user.service;
  425. import org.springframework.beans.factory.annotation.Autowired;
  426. import org.springframework.stereotype.Service;
  427. import tdxy.bean.UserInfoBean;
  428. import tdxy.dao.BaseDao;
  429. import tdxy.util.TdxyUtil;
  430. @Service
  431. public class UserInfoService {
  432.     @Autowired
  433.     private BaseDao baseDao;
  434.     public UserInfoBean queryUserInfoById(String id) {
  435.         return (UserInfoBean) baseDao.load(UserInfoBean.class, id);
  436.     }
  437.     public void addUserInfo(UserInfoBean userInfo) {
  438.         try {
  439.             userInfo.setId(TdxyUtil.getId());
  440.             userInfo.setAddress("32132");
  441.             baseDao.save(userInfo);
  442.         } catch (Exception e) {
  443.             e.printStackTrace();
  444.         }
  445.     }
  446. }
  447. 配置过程到此结束,希望大家一起讨论共同进步。
分享到:
评论

相关推荐

    springmvc, spring5.x , hibernate5.x 整合

    首先,我们需要在Spring配置中声明Hibernate的DataSource和SessionFactory,然后通过Spring的JdbcTemplate或Hibernate的Session接口进行数据访问。接着,我们定义Spring MVC的Controller,它将接收HTTP请求,通过...

    spring4.x________

    5. AOP(面向切面编程)改进:Spring 4.x提供了更灵活的AOP配置,包括基于注解的切点表达式和类型安全的advice匹配。 6. 改进的测试框架:Spring Test模块提供了更强大的测试支持,包括对Spring Boot应用程序的集成...

    springmvc+spring4.x+hibernate4.x整合实现对学生信息的增删改查

    在本项目中,我们主要探讨的是如何将Spring MVC、Spring 4.x 和 Hibernate 4.x 框架整合,以实现对学生信息的CRUD(创建、读取、更新和删除)操作。数据库方面,选用的是Microsoft的SQL Server 2005。下面,我们将...

    Struts2.X+Hibernate3.X+Spring2.5 整合

    标题"Struts2.X+Hibernate3.X+Spring2.5 整合"指的是将这三个框架的特定版本(Struts2.X,Hibernate3.X,Spring2.5)集成到同一个项目中,实现高效的企业级应用开发。这种整合能够充分利用各个框架的优势,使开发者...

    精通Spring 4.x 企业应用开发实战.pdf 和项目代码

    《精通Spring 4.x 企业应用开发实战》是一本深入探讨Spring 4.x框架在企业级应用中的实践指南。本书旨在帮助开发者全面理解和掌握Spring框架的核心功能和最佳实践,通过实际项目案例,让读者能够在实际工作中灵活...

    精通Spring4.x+企业应用开发实战 配套光盘(源码+资源)

    6. **Spring Boot**:虽然不是Spring4.x的直接组成部分,但Spring Boot与Spring4.x紧密相关,它简化了Spring应用的初始搭建和配置,基于“约定优于配置”的原则,使得快速开发成为可能。 7. **Spring Security**:...

    spring mvc spring4.x hibernate4.注解方式注入

    在IT行业中,Spring MVC、Spring 4.x和Hibernate 4是三个非常重要的框架,它们各自在Web应用开发中承担着核心角色。Spring MVC是用于构建Web应用程序的模型-视图-控制器(MVC)框架,Spring 4.x是Spring框架的一个...

    SSH(Struts2.1+Spring2.X+Hibernate3.X)整合,新手必备

    【Struts2.1、Spring3.0、Hibernate3.3整合与S2SH的XML文件拆分.docx】文档则可能专注于XML配置文件的拆分和组织,因为大型项目中,将所有配置集中在一个文件可能导致管理和维护困难。拆分XML文件可以使代码结构更加...

    Spring4.X教学视频

    6. **Spring Boot**:虽然不是Spring4.X的直接部分,但Spring Boot是构建现代Spring应用的流行工具,它简化了配置并提供了内置的服务器和starter依赖。视频可能也会涉及Spring Boot的使用。 7. **Spring Security**...

    spring,struts1.x ,hibernate整合

    Spring、Struts1.x 和 Hibernate 是经典的 Java Web 开发框架,它们的整合是构建企业级应用的常见方式。这三个框架分别负责不同的职责:Spring 提供依赖注入和事务管理,Struts1.x 负责视图和控制层,而 Hibernate ...

    精通Spring4.x企业应用开发实战pdf+源码

    这本书涵盖了Spring框架的核心概念、重要特性和实际应用,旨在帮助开发者熟练掌握Spring4.x版本的各种开发技能,以提高软件项目的效率和质量。源码的提供更是为读者提供了亲自动手实践的机会,使理论与实践相结合,...

    spring Spring MVC Hibernate 4.x 整合案例

    Hibernate 4.x版本在前一版本的基础上增加了更多优化和改进,如支持JPA 2.1规范、性能提升以及更好的数据库平台兼容性。 在这个整合案例中,我们将看到如何配置Spring、Spring MVC和Hibernate,以实现一个包含增删...

    精通Spring4.x(包含源码)

    通过对以上知识点的学习,开发者能够全面掌握Spring4.x在企业级应用中的使用,并具备独立设计和开发复杂系统的能力。同时,结合实际的项目经验,这些知识将转化为强大的工具,助力开发者在软件开发领域取得更大的...

    Struts1.x Spring2.x Hibernate3.x DWR2.x整合工具文档v1.00

    ### Struts1.x、Spring2.x、Hibernate3.x 和 DWR2.x 整合知识点解析 ...通过以上详细的配置和解释,可以有效地实现Struts1.x、Spring2.x、Hibernate3.x 和 DWR2.x 的整合,为开发者提供了一个稳定、高效的技术栈。

    Spring 3.1.x + Hibernate 4.2.x+JBPM 5.2 + Ecache例子源码

    标题中的"Spring 3.1.x + Hibernate 4.2.x + JBPM 5.2 + Ecache例子源码"代表了一个集成开发环境,其中包含了四个关键的技术组件: 1. **Spring 3.1.x**:这是一个开源的应用框架,主要用于简化Java企业级应用的...

    Spring 3.x 中文开发手册.pdf

    虽然文档中提到对 Hibernate 4 的支持不感兴趣,但 Spring 3.x 对 Hibernate 4 提供了更好的支持,增强了与 ORM 技术的整合能力,为开发者提供了更多的选择。 #### 七、Spring 测试框架 Spring 3.x 的测试框架进行...

    struts2.3.x+spring3.1.x+hibernate4.1整合工程(好用)

    通过pom.xml文件配置相关的依赖库,实现项目的模块化和自动化构建。 综上所述,这个整合工程实现了MVC架构,通过Spring的控制反转和面向切面编程提高了代码的解耦和可测试性,Hibernate则简化了数据库操作,提高了...

    Ext2.1 struts1.x spring 2.x hibernate 2.x

    尽管之后的版本(如Hibernate 3.x和4.x)增加了更多功能和性能优化,但Hibernate 2.x仍是许多项目的基础。 在实际项目中,这四个技术的组合通常用来创建一个三层架构的应用:EXT JS 2.1负责前端交互和展示,Struts1...

    精通Spring 4.x 企业应用开发实战 + 源码

    阅读《精通Spring 4.x 企业应用开发实战》这本书,读者将学习到如何配置和使用这些核心特性,以及如何结合实际项目需求进行定制化开发。书中提供的源码分析有助于读者更深入地理解Spring的工作原理,从而提升开发...

    Spring 4.X:企业应用开发实战精通 完整版

    7. **Spring Boot**:虽然不在4.x版本范围内,但作为Spring的现代化启动器,Spring Boot简化了Spring应用的初始搭建和配置,常与Spring 4.x结合使用。 8. **Spring Security**:Spring的安全模块,提供了身份验证和...

Global site tag (gtag.js) - Google Analytics