struts-2.3.1+spring-framework-3.2.2+hibernate-4.1.1整合历程<第三部分>(详解)

最新推荐文章于 2024-07-26 00:55:46 发布
最新推荐文章于 2024-07-26 00:55:46 发布
阅读量942 收藏
点赞数
分类专栏： java 文章标签： struts2 hibernate spring
在前两部分的编写中，Struts2和Hibernate已经成功整合，Struts2是MVC模式的实现，将业务逻辑和数据显示分离，Hibernate负责数据库与实体对象的映射，将关系数据模型转变成对象模型加以操作，符合面向对象的编程方式，但Spring究竟怎么整合进来，又负责怎样的功能，IOC（Inversion of Control），AOP（Aspect Oriented Programming）到底是什么概念，Spring带来了哪些好处，本文将都会涉及到，而且都会通过整个整合过程中的实例加以说明。

    和之前的操作步骤一样，首先要进行导入支持Spring的jar包，然后创建Spring的配置文件，然后进行配置文件的编写，然后可以通过实例检测是否成功。

    步骤一：导入支持Spring的Jar包，进入解压后文件路径spring-framework-3.2.2\libs下面，找到以下10个基本jar包拷贝到项目结构中lib目录下，具体的功能如下所示：

jar包(.jar)
作用
spring-aop-3.2.2
基于AOP的Spring特性如声明型事务管理
spring-aspects-3.2.2
Spring提供对AspectJ框架的整合
spring-beans-3.2.2
它包含访问配置文件，创建和管理文件，创建和管理bean以及进行（IoC/DI）操作相关的所有类
spring-context-3.2.2
Spring提供在基础IoC功能上的扩展服务，此外还提供许多企业级服务的支持，如邮件服务、任务调度、JNDI定位、EJB集成、远程访问、缓存以及各种视图层框架的封装等
spring-core-3.2.2
Spring3.2.2的核心工具包
spring-expression-3.2.2
Spring表达式语言
spring-jdbc-3.2.2
对JDBC的简单封装
spring-orm-3.2.2
整合第三方的ORM框架，如hibernate,ibatis,jdo，以及spring的JPA实现
spring-tx-3.2.2
spring对事物的管理
spring-web-3.2.2
包含Web应用开发时，用到的Spring框架
    

    注：这里面没有将所有的jar包都导入，一个是因为本文中没有用到相应的jar包，二是在整合过程中会遇到jar包缺少的异常，或者为了解决某些问题，要手动导入某些jar包，这些都会在整合过程中遇到，有经验的读者可以一开始就将所有的jar包导入，这样可以避免不需要的异常，但为了发现一些整合时候可能遇到的异常，本文将具体问题具体分析。

    此时项目中的jar包如图1所示：


               图1

    步骤二：创建文件applicationContext.xml，首先如图2所示，


                           图2

然后如图3所示，


                            图3

点击finish，完成applicationContext.xml创建，此时完整的项目结构如图4所示：


             图4

    步骤三：编写配置文件，一般在开发中，自己从头到尾写配置的开发是不现实的，也是不需要的，都是copy改，当然本文也是采取这样的方式，但是不一样的是，这些配置文件我会通过spring说明文档，从中进行拷贝，然后spring说明文档在解压后的spring-framework-3.2.2\docs\spring-framework-reference\htmlsingle目录下，双击index.html打开说明文档,然后在网页中CTRL+F键弹出搜索框，然后输入<?xml version="1.0" encoding="UTF-8"?>，搜索到如图5所示的配置信息：


                                         图5

    然后将搜到的内容copy到项目中applicationContext.xml的配置文件中，并更改成以下内容，此时applicationContext.xml中的内容如下所示：

applicationContext.xml

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
  7.            http://www.springframework.org/schema/context  
  8.            http://www.springframework.org/schema/context/spring-context-3.2.xsd">  
  9.     <context:annotation-config />  
  10.       
  11. </beans>  

有警告信息不要担心，可以将配置文件关闭后重新打开警告信息将会消失。此时可以写一个测试类完成Spring是否成功配置的测试，在test下com.steven.test新建一个SpringTest.java的类，

SpringTest.java代码如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.steven.test;  
  2.   
  3. import org.junit.Test;  
  4. import org.springframework.context.ApplicationContext;  
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  6.   
  7. /** 
  8.  * 用来进行Spring的测试类 
  9.  *  
  10.  * @author Steven 
  11.  *  
  12.  */  
  13. public class SpringTest {  
  14.     @Test  
  15.     /** 
  16.      * 用来测试是否Spring导入成功，配置成功 
  17.      */  
  18.     public void testSpring() {  
  19.         ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");  
  20.         System.out.println(appContext);  
  21.     }  
  22. }  

    其中ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");依旧来自Spring文档，如图6所示：


                                             图6

此时进行JUnit测试，但运行中会出现一个异常，具体如下所示:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory  
  2.     at org.springframework.context.support.AbstractApplicationContext.<init>(AbstractApplicationContext.java:164)  
  3.     at org.springframework.context.support.AbstractRefreshableApplicationContext.<init>(AbstractRefreshableApplicationContext.java:89)  
  4.     at org.springframework.context.support.AbstractRefreshableConfigApplicationContext.<init>(AbstractRefreshableConfigApplicationContext.java:58)  
  5.     at org.springframework.context.support.AbstractXmlApplicationContext.<init>(AbstractXmlApplicationContext.java:61)  
  6.     at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:136)  
  7.     at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:83)  
  8.     at com.steven.test.SpringTest.testSpring(SpringTest.java:19)  
  9.     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)  
  10.     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)  
  11.     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)  
  12.     at java.lang.reflect.Method.invoke(Method.java:597)  
  13.     at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)  
  14.     at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)  
  15.     at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)  
  16.     at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)  
  17.     at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)  
  18.     at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)  
  19.     at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:73)  
  20.     at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:46)  
  21.     at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180)  
  22.     at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41)  
  23.     at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173)  
  24.     at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)  
  25.     at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)  
  26.     at org.junit.runners.ParentRunner.run(ParentRunner.java:220)  
  27.     at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46)  
  28.     at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)  
  29.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)  
  30.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)  
  31.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)  
  32.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)  
  33. Caused by: java.lang.ClassNotFoundException: org.apache.commons.logging.LogFactory  
  34.     at java.net.URLClassLoader$1.run(URLClassLoader.java:200)  
  35.     at java.security.AccessController.doPrivileged(Native Method)  
  36.     at java.net.URLClassLoader.findClass(URLClassLoader.java:188)  
  37.     at java.lang.ClassLoader.loadClass(ClassLoader.java:307)  
  38.     at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)  
  39.     at java.lang.ClassLoader.loadClass(ClassLoader.java:252)  
  40.     at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)  
  41.     ... 31 more  

这个异常是缺少org.apache.commons.logging.LogFactory这个类，所以要解决就要下载commons-logging-1.1.1.jar这个jar包（http://ishare.iask.sina.com.cn/download/explain.php?fileid=13433467），然后添加到lib路径下，此时再次运行，会出现以下结果，表示开始的导入和配置成功。

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. 2013-12-12 22:54:00 org.springframework.context.support.AbstractApplicationContext prepareRefresh  
  2. 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1d225a7: startup date [Thu Dec 12 22:54:00 CST 2013]; root of context hierarchy  
  3. 2013-12-12 22:54:01 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions  
  4. 信息: Loading XML bean definitions from class path resource [applicationContext.xml]  
  5. 2013-12-12 22:54:02 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons  
  6. 信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@a3d3b: defining beans [org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.context.annotation.internalPersistenceAnnotationProcessor,org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor]; root of factory hierarchy  
  7. org.springframework.context.support.ClassPathXmlApplicationContext@1d225a7: startup date [Thu Dec 12 22:54:00 CST 2013]; root of context hierarchy  
经过这几个步骤，初始的Spring已经加载进来了，但具体的含义是什么，下面将进行介绍。

    注：首先applicationContext.xml的文件名不是必须的，也可以是其他的名称，比如常用的还有beans.xml，这个xml中头部都是一些xsd（XML Schemas Definition）文件，其作用是定义一份XML文档的合法组件群，定义了可以出现在文档里的元素；可以出现在文档里的属性；哪些元素是子元素；子元素的顺序；子元素的数量；一个元素应是否能包含文本，或应该是空的；元素和属性的数据类型；元素和属性的默认值和固定值。这时候，就可以在配置文件中进行配置了，在解压后的jar包spring-framework-3.2.2\schema路径下面，定义了很多xsd文件，一般在电脑可以上网的情况下，工具中如果没有，就会通过网络将schema文件下载并缓存在硬盘上，第二种可以通过手动添加schema文件，可以通过点击windwos->preferences->myeclipse->files and editors->xml->xmlcatalog点"add",在出现的窗口中的Key Type中选择URI,在location中选"File system",然后在spring解压目录的dist/resources目录中选择spring-beans-3.2.xsd,回到设置窗口的时候不要急着关闭窗口,应把窗口中的Key Type改为Schema location,Key改为http://www.springframework.org/schema/beans/spring-beans-3.2.xsd，如图7所示：


                           图7

    这样就可以解析导入的schema文件了。

    在测试的时候，得到ApplicationContext是使用ClassPathXmlApplicationContext这个类获得的，这是方法一，第二种方法可以通过ApplicationContext appContext = new FileSystemXmlApplicationContext(new String[] {"src/applicationContext.xml"});获取到，两种方式都可以进行测试，一个是通过class路径找到配置文件，一个是通过文件路径找到。

    

            然后通过下面的一个小例子看看Spring，IOC的魅力，

    首先在applicationContext.xml中加入如下的配置，然后此时配置如下所示：

    applicationContext.xml

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
  7.            http://www.springframework.org/schema/context  
  8.            http://www.springframework.org/schema/context/spring-context-3.2.xsd">  
  9.     <context:annotation-config />  
  10.     <!-- 用来格式化日期属性 -->  
  11.     <bean id="dateFormat" class="java.text.SimpleDateFormat">  
  12.         <constructor-arg value="yyyy-MM-dd" />  
  13.     </bean>  
  14.     <!-- 通过手动配置 xml 实现 spring IOC -->  
  15.     <bean id="user" class="com.steven.entity.User">  
  16.         <property name="userId" value="1" />  
  17.         <property name="userName" value="Steven" />  
  18.         <property name="birthday">  
  19.             <bean factory-bean="dateFormat" factory-method="parse">  
  20.                 <constructor-arg value="1990-01-01" />  
  21.             </bean>  
  22.         </property>  
  23.         <property name="age" value="23" />  
  24.         <property name="isVip" value="true" />  
  25.     </bean>  
  26. </beans>  

此时测试类如下所示，

SpringTest.java

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.steven.test;  
  2.   
  3. import org.junit.Test;  
  4. import org.springframework.context.ApplicationContext;  
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  6. import org.springframework.context.support.FileSystemXmlApplicationContext;  
  7.   
  8. import com.steven.entity.User;  
  9.   
  10. /** 
  11.  * 用来进行Spring的测试类 
  12.  *  
  13.  * @author Steven 
  14.  *  
  15.  */  
  16. public class SpringTest {  
  17.     @Test  
  18.     /** 
  19.      * 用来测试是否Spring导入成功，配置成功 
  20.      */  
  21.     public void testSpring() {  
  22.         // 方式一  
  23.         // ApplicationContext appContext = new  
  24.         // ClassPathXmlApplicationContext("applicationContext.xml");  
  25.         // 方式二  
  26.         ApplicationContext appContext = new FileSystemXmlApplicationContext(  
  27.                 new String[] { "src/applicationContext.xml" });  
  28.         System.out.println(appContext);  
  29.     }  
  30.   
  31.     @Test  
  32.     /** 
  33.      * 通过IOC方式进行获取Spring容器代理生成的User对象 
  34.      */  
  35.     public void testGetUser() {  
  36.         ApplicationContext ac = new ClassPathXmlApplicationContext(  
  37.                 "applicationContext.xml");  
  38.         User user = (User) ac.getBean("user");  
  39.         System.out.println(user);  
  40.     }  
  41. }  

然后执行JUnit测试，运行结果如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. 2013-12-13 22:04:00 org.springframework.context.support.AbstractApplicationContext prepareRefresh  
  2. 信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1d225a7: startup date [Fri Dec 13 22:04:00 CST 2013]; root of context hierarchy  
  3. 2013-12-13 22:04:00 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions  
  4. 信息: Loading XML bean definitions from class path resource [applicationContext.xml]  
  5. 2013-12-13 22:04:00 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons  
  6. 信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@140984b: defining beans [org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.context.annotation.internalPersistenceAnnotationProcessor,dateFormat,user,org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor]; root of factory hierarchy  
  7. 用户信息： [年龄是23, 生日是Mon Jan 01 00:00:00 CST 1990, 用户编号是1, 用户名是Steven, 是会员]  

    此时配置的用户信息已经打印出来。这个时候我们来看看发生了什么事情了，通过ac.getBean("user")获得了配置中的User对象，其实是当Spring容器启动的时候就会对配置文件进行解析，在配置文件中有<bean>的节点，就会根据<bean>中的内容通过一系列Spring内部操作获得一个key为user的对象User，其实是通过java的反射机制创建User的对象，而且还是无参构造，如果将User中的无参构造去掉，或者写一个有参构造，这时候执行就会报以下的异常：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'user' defined in class path resource [applicationContext.xml]: Instantiation of bean failed; nested exception is org.springframework.beans.BeanInstantiationException: Could not instantiate bean class [com.steven.entity.User]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.steven.entity.User.<init>()  
  2.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateBean(AbstractAutowireCapableBeanFactory.java:1013)  
  3.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:959)  
  4.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:490)  
  5.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:461)  
  6.     at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:295)  
  7.     at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:223)  
  8.     at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:292)  
  9.     at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:194)  
  10.     at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:626)  
  11.     at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:932)  
  12.     at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:479)  
  13.     at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:139)  
  14.     at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:83)  
  15.     at com.steven.test.SpringTest.testGetUser(SpringTest.java:36)  
  16.     at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)  
  17.     at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)  
  18.     at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)  
  19.     at java.lang.reflect.Method.invoke(Method.java:597)  
  20.     at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)  
  21.     at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)  
  22.     at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)  
  23.     at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)  
  24.     at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)  
  25.     at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)  
  26.     at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:73)  
  27.     at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:46)  
  28.     at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180)  
  29.     at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41)  
  30.     at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173)  
  31.     at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)  
  32.     at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)  
  33.     at org.junit.runners.ParentRunner.run(ParentRunner.java:220)  
  34.     at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46)  
  35.     at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)  
  36.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)  
  37.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)  
  38.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)  
  39.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)  
  40. Caused by: org.springframework.beans.BeanInstantiationException: Could not instantiate bean class [com.steven.entity.User]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.steven.entity.User.<init>()  
  41.     at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:83)  
  42.     at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateBean(AbstractAutowireCapableBeanFactory.java:1006)  
  43.     ... 37 more  
  44. Caused by: java.lang.NoSuchMethodException: com.steven.entity.User.<init>()  
  45.     at java.lang.Class.getConstructor0(Class.java:2706)  
  46.     at java.lang.Class.getDeclaredConstructor(Class.java:1985)  
  47.     at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:78)  
  48.     ... 38 more  
其实将配置文件中的value值设置到对象属性中是通过调用setXx的方法，如果将set后面的改成和属性不一样的单词就会报错。这个可以自己手动试试。

    所以Ioc的本质就是将创建对象（new User（））的主动权交给Spring容器了，这时候我想要User对象，只要问Spring要，然后Spring就会给我注射一个User对象，这就是Ioc（控制反转），或者叫DI（依赖注入），User依赖Spring容器注入给自己一个实例。这样做的好处是将对象的创建交给了Spring容器，就好似实现了热插拔的效果，具体的只要外部定义规定一样的，拿过来用就好了，这样就做到代码解耦和了。

    以上是通过手动配置bean文件，通过Spring上下文（ApplicationContext）获得容器产生的对象，下面通过配置将hibernate.cfg.xml替换掉，这段代码也可以从文档中查看，为了简单起见，这里不再给出查找过程，想必大家已经可以掌握了如何查找配置的方法。可以复制一下给出的配置即可。

applicationContext.xml

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
  7.            http://www.springframework.org/schema/context  
  8.            http://www.springframework.org/schema/context/spring-context-3.2.xsd">  
  9.     <context:annotation-config />  
  10.     <!-- 用来格式化日期属性 -->  
  11.     <bean id="dateFormat" class="java.text.SimpleDateFormat">  
  12.         <constructor-arg value="yyyy-MM-dd" />  
  13.     </bean>  
  14.     <!-- 通过手动配置 xml 实现 spring IOC -->  
  15.     <bean id="user" class="com.steven.entity.User">  
  16.         <property name="userId" value="1" />  
  17.         <property name="userName" value="Steven" />  
  18.         <property name="birthday">  
  19.             <bean factory-bean="dateFormat" factory-method="parse">  
  20.                 <constructor-arg value="1990-01-01" />  
  21.             </bean>  
  22.         </property>  
  23.         <property name="age" value="23" />  
  24.         <property name="isVip" value="true" />  
  25.     </bean>  
  26.   
  27.     <!-- 通过spring配置取代hibernate.cfg.xml -->  
  28.     <bean  
  29.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  30.         <property name="locations">  
  31.             <value>classpath:jdbc.properties</value>  
  32.         </property>  
  33.     </bean>  
  34.     <!-- 配置数据库连接所需要的基本信息 -->  
  35.     <bean id="dataSource"  
  36.         class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
  37.         <property name="driverClassName" value="${jdbc.driverClassName}" />  
  38.         <property name="url" value="${jdbc.url}" />  
  39.         <property name="username" value="${jdbc.username}" />  
  40.         <property name="password" value="${jdbc.password}" />  
  41.     </bean>  
  42.   
  43.     <!-- 配置sessionFactory -->  
  44.     <bean id="sessionFactory"  
  45.         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">  
  46.         <property name="dataSource" ref="dataSource" />  
  47.         <property name="packagesToScan">  
  48.             <list>  
  49.                 <value>com.steven</value>  
  50.             </list>  
  51.         </property>  
  52.         <property name="hibernateProperties">  
  53.             <props>  
  54.                 <prop key="hibernate.dialect">  
  55.                     org.hibernate.dialect.MySQLDialect  
  56.                 </prop>  
  57.                 <prop key="hibernate.show_sql">true</prop>  
  58.                 <prop key="hibernate.format_sql">true</prop>  
  59.                 <prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSessionContext  
  60.                 </prop>  
  61.             </props>  
  62.         </property>  
  63.     </bean>  
  64. </beans>  
此时将不再需要hibernate.cfg.xml的配置文件，但这时候添加了jdbc.properties的资源文件，项目结构图如图8所示：


           图8

jdbc.properties的内容如下：

[plain] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. jdbc.driverClassName=com.mysql.jdbc.Driver  
  2. jdbc.url=jdbc\:mysql\://localhost\:3306/steven  
  3. jdbc.username=root  
  4. jdbc.password=mysqladmin  
到底是否已经将hibernate.cfg.xml配置文件取代，此时可以通过测试查看，在SpringTest.java中添加如下的测试方法:

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. @Test  
  2.     /** 
  3.      * 通过spring配置文件替代hibernate配置文件，测试是否成功 
  4.      */  
  5.     public void testUser() {  
  6.         //获取spring容器上下文  
  7.         ApplicationContext ac = new ClassPathXmlApplicationContext(  
  8.                 "applicationContext.xml");  
  9.         //获取配置文件中的session工厂(通过Spring的控制反转)  
  10.         SessionFactory sessionFactory = (SessionFactory) ac  
  11.                 .getBean("sessionFactory");  
  12.         //获取session(连接)  
  13.         Session session = sessionFactory.openSession();  
  14.         //通过hibernate方式的获取  
  15.         User user = (User) session.get(User.class, 1);  
  16.         //打印获取信息F  
  17.         System.out.println(user);  
  18.     }  
然后执行JUnit测试，此时的执行效果如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. …………………………………………  
  2. …………………………………………  
  3. Hibernate:   
  4.     select  
  5.         user0_.userId as userId0_0_,  
  6.         user0_.age as age0_0_,  
  7.         user0_.birthday as birthday0_0_,  
  8.         user0_.isVip as isVip0_0_,  
  9.         user0_.userName as userName0_0_   
  10.     from  
  11.         t_user user0_   
  12.     where  
  13.         user0_.userId=?  
  14. 用户信息： [年龄是1, 生日是2013-12-10 20:39:16.0, 用户编号是1, 用户名是Steven, 是会员]  
    所以此时可以断定，SessionFactory已经通过Spring容器获取，而Hibernate的配置文件已经被Spring配置文件替代，所以这个时候可以说是Hibernate已经和Spring整合。

    既然Hibernate已经整合进了Spring，那么就可以利用Spring的控制反转来替代Hibernate时候对于Dao类编写时候不必要的冗余代码。
    在实现Hibernate和Spring的完全整合的时候，可以通过注解的方式进行，此时需要在applicationContext.xml中<context:annotation-config />后添加一句<context:component-scan base-package="com.steven" />，既是注解方式注入对象的时候寻找Spring容器产生的对象是在包的范围下面寻找，此时配置文件添加为：

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <context:annotation-config />  
  2.     <context:component-scan base-package="com.steven" />  
    下面将实施将Dao中HibernateUtil使用Spring容器的注入产生SessionFactory对象，从而可以获得Session，继而可以通过Session下面的方法实现增删改查（crud）的功能。

    这个时候会引入一个新的层次service层，这个层次一则是考虑到dao仅仅是对一个实体类的操作，如果有事务的的操作就可以放到service层次解决，而且可以实现Spring的事务管理机制。

    此时新建两个包com.steven.service.iface,com.steven.service.impl,而且新增了BaseDao类，实现所有重复的增删改查的操作，然后具体的UserDao在实现IUserDao的时候要继承这个类，这样所有的重复方法就可以实现复用了。

    这个时候的项目框架就搭建成如图9所示：


           图9

此时变更的代码有新增的BaseDao.java,UserDao.java,新增的IUserService.java,UserService.java,具体的代码如下所示：

BaseDao.java

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.steven.dao.iface;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.hibernate.Query;  
  6. import org.hibernate.Session;  
  7. import org.hibernate.SessionFactory;  
  8. import org.springframework.beans.factory.annotation.Autowired;  
  9.   
  10. /** 
  11.  * 集成hibernate3和spring的时候， 
  12.  * spring的ORM包里提供了HibernateSupport和HibernateTemplate这两个辅助类， 
  13.  * 建议使用HibernateTemplate。 不过在Hibernate4里，spring不再提供这种辅助类，将使用hibernate4的原生API 
  14.  * http://blog.csdn.net/dlutxie/article/details/8771371 
  15.  *  
  16.  * @author Steven 
  17.  *  
  18.  * @param <T> 
  19.  */  
  20. public abstract class BaseDao<T> implements IBaseDao<T> {  
  21.   
  22.     // 具体到哪个实体类的DAO功能  
  23.     private Class<T> entityClass;  
  24.   
  25.     // 自动注入  
  26.     @Autowired  
  27.     private SessionFactory sessionFactory;  
  28.   
  29.     /** 
  30.      * 通过Spring注入的sessionFactory获取session 
  31.      *  
  32.      * @return 
  33.      */  
  34.     public Session getSession() {  
  35.         return this.sessionFactory.getCurrentSession();  
  36.     }  
  37.   
  38.     /** 
  39.      * 当前进行操作的类的实例 
  40.      *  
  41.      * @param entityClass 
  42.      */  
  43.     public BaseDao(Class<T> entityClass) {  
  44.         this.entityClass = entityClass;  
  45.     }  
  46.   
  47.     /** 
  48.      * 删除操作 
  49.      */  
  50.     public void delete(T t) {  
  51.         this.getSession().delete(t);  
  52.     }  
  53.   
  54.     /** 
  55.      * 获取所有的对象集合 
  56.      */  
  57.     @SuppressWarnings("unchecked")  
  58.     public List<T> getAll() {  
  59.         String hql = "from " + entityClass.getSimpleName();  
  60.         Query query = this.getSession().createQuery(hql);  
  61.         return query.list();  
  62.     }  
  63.   
  64.     /** 
  65.      * 根据Id获取对象的操作 
  66.      */  
  67.     @SuppressWarnings("unchecked")  
  68.     public T getById(int id) {  
  69.         return (T) this.getSession().get(this.entityClass, id);  
  70.     }  
  71.   
  72.     /** 
  73.      * 插入对象操作 
  74.      */  
  75.     public void insert(T t) {  
  76.         this.getSession().save(t);  
  77.     }  
  78.   
  79.     /** 
  80.      * 更新操作 
  81.      */  
  82.     public void update(T t) {  
  83.         this.getSession().update(t);  
  84.     }  
  85. }  

UserDao.java
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.steven.dao.impl;  
  2.   
  3. import org.springframework.stereotype.Repository;  
  4.   
  5. import com.steven.dao.iface.BaseDao;  
  6. import com.steven.dao.iface.IUserDao;  
  7. import com.steven.entity.User;  
  8.   
  9. /** 
  10.  * UserDao已经继承了BaseDao，其中的所有方法均已经被BaseDao实现 
  11.  *  
  12.  * @author Steven 
  13.  *  
  14.  */  
  15.   
  16. //@Component("userDao")  
  17. @Repository  
  18. //一定要实现IUserDao这个接口  
  19. public class UserDao extends BaseDao<User> implements IUserDao {  
  20.   
  21.     public UserDao() {  
  22.         super(User.class);  
  23.     }  
  24. }  


IUserService.java
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.steven.service.iface;  
  2.   
  3. import java.util.List;  
  4.   
  5. import com.steven.entity.User;  
  6.   
  7. /** 
  8.  * 业务层 
  9.  *  
  10.  * @author Steven 
  11.  *  
  12.  */  
  13. public interface IUserService {  
  14.     /** 
  15.      * 新增一个用户业务操作 
  16.      *  
  17.      * @param user 
  18.      */  
  19.     public void addUser(User user);  
  20.   
  21.     /** 
  22.      * 根据用户Id获取用户操作 
  23.      *  
  24.      * @param userId 
  25.      * @return 
  26.      */  
  27.     public User getUserById(int userId);  
  28.   
  29.     /** 
  30.      * 获取所有的用户集合 
  31.      *  
  32.      * @return 
  33.      */  
  34.     public List<User> getAll();  
  35.   
  36. }  
UserService.java
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.steven.service.impl;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.springframework.beans.factory.annotation.Autowired;  
  6. import org.springframework.stereotype.Service;  
  7.   
  8. import com.steven.dao.iface.IUserDao;  
  9. import com.steven.entity.User;  
  10. import com.steven.service.iface.IUserService;  
  11.   
  12. /** 
  13.  * 具体的业务层实现 
  14.  */  
  15. @Service  
  16. public class UserService implements IUserService {  
  17.   
  18.     @Autowired  
  19.     private IUserDao userDao;  
  20.   
  21.     public void addUser(User user) {  
  22.         userDao.insert(user);  
  23.     }  
  24.   
  25.     public User getUserById(int userId) {  
  26.         return userDao.getById(userId);  
  27.     }  
  28.   
  29.     public List<User> getAll() {  
  30.         return userDao.getAll();  
  31.     }  
  32.   
  33. }  

在上面的代码中用到了几个注解，这里将进行详细讲解

@Repository代表仓库. 一般注解在DAO实现类上, 只要看到这个注解, 就知道这个类是一个跟数据存储有关的类. 
@Service代表业务实现. 一般注解在Service实现类上.
如果你的类不是以上类型(数据存储类, 业务类), 可以笼统的使用@Component

@Autowire是注入对象的方式，自动注入，默认是按照类型的，此时就是需要<context:component-scan base-package="com.steven" />，自动在这个包下面进行搜索，搜索不到将会报错Could not autowire field，所以如果用到这个注解，在配置过程中要注意包的范围。


    这个时候可以查看是否配置成功，是否注解可以进行工作，是否BaseDao的编写已经趋于正常。依旧在SpringTest.java中编写JUnit测试方法,但此时在进行测试的时候就不是和原来一样的环境了，首先这个是Spring容器进行配置的，而且所有的bean都是自动注入的，因此需要一个Spring的环境，此时更改的地方或者添加了什么地方我将详细列出，

1，增加了spring-framework-3.2.2\libs\spring-test-3.2.2.jar这个jar包，为测试营造了一个Spring的环境，

2，将src\applicationContext.xml中添加一句配置，事务的配置，因为在Dao中获得Session的时候是通过sessionFactory.getCurrentSession()获取的，如果通过sessionFactory.openSession()获取就不需要配置事务，( 这个可以自己动手试一下，就将BaseDao中获取Session的方法改为openSession()，然后测试类中不要加事务的注解即可，本文考虑复杂一些的使用方式)因为getCurrentSession（）要从当前事务中获取得到Session，

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <!-- 配置事务 -->  
  2.     <bean id="transactionManager"  
  3.         class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
  4.         <property name="sessionFactory" ref="sessionFactory" />  
  5.     </bean>  
3，将添加过配置的app licationContext.xml文件复制到测试路径的com.steven.test包下，既test\com\steven\test\applicationContext.xml这个路径下，

4，在SpringTest.java中加了几个注解@RunWith（既SpringTest的环境中初始化Spring容器），@ContextConfiguration（找到test路径下的配置文件），@Transactional（打开事务，避免找不到currentSession）。

下面给出更改后的项目结构图，如图10所示：


              图10

此时的applicationContext.xml（两个路径下都要求配置同步）的内容如下：

applicationContext.xml

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
  7.            http://www.springframework.org/schema/context  
  8.            http://www.springframework.org/schema/context/spring-context-3.2.xsd">  
  9.     <context:annotation-config />  
  10.     <context:component-scan base-package="com.steven" />  
  11.     <!-- 用来格式化日期属性 -->  
  12.     <bean id="dateFormat" class="java.text.SimpleDateFormat">  
  13.         <constructor-arg value="yyyy-MM-dd" />  
  14.     </bean>  
  15.     <!-- 通过手动配置 xml 实现 spring IOC -->  
  16.     <bean id="user" class="com.steven.entity.User">  
  17.         <property name="userId" value="1" />  
  18.         <property name="userName" value="Steven" />  
  19.         <property name="birthday">  
  20.             <bean factory-bean="dateFormat" factory-method="parse">  
  21.                 <constructor-arg value="1990-01-01" />  
  22.             </bean>  
  23.         </property>  
  24.         <property name="age" value="23" />  
  25.         <property name="isVip" value="true" />  
  26.     </bean>  
  27.   
  28.     <!-- 通过spring配置取代hibernate.cfg.xml -->  
  29.     <bean  
  30.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  31.         <property name="locations">  
  32.             <value>classpath:jdbc.properties</value>  
  33.         </property>  
  34.     </bean>  
  35.     <!-- 配置数据库连接所需要的基本信息 -->  
  36.     <bean id="dataSource"  
  37.         class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
  38.         <property name="driverClassName" value="${jdbc.driverClassName}" />  
  39.         <property name="url" value="${jdbc.url}" />  
  40.         <property name="username" value="${jdbc.username}" />  
  41.         <property name="password" value="${jdbc.password}" />  
  42.     </bean>  
  43.   
  44.     <!-- 配置sessionFactory -->  
  45.     <bean id="sessionFactory"  
  46.         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">  
  47.         <property name="dataSource" ref="dataSource" />  
  48.         <property name="packagesToScan">  
  49.             <list>  
  50.                 <value>com.steven</value>  
  51.             </list>  
  52.         </property>  
  53.         <property name="hibernateProperties">  
  54.             <props>  
  55.                 <prop key="hibernate.dialect">  
  56.                     org.hibernate.dialect.MySQLDialect  
  57.                 </prop>  
  58.                 <prop key="hibernate.show_sql">true</prop>  
  59.                 <prop key="hibernate.format_sql">true</prop>  
  60.                 <prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSessionContext  
  61.                 </prop>  
  62.             </props>  
  63.         </property>  
  64.     </bean>  
  65.     <!-- 配置事务 -->  
  66.     <bean id="transactionManager"  
  67.         class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
  68.         <property name="sessionFactory" ref="sessionFactory" />  
  69.     </bean>  
  70. </beans>  
这个时候的SpringTest.java如下所示：

SpringTest.java

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.steven.test;  
  2.   
  3. import java.util.Date;  
  4. import java.util.List;  
  5.   
  6. import org.hibernate.Session;  
  7. import org.hibernate.SessionFactory;  
  8. import org.junit.Test;  
  9. import org.junit.runner.RunWith;  
  10. import org.springframework.beans.factory.annotation.Autowired;  
  11. import org.springframework.context.ApplicationContext;  
  12. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  13. import org.springframework.context.support.FileSystemXmlApplicationContext;  
  14. import org.springframework.test.context.ContextConfiguration;  
  15. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
  16. import org.springframework.transaction.annotation.Transactional;  
  17.   
  18. import com.steven.dao.iface.IUserDao;  
  19. import com.steven.entity.User;  
  20. import com.steven.service.iface.IUserService;  
  21.   
  22. /** 
  23.  * 用来进行Spring的测试类 
  24.  *  
  25.  * @author Steven 
  26.  *  
  27.  */  
  28. // 需要额外添加spring-test包  
  29. // 这个包代表在spring容器中进行测试  
  30. @RunWith(SpringJUnit4ClassRunner.class)  
  31. // 这个包代表引入test/com/steven/test/applicationContext.xml文件  
  32. @ContextConfiguration(locations = "applicationContext.xml")  
  33. // 这个包代表开启事物，这样可以阻止No Session found for current thread的异常出现  
  34. @Transactional  
  35. public class SpringTest {  
  36.     @Autowired  
  37.     private IUserDao userDao;  
  38.     @Autowired  
  39.     private IUserService userService;  
  40.   
  41.     @Test  
  42.     /** 
  43.      * 用来测试是否Spring导入成功，配置成功 
  44.      */  
  45.     public void testSpring() {  
  46.         // 方式一  
  47.         // ApplicationContext appContext = new  
  48.         // ClassPathXmlApplicationContext("applicationContext.xml");  
  49.         // 方式二  
  50.         ApplicationContext appContext = new FileSystemXmlApplicationContext(  
  51.                 new String[] { "applicationContext.xml" });  
  52.         System.out.println(appContext);  
  53.     }  
  54.   
  55.     @Test  
  56.     /** 
  57.      * 通过IOC方式进行获取Spring容器代理生成的User对象 
  58.      */  
  59.     public void testGetUser() {  
  60.         ApplicationContext ac = new ClassPathXmlApplicationContext(  
  61.                 "applicationContext.xml");  
  62.         User user = (User) ac.getBean("user");  
  63.         System.out.println(user);  
  64.     }  
  65.   
  66.     @Test  
  67.     /** 
  68.      * 通过spring配置文件替代hibernate配置文件，测试是否成功 
  69.      */  
  70.     public void testUser() {  
  71.         // 获取spring容器上下文  
  72.         ApplicationContext ac = new ClassPathXmlApplicationContext(  
  73.                 "applicationContext.xml");  
  74.         // 获取配置文件中的session工厂(通过Spring的控制反转)  
  75.         SessionFactory sessionFactory = (SessionFactory) ac  
  76.                 .getBean("sessionFactory");  
  77.         // 获取session(连接)  
  78.         Session session = sessionFactory.openSession();  
  79.         // 通过hibernate方式的获取  
  80.         User user = (User) session.get(User.class, 1);  
  81.         // 打印获取信息F  
  82.         System.out.println(user);  
  83.     }  
  84.   
  85.     @Test  
  86.     /** 
  87.      * 用来测试是否可以自动将UserDao对象注入，而且获取所有人的集合的方法是正确的 
  88.      */  
  89.     public void testUserDao() {  
  90.         List<User> list = userDao.getAll();  
  91.         for (User user : list) {  
  92.             System.out.println(user);  
  93.         }  
  94.     }  
  95.   
  96.     @Test  
  97.     /** 
  98.      * 用来测试业务层的代码是否正确，UserService是否已经成功注入 
  99.      */  
  100.     public void testUserService() {  
  101.         User user = new User("song", 1, new Date(), false);  
  102.         userService.addUser(user);  
  103.     }  
  104.   
  105. }  
然后进行测试，这里有个好处，在模拟的Spring容器中测试对数据库的操作都会进行回滚，其结果如下所示：

testUserDao()

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. ………………  
  2. Hibernate:   
  3.     select  
  4.         user0_.userId as userId0_,  
  5.         user0_.age as age0_,  
  6.         user0_.birthday as birthday0_,  
  7.         user0_.isVip as isVip0_,  
  8.         user0_.userName as userName0_   
  9.     from  
  10.         t_user user0_  
  11. 用户信息： [年龄是1, 生日是2013-12-10 20:39:16.0, 用户编号是1, 用户名是Steven, 是会员]  
  12. 用户信息： [年龄是1, 生日是2013-12-10 21:24:08.0, 用户编号是2, 用户名是Lily, 不是会员]  
  13. 用户信息： [年龄是1, 生日是2013-12-10 21:24:23.0, 用户编号是3, 用户名是Tom, 不是会员]  
  14. …………  

testUserService()

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. …………Hibernate:   
  2.     insert   
  3.     into  
  4.         t_user  
  5.         (age, birthday, isVip, userName)   
  6.     values  
  7.         (?, ?, ?, ?)  
  8. 2013-12-14 12:54:08 org.springframework.test.context.transaction.TransactionalTestExecutionListener endTransaction  
  9. 信息: Rolled back transaction after test execution for test context [TestContext@15d45d9 testClass = SpringTest, testInstance = com.steven.test.SpringTest@94aa42, testMethod = testUserService@SpringTest, testException = [null], mergedContextConfiguration = [MergedContextConfiguration@35dc95 testClass = SpringTest, locations = '{classpath:/com/steven/test/applicationContext.xml}', classes = '{}', contextInitializerClasses = '[]', activeProfiles = '{}', contextLoader = 'org.springframework.test.context.support.DelegatingSmartContextLoader', parent = [null]]]  

             注：在这个过程中思路是首先在没有更改任何代码和配置的时候，测试方法的运行会报java.lang.NullPointerException异常，然后原因是没有Spring容器的环境，加了Spring-test jar包，配置注解@RunWith后，如果没有将applicationContext.xml拷贝到com.steven.test目录下，会报class path resource [com/steven/test/applicationContext.xml] cannot be opened because it does not exist异常，然后拷贝后，增加注解@ContextConfiguration，如果没有配置事务，会报No bean named 'transactionManager' is defined异常，这个时候加入配置，增加注解@Transactional即可解决这些个异常。

    测试方法的执行过程：当运行JUnit测试方法userService.addUser(user)时候，我们可以看看这个逆过程，运行方法，必须对象要实例化，然后通过SpringTest类中IUserService userService进行@Autowired的配置，自动按照类型注入一个UserService(因为此类使用@Service注解)对象，然后再看UserService.java中IUserDao userDao进行@Autowired的配置，那就自动按照类型注入一个实现类UserDao(因为此类使用@Repository注解)的对象，而UserDao中的方法都被BaseDao实现，而且BaseDao总sessionFactory又是通过Autowired的，然后Spring的配置文件中又有sessionFactory的Id，所以可以自动获取到，这就是这个逆过程，其实是Spring容器启动的时候，这些资源都会被自动注入，然后在使用的时候就可以不需要new了，全部都有Spring容器代理，IOC的精髓也就在这里了。

    有可能在自己搭建的过程中还会遇到其他的异常，那个时候就要好好进行分析，可以google一下，或者百度一下，将问题的实质搞清楚，理解了这些原理后，应该很容易就会找到解决方案，如果按照我的步骤下来，排除自身放错位置，写错文件的问题外，是不会出现异常的，而且可能的异常我都写出来了。所以在这个过程中，大家要留心一些。

    如果有什么我可能没有发现的异常，大家也可以提出来，这样的话，我可以进行修改或者增强文章的可读性，如果我有什么错误的地方，或者由于自己的理解有些偏差，文字的叙述没有清楚，也请大家指出，整合Spring过程真心不简单，我考虑东西一多，就失去了文章的简洁性，引入的东西越多，越会造成大家知识的疯狂补充，会造成阅读理解的困难，所以在文章中我尽量对于一些知识点提一下，然后具体的实现可以参照其他人的博文，或者日后我会给出相应的补充博文介绍，这样对于懂原理的人来说不会因为一些与搭建框架无关的东西而浪费时间，也不会让初学者感到很困惑，东西那么多，什么时候是个头才能学完。

    Spring的事务管理机制，这里仅仅提供配置，具体的介绍可以参照其他博文，因为Spring事务管理也是很重要的东西，下面需要更改配置applicationContext.xml进行简单的事务管理，从而使在对数据库操作的过程中，如果遇到问题，就会回滚之前的操作，不会出现误操作的过程。这个过程中将用到Spring另外一个比较重要的特性，AOP(面向切面编程)，这个本质是Java的动态代理机制，具体的动态代理介绍，请参照我的动态代理机制讲解的博文或者其他人动态代理机制讲解的博文。此时applicationContext.xml的内容如下所示：
applicationContext.xml

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
  4.     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans  
  6.            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
  7.            http://www.springframework.org/schema/context  
  8.            http://www.springframework.org/schema/context/spring-context-3.2.xsd  
  9.            http://www.springframework.org/schema/aop  
  10.            http://www.springframework.org/schema/aop/spring-aop-3.2.xsd  
  11.            http://www.springframework.org/schema/tx   
  12.            http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">  
  13.     <context:annotation-config />  
  14.     <context:component-scan base-package="com.steven" />  
  15.     <!-- 用来格式化日期属性 -->  
  16.     <bean id="dateFormat" class="java.text.SimpleDateFormat">  
  17.         <constructor-arg value="yyyy-MM-dd" />  
  18.     </bean>  
  19.     <!-- 通过手动配置 xml 实现 spring IOC -->  
  20.     <bean id="user" class="com.steven.entity.User">  
  21.         <property name="userId" value="1" />  
  22.         <property name="userName" value="Steven" />  
  23.         <property name="birthday">  
  24.             <bean factory-bean="dateFormat" factory-method="parse">  
  25.                 <constructor-arg value="1990-01-01" />  
  26.             </bean>  
  27.         </property>  
  28.         <property name="age" value="23" />  
  29.         <property name="isVip" value="true" />  
  30.     </bean>  
  31.   
  32.     <!-- 通过spring配置取代hibernate.cfg.xml -->  
  33.     <bean  
  34.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
  35.         <property name="locations">  
  36.             <value>classpath:jdbc.properties</value>  
  37.         </property>  
  38.     </bean>  
  39.     <!-- 配置数据库连接所需要的基本信息 -->  
  40.     <bean id="dataSource"  
  41.         class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
  42.         <property name="driverClassName" value="${jdbc.driverClassName}" />  
  43.         <property name="url" value="${jdbc.url}" />  
  44.         <property name="username" value="${jdbc.username}" />  
  45.         <property name="password" value="${jdbc.password}" />  
  46.     </bean>  
  47.   
  48.     <!-- 配置sessionFactory -->  
  49.     <bean id="sessionFactory"  
  50.         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">  
  51.         <property name="dataSource" ref="dataSource" />  
  52.         <property name="packagesToScan">  
  53.             <list>  
  54.                 <value>com.steven</value>  
  55.             </list>  
  56.         </property>  
  57.         <property name="hibernateProperties">  
  58.             <props>  
  59.                 <prop key="hibernate.dialect">  
  60.                     org.hibernate.dialect.MySQLDialect  
  61.                 </prop>  
  62.                 <prop key="hibernate.show_sql">true</prop>  
  63.                 <prop key="hibernate.format_sql">true</prop>  
  64.                 <prop key="hibernate.current_session_context_class">org.springframework.orm.hibernate4.SpringSessionContext  
  65.                 </prop>  
  66.             </props>  
  67.         </property>  
  68.     </bean>  
  69.   
  70.     <!-- 配置事物 -->  
  71.     <bean id="transactionManager"  
  72.         class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
  73.         <property name="sessionFactory" ref="sessionFactory" />  
  74.     </bean>  
  75.   
  76.     <!--  
  77.         PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。  
  78.         PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。  
  79.         PROPAGATION_MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。  
  80.         PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。  
  81.         PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。  
  82.         PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。  
  83.         PROPAGATION_NESTED：支持当前事务，如果当前事务存在，则执行一个嵌套事务，如果当前没有事务，就新建一个事务。  
  84.     -->  
  85.   
  86.     <tx:advice id="txAdvice" transaction-manager="transactionManager">  
  87.         <tx:attributes>  
  88.             <tx:method name="get*" read-only="true" propagation="REQUIRED" />  
  89.             <!-- 
  90.                 之前是NOT_SUPPORT 
  91.             -->  
  92.             <tx:method name="find*" read-only="true" propagation="REQUIRED" />  
  93.             <!-- 
  94.                 之前是NOT_SUPPORT 
  95.             -->  
  96.             <tx:method name="save*" propagation="REQUIRED" />  
  97.             <tx:method name="update*" propagation="REQUIRED" />  
  98.             <tx:method name="remove*" propagation="REQUIRED" />  
  99.             <tx:method name="add*" propagation="REQUIRED" />  
  100.             <!--默认其他方法都是REQUIRED-->  
  101.             <tx:method name="*" propagation="REQUIRED" />  
  102.         </tx:attributes>  
  103.     </tx:advice>  
  104.   
  105.     <!-- 事务的AOP配置 -->  
  106.     <aop:config>  
  107.         <!-- 配置一个切入点，匹配UserService的所有方法的执行 -->  
  108.         <!-- 方法一定要写切点类最完整的包路径，否则会出现No Session found for current thread异常 -->  
  109.         <aop:pointcut expression="execution(public * com.steven.service.impl.*.*(..))"  
  110.             id="userPointCut" />  
  111.         <!-- 指定在userpointCut切入点应用txAdvice事务增强处理 -->  
  112.         <aop:advisor advice-ref="txAdvice" pointcut-ref="userPointCut" />  
  113.     </aop:config>  
  114.   
  115. </beans>  

如果此时就运行testUserDao()测试方法，会有以下异常抛出

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. java.lang.IllegalStateException: Failed to load ApplicationContext  
  2.     at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContext(CacheAwareContextLoaderDelegate.java:99)  
  3.     at org.springframework.test.context.TestContext.getApplicationContext(TestContext.java:122)  
  4.     at org.springframework.test.context.web.ServletTestExecutionListener.setUpRequestContextIfNecessary(ServletTestExecutionListener.java:105)  
  5.     at org.springframework.test.context.web.ServletTestExecutionListener.prepareTestInstance(ServletTestExecutionListener.java:74)  
  6.     at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:312)  
  7.     at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTest(SpringJUnit4ClassRunner.java:211)  
  8.     at org.springframework.test.context.junit4.SpringJUnit4ClassRunner$1.runReflectiveCall(SpringJUnit4ClassRunner.java:288)  
  9.     at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)  
  10.     at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.methodBlock(SpringJUnit4ClassRunner.java:284)  
  11.     at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:231)  
  12.     at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:88)  
  13.     at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180)  
  14.     at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41)  
  15.     at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173)  
  16.     at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)  
  17.     at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)  
  18.     at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)  
  19.     at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:71)  
  20.     at org.junit.runners.ParentRunner.run(ParentRunner.java:220)  
  21.     at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:174)  
  22.     at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46)  
  23.     at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)  
  24.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)  
  25.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)  
  26.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)  
  27.     at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)  
  28. Caused by: org.springframework.beans.factory.BeanDefinitionStoreException: Unexpected exception parsing XML document from class path resource [com/steven/test/applicationContext.xml]; nested exception is java.lang.NoClassDefFoundError: org/aopalliance/intercept/MethodInterceptor  
  29.     at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(XmlBeanDefinitionReader.java:412)  
  30.     at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:334)  
  31.     at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:302)  
  32.     at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:174)  
  33.     at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:209)  
  34.     at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:180)  
  35.     at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:243)  
  36.     at org.springframework.test.context.support.AbstractGenericContextLoader.loadBeanDefinitions(AbstractGenericContextLoader.java:233)  
  37.     at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:117)  
  38.     at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:60)  
  39.     at org.springframework.test.context.support.AbstractDelegatingSmartContextLoader.delegateLoading(AbstractDelegatingSmartContextLoader.java:100)  
  40.     at org.springframework.test.context.support.AbstractDelegatingSmartContextLoader.loadContext(AbstractDelegatingSmartContextLoader.java:248)  
  41.     at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContextInternal(CacheAwareContextLoaderDelegate.java:64)  
  42.     at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContext(CacheAwareContextLoaderDelegate.java:91)  
  43.     ... 25 more  
  44. Caused by: java.lang.NoClassDefFoundError: org/aopalliance/intercept/MethodInterceptor  
  45.     at java.lang.ClassLoader.defineClass1(Native Method)  
  46.     at java.lang.ClassLoader.defineClass(ClassLoader.java:621)  
  47.     at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:124)  
  48.     at java.net.URLClassLoader.defineClass(URLClassLoader.java:260)  
  49.     at java.net.URLClassLoader.access$000(URLClassLoader.java:56)  
  50.     at java.net.URLClassLoader$1.run(URLClassLoader.java:195)  
  51.     at java.security.AccessController.doPrivileged(Native Method)  
  52.     at java.net.URLClassLoader.findClass(URLClassLoader.java:188)  
  53.     at java.lang.ClassLoader.loadClass(ClassLoader.java:307)  
  54.     at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)  
  55.     at java.lang.ClassLoader.loadClass(ClassLoader.java:252)  
  56.     at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)  
  57.     at org.springframework.transaction.config.TxAdviceBeanDefinitionParser.getBeanClass(TxAdviceBeanDefinitionParser.java:72)  
  58.     at org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser.parseInternal(AbstractSingleBeanDefinitionParser.java:66)  
  59.     at org.springframework.beans.factory.xml.AbstractBeanDefinitionParser.parse(AbstractBeanDefinitionParser.java:59)  
  60.     at org.springframework.beans.factory.xml.NamespaceHandlerSupport.parse(NamespaceHandlerSupport.java:73)  
  61.     at org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseCustomElement(BeanDefinitionParserDelegate.java:1438)  
  62.     at org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseCustomElement(BeanDefinitionParserDelegate.java:1428)  
  63.     at org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.parseBeanDefinitions(DefaultBeanDefinitionDocumentReader.java:185)  
  64.     at org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions(DefaultBeanDefinitionDocumentReader.java:139)  
  65.     at org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.registerBeanDefinitions(DefaultBeanDefinitionDocumentReader.java:108)  
  66.     at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.registerBeanDefinitions(XmlBeanDefinitionReader.java:493)  
  67.     at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(XmlBeanDefinitionReader.java:390)  
  68.     ... 38 more  
  69. Caused by: java.lang.ClassNotFoundException: org.aopalliance.intercept.MethodInterceptor  
  70.     at java.net.URLClassLoader$1.run(URLClassLoader.java:200)  
  71.     at java.security.AccessController.doPrivileged(Native Method)  
  72.     at java.net.URLClassLoader.findClass(URLClassLoader.java:188)  
  73.     at java.lang.ClassLoader.loadClass(ClassLoader.java:307)  
  74.     at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)  
  75.     at java.lang.ClassLoader.loadClass(ClassLoader.java:252)  
  76.     at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)  
  77.     ... 61 more  
同样，这是缺少附加的jar包造成的，这个时候就需要添加aopalliance-1.0.jar(http://mirrors.ibiblio.org/pub/mirrors/maven/aopalliance/jars/aopalliance-1.0.jar)，aspectjweaver-1.7.0.jar(http://ishare.iask.sina.com.cn/download/explain.php?fileid=13433573)两个jar包，主要在Spring AOP时候所要用到的包。然后在执行测试方法，就不会抛出异常了。

    下面可以通过一个实例来讲解AOP的具体效果，因为我们有了Service层，为什么要有此层，项目中大家经常会遇到一个场景，就是在进行处理正常的业务逻辑的时候，需要添加一些固定的项目日志，大家可以认为，最多就在每个处理类中写日志不就行了吗，但如果项目很大，而且日志都是冗余的，也就是说日志内容都是规定的，那么在这个过程中除了白费力气，而且浪费很多的时间写日志，而AOP的思想就是，通过动态代理机制，日志只要写完一遍当做模板，以后所有的处理类中，都可以进行复用，而且都可以在处理操作的过程前，后，过程中添加日志，这样就好似你去酒店住宿，在之前之后都会有人帮你清扫房间，而这些都是与你有关，而不是你所控制的，都是酒店分配好了。这里也是，在处理类执行前先执行日志，然后处理完的时候在执行日志，代码还是原来的代码，但执行的效果却增加了日志处理的操作，就是在你正常的业务操作中切入了日志的操作，这就是AOP(面向切面编程)的简单理解。其本质就是动态代理机制。

    AOP面向切面可以通过两种方式实现，同样是配置和注解，我给出两种方式，都可以进行，下面给出手动配置的时候需要在applicationContext中添加的配置内容

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <!-- 声明日志切面类 -->  
  2.     <bean id="logAspectBean" class="com.steven.aop.LogAspect"></bean>  
  3.   
  4.     <!-- 日志切面的AOP实现 -->  
  5.     <aop:config>  
  6.         <!-- 配置一个切入点，匹配UserService的所有方法的执行 -->  
  7.         <aop:aspect id="logAspect" ref="logAspectBean">  
  8.             <!-- 方法一定要写切点类最完整的包路径，否则会出现No Session found for current thread异常 -->  
  9.             <aop:pointcut expression="execution(public * com.steven.service.impl.*.*(..))"  
  10.                 id="allMethod" />  
  11.             <!-- 应用前置通知 -->  
  12.             <aop:before method="before" pointcut-ref="allMethod" />  
  13.             <!-- 应用后置通知 -->  
  14.             <aop:after-returning method="afterReturn"  
  15.                 pointcut-ref="allMethod" />  
  16.             <!-- 应用最终通知 -->  
  17.             <aop:after method="after" pointcut-ref="allMethod" />  
  18.             <!-- 应用抛出异常后通知 -->  
  19.             <aop:after-throwing method="afterThrowing"  
  20.                 pointcut-ref="allMethod" />  
  21.         </aop:aspect>  
  22.     </aop:config>  
或者可以进行如下配置：

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <!-- 声明日志切面类 -->  
  2.     <bean id="logAspectBean" class="com.steven.aop.LogAspect"></bean>  
  3.   
  4.     <aop:config>  
  5.         <!-- 配置一个切面 -->  
  6.         <aop:aspect id="logAspect" ref="logAspectBean">  
  7.             <!-- 定义切入点,指定切入点表达式 -->  
  8.             <aop:pointcut id="allMethod"  
  9.                 expression="execution(public * com.steven.service.impl.*.*(..))" />  
  10.             <!-- 应用环绕通知 -->  
  11.             <aop:around method="doAround" pointcut-ref="allMethod" />  
  12.         </aop:aspect>  
  13.     </aop:config>  
此时的切面类LogAspect.java如下所示：

LogAspect.java

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.steven.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.ProceedingJoinPoint;  
  5.   
  6. /** 
  7.  * 日志切面类 
  8.  *  
  9.  * @author Steven 
  10.  *  
  11.  */  
  12. public class LogAspect {  
  13.     // 定义切入点，提供一个方法，这个方法的名字就是改切入点的id  
  14.     @SuppressWarnings("unused")  
  15.     private void allMethod() {  
  16.     }  
  17.   
  18.     // 任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型  
  19.     public void before(JoinPoint call) {  
  20.         String clazz = call.getTarget().getClass().getName();  
  21.         // 获取目标对象上正在执行的方法名  
  22.         String methodName = call.getSignature().getName();  
  23.         System.out.println("前置通知:" + clazz + "类的" + methodName + "方法开始了...");  
  24.     }  
  25.   
  26.     // 访问命名切入点来应用后置通知  
  27.     public void afterReturn() {  
  28.         System.out.println("后置通知:方法正常结束...");  
  29.     }  
  30.   
  31.     // 应用最终通知  
  32.     public void after() {  
  33.         System.out.println("最终通知:不管方法有没有正常执行完成，一定会返回的...");  
  34.     }  
  35.   
  36.     // 应用异常抛出后通知  
  37.     public void afterThrowing() {  
  38.         System.out.println("异常抛出后通知:方法执行时出现异常...");  
  39.     }  
  40.   
  41.     // 应用周围通知  
  42.     // @Around("allMethod()")  
  43.     // 用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型  
  44.     public Object doAround(ProceedingJoinPoint call) throws Throwable {  
  45.         Object result = null;  
  46.         this.before(call);// 相当于前置通知  
  47.         try {  
  48.             result = call.proceed();  
  49.             this.afterReturn(); // 相当于后置通知  
  50.         } catch (Throwable e) {  
  51.             this.afterThrowing(); // 相当于异常抛出后通知  
  52.             throw e;  
  53.         } finally {  
  54.             this.after(); // 相当于最终通知  
  55.         }  
  56.         return result;  
  57.     }  
  58. }  
如果全部用注解的方式，则只要添加如下配置：

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <bean id="logAspectAnnotationBean" class="com.steven.aop.LogAspectAnnotation"></bean>  
  2. <!-- 启用spring对AspectJ注解的支持 -->     
  3. <aop:aspectj-autoproxy />  

这个时候对应的LogAspectAnnotation.java代码如下：

LogAspectAnnotation.java

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.steven.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.ProceedingJoinPoint;  
  5. import org.aspectj.lang.annotation.After;  
  6. import org.aspectj.lang.annotation.AfterReturning;  
  7. import org.aspectj.lang.annotation.AfterThrowing;  
  8. import org.aspectj.lang.annotation.Aspect;  
  9. import org.aspectj.lang.annotation.Before;  
  10. import org.aspectj.lang.annotation.Pointcut;  
  11.   
  12. /** 
  13.  * 日志切面类 
  14.  *  
  15.  * @author Steven 
  16.  *  
  17.  */  
  18. @Aspect  
  19. public class LogAspectAnnotation {  
  20.     // 定义切入点，提供一个方法，这个方法的名字就是改切入点的id  
  21.     @SuppressWarnings("unused")  
  22.     @Pointcut("execution(* com.steven.service.impl.*.*(..))")  
  23.     private void allMethod() {  
  24.     }  
  25.   
  26.     // 任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型  
  27.     @Before("execution(* com.steven.service.impl.*.*(..))")  
  28.     public void before(JoinPoint call) {  
  29.         String clazz = call.getTarget().getClass().getName();  
  30.         // 获取目标对象上正在执行的方法名  
  31.         String methodName = call.getSignature().getName();  
  32.         System.out.println("前置通知:" + clazz + "类的" + methodName + "方法开始了...");  
  33.     }  
  34.   
  35.     // 访问命名切入点来应用后置通知  
  36.     @AfterReturning("allMethod()")  
  37.     public void afterReturn() {  
  38.         System.out.println("后置通知:方法正常结束...");  
  39.     }  
  40.   
  41.     // 应用最终通知  
  42.     @After("allMethod()")  
  43.     public void after() {  
  44.         System.out.println("最终通知:不管方法有没有正常执行完成，一定会返回的...");  
  45.     }  
  46.   
  47.     // 应用异常抛出后通知  
  48.     @AfterThrowing("allMethod()")  
  49.     public void afterThrowing() {  
  50.         System.out.println("异常抛出后通知:方法执行时出现异常...");  
  51.     }  
  52.   
  53.     // 应用周围通知  
  54.     // @Around("allMethod()")  
  55.     // 用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型  
  56.     public Object doAround(ProceedingJoinPoint call) throws Throwable {  
  57.         Object result = null;  
  58.         this.before(call);// 相当于前置通知  
  59.         try {  
  60.             result = call.proceed();  
  61.             this.afterReturn(); // 相当于后置通知  
  62.         } catch (Throwable e) {  
  63.             this.afterThrowing(); // 相当于异常抛出后通知  
  64.             throw e;  
  65.         } finally {  
  66.             this.after(); // 相当于最终通知  
  67.         }  
  68.         return result;  
  69.     }  
  70. }  

此时的项目结构图如图11所示：


          图11

这个时候在执行testUserService()方法的时候，控制台出现以下结果：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. ……………………  
  2. 前置通知:com.steven.service.impl.UserService类的addUser方法开始了...  
  3. Hibernate:   
  4.     insert   
  5.     into  
  6.         t_user  
  7.         (age, birthday, isVip, userName)   
  8.     values  
  9.         (?, ?, ?, ?)  
  10. 最终通知:不管方法有没有正常执行完成，一定会返回的...  
  11. 后置通知:方法正常结束...  
  12. …………………………  
说明面向切面的日志切面已经成功起作用。

这个时候就完成了IOC和AOP的完全降解，下面将对Struts，Hibernate，Spring进行全方位的整合。

下面对UserAction.java通过注入Ioc的方式注入UserService对象，

UserAction.java

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.steven.action;  
  2.   
  3. import java.util.List;  
  4. import java.util.Map;  
  5.   
  6. import org.apache.struts2.interceptor.RequestAware;  
  7. import org.springframework.beans.factory.annotation.Autowired;  
  8.   
  9. import com.opensymphony.xwork2.ActionSupport;  
  10. import com.steven.entity.User;  
  11. import com.steven.service.iface.IUserService;  
  12.   
  13. /** 
  14.  * 通过继承ActionSupport获得Struts2的已有功能， 
  15.  * 通过实现RequestAware获取request(这种方式常用，还有其他三种方式，这里不再赘述) 
  16.  * 四种获取request方式请参照http://blog.csdn.net/ms2146/article/details/5406004 
  17.  *  
  18.  * @author Steven 
  19.  *  
  20.  */  
  21. public class UserAction extends ActionSupport implements RequestAware {  
  22.     private static final long serialVersionUID = 1L;  
  23.     private Map<String, Object> request;  
  24.     // private UserDao userDao = new UserDao();  
  25.     @Autowired  
  26.     private IUserService userService;  
  27.   
  28.     @Override  
  29.     public String execute() throws Exception {  
  30.         // userDao.insert(new User("Lily", 1, new Date(), false));  
  31.         // userDao.insert(new User("Tom", 1, new Date(), false));  
  32.         // 创建一个用户集合  
  33.         List<User> userList = userService.getAll();  
  34.         // 创建用户并添加到用户集合中  
  35.         // userList.add(new User("Steven", 1, new Date(), true));  
  36.         // userList.add(new User("Lily", 1, new Date(), false));  
  37.         // userList.add(new User("Tom", 1, new Date(), false));  
  38.   
  39.         // 将用户存储到ActionContext中(可以通过ognl表达式获取)  
  40.         request.put("userList", userList);  
  41.         return SUCCESS;  
  42.     }  
  43.   
  44.     public void setRequest(Map<String, Object> request) {  
  45.         this.request = request;  
  46.     }  
  47.   
  48. }  
这个时候就可以启动服务器，然后看看加上Struts2的效果了，但此时会报如下异常,如图12所示：


                                              图12

    这个异常是在action层出现的，是说userService为空，但之前JUnit中不是没有任何异常吗，但不要忘记了前提是将测试的环境注解成了Spring容器的环境，而此时整合了Struts2，但Spring仅仅是代码中写到，而具体在服务器启动的时候，Struts加载时候，却没有加载Spring，所以这个时候Spring就没有了环境，所有的bean都为空值，所以就报了这个空指针异常。

    解决方法如下：首先将struts-2.3.1\lib\struts2-spring-plugin-2.3.1.jar路径下的jar包拷到lib路径下，然后将web.xml文件更改如下：

web.xml

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
  5.   
  6.     <!-- Struts2过滤器，将所有的请求进行拦截并进行处理 -->  
  7.     <filter>  
  8.         <filter-name>struts2</filter-name>  
  9.         <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
  10.     </filter>  
  11.   
  12.     <filter-mapping>  
  13.         <filter-name>struts2</filter-name>  
  14.         <url-pattern>/*</url-pattern>  
  15.     </filter-mapping>  
  16.   
  17.     <!-- 用来将spring在服务器启动的时候交给struts2 -->  
  18.     <listener>  
  19.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  20.     </listener>  
  21.   
  22.     <context-param>  
  23.         <param-name>contextConfigLocation</param-name>  
  24.         <param-value>WEB-INF/classes/applicationContext.xml</param-value>  
  25.     </context-param>  
  26.   
  27.     <welcome-file-list>  
  28.         <welcome-file>index.jsp</welcome-file>  
  29.     </welcome-file-list>  
  30.   
  31. </web-app>  

这个时候进行重新启动服务器，打开首页后，点击这里，就可以出现以下界面了,如图13所示：


                                             图13

此时后台的运行结果为：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. 前置通知:com.steven.service.impl.UserService类的getAll方法开始了...  
  2. Hibernate:   
  3.     select  
  4.         user0_.userId as userId0_,  
  5.         user0_.age as age0_,  
  6.         user0_.birthday as birthday0_,  
  7.         user0_.isVip as isVip0_,  
  8.         user0_.userName as userName0_   
  9.     from  
  10.         t_user user0_  
  11. 最终通知:不管方法有没有正常执行完成，一定会返回的...  
  12. 后置通知:方法正常结束...  

到此，SSH已经全部整合完成。

    再来回顾一下整个整合过程，Struts2用来对整个请求和相应的处理，Hibernate对数据库的关系和对象的映射，Spring对全局bean的管理和事务机制，对model进行控制。在这个过程中遇到异常是很正常的现象，但如果能够知道异常产生的原因和解决的方法，那么就可以在使用中随心所欲的使用这SSH带来的好处，但其弊端也很明显，配置太麻烦，效率都要自己进行把关。在开发中SSH的使用很普遍，但仅仅使用Spring或者Hibernate也是存在的，Struts2依赖web容器，而Spring，Hibernate没有这个问题，可以单独使用，所以项目中具体如何搭配，都要看具体的问题具体的分析。

    在此恭祝大家学习愉快！

转至：http://blog.csdn.net/songdeitao/article/details/17288473

拥有必珍惜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Spring 框架详解
qq_41803426的博客
01-11 6751
文章目录1 Spring入门1.1 Spring 简介1.1.1 Spring的由来1.1.2 Spring的优点1.1.3 Spring的体系结构1.2 Spring 开发环境1.2.1 环境准备1.2.2 创建 Spring 工程1.3 使用IDEA开发 Spring 入门程序2 Spring IoC2.1 Spring IoC 的基本概念2.2 Spring IoC 容器2.2.1 BeanFactory2.2.2 ApplicationContext3 Spring Bean4 Spring AOP
JavaEE知识体系
热门推荐
yuh2012的博客
07-11 2万+
1 1.文件上传下载 1.1 文件上传 1.1.1 文件上传的作用 例如网络硬盘！就是用来上传下载文件的。 在智联招聘上填写一个完整的简历还需要上传照片呢。 1.1.2 文件上传对页面的要求 1.必须使用表单，而不能是超链接； 2.表单的method必须是POST，而不能是GET； 3.表单的enctype必须是multipart/form-data； 4.在表单中添加file表
Spring Web框架与Struts的区别
维仔的专栏
07-20 511
下面是从struts的角度来谈谈spring自带的web框架的使用。当然，我们在配置web框架前，需要把spring配置好，这里就不多说了。 1.web框架核心servlet在web.xml中的配置。  Dispatcher org.springframework.web.servlet.DispatcherServlet   contextConfigLocation  /W
struts-2.3.1+spring-framework-3.2.2+hibernate-4.1.1整合历程<第一部分>(详解)
chuifuhuo6864的博客
07-29 106
从事JavaEE工作已经许久了，在这个期间学习了很多的知识，也熟练了很多之前总是语罢于嘴的技术，在这个过程中收获着很多的东西，但是由于现在工作的局限性，很多之前学止于书的技术都渐渐忘却，在整理这篇文章的时候，一则出于对知识的回顾，因此可以作为刚学习SSH搭建的程序员参考资料，二则在搭建...
struts-2.3.1+spring-framework-3.2.2+hibernate-4.1.1整合历程<第二部分>(详解)
chuifuhuo6864的博客
07-29 99
第一部分讲解了Struts2的建立过程，这部分将在其基础上完成Hibernate的整合。 Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在...
Java进阶诀窍
张天疯的专栏
02-19 1909
 第1章  Java应用运行及开发环境的搭建 31.1  Windows下Java开发环境的配置 31.1.1  概述 31.1.2  相关软件介绍 31.1.3  Tomcat的基本配置 81.1.4  J2EE的相关部署规范 91.1.5  Tomcat体系结构 101.2  Eclipse的安装和使用 111.2.1  Eclipse的下载和安装 111.2.2  MyEclipse的下载和
JavaEE
zhujianing的博客
01-18 3535
浙江工业大学 JAVAEE实验报告                   姓名：朱佳柠             目录 个人总结：... 3 1       实验一：Struts基础... 6 1.1
java学习笔记
Spring的博客
05-06 9036
这是我学习的笔记，与大家共勉。
struts-2.3.1+spring3.1.1+hibernate3.6.9整合&配置文件
04-02
这个压缩包文件"struts-2.3.1+spring3.1.1+hibernate3.6.9整合&配置文件"提供了将这三个框架整合使用的配置和依赖。下面我们将详细讨论这三个框架以及它们的整合过程。 **Struts 2** 是一个基于MVC设计模式的Java ...
jaxb-api-2.3.1-API文档-中文版.zip
04-23
赠送jar包：jaxb-api-2.3.1.jar； 赠送原API文档：jaxb-api-2.3.1-javadoc.jar； 赠送源代码：jaxb-api-2.3.1-sources.jar； 赠送Maven依赖信息文件：jaxb-api-2.3.1.pom； 包含翻译后的API文档：jaxb-api-2.3.1-...
nanohttpd-2.3.1.jar
08-24
nanohttpd-2.3.1.jar最新版java http服务器
搞定J2EE：STRUTS+SPRING+HIBERNATE整合详解与典型案例 (1)
09-04
12.6 整合Struts、Spring和Hibernate实现用户管理 12.6.1 Struts、Spring和Hibernate的整合方式 12.6.2 编写用户注册画面regedit.jsp 12.6.3 编写用户登录画面login.jsp 12.6.4 编写注册控制器RegeditAction.java ...
xxl-job-2.3.1
06-19
XXL-JOB是一个分布式任务调度平台，主要由调度中心（XXL-JOB-SCHEDULER）和执行器（XXL-JOB-EXECUTOR）两部分组成。版本2.3.1是该平台的一个稳定版本，提供了丰富的功能和优化，旨在帮助开发者实现简单、高效且可...
深入探索Stage #2：属性中的XSS注入技术
weixin_43822401的博客
06-04 676
在Web安全的学习旅程中，XSS（跨站脚本）注入是一个不可忽视的话题。"XSS Challenges"闯关游戏的Stage #2专为进阶学习者设计，专注于属性中的XSS注入技术。本文将详细介绍这一阶段的实操过程和关键概念。
java springboot 集成 阿里通义千问
qq_25987725的博客
07-25 386
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
【过滤器 vs 拦截器】SpringBoot中过滤器与拦截器：明智选择的艺术（如何在项目中做出明智选择）
weixin_68020300的博客
07-25 1079
本文深入剖析了SpringBoot框架下过滤器与拦截器的核心差异及应用场景，指导开发者在面对请求-响应周期中的不同需求时，如何做出最佳技术选择。无论是实现安全性、日志记录，还是权限控制与数据预处理，本文都将帮助你理解何时何地使用过滤器或拦截器，以构建更加高效、可维护的Web应用程序。通过对比二者的特性与优劣，本文旨在赋能开发者，使其在实际项目中灵活运用这两种强大工具，达成项目目标。
【Spring Framework】使用完全注解方式开发
最新发布
u013675821的博客
07-26 1016
本文介绍了如何使用 Spring 完全注解化的方式来进行开发。通过使用注解，我们可以减少 XML 配置文件的使用，使项目的配置更加直观和简洁。配置类：使用@Bean等注解定义配置类。数据库配置：使用DataSource以及@Autowired自动装配数据源。服务层和控制器层：使用@Service和注解定义业务逻辑和控制器，并使用@Autowired注入依赖。AOP 和事务管理：通过@Aspect和注解实现日志记录和事务管理。
<dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter-test</artifactId> <version>2.3.1</version> <scope>test</scope>
07-14
对于 MyBatis 2.3.1 版本的 Spring Boot 工程，如果你想在测试中使用 MyBatis，可以添加以下依赖： ```xml <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter-test</artifactId> <version>2.3.1</version> <scope>test</scope> </dependency> ``` 这个依赖是用于在测试环境中集成 MyBatis 和 Spring Boot 的，它提供了一些用于测试的工具类和配置。通过在测试类中使用这些工具类，你可以方便地进行 MyBatis 相关的单元测试。 需要注意的是，这个依赖的作用范围（scope）被设置为 test，这意味着它只会在测试环境中生效，不会被包含在实际部署的应用程序中。这样可以避免将测试相关的依赖引入到生产环境中。 请确保在你的 pom.xml 文件中添加了正确的依赖配置，并执行 Maven 构建以下载并安装相应的依赖。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值