spring4集成jotm

合集下载

spring4.x + hibernate4.x 配置详解

spring4.x + hibernate4.x 配置详解关于spring和hibernate的使用以及特征等等，在此不再啰嗦，相信大家也都知道，或者去搜索一下即可。

本篇博文的内容主要是我最近整理的关于spring4.x 和hibernate 4.x 相关配置和使用方式，当然spring3.x以及hibernate4.x也可以借鉴。

首先是配置文件web.xml 增加以下代码即可<context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:/applicationContext.xml</param-value> </context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</l istener-class></listener>然后建立 applicationContext.xml 文件，src下。

文件内容如下，注释我尽量写的很详细<beans xmlns:xsi="/2001/XMLSchema-instance"xmlns="/schema/beans"xmlns:aop="http://ww /schema/aop"xmlns:context="/schema/context"xmlns:tx="ht tp:///schema/tx"xmlns:cache="/schema/cache"xmlns:p="http:// /schema/p"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-4.0.xsd/schema/aop/schema/aop/spring-aop-4.0.xsd/schema/context/schema/context/spring-context-4.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd/schema/cache http://www.springframewor /schema/cache/spring-cache-4.0.xsd"><context:property-placeholder location="classpath*:/appConfig.properties"/>  <bean id="dataSource"class="boPooledDataSourc e"destroy-method="close"><property name="driverClass"value="${jdbc.driver}"/><property name="jdbcUrl"value="${jdbc.url}"/><property name="user"value="${ername}"/><property name="password"value="${jdbc.password}"/><property name="initialPoolSize"value="5"/></bean><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource"ref="dataSource"/><property name="hibernateProperties"><value>hibernate.dialect=org.hibernate.dialect.MySQLDialecthibernate.hbm2ddl.auto=updatehibernate.show_sql=truehibernate.format_sql=truee_second_level_cache=falsee_query_cache=falsehibernate.jdbc.fetch_size=50hibernate.jdbc.batch_size=50hibernate.connection.autocommit=truehibernate.connection.release_mode=autohibernate.current_session_context_class=org.springframework.or m.hibernate4.SpringSessionContextjavax.persistence.validation.mode=none</value></property><property name="packagesToScan"value="tdxy.bean"/> </bean><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager "><property name="sessionFactory"ref="sessionFactory"/> </bean><bean class="org.springframework.beans.factory.annotation.AutowiredAnnotati onBeanPostProcessor"/><context:component-scan base-package="tdxy"/><tx:advice id="txAdvice"transaction-manager="transactionManager"> <tx:attributes><!-- 事务执行方式REQUIRED：指定当前方法必需在事务环境中运行，如果当前有事务环境就加入当前正在执行的事务环境，如果当前没有事务，就新建一个事务。

JOTM

<tx:annotation-driven transaction-manager="txManager" />
</beans>
我配置了两个oracle的数据源。两个数据源都交给JOTM来管理。同时有两个service:Dao1ServiceImpl\Dao2ServiceImpl分别操作两个数据源的表。为这两个service添加事务
this.jdbcTemplate = jdbcTemplate;
}
public void add() {
String str = "insert into t_staff(PK_ID,NAME,STAFF_TYPE,IS_DISABLE) values(2,'wyb','客服','0')";
两个service实现如下：
package com.test;
import org.springframework.jdbc.core.JdbcTemplate;
public class Dao1ServiceImpl implements IDao1Service {
</bean>
<bean id="postTemplate"
class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="postDS" />
<bean class="org.enhydra.jdbc.standard.StandardXADataSource"

Struts2+Spring3+Hibernate4+Maven整合

Struts2+Spring3+Hibernate4+Maven整合目录1.建立Maven工程2.搭建Spring33.搭建Struts2并整合Spring34.搭建Hibernate4并整合Spring3内容1.建立Maven工程第一步：第二步：第三步：第四步：注意：这里的JDK要选择默认的，这样别人在使用的时候，如何JDk不一致的话也不会出错，如下图所示：第五步：Maven标准目录src/main/javasrc/main/resourcessrc/test/javasrc/test/resources第六步：发布项目：Maven install清除编译过的项目：Maven cleanOK,Mean 工程创建成功！2. 搭建 Spring3(1)下载Spring3需要的jar包1.spring-core2.spring-context3.spring-jdbc4.spring-beans5.spring-web6.spring-expression7.spring-orm在pom.xml中编写Spring3需要的包，maven会自动下载这些包。

<dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-expression</artifactId><version>3.1.2.RELEASE</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-orm</artifactId><version>3.1.2.RELEASE</version></dependency>(2)编写Spring配置文件<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans" xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd /schema/context/schema/context/spring-context-3.0.xsd "><context:property-placeholderlocation="classpath:config.properties"/><context:component-scan base-package="com.zc.dao,com.zc.service" /></beans>(3)编写测试首先，在src/main/java中创建com.zc.service包，在包中编写一个UserService 接口，代码如下：package com.zc.service;/*** 测试* @author ZC* */public interface UserService {public void test();}然后，在src/main/java中创建com.zc.service.imple包，在包中编写UserServiceImple 实现类，代码如下：package com.zc.service.impl;import org.springframework.stereotype.Service;import erService;@Service("userService")public class UserServiceImpl implements UserService {@Overridepublic void test() {System.out.println("Hello World!");}}注意：@Service("userService")使用junit注解完成service 注入，所以还要在pom.xml中配置junit注解。

spring+tomcat+jotm集成

Tomcat集成jotm一、由容器管理jta事务1．1介绍Jtom（java open Transaction Manager）是java写的事务管理器并实现了jta接口，而且是开源项目。

Tomcat是servlet容器用于servlet和jsp技术的官方参考实现。

属于apache组织。

1.2MySQL配置创建两个表。

1.3安装所需jar包为让web应用使用jotm，项目及tomcat需要访问jotm jar包。

以下是此处。

创建文件名为carol.properties的属性文件并放到${tomcat_home}\common\classes\下。

其内容如下：1.4配置tomcat(server.xml)1.5项目上下文配置(context.xml)1.6 Web.xml配置部需要生命。

1.7在spring上下文文件配置注意：在spring上下文中使用jta事务管理器的话，容器会自动在环境中搜索jta事务。

该环境指应用服务器环境。

※需要把项目中lib下的jta包删除，只留在${tomcat_home}\common\jta.jar。

否则会出现说UserTransaction没有指定的问题。

※经过测试发现，对于jotm和xapool的jar包版本过低，出现不支持操作异常（UnsupportedOperationException）,所以不能用jotm-1.4.3\lib下的jar包，使用jotm-2.0.10\lib下的jar包替换即可。

二、使用spring管理的jta事务Jtom是独立的全局事务管理器，因此他在非j2ee容器下也可以使用。

而且相对来说要比让容器管理jta事务要简单。

2.1在上下文中安装jotm实例2.2将该beanDI到jta事务管理器的UserTransaction属性上2.3使用Enhydra's XAPool提供分布式连接池注意：该包在${tomcat_home}\common\lib\xapool.jar。

北京动力节点-Spring4讲义-第5章SSH框架整合技术

第5 章SSH 框架整合技术5.1 Spring 与Hibernate 整合除了JdbcTemplate 外，Spring 还可通过Hi b e r nate 来完成Dao 的工作。

即将Spring 与Hibernate 进行整合。

举例：项目spring_hibernate（在dao_jdbcTemplate 基础上修改）5.1.1 导入Jar 包除了Spring 的基本Jar 包外，还需要以下几种Jar 包：（1）Spring AOP 的两个Jar 包（2）AspectJ 的两个Jar 包（3）Spring 的JDBC 的Jar 包（4）Spring 整合ORM 的Jar 包Spring 整合ORM 框架的Jar 包，在Spring 框架解压目录下的libs 目录中。

（5）Spring 的事务Jar 包Spring 的事务Jar 包，在Spring 框架解压目录下的libs 目录中。

（6）Hibernate 的基本Jar 包Hibernate 的基本Jar 包中已经包含了C3P0 数据源的Jar 包，且版本高于Spring 中提供的版本。

所以直接使用Hibernate 中的即可。

2Hibernate 的基本Jar 包中已经包含了MySql 的驱动Jar 包，所以不用再导入了。

5.1.2 实体映射文件的配置5.1.3 注册数据源Spring 配置文件中数据源与jdbc 属性文件的注册，与template_jdbc 项目中的相同。

5.1.4 配置SessionFactorySpring 的精髓是，所有的Bean 均由Spring 容器统一管理，所以在SPring 中若要使用Hibernate，就需要将SessionFactory 交由Spring 来管理。

配置SessionFactory 的Bean，将hibernate.cfg.xml 文件替换掉。

使用的实现类为LocalSessionFactoryBean，注意，是hibernate5 包下的。

Spring4基本使用

Spring4基本使⽤前⾔虽然现在基本上是 springboot 的天下了，但是传统的 spring4 在⼴⼤的软件企业中仍然占据很⼤⽐例。

⼀上⼿能⽤，但是要让我从⽆到有搭⼀个spring4的开发环境出来，可能会磕磕碰碰，耽误不少时间，所以这⾥从⽆到有搭⼀个 spring4的开发环境出来，⼀步步完善，也复习下 spring 的基本⽤法，温故知新。

创建maven项⽬，引⼊spring4的⼀些核⼼包和常⽤扩展包。

我⽤的是spring4最新版本4.3.24.RELEASEpom.xmlxml version="1.0" encoding="UTF-8"><project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.hz</groupId><artifactId>admin</artifactId><version>1.0-SNAPSHOT</version><packaging>war</packaging><name>admin Maven Webapp</name><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><piler.source>1.8</piler.source><piler.target>1.8</piler.target><spring.version>4.3.24.RELEASE</spring.version><junit.version>4.11</junit.version><jackson.version>2.9.8</jackson.version></properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>${junit.version}</version><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-beans</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-core</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aspects</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-test</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-tx</artifactId><version>${spring.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId><version>${spring.version}</version><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>${jackson.version}</version></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-core</artifactId><version>${jackson.version}</version></dependency><dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-annotations</artifactId><version>${jackson.version}</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>${spring.version}</version></dependency></dependencies><build><finalName>admin</finalName><pluginManagement><plugins><plugin><artifactId>maven-clean-plugin</artifactId><version>3.1.0</version></plugin><plugin><artifactId>maven-resources-plugin</artifactId><version>3.0.2</version></plugin><plugin><artifactId>maven-compiler-plugin</artifactId><version>3.8.0</version><configuration><source>${piler.source}</source><target>${piler.target}</target></configuration></plugin><plugin><artifactId>maven-surefire-plugin</artifactId><version>2.22.1</version></plugin><plugin><artifactId>maven-war-plugin</artifactId><version>3.2.2</version></plugin><plugin><artifactId>maven-install-plugin</artifactId><version>2.5.2</version></plugin><plugin><artifactId>maven-deploy-plugin</artifactId><version>2.8.2</version></plugin><plugin><groupId>org.eclipse.jetty</groupId><artifactId>jetty-maven-plugin</artifactId><version>9.4.18.v20190429</version><configuration><httpConnector><port>8082</port> </httpConnector><scanIntervalSeconds>2</scanIntervalSeconds><webApp><contextPath>/</contextPath></webApp></configuration></plugin></plugins></pluginManagement></build></project>配置web.xmlweb.xml⽂件是web项⽬的启动⽂件，要想在web项⽬中使⽤spring，需要在这⾥配置spring<!DOCTYPE web-app PUBLIC"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN""/dtd/web-app_2_3.dtd" ><web-app><display-name>Archetype Created Web Application</display-name><context-param><param-name>contextConfigLocation</param-name><param-value>classpath:/spring.xml</param-value> <listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener><servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:/spring/spring-mvc.xml</param-value>  </init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>/</url-pattern></servlet-mapping><welcome-file-list><welcome-file>login.html</welcome-file></welcome-file-list><error-page> <error-code>404</error-code><location>/nopage.html</location></error-page><error-page> <exception-type>ng.NullPointerException</exception-type><location>/error.html</location></error-page><session-config><session-timeout>360</session-timeout></session-config></web-app>配置mvcspring-mvc.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/context /schema/context/spring-context-4.1.xsd/schema/mvc /schema/mvc/spring-mvc-4.1.xsd"><context:component-scan base-package="com.hz.*.controller"/><mvc:default-servlet-handler /><mvc:annotation-driven /><bean id="mappingJacksonHttpMessageConverter"class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"><property name="supportedMediaTypes"><list><value>text/html;charset=UTF-8</value></list></property></bean><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"id="internalResourceViewResolver"><property name="prefix" value="/WEB-INF/page/" /><property name="suffix" value=".jsp" /></bean></beans>项⽬结构测试Controllerpackage mon.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;import java.util.HashMap;import java.util.Map;@Controller()@RequestMapping("test")public class TestController {@RequestMapping("/info")@ResponseBodypublic Object test(Integer val){// contentType=application/x-www-form-urlencoded System.out.println(val == null ? "null" : val.toString()); HashMap<String, Object> map = new HashMap<>(); map.put("prop", "value");map.put("prop1", "value1");return map;}}postman测试。

SpringMVC+Hibernate4+Spring3整合开发

SpringMVC+Hibernate4+Spring3整合开发·使用开发工具Myeclipse2014 、Subversion、·首先新建立一个项目SHSpringMVC ，组织好文件结构·将所建立的简单的项目发布到SVN服务器上，（如果你仅仅是想在本机搭建一个开发环境的话，不必要用SVN的，下面关于svn的发布，可以略过）选择SVN 点击Next;找到你的SVN服务资源库，如果没有的话，可以选择创建新的资源库位置；默认点击finish，然后把项目提交上去，就OK了，开始配置三个框架的开发，严谨来说是两个框架；看到如下图所示的界面说明你的项目就发布到SVN服务器上了；·接下来，就要配置开发包，也就是支持的JAR包，首先添加Spring支持，同时呢SpringMVC也是添加上了，我们要做的就是配置MVC框架；配置过程分为手动配置和自动配置，现在大部分工具都支持了自动配置，很少人再去手动配置编写配置文件了，那我们就采用自动配置的方式配置这两大框架的整合开发环境；在项目上右键→Myeclipse→Project Facets→Install Spring Facet持，点击Finish;右键空白处→new 按照下图所示配置，添加Hibernate支持，项目右键→myeclipse→project facets→install hibernate facet选择你刚刚创建的一个数据源，也就是下图显示的DB Driver,下面的一些信息就自动生成了；就选择默认核心包，没必要增加其他插件，OK 了；·增加完成之后，Hibernate 在applicationContext.xml 文件之中增加了如下的几个配置； <bean id ="sessionFactory" 这个bean 是用来连接数据库的，但是缺少了数据库的连接属性，连接属性，我们刚刚放到hibernate.cfg.xml文件之中了，但是为了项目的方便移植和可维护方便，我们就要把配置写到一个配置文件之中，所以需要在applicationContext.xml文件的sessionFactory这个bean之中增加priperty属性；class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="configLocation"value="classpath:hibernate.cfg.xml"></property>→当我们将c3p0的数据库配置添加好之后，这个配置也就可以删掉了；</bean><bean id="transactionManager"→这个bean用来配置事务提交的，不过还不完善，还需要配置很多东西，class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory"ref="sessionFactory"/> </bean>·下面我们新建立一个db.properties的资源文件，用来编写数据库连接信息；db.driverClass=org.gjt.mm.mysql.Driverdb.url=jdbc:mysql://localhost:3306/mysqlername=rootdb.password=mysqladmin我们怎么用这个配置文件呢，当然是需要在applicationContext.xml文件之中配置了；要想知道怎么配置使用这个database.properties这个资源文件，我们必须要了解的当然是ComboPooledDataSource这个类了，ng.Objectcom.mchange.v2.c3p0.impl.AbstractIdentityTokenizedcom.mchange.v2.c3p0.impl.IdentityTokenResolvablecom.mchange.v2.c3p0.impl.PoolBackedDataSourceBasecom.mchange.v2.c3p0.impl.AbstractPoolBackedDataSourcecom.mchange.v2.c3p0.AbstractComboPooledDataSourceboPooledDataSource我们看到ComboPooledDataSource这个类本身仅仅定义了几个构造方法而已，我们需要从他的父类中查找看看；我们能从文档中查到，有很多的setter、getter方法，这意味着什么呢，通过反射调用可以设置内容；也就是说，配置的dataSource这个bean的property的name值都是一定的，也就是不能自己定义，需要用提供好的那些属性名称，值也是有范围的；<bean id="dataSource"class="boPooledDataSource"destroy-method="close"><property name="driverClass"value="${db.driverClass}"/><property name="jdbcUrl"value="${db.url}"/><property name="user"value="${ername}"/><property name="password"value="${db.password}"/><property name="maxPoolSize"value="10000"/><property name="minPoolSize"value="1"/><property name="initialPoolSize"value="1"/><property name="maxIdleTime"value="20"/></bean>配置完成此bean就可与修改sessionFactory这个bean了，我们需要做的就是将其中的property修改为<bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource"/></bean>配置好这里，那hibernate.cfg.xml文件之中的数据库连接信息也就不需要了，我们就可以直接删掉了，hibernate.cfg.xml文件就编程如下的配置了，可以添加show_sql 、format_sql<?xml version='1.0'encoding='UTF-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/dtd/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><property name="dialect">org.hibernate.dialect.MySQLDialect</property><property name="myeclipse.connection.profile">mysql</property><property name="show_sql">true</property><property name="format_sql">true</property></session-factory></hibernate-configuration>下面还是需要配置applicationContext.xml文件，配置事务通知属性，这个我也不是很了解怎么配置的，在网上找了一份，可以按照这个配置；<tx:advice id="txAdvice"transaction-manager="transactionManager"> <tx:attributes><tx:method name="update*"propagation="REQUIRED"/><tx:method name="insert*"propagation="REQUIRED"/><tx:method name="edit*"propagation="REQUIRED"/><tx:method name="save*"propagation="REQUIRED"/><tx:method name="add*"propagation="REQUIRED"/><tx:method name="new*"propagation="REQUIRED"/><tx:method name="set*"propagation="REQUIRED"/><tx:method name="remove*"propagation="REQUIRED"/><tx:method name="delete*"propagation="REQUIRED"/><tx:method name="change*"propagation="REQUIRED"/><tx:method name="get*"propagation="REQUIRED"read-only="true"/><tx:method name="list*"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="*"propagation="REQUIRED"read-only="true"/> </tx:attributes></tx:advice>然后需要找一个log4j.properties的组件，在hibernate的开发文件包之中有一个，应该可以用，你从网上下载好hibernate的文件解压之后，从下面的这个目录可以找到一个log4j.properties文件；\hibernate-release-4.3.8.Final\hibernate-release-4.3.8.Final\project\etc最后要为项目添加annotation、aop、mvc开发支持，最重要的不要忘了，添加database.properties文件的位置，放到dataSource的bean上面就可以了；<context:property-placeholder location="classpath:database.properties"/>配置Annotation<context:annotation-config/><context:component-scan base-package="cn.oracle"/><mvc:annotation-driven/><mvc:default-servlet-handler/>接下来配置web.xml文件，配置Spring MVC的默认servlet处理用户请求；<servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet -class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value> </init-param></servlet><servlet-mapping><servlet-name>springmvc</servlet-name><url-pattern>*.action</url-pattern></servlet-mapping>此时你把项目部署到tomcat 或者weblogic上，看会不会报错，不报错误应该可开发使用了；如果你还要配置Springmvc的资源文件的话，还需要在applicationContext.xml文件之中配置另外一个bean <bean id="messageSource"class="org.springframework.context.support.ResourceBundleMessageSource"> <property name="basenames"><array><value>Message</value><value>Pages</value></array></property></bean>这上面的配置其实就是配置了ResourceBundleMessageSource 这个类下的basenames属性；private String[] basenames = new String[0];。

spring集成web框架

---------------------------------------------------------------最新资料推荐------------------------------------------------------spring集成web框架Spring 集成其他 Web 框架虽然 Spring 本身也提供了一个功能非常强大的 MVC 框架，并且和 Spring 的 IoC 容器无缝集成，非常便于使用。

不过，在实际情况中，我们还不得不考虑众多采用第三方 MVC 框架的 Web 应用程序，例如，采用 Strtus、WebWork 等。

如果要将这些应用程序的逻辑组件和持久化组件纳入 Spring 的 IoC 容器中进行管理，就必须考虑如何集成这些第三方的MVC 框架。

Spring 强大的集成和扩展能力使得集成第三方 MVC 框架成为轻而易举的事情。

与第三方 MVC 框架集成时，需要考虑的问题是如何在第三方MVC 框架中访问 Spring IoC容器管理的 Bean，或者说，如何获取Spring IoC 容器的实例。

我们还要保证在第三方MVC 框架开始处理用户请求之前，Spring 的 IoC 容器必须初始化完毕。

有两种方式可以自动加载 Spring 的 IoC 容器。

一种是利用第三方框架的扩展点，实现加载 Spring 的 IoC 容器，例如，Struts 就提供了 Plugin 扩展。

第二种方式是在 web.xml中定义 Listener 或 Servlet，让 Web 应用程序一启动就自动加载 Spring 的 IoC 容器。

1 / 3这种方式较为通用，对于一些不太常见的第三方 MVC 框架，也可以用这种方式来尝试与Spring 集成。

如果正在使用基于 Servlet 2.3 或更高规范的 Web 服务器，则应当使用 Spring 提供的ContextLoaderListener 来加载 IoC 容器，因为根据 Servlet 2.3 规范，所有的Listener 都会在 Servlet被初始化之前完成初始化。

SpringMVC Spring4.0 Hibernate 简单的整合

SpringMVC+Spring4.0+Hibernate 简单的整合学习的初始一个Hello World。

1、搭建好环境工欲善其事,必先利其这是需要的jar简单的说下：standard.jar 这个jar包是我们在jsp中使用JSTL标签的时候用到的。

你也可以使用SpringEL 。

servlet-api.jar 这是你在SpringMvc中用到HttpServletRequest 等这些类。

导入的包都OK了，上传下载的包我没有导。

现在就应该到配置文件了。

2、配置文件2.1web.xml项目使用了什么框架。

看这个配置就知道了。

org.springframework.web.util.Log4jConfigListenerorg.springframework.web.context.ContextLoaderListener contextConfigLocationclasspath:applicationContext*.xmlspringmvcorg.springframework.web.servlet.DispatcherServletcontextConfigLocationclasspath*:springmvc-servlet.xml1springmvc2.2 applicationContext.xml 的配置我的数据库连接使用的是spirng进行连接。

然后使用了mysql.properties 配置的文件解耦。

注意如果你的spring、hibernate 的版本和我的不一样。

你修改下面绿色字体版本号。

hibernate4.LocalSessionFactoryBean">.hibernate4.HibernateTransactionManager">2.3 mysql.propertiese#注意格式jdbcUrl = jdbc:mysql:///springdriverClass = com.mysql.jdbc.Driveruser = rootpassword = root2.4 hibernate的配置org.hibernate.dialect.MySQL5InnoDBDialecttrueupdate2.5 SpringMvc的配置springmvc-servlet.xm3、配置文件已经OK了，我主要是写个登录的HelloWorld 我都是居于注解的方式来实现的。

Spring 4支持的Java 8功能

Spring Framework 4支持Java 8语言和API功能。

在本文中，我们将关注Spring 4支持的新Java 8功能。

最重要的是lambda表达式、方法引用、JSR-310 Date and Time以及可重复注释。

Lambda表达式Spring代码库使用了大量的函数式接口，使用Java 8，我们可以使用lambda表达式编写更干净、更紧凑的代码。

每当期望函数式接口的对象时，我们就可以供给lambda表达式。

让我们在讲下一个内容之前先了解函数式接口。

函数式接口具有单个抽象方法的接口可以被称为函数式接口。

这里有一些JDK函数式接口的例子：比较程序是函数式的，因为它只有一个抽象非Object方法。

虽然它声明了两个抽象方法，’equals’是对应Object中public的方法，因此从计数中排除。

具有Object类方法而没有非Object方法的接口不是函数式接口。

如果接口具有抽象的非对象类方法并扩展了一个只有对象类方法的非函数式接口，则该接口是函数式的。

Spring框架函数式接口的示例FunctionalInterface注释可以在接口声明的顶部使用，但它不是强制的。

编译器使用此注释来检测接口是否是有效的函数式接口。

如果我们尝试定义不止单个的抽象方法到接口，那么编译器会抛出错误。

函数描述符接口的函数描述符是接口单个抽象方法的方法类型。

方法类型包括参数类型，返回类型和throws子句。

例子：如何编写Lambda表达式Lambda表达式语法可以分为三部分：箭头（–>）参数列表：lambda表达式可以包含零个或多个参数，例如：() →{ System.out.println(“No arguments”); }(String arg) →{ System.out.println(“One argument : ”+arg); }(String arg1, Integer arg2) →{ System.out.println(“Two arguments : ”+arg1+”and ”+arg2); }表达式主体：可以是单个表达式或代码块。

SpringMVC+Hibernate4+Spring3整合开发实现CRUD

·在实现CRUD之前，我想你的开发环境已经搭建好了，我们就不作搭建的说明了，直接进入正题；一般搭建环境都是项目经理的事情，项目经理搭建完环境，就会把环境放到svn服务器上，你只需要从服务器上检出项目环境开发即可；File→Inport→SVN→从SVN检出项目我的资源库已经创建好了，你从视图中打开资源库视图创建一个资源库就好了，选择项目文件夹finish即可；·我们首先要生成简单Java类，也称POJO类，既然有添加hibernate的开发支持，当然要用hibernate提供的功能了,那我们首先编写一个数据库创建脚本，其中包括最常用的字段即可，就编写一个雇员表吧；USE mysql ;DROP TABLE emp ;CREATE TABLE emp(empno INT AUTO_INCREMENT ,ename VARCHAR(30) NOT NULL ,hiredate DATE ,sal VARCHAR(50) NOT NULL ,CONSTRAINT pk_nid PRIMARY KEY(empno)) ;·用hibernate生成一个表的对应的简单java类，打开DB Browser视图→找到对应的表右键→hibernate Reverse Engineering……这个界面就按照下图的设置，下图中没显示的部分，取消勾选，不做设置；·配置完成之后，会生成一个以表名称为类名的一个简单java类，不过首字母大写，采用的annotation注解的方式和数据表配置了映射关系，生成的类会有一些警告，压制一些就OK了，生成的构造方法没有任何用处，删掉即可，一些注释也可以删掉了，另外增加一个toString()方法，这样在做一些异常调试的时候很方便，此类我做了一点简单的注释，可以一看；Emp.javapackage cn.oracle.pojo;import java.util.Date;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.Table;import javax.persistence.Temporal;import javax.persistence.TemporalType;@SuppressWarnings("serial")→压制警告用的@Entity→代表这一个实体，与数据表映射对应；@Table(name = "emp", catalog = "mysql")→此设置了这个实体对应的数据库名称和表名称；name 属性是表名称，catalog 是你用到数据库的名字；public class Emp implements java.io.Serializable {private Integer empno;→对应的字段名称；private String ename; →对应的字段名称；private Date hiredate; →对应的字段名称；private String sal; →对应的字段名称；@Id→表示这个字段值主键，唯一的@GeneratedValue→表示此字段自动增长，@Column(name = "empno", unique = true, nullable = false)→对应表中的列的属性，name 表示列名称，unique表示唯一性,nullable表示是否为空；public Integer getEmpno() {return this.empno;}public void setEmpno(Integer empno) {this.empno = empno;}@Column(name = "ename", nullable = false, length = 30)→length表示长度public String getEname() {return this.ename;}public void setEname(String ename) {this.ename = ename;}@Temporal(TemporalType.DATE)→专门标注日期的；@Column(name = "hiredate", length = 10)public Date getHiredate() {return this.hiredate;}public void setHiredate(Date hiredate) {this.hiredate = hiredate;}@Column(name = "sal", nullable = false, length = 50)public String getSal() {return this.sal;}public void setSal(String sal) {this.sal = sal;}@Overridepublic String toString() {return"Emp [empno=" + empno + ", ename=" + ename + ", hiredate="+ hiredate + ", sal=" + sal + "]";}}·简单java类完成是第一步，然后我们需要配置数据库连接了，这是正常的思维模式，也就是最基本的JDBC开发思维模式，但是这一步spring已经在配置的时候已经交给了spring管理了数据库的连接池，只要得到对应的bean就可以得到数据库连接了，也就能操作数据库了；数据库连接类也就相当于spring给我们提供好了，那接下来就是编写接口了，首先编写DAO层接口，DAO(data access Object) 叫做数据访问对象，首先，我们利用泛型编写一个公共的DAO接口，实现基本的CRUD ，当数据表非常多的时候编写此公共的接口很节省代码的；IDAO.javapackage cn.oracle.dao;import java.util.List;public interface IDAO<K,V> {/*** 增加一条数据；* @param vo 简单Java类对象；* @return返回一个boolean对象，增加成功返回true,增加失败返回false;* @throws Exception*/public boolean doCreate(V vo)throws Exception;/*** 更新一条数据；* @param vo 简单Java类对象；* @return返回一个boolean对象，更新成功返回true,更新失败返回false;* @throws Exception*/public boolean doUpdate(V vo)throws Exception;/*** 删除一条数据；* @param id 简单Java类对象的id；* @return返回一个boolean对象，删除成功返回true,删除失败返回false;* @throws Exception*/public boolean doRemove(int id)throws Exception;/*** 查询出一条数据，* @param id 数据对应的id* @return返回一个简单java类对象；* @throws Exception*/public K findById(int id)throws Exception;/*** 查询所有的数据；* @return返回一个简单Java类对象；* @throws Exception*/public List<V> findAll()throws Exception;/*** 模糊查询，也是分页要用的一个方法；* @param column 列名称* @param keyWord 关键字* @param currentPage 当前页* @param lineSize 每页现实的数据条目* @return返回一个List集合；* @throws Exception*/public List<V> findAll(String column,String keyWord,IntegercurrentPage,Integer lineSize)throws Exception;/*** 统计模糊查询的条目* @param column 列名称* @param keyWord 关键字* @return返回一个整数* @throws Exception*/public int getAllCount(String column,String keyWord)throws Exception;}·公共的接口开发完成了，我们接下来就开发IEmpDAO接口，这个接口直接继承IDAO 接口即可，是不是很方便，直接继承即可，如果你需要扩充什么方法的话，直接编写方法即可，package cn.oracle.dao;import cn.oracle.pojo.Emp;public interface IEmpDAO extends IDAO<Integer, Emp> {}·然后当然是编写接口的实现类了，也就是编写方法的具体实现，EmpDAOImpl.javapackage cn.oracle.dao.impl;import java.util.List;import javax.annotation.Resource;import org.hibernate.Criteria;import org.hibernate.Query;import org.hibernate.SessionFactory;import ponent;import cn.oracle.dao.IEmpDAO;import cn.oracle.pojo.Emp;@Component→这个就是Annotation注解，其实你可以理解为在applicationContext.xml文件之中配置了一个bean<bean id=”empDAOImpl” class=”cn.oracle.dao.impl.EmpDAOImpl”>→Component<property name=”sessionFactory” ref=”sessionFactory”/>→Resource</bean>public class EmpDAOImpl implements IEmpDAO {@Resourceprivate SessionFactory sessionFactory;@Overridepublic boolean doCreate(Emp vo) throws Exception {return this.sessionFactory.getCurrentSession().save(vo) != null;}→使用Session接口的save方法来保存数据；@Overridepublic boolean doUpdate(Emp vo) throws Exception {String hql="UPDATE Emp AS e SET e.ename=?,e.hiredate=?,e.sal=? WHERE e.empno=?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, vo.getEname());query.setDate(1, vo.getHiredate());query.setString(2, vo.getSal());return query.executeUpdate()>0;}→使用Query实现更新；@Overridepublic boolean doRemove(int id) throws Exception {String hql="DELETE FROM Emp As e WHERE e.empno=?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setInteger(0, id);return query.executeUpdate()>0;}→使用Query接口实现删除；@Overridepublic Emp findById(int id) throws Exception {return (Emp) this.sessionFactory.getCurrentSession().get(Emp.class, id);}→使用Session接口查询数据；@SuppressWarnings("unchecked")@Overridepublic List<Emp> findAll() throws Exception {Criteriacriteria=this.sessionFactory.getCurrentSession().createCriteria(Emp.class);List<Emp> all=criteria.list();return all;} →使用criteria接口实现全部查询；@SuppressWarnings("unchecked")@Overridepublic List<Emp> findAll(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { String hql="FROM Emp AS e WHERE e."+column+" LIKE ?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");query.setFirstResult((currentPage-1)*lineSize);query.setMaxResults(lineSize);return (List<Emp>)query.list();}→使用query接口实现分页模糊查询；@Overridepublic int getAllCount(String column, String keyWord) throws Exception { String hql="SELECT COUNT(e.empno) FROM Emp AS e WHERE "+column+" LIKE ?";Query query=this.sessionFactory.getCurrentSession().createQuery(hql);query.setString(0, "%"+keyWord+"%");Integer count=((Long)query.uniqueResult()).intValue();return count;} →使用query接口完成统计；}·编写完成DAO层之后，我们就要做的就是编写服务层了，也就是对DAO层接口的调用，IEmpService.javapackage cn.oracle.service;import java.util.List;import java.util.Map;import cn.oracle.pojo.Emp;public interface IEmpService {public boolean insert(Emp vo)throws Exception;public boolean update(Emp vo)throws Exception;public boolean delete(int id)throws Exception;public Emp get(int id)throws Exception;public List<Emp> list()throws Exception;public Map<String ,Object> list(String column,String keyWord,Integer currentPage,Integer lineSize)throws Exception;}·接口编写完成，之后我们就应该编写实现类了；EmpServiceImpl.javapackage cn.oracle.service.impl;import java.util.HashMap;import java.util.List;import java.util.Map;import javax.annotation.Resource;import org.springframework.stereotype.Service;import cn.oracle.dao.IEmpDAO;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;@Service Service层的专用Annotation注解；public class EmpServiceImpl implements IEmpService {@Resourceprivate IEmpDAO empDAO;@Overridepublic boolean insert(Emp vo) throws Exception {return this.empDAO.doCreate(vo);}@Overridepublic boolean update(Emp vo) throws Exception {return this.empDAO.doUpdate(vo);}@Overridepublic boolean delete(int id) throws Exception {return this.empDAO.doRemove(id);}@Overridepublic Emp get(int id) throws Exception {return this.empDAO.findById(id);}@Overridepublic List<Emp> list() throws Exception {return this.empDAO.findAll();}@Overridepublic Map<String, Object> list(String column, String keyWord,Integer currentPage, Integer lineSize) throws Exception { Map<String ,Object> map=new HashMap<String,Object>();map.put("allEmps", this.empDAO.findAll(column, keyWord, currentPage, lineSize));map.put("allCount", this.empDAO.getAllCount(column, keyWord));return map;}}·到此，后台业务层的增删改查就完成了，然后就是控制器的编写了，我们用的是springmvc的话，自然编写起来很方便的；EmpAction.javapackage cn.oracle.action;import java.util.List;import javax.annotation.Resource;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.servlet.ModelAndView;import cn.oracle.pojo.Emp;import cn.oracle.service.IEmpService;@Controller→spring mvc的专用annotation注解，代表一个控制器；@RequestMapping("/pages/front/emp/*") →映射路径public class EmpAction {@Resourceprivate IEmpService empService;@RequestMapping(value="emp_list.jsp",method=RequestMethod.GET)public ModelAndView list(HttpServletRequest request,HttpServletResponse response){List<Emp> allEmps=null;try {allEmps=this.empService.list();} catch (Exception e) {e.printStackTrace();}ModelAndView mav=new ModelAndView();mav.setViewName("/pages/front/emp/emp_list.jsp");mav.addObject("allEmps", allEmps);System.out.println(allEmps); 我们就用一个简单的连接做测试，如果后台输出了这些对象的话，说明我们就完成了页面的操作了；return mav;}}如果后台有输出这些信息，说明你的所有配置正常，开发CRUD没任何问题的；。

spring4中文技术手册==

在《静态代理和动态代理》中提到了面向方面编程，主要就是基于动态代理。

单独抽象出非业务的功能，服务于某些业务方法。

Spring提供了四种很实用的Advice，分别为：Before Advice, After Returning Advice, Around Advice, After throwing Advice。

都是方法级别的，就是在某个方法执行前后插入一些非业务的操作，如打日志或者判断权限等。

对于这四种advice的实现，spring都提供了三种方法，分别为基于接口、基于xml和基于annotation(注释)。

Before Advice会在目标对象的方法执行之前被调用；After Advice会在目标方法执行之后被调用；Around Advice则可以在目标方法执行前后同时加上相关服务；Throw Advice是在异常发生后执行某些操作。

1.基于接口的Advice这个就需要自定义的Aspect实现Spring接口。

BeforeAdvice需要实现org.springframework.aop.MethodBeforeAdvice接口：After Advice实现org.springframework.aop.AfterReturningAdvice接口：Around Advice需要实现org.aopalliance.intercept.MethodInterceptor接口：类前面的注释说明了该方法的使用，就是要在invoke()方法中调用MethodInvocation.proceed()，将执行传给下一个Interceptor，最终执行目标方法。

在proceed()方法前后加操作，到达Aroud advice的作用。

在Aspect定义好后，就需要在bean定义文件中进行配置，通过org.springframework.aop.framework.ProxyFactoryBean的配置，指出接口、目标类和Aspect。

spring4新特性缓存框架增强

20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. }
public User delete(User user) { users.remove(user); return user; } @CacheEvict(value = "user", allEntries = true) public void deleteAll() { users.clear(); } @Cacheable(value = "user", key = "#id") public User findById(final Long id) { System.out.println("cache miss, invoke find by id, id:" + id); for (User user : users) { if (user.getId().equals(id)) { return user; } } return null; }
2/6
40. alue) { 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. } } };
public void handleCachePutError(RuntimeException exception, Cache cache, Object key, Object v System.out.println("cache put error"); } @Override public void handleCacheEvictError(RuntimeException exception, Cache cache, Object key) { System.out.println("cache evict error"); } @Override public void handleCacheClearError(RuntimeException exception, Cache cache) { System.out.println("cache clear error"); }

Spring+Hibernate整合

至于配置文件为什么这样写，这里不做解释。本文重点描述怎样将 Spring 和 Hibernate
2
两个框架集成起来。在完成了上面的 Log4j 导入工作后，再将数据库连接 Jar 包导入，这里用的是 MySQL 数
据库，所以使用 mysql-connector-java-commercial-5.1.25-bin.jar，这个也是直接将 Jar 包拷到工程的 WebRoot/WEB-INF/lib 目录下即可。所有基础工作做完后工程的结构应该是图 3 的样子：
</bean> </beans>
我们发现，配置文件中自动添加了 id 为 sessionFactory 的 bean，这个是由于我们添加了 Hibernate 支持后 MyEclipse 为我们自动生成的配置，当然了这个还不能直接使用，我们还需要进行详细的配置。
五、在配置文件中添加 Hibernate 配置
 <bean id="dataSource" class="mons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property> <property name="url" value="jdbc:mysql://localhost:3306/test_db" /> <property name="username" value="root" /> <property name="password" value="" /> </bean>

Spring整合Hibernate详细步骤

Spring整合Hibernate详细步骤⼀、概述 Spring整合Hibernate有什么好处？ 1、由IOC容器来管理Hibernate的SessionFactory 2、让Hibernate使⽤上Spring的声明式事务⼆、整合步骤整合前准备：持久化类：@Entitypublic class Book{private Integer id;private String bookName;private String isbn;private int price;private int stock;public Integer getId(){return id;}public void setId(Integer id){this.id = id;}public String getBookName(){return bookName;}public void setBookName(String bookName){this.bookName = bookName;}public String getIsbn(){return isbn;}public void setIsbn(String isbn){this.isbn = isbn;}public int getPrice(){return price;}public void setPrice(int price){this.price = price;}public int getStock(){return stock;}public void setStock(int stock){this.stock = stock;}public Book(Integer id, String bookName, String isbn, int price, int stock){super();this.id = id;this.bookName = bookName;this.isbn = isbn;this.price = price;this.stock = stock;}} Dao层：public interface BookDao{public String findBookById(int id);public void saveBook(Book book);} DaoImpl:@Repositorypublic class BookDaoImpl implements BookDao{@Autowiredprivate SessionFactory sessionFactory;//获取和当前线程绑定的Seesionprivate Session getSession(){return sessionFactory.getCurrentSession();}public String findBookById(int id){String hql="SELECT bookName from Book where id=?";Query query=getSession().createQuery(hql).setInteger(0, id);String str= query.uniqueResult().toString();return str;}public void saveBook(Book book){getSession().save(book);}} Service层：public interface BookService{public String findBookById(int id);public void saveBook(Book book);} ServiceImpl：@Servicepublic class BookServiceImpl implements BookService{@Autowiredprivate BookDao bookDao;public String findBookById(int id){return bookDao.findBookById(id);}public void saveBook(Book book){bookDao.saveBook(book);}} 1、加⼊Hibernate加⼊hibernate jar包添加Hibernate的配置⽂件：hibernate.cfg.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory> <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property><property name="hibernate.show_sql">true</property><property name="hbm2ddl.auto">update</property></session-factory></hibernate-configuration>编写持久化类对应的.hbm.xml⽂件<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="com.demo.ssm.po.Book" table="BOOK"><id name="id" type="ng.Integer"><column name="ID"/><generator class="native"/></id><property name="bookName" type="ng.String"><column name="BOOK_NAME"/></property><property name="isbn" type="ng.String"><column name="ISBN"/></property><property name="price" type="int"><column name="PRICE"/></property><property name="stock" type="int"><column name="STOCK"/></property></class></hibernate-mapping> 2、加⼊Spring加⼊spring jar包加⼊Spring配置⽂件<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /schema/context /schema/context/spring-context-4.1.xsd/schema/aop /schema/aop/spring-aop-4.1.xsd/schema/tx /schema/tx/spring-tx-4.1.xsd"><context:component-scan base-package="com.demo.ssm"></context:component-scan><bean id="dataSource" class="mons.dbcp.BasicDataSource" destroy-method="close"><property name="driverClassName" value="com.mysql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost/test"/><property name="username" value="root"></property><property name="password" value="281889"></property></bean><bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean" lazy-init="false"><property name="dataSource" ref="dataSource"/><property name="configLocation" value="classpath:hibernate.cfg.xml"></property><property name="mappingLocations" value="classpath:com/demo/ssm/po/*.hbm.xml"></property></bean><bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory"></property></bean><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="get*" read-only="true"/><tx:method name="*"/></tx:attributes></tx:advice><aop:config><aop:pointcut expression="execution(* com.demo.ssm.daoImpl.*.*(..))" id="txPointcut"/><aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/></aop:config></beans> 3、编写测试类public class BookDaoImplTest{private ApplicationContext context=null;private BookService bookService=null;{context= new ClassPathXmlApplicationContext("applicationContext.xml");bookService=context.getBean(BookService.class);}@Testpublic void test(){DataSource dataSource=(DataSource) context.getBean(DataSource.class); System.out.println(dataSource);}@Testpublic void test2(){String bookName=bookService.findBookById(1);System.out.println(bookName);}@Testpublic void test3(){bookService.saveBook(new Book(2, "android源码分析", "1002", 45, 10)); }}。

分布式业务的异常解决思路

分布式业务的异常解决思路传统意义上的事务被定义在数据层⾯，它是指⼀组原⼦操作，这组原⼦操作必须按照既定的顺序全部执⾏成功。

如果某⼀个或者多个原⼦操作失败，则回退所有之前的原⼦操作到原来的状态。

事务的特点主要有四个：原⼦性（ Atomicity ）、⼀致性（ Consistency ）、隔离性（ Isolation ）和持久性（ Durability ）。

⼀个标准的事务必须同时满⾜这四个特性，否则就⽆法保持业务数据的正确性⼀⼀并且在 SQL 规范中也明确定义了这些特性的实现标准，例如它定义了四类事务隔离级别： Read Uncommitted （读未提交〉、 Read Committed （读⼰提交）、Repeatable Read（可重复读）和 Serializable （可串⾏化〉。

传统业务环境下这些原⼦数据操作都在同⼀个数据库实例上完成，⽽随着企业中各系统的复杂度增加，就可能会出现事务跨两个或者多个系统数据库实例的情况，后⼀种事务处理机制就是常说的分布式事务。

1.分布式事务与两阶段提交协议（2PC）--作⽤于系统数据层两阶段提交协议（ 2PC ）。

简单来说这个协议中提到两个阶段是指准备阶段和提交阶段它的实现⼀般需要⼀个事务协调者来统⼀所有⼯作，协调者⾸先向参与事务动作的各个数据节点提交准备请求（也叫检查请求），并等待所有参与此事务的数据节点返回确认信息。

当各个数据节点收到这个准备请求后就会检查⾃⼰是否有条件执⾏⾃⼰负责的处理部分，并且执⾏但不提交各⾃负责的这部分数据操作。

这是⼀个同步过程，在收到所有节点确认信息之前协调者都不会发出下⼀步的执⾏指令，各个节点被锁定／预占的资源也不会被释放⼀⼀因为各数据节点的处理过程都未正式提交。

如果在这个过程中任何⼀个数据节点返回了“不可⽤”或者等待超时，那么协调者就会向各个参与事务动作的处理节点发出“回液”指令，各个处理节点就会回滚／释放资源，并将回滚结果回馈给协调者；如果协调者收到所有处理节点“准备好”／“同意”的信号，那么就会进⼊第⼆个阶段⼀⼀通知各个处理节点“提交” 。