2十3十4=320则<1=
点击联系发帖人
时间：2016-09-16 23:18
struts-2.3.1+spring-framework-3.2.2+hibernate-4.1.1整合历程&第三部分&(详解)
在前两部分的编写中，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
&?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.2.xsd">
有警告信息不要担心，可以将配置文件关闭后重新打开警告信息将会消失。此时可以写一个测试类完成Spring是否成功配置的测试，在test下com.steven.test新建一个SpringTest.java的类， SpringTest.java代码如下所示： package com.steven.import org.junit.Timport org.springframework.context.ApplicationCimport org.springframework.context.support.ClassPathXmlApplicationC/** * 用来进行Spring的测试类 *
* @author Steven *
*/public class SpringTest { @Test /**
* 用来测试是否Spring导入成功，配置成功
*/ public void testSpring() {
ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(appContext); }} 其中ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");依旧来自Spring文档，如图6所示： 图6 此时进行JUnit测试，但运行中会出现一个异常，具体如下所示: java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory at org.springframework.context.support.AbstractApplicationContext.(AbstractApplicationContext.java:164) at org.springframework.context.support.AbstractRefreshableApplicationContext.(AbstractRefreshableApplicationContext.java:89) at org.springframework.context.support.AbstractRefreshableConfigApplicationContext.(AbstractRefreshableConfigApplicationContext.java:58) at org.springframework.context.support.AbstractXmlApplicationContext.(AbstractXmlApplicationContext.java:61) at org.springframework.context.support.ClassPathXmlApplicationContext.(ClassPathXmlApplicationContext.java:136) at org.springframework.context.support.ClassPathXmlApplicationContext.(ClassPathXmlApplicationContext.java:83) at com.steven.test.SpringTest.testSpring(SpringTest.java:19) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20) at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28) at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:73) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:46) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41) at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173) at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28) at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31) at org.junit.runners.ParentRunner.run(ParentRunner.java:220) at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46) at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)Caused by: java.lang.ClassNotFoundException: mons.logging.LogFactory at java.net.URLClassLoader$1.run(URLClassLoader.java:200) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(URLClassLoader.java:188) at java.lang.ClassLoader.loadClass(ClassLoader.java:307) at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301) at java.lang.ClassLoader.loadClass(ClassLoader.java:252) at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320) ... 31 more 这个异常是缺少mons.logging.LogFactory这个类，所以要解决就要下载commons-logging-1.1.1.jar这个jar包（http://ishare..cn/download/explain.php?fileid=），然后添加到lib路径下，此时再次运行，会出现以下结果，表示开始的导入和配置成功。 22:54:00 org.springframework.context.support.AbstractApplicationContext prepareRefresh信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1d225a7: startup date [Thu Dec 12 22:54:00 CST 2013]; root of context hierarchy 22:54:01 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions信息: Loading XML bean definitions from class path resource [applicationContext.xml] 22:54:02 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons信息: 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 hierarchyorg.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 &?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.2.xsd">
此时测试类如下所示， SpringTest.java package com.steven.import org.junit.Timport org.springframework.context.ApplicationCimport org.springframework.context.support.ClassPathXmlApplicationCimport org.springframework.context.support.FileSystemXmlApplicationCimport com.steven.entity.U/** * 用来进行Spring的测试类 *
* @author Steven *
*/public class SpringTest { @Test /**
* 用来测试是否Spring导入成功，配置成功
*/ public void testSpring() {
// ApplicationContext appContext = new
// ClassPathXmlApplicationContext("applicationContext.xml");
ApplicationContext appContext = new FileSystemXmlApplicationContext(
new String[] { "src/applicationContext.xml" });
System.out.println(appContext); } @Test /**
* 通过IOC方式进行获取Spring容器代理生成的User对象
*/ public void testGetUser() {
ApplicationContext ac = new ClassPathXmlApplicationContext(
"applicationContext.xml");
User user = (User) ac.getBean("user");
System.out.println(user); }} 然后执行JUnit测试，运行结果如下所示： 22:04:00 org.springframework.context.support.AbstractApplicationContext prepareRefresh信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1d225a7: startup date [Fri Dec 13 22:04:00 CST 2013]; root of context hierarchy 22:04:00 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions信息: Loading XML bean definitions from class path resource [applicationContext.xml] 22:04:00 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons信息: 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用户信息： [年龄是23, 生日是Mon Jan 01 00:00:00 CST 1990, 用户编号是1, 用户名是Steven, 是会员] 此时配置的用户信息已经打印出来。这个时候我们来看看发生了什么事情了，通过ac.getBean("user")获得了配置中的User对象，其实是当Spring容器启动的时候就会对配置文件进行解析，在配置文件中有的节点，就会根据中的内容通过一系列Spring内部操作获得一个key为user的对象User，其实是通过java的反射机制创建User的对象，而且还是无参构造，如果将User中的无参构造去掉，或者写一个有参构造，这时候执行就会报以下的异常：org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'user' defined in class path resource [applicationContext.xml]: Instanti nested exception is org.springframework.beans.BeanInstantiationException: Could not instantiate bean class [com.steven.entity.User]: No defau nested exception is java.lang.NoSuchMethodException: com.steven.entity.User.() at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateBean(AbstractAutowireCapableBeanFactory.java:1013) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:959) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:490) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:461) at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:295) at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:223) at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:292) at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:194) at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:626) at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:932) at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:479) at org.springframework.context.support.ClassPathXmlApplicationContext.(ClassPathXmlApplicationContext.java:139) at org.springframework.context.support.ClassPathXmlApplicationContext.(ClassPathXmlApplicationContext.java:83) at com.steven.test.SpringTest.testGetUser(SpringTest.java:36) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20) at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28) at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:73) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:46) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41) at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173) at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28) at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31) at org.junit.runners.ParentRunner.run(ParentRunner.java:220) at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46) at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)Caused by: org.springframework.beans.BeanInstantiationException: Could not instantiate bean class [com.steven.entity.User]: No defau nested exception is java.lang.NoSuchMethodException: com.steven.entity.User.() at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:83) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateBean(AbstractAutowireCapableBeanFactory.java:1006) ... 37 moreCaused by: java.lang.NoSuchMethodException: com.steven.entity.User.() at java.lang.Class.getConstructor0(Class.java:2706) at java.lang.Class.getDeclaredConstructor(Class.java:1985) at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:78) ... 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 &?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.2.xsd">
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
classpath:jdbc.properties
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
com.steven
org.hibernate.dialect.MySQLDialect
org.springframework.orm.hibernate4.SpringSessionContext
此时将不再需要hibernate.cfg.xml的配置文件，但这时候添加了jdbc.properties的资源文件，项目结构图如图8所示： 图8 jdbc.properties的内容如下： jdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc/:mysql/://localhost/:3306/stevenjdbc.username=rootjdbc.password=mysqladmin 到底是否已经将hibernate.cfg.xml配置文件取代，此时可以通过测试查看，在SpringTest.java中添加如下的测试方法:@Test /**
* 通过spring配置文件替代hibernate配置文件，测试是否成功
*/ public void testUser() {
//获取spring容器上下文
ApplicationContext ac = new ClassPathXmlApplicationContext(
"applicationContext.xml");
//获取配置文件中的session工厂(通过Spring的控制反转)
SessionFactory sessionFactory = (SessionFactory) ac
.getBean("sessionFactory");
//获取session(连接)
Session session = sessionFactory.openSession();
//通过hibernate方式的获取
User user = (User) session.get(User.class, 1);
//打印获取信息F
System.out.println(user); } 然后执行JUnit测试，此时的执行效果如下所示：……………………………………………………………………………………Hibernate: select user0_.userId as userId0_0_, user0_.age as age0_0_, user0_.birthday as birthday0_0_, user0_.isVip as isVip0_0_, user0_.userName as userName0_0_ from t_user user0_ where user0_.userId=?用户信息： [年龄是1, 生日是 20:39:16.0, 用户编号是1, 用户名是Steven, 是会员] 所以此时可以断定，SessionFactory已经通过Spring容器获取，而Hibernate的配置文件已经被Spring配置文件替代，所以这个时候可以说是Hibernate已经和Spring整合。 既然Hibernate已经整合进了Spring，那么就可以利用Spring的控制反转来替代Hibernate时候对于Dao类编写时候不必要的冗余代码。 在实现Hibernate和Spring的完全整合的时候，可以通过注解的方式进行，此时需要在applicationContext.xml中后添加一句，既是注解方式注入对象的时候寻找Spring容器产生的对象是在包的范围下面寻找，此时配置文件添加为：
下面将实施将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 package com.steven.dao.import java.util.Limport org.hibernate.Qimport org.hibernate.Simport org.hibernate.SessionFimport org.springframework.beans.factory.annotation.A/** * 集成hibernate3和spring的时候， * spring的ORM包里提供了HibernateSupport和HibernateTemplate这两个辅助类， * 建议使用HibernateTemplate。 不过在Hibernate4里，spring不再提供这种辅助类，将使用hibernate4的原生API * http://blog.csdn.net/dlutxie/article/details/8771371 *
* @author Steven *
*/public abstract class BaseDao implements IBaseDao { // 具体到哪个实体类的DAO功能 private Class entityC // 自动注入 @Autowired private SessionFactory sessionF /**
* 通过Spring注入的sessionFactory获取session
*/ public Session getSession() {
return this.sessionFactory.getCurrentSession(); } /**
* 当前进行操作的类的实例
* @param entityClass
*/ public BaseDao(Class entityClass) {
this.entityClass = entityC } /**
* 删除操作
*/ public void delete(T t) {
this.getSession().delete(t); } /**
* 获取所有的对象集合
*/ @SuppressWarnings("unchecked") public List getAll() {
String hql = "from " + entityClass.getSimpleName();
Query query = this.getSession().createQuery(hql);
return query.list(); } /**
* 根据Id获取对象的操作
*/ @SuppressWarnings("unchecked") public T getById(int id) {
return (T) this.getSession().get(this.entityClass, id); } /**
* 插入对象操作
*/ public void insert(T t) {
this.getSession().save(t); } /**
* 更新操作
*/ public void update(T t) {
this.getSession().update(t); }} UserDao.java package com.steven.dao.import org.springframework.stereotype.Rimport com.steven.dao.iface.BaseDimport com.steven.dao.iface.IUserDimport com.steven.entity.U/** * UserDao已经继承了BaseDao，其中的所有方法均已经被BaseDao实现 *
* @author Steven *
*///@Component("userDao")@Repository//一定要实现IUserDao这个接口public class UserDao extends BaseDao implements IUserDao { public UserDao() {
super(User.class); }}IUserService.javapackage com.steven.service.import java.util.Limport com.steven.entity.U/** * 业务层 *
* @author Steven *
*/public interface IUserService { /**
* 新增一个用户业务操作
* @param user
*/ public void addUser(User user); /**
* 根据用户Id获取用户操作
* @param userId
*/ public User getUserById(int userId); /**
* 获取所有的用户集合
*/ public List getAll();}UserService.java package com.steven.service.import java.util.Limport org.springframework.beans.factory.annotation.Aimport org.springframework.stereotype.Simport com.steven.dao.iface.IUserDimport com.steven.entity.Uimport com.steven.service.iface.IUserS/** * 具体的业务层实现 */@Servicepublic class UserService implements IUserService { @Autowired private IUserDao userD public void addUser(User user) {
userDao.insert(user); } public User getUserById(int userId) {
return userDao.getById(userId); } public List getAll() {
return userDao.getAll(); }}在上面的代码中用到了几个注解，这里将进行详细讲解 @Repository代表仓库. 一般注解在DAO实现类上, 只要看到这个注解, 就知道这个类是一个跟数据存储有关的类. @Service代表业务实现. 一般注解在Service实现类上. 如果你的类不是以上类型(数据存储类, 业务类), 可以笼统的使用@Component
@Autowire是注入对象的方式，自动注入，默认是按照类型的，此时就是需要，自动在这个包下面进行搜索，搜索不到将会报错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，
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
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 &?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.2.xsd">
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
classpath:jdbc.properties
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
com.steven
org.hibernate.dialect.MySQLDialect
org.springframework.orm.hibernate4.SpringSessionContext
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
这个时候的SpringTest.java如下所示： SpringTest.java package com.steven.import java.util.Dimport java.util.Limport org.hibernate.Simport org.hibernate.SessionFimport org.junit.Timport org.junit.runner.RunWimport org.springframework.beans.factory.annotation.Aimport org.springframework.context.ApplicationCimport org.springframework.context.support.ClassPathXmlApplicationCimport org.springframework.context.support.FileSystemXmlApplicationCimport org.springframework.test.context.ContextCimport org.springframework.test.context.junit4.SpringJUnit4ClassRimport org.springframework.transaction.annotation.Timport com.steven.dao.iface.IUserDimport com.steven.entity.Uimport com.steven.service.iface.IUserS/** * 用来进行Spring的测试类 *
* @author Steven *
*/// 需要额外添加spring-test包// 这个包代表在spring容器中进行测试@RunWith(SpringJUnit4ClassRunner.class)// 这个包代表引入test/com/steven/test/applicationContext.xml文件@ContextConfiguration(locations = "applicationContext.xml")// 这个包代表开启事物，这样可以阻止No Session found for current thread的异常出现@Transactionalpublic class SpringTest { @Autowired private IUserDao userD @Autowired private IUserService userS @Test /**
* 用来测试是否Spring导入成功，配置成功
*/ public void testSpring() {
// ApplicationContext appContext = new
// ClassPathXmlApplicationContext("applicationContext.xml");
ApplicationContext appContext = new FileSystemXmlApplicationContext(
new String[] { "applicationContext.xml" });
System.out.println(appContext); } @Test /**
* 通过IOC方式进行获取Spring容器代理生成的User对象
*/ public void testGetUser() {
ApplicationContext ac = new ClassPathXmlApplicationContext(
"applicationContext.xml");
User user = (User) ac.getBean("user");
System.out.println(user); } @Test /**
* 通过spring配置文件替代hibernate配置文件，测试是否成功
*/ public void testUser() {
// 获取spring容器上下文
ApplicationContext ac = new ClassPathXmlApplicationContext(
"applicationContext.xml");
// 获取配置文件中的session工厂(通过Spring的控制反转)
SessionFactory sessionFactory = (SessionFactory) ac
.getBean("sessionFactory");
// 获取session(连接)
Session session = sessionFactory.openSession();
// 通过hibernate方式的获取
User user = (User) session.get(User.class, 1);
// 打印获取信息F
System.out.println(user); } @Test /**
* 用来测试是否可以自动将UserDao对象注入，而且获取所有人的集合的方法是正确的
*/ public void testUserDao() {
List list = userDao.getAll();
for (User user : list) {
System.out.println(user);
} } @Test /**
* 用来测试业务层的代码是否正确，UserService是否已经成功注入
*/ public void testUserService() {
User user = new User("song", 1, new Date(), false);
userService.addUser(user); }} 然后进行测试，这里有个好处，在模拟的Spring容器中测试对数据库的操作都会进行回滚，其结果如下所示： testUserDao()
………………Hibernate: select user0_.userId as userId0_, user0_.age as age0_, user0_.birthday as birthday0_, user0_.isVip as isVip0_, user0_.userName as userName0_ from t_user user0_用户信息： [年龄是1, 生日是 20:39:16.0, 用户编号是1, 用户名是Steven, 是会员]用户信息： [年龄是1, 生日是 21:24:08.0, 用户编号是2, 用户名是Lily, 不是会员]用户信息： [年龄是1, 生日是 21:24:23.0, 用户编号是3, 用户名是Tom, 不是会员]………… testUserService()…………Hibernate: insert into t_user (age, birthday, isVip, userName) values (?, ?, ?, ?) 12:54:08 org.springframework.test.context.transaction.TransactionalTestExecutionListener endTransaction信息: 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 &?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.2.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.2.xsdhttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
classpath:jdbc.properties
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
com.steven
org.hibernate.dialect.MySQLDialect
org.springframework.orm.hibernate4.SpringSessionContext
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<aop:pointcut expression="execution(public * com.steven.service.impl.*.*(..))"
id="userPointCut" />
如果此时就运行testUserDao()测试方法，会有以下异常抛出 java.lang.IllegalStateException: Failed to load ApplicationContext at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContext(CacheAwareContextLoaderDelegate.java:99) at org.springframework.test.context.TestContext.getApplicationContext(TestContext.java:122) at org.springframework.test.context.web.ServletTestExecutionListener.setUpRequestContextIfNecessary(ServletTestExecutionListener.java:105) at org.springframework.test.context.web.ServletTestExecutionListener.prepareTestInstance(ServletTestExecutionListener.java:74) at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:312) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTest(SpringJUnit4ClassRunner.java:211) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner$1.runReflectiveCall(SpringJUnit4ClassRunner.java:288) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.methodBlock(SpringJUnit4ClassRunner.java:284) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:231) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:88) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41) at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173) at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28) at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61) at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31) at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:71) at org.junit.runners.ParentRunner.run(ParentRunner.java:220) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:174) at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46) at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)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 at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(XmlBeanDefinitionReader.java:412) at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:334) at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:302) at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:174) at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:209) at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:180) at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:243) at org.springframework.test.context.support.AbstractGenericContextLoader.loadBeanDefinitions(AbstractGenericContextLoader.java:233) at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:117) at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:60) at org.springframework.test.context.support.AbstractDelegatingSmartContextLoader.delegateLoading(AbstractDelegatingSmartContextLoader.java:100) at org.springframework.test.context.support.AbstractDelegatingSmartContextLoader.loadContext(AbstractDelegatingSmartContextLoader.java:248) at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContextInternal(CacheAwareContextLoaderDelegate.java:64) at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContext(CacheAwareContextLoaderDelegate.java:91) ... 25 moreCaused by: java.lang.NoClassDefFoundError: org/aopalliance/intercept/MethodInterceptor at java.lang.ClassLoader.defineClass1(Native Method) at java.lang.ClassLoader.defineClass(ClassLoader.java:621) at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:124) at java.net.URLClassLoader.defineClass(URLClassLoader.java:260) at java.net.URLClassLoader.access$000(URLClassLoader.java:56) at java.net.URLClassLoader$1.run(URLClassLoader.java:195) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(URLClassLoader.java:188) at java.lang.ClassLoader.loadClass(ClassLoader.java:307) at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301) at java.lang.ClassLoader.loadClass(ClassLoader.java:252) at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320) at org.springframework.transaction.config.TxAdviceBeanDefinitionParser.getBeanClass(TxAdviceBeanDefinitionParser.java:72) at org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser.parseInternal(AbstractSingleBeanDefinitionParser.java:66) at org.springframework.beans.factory.xml.AbstractBeanDefinitionParser.parse(AbstractBeanDefinitionParser.java:59) at org.springframework.beans.factory.xml.NamespaceHandlerSupport.parse(NamespaceHandlerSupport.java:73) at org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseCustomElement(BeanDefinitionParserDelegate.java:1438) at org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseCustomElement(BeanDefinitionParserDelegate.java:1428) at org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.parseBeanDefinitions(DefaultBeanDefinitionDocumentReader.java:185) at org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions(DefaultBeanDefinitionDocumentReader.java:139) at org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.registerBeanDefinitions(DefaultBeanDefinitionDocumentReader.java:108) at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.registerBeanDefinitions(XmlBeanDefinitionReader.java:493) at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(XmlBeanDefinitionReader.java:390) ... 38 moreCaused by: java.lang.ClassNotFoundException: org.aopalliance.intercept.MethodInterceptor at java.net.URLClassLoader$1.run(URLClassLoader.java:200) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(URLClassLoader.java:188) at java.lang.ClassLoader.loadClass(ClassLoader.java:307) at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301) at java.lang.ClassLoader.loadClass(ClassLoader.java:252) at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320) ... 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..cn/download/explain.php?fileid=)两个jar包，主要在Spring AOP时候所要用到的包。然后在执行测试方法，就不会抛出异常了。 下面可以通过一个实例来讲解AOP的具体效果，因为我们有了Service层，为什么要有此层，项目中大家经常会遇到一个场景，就是在进行处理正常的业务逻辑的时候，需要添加一些固定的项目日志，大家可以认为，最多就在每个处理类中写日志不就行了吗，但如果项目很大，而且日志都是冗余的，也就是说日志内容都是规定的，那么在这个过程中除了白费力气，而且浪费很多的时间写日志，而AOP的思想就是，通过动态代理机制，日志只要写完一遍当做模板，以后所有的处理类中，都可以进行复用，而且都可以在处理操作的过程前，后，过程中添加日志，这样就好似你去酒店住宿，在之前之后都会有人帮你清扫房间，而这些都是与你有关，而不是你所控制的，都是酒店分配好了。这里也是，在处理类执行前先执行日志，然后处理完的时候在执行日志，代码还是原来的代码，但执行的效果却增加了日志处理的操作，就是在你正常的业务操作中切入了日志的操作，这就是AOP(面向切面编程)的简单理解。其本质就是动态代理机制。 AOP面向切面可以通过两种方式实现，同样是配置和注解，我给出两种方式，都可以进行，下面给出手动配置的时候需要在applicationContext中添加的配置内容
<aop:pointcut expression="execution(public * com.steven.service.impl.*.*(..))"
id="allMethod" />
<aop:after-returning method="afterReturn"
pointcut-ref="allMethod" />
<aop:after-throwing method="afterThrowing"
pointcut-ref="allMethod" />
或者可以进行如下配置：
<aop:pointcut
expression="execution(public * com.steven.service.impl.*.*(..))" />
此时的切面类LogAspect.java如下所示： LogAspect.java package com.steven.import org.aspectj.lang.JoinPimport org.aspectj.lang.ProceedingJoinP/** * 日志切面类 *
* @author Steven *
*/public class LogAspect { // 定义切入点，提供一个方法，这个方法的名字就是改切入点的id @SuppressWarnings("unused") private void allMethod() { } // 任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型 public void before(JoinPoint call) {
String clazz = call.getTarget().getClass().getName();
// 获取目标对象上正在执行的方法名
String methodName = call.getSignature().getName();
System.out.println("前置通知:" + clazz + "类的" + methodName + "方法开始了..."); } // 访问命名切入点来应用后置通知 public void afterReturn() {
System.out.println("后置通知:方法正常结束..."); } // 应用最终通知 public void after() {
System.out.println("最终通知:不管方法有没有正常执行完成，一定会返回的..."); } // 应用异常抛出后通知 public void afterThrowing() {
System.out.println("异常抛出后通知:方法执行时出现异常..."); } // 应用周围通知 // @Around("allMethod()") // 用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型 public Object doAround(ProceedingJoinPoint call) throws Throwable {
Object result =
this.before(call);// 相当于前置通知
result = call.proceed();
this.afterReturn(); // 相当于后置通知
} catch (Throwable e) {
this.afterThrowing(); // 相当于异常抛出后通知
} finally {
this.after(); // 相当于最终通知
}} 如果全部用注解的方式，则只要添加如下配置：
这个时候对应的LogAspectAnnotation.java代码如下： LogAspectAnnotation.java
package com.steven.import org.aspectj.lang.JoinPimport org.aspectj.lang.ProceedingJoinPimport org.aspectj.lang.annotation.Aimport org.aspectj.lang.annotation.AfterRimport org.aspectj.lang.annotation.AfterTimport org.aspectj.lang.annotation.Aimport org.aspectj.lang.annotation.Bimport org.aspectj.lang.annotation.P/** * 日志切面类 *
* @author Steven *
*/@Aspectpublic class LogAspectAnnotation { // 定义切入点，提供一个方法，这个方法的名字就是改切入点的id @SuppressWarnings("unused") @Pointcut("execution(* com.steven.service.impl.*.*(..))") private void allMethod() { } // 任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型 @Before("execution(* com.steven.service.impl.*.*(..))") public void before(JoinPoint call) {
String clazz = call.getTarget().getClass().getName();
// 获取目标对象上正在执行的方法名
String methodName = call.getSignature().getName();
System.out.println("前置通知:" + clazz + "类的" + methodName + "方法开始了..."); } // 访问命名切入点来应用后置通知 @AfterReturning("allMethod()") public void afterReturn() {
System.out.println("后置通知:方法正常结束..."); } // 应用最终通知 @After("allMethod()") public void after() {
System.out.println("最终通知:不管方法有没有正常执行完成，一定会返回的..."); } // 应用异常抛出后通知 @AfterThrowing("allMethod()") public void afterThrowing() {
System.out.println("异常抛出后通知:方法执行时出现异常..."); } // 应用周围通知 // @Around("allMethod()") // 用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型 public Object doAround(ProceedingJoinPoint call) throws Throwable {
Object result =
this.before(call);// 相当于前置通知
result = call.proceed();
this.afterReturn(); // 相当于后置通知
} catch (Throwable e) {
this.afterThrowing(); // 相当于异常抛出后通知
} finally {
this.after(); // 相当于最终通知
}} 此时的项目结构图如图11所示： 图11 这个时候在执行testUserService()方法的时候，控制台出现以下结果： ……………………前置通知:com.steven.service.impl.UserService类的addUser方法开始了...Hibernate: insert into t_user (age, birthday, isVip, userName) values (?, ?, ?, ?)最终通知:不管方法有没有正常执行完成，一定会返回的...后置通知:方法正常结束...………………………… 说明面向切面的日志切面已经成功起作用。 这个时候就完成了IOC和AOP的完全降解，下面将对Struts，Hibernate，Spring进行全方位的整合。 下面对UserAction.java通过注入Ioc的方式注入UserService对象， UserAction.java package com.steven.import java.util.Limport java.util.Mimport org.apache.struts2.interceptor.RequestAimport org.springframework.beans.factory.annotation.Aimport com.opensymphony.xwork2.ActionSimport com.steven.entity.Uimport com.steven.service.iface.IUserS/** * 通过继承ActionSupport获得Struts2的已有功能， * 通过实现RequestAware获取request(这种方式常用，还有其他三种方式，这里不再赘述) * 四种获取request方式请参照http://blog.csdn.net/ms2146/article/details/5406004 *
* @author Steven *
*/public class UserAction extends ActionSupport implements RequestAware { private static final long serialVersionUID = 1L; private Map // private UserDao userDao = new UserDao(); @Autowired private IUserService userS @Override public String execute() throws Exception {
// userDao.insert(new User("Lily", 1, new Date(), false));
// userDao.insert(new User("Tom", 1, new Date(), false));
// 创建一个用户集合
List userList = userService.getAll();
// 创建用户并添加到用户集合中
// userList.add(new User("Steven", 1, new Date(), true));
// userList.add(new User("Lily", 1, new Date(), false));
// userList.add(new User("Tom", 1, new Date(), false));
// 将用户存储到ActionContext中(可以通过ognl表达式获取)
request.put("userList", userList);
return SUCCESS; } public void setRequest(Map request) {
this.request = }} 这个时候就可以启动服务器，然后看看加上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 &?xml version="1.0" encoding="UTF-8"?><web-app version="2.4" xmlns="/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="/xml/ns/j2ee /xml/ns/j2ee/web-app_2_4.xsd">
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
org.springframework.web.context.ContextLoaderListener
contextConfigLocation
WEB-INF/classes/applicationContext.xml
这个时候进行重新启动服务器，打开首页后，点击这里，就可以出现以下界面了,如图13所示：
图13 此时后台的运行结果为： 前置通知:com.steven.service.impl.UserService类的getAll方法开始了...Hibernate: select user0_.userId as userId0_, user0_.age as age0_, user0_.birthday as birthday0_, user0_.isVip as isVip0_, user0_.userName as userName0_ from t_user user0_最终通知:不管方法有没有正常执行完成，一定会返回的...后置通知:方法正常结束... 到此，SSH已经全部整合完成。
再来回顾一下整个整合过程，Struts2用来对整个请求和相应的处理，Hibernate对数据库的关系和对象的映射，Spring对全局bean的管理和事务机制，对model进行控制。在这个过程中遇到异常是很正常的现象，但如果能够知道异常产生的原因和解决的方法，那么就可以在使用中随心所欲的使用这SSH带来的好处，但其弊端也很明显，配置太麻烦，效率都要自己进行把关。在开发中SSH的使用很普遍，但仅仅使用Spring或者Hibernate也是存在的，Struts2依赖web容器，而Spring，Hibernate没有这个问题，可以单独使用，所以项目中具体如何搭配，都要看具体的问题具体的分析。
在此恭祝大家学习愉快！
最新教程周点击榜
微信扫一扫}
在前两部分的编写中，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
&?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.2.xsd">
有警告信息不要担心，可以将配置文件关闭后重新打开警告信息将会消失。此时可以写一个测试类完成Spring是否成功配置的测试，在test下com.steven.test新建一个SpringTest.java的类， SpringTest.java代码如下所示： package com.steven.import org.junit.Timport org.springframework.context.ApplicationCimport org.springframework.context.support.ClassPathXmlApplicationC/** * 用来进行Spring的测试类 *
* @author Steven *
*/public class SpringTest { @Test /**
* 用来测试是否Spring导入成功，配置成功
*/ public void testSpring() {
ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println(appContext); }} 其中ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");依旧来自Spring文档，如图6所示： 图6 此时进行JUnit测试，但运行中会出现一个异常，具体如下所示: java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory at org.springframework.context.support.AbstractApplicationContext.(AbstractApplicationContext.java:164) at org.springframework.context.support.AbstractRefreshableApplicationContext.(AbstractRefreshableApplicationContext.java:89) at org.springframework.context.support.AbstractRefreshableConfigApplicationContext.(AbstractRefreshableConfigApplicationContext.java:58) at org.springframework.context.support.AbstractXmlApplicationContext.(AbstractXmlApplicationContext.java:61) at org.springframework.context.support.ClassPathXmlApplicationContext.(ClassPathXmlApplicationContext.java:136) at org.springframework.context.support.ClassPathXmlApplicationContext.(ClassPathXmlApplicationContext.java:83) at com.steven.test.SpringTest.testSpring(SpringTest.java:19) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20) at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28) at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:73) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:46) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41) at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173) at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28) at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31) at org.junit.runners.ParentRunner.run(ParentRunner.java:220) at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46) at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)Caused by: java.lang.ClassNotFoundException: mons.logging.LogFactory at java.net.URLClassLoader$1.run(URLClassLoader.java:200) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(URLClassLoader.java:188) at java.lang.ClassLoader.loadClass(ClassLoader.java:307) at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301) at java.lang.ClassLoader.loadClass(ClassLoader.java:252) at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320) ... 31 more 这个异常是缺少mons.logging.LogFactory这个类，所以要解决就要下载commons-logging-1.1.1.jar这个jar包（http://ishare..cn/download/explain.php?fileid=），然后添加到lib路径下，此时再次运行，会出现以下结果，表示开始的导入和配置成功。 22:54:00 org.springframework.context.support.AbstractApplicationContext prepareRefresh信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1d225a7: startup date [Thu Dec 12 22:54:00 CST 2013]; root of context hierarchy 22:54:01 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions信息: Loading XML bean definitions from class path resource [applicationContext.xml] 22:54:02 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons信息: 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 hierarchyorg.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 &?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.2.xsd">
此时测试类如下所示， SpringTest.java package com.steven.import org.junit.Timport org.springframework.context.ApplicationCimport org.springframework.context.support.ClassPathXmlApplicationCimport org.springframework.context.support.FileSystemXmlApplicationCimport com.steven.entity.U/** * 用来进行Spring的测试类 *
* @author Steven *
*/public class SpringTest { @Test /**
* 用来测试是否Spring导入成功，配置成功
*/ public void testSpring() {
// ApplicationContext appContext = new
// ClassPathXmlApplicationContext("applicationContext.xml");
ApplicationContext appContext = new FileSystemXmlApplicationContext(
new String[] { "src/applicationContext.xml" });
System.out.println(appContext); } @Test /**
* 通过IOC方式进行获取Spring容器代理生成的User对象
*/ public void testGetUser() {
ApplicationContext ac = new ClassPathXmlApplicationContext(
"applicationContext.xml");
User user = (User) ac.getBean("user");
System.out.println(user); }} 然后执行JUnit测试，运行结果如下所示： 22:04:00 org.springframework.context.support.AbstractApplicationContext prepareRefresh信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@1d225a7: startup date [Fri Dec 13 22:04:00 CST 2013]; root of context hierarchy 22:04:00 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions信息: Loading XML bean definitions from class path resource [applicationContext.xml] 22:04:00 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons信息: 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用户信息： [年龄是23, 生日是Mon Jan 01 00:00:00 CST 1990, 用户编号是1, 用户名是Steven, 是会员] 此时配置的用户信息已经打印出来。这个时候我们来看看发生了什么事情了，通过ac.getBean("user")获得了配置中的User对象，其实是当Spring容器启动的时候就会对配置文件进行解析，在配置文件中有的节点，就会根据中的内容通过一系列Spring内部操作获得一个key为user的对象User，其实是通过java的反射机制创建User的对象，而且还是无参构造，如果将User中的无参构造去掉，或者写一个有参构造，这时候执行就会报以下的异常：org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'user' defined in class path resource [applicationContext.xml]: Instanti nested exception is org.springframework.beans.BeanInstantiationException: Could not instantiate bean class [com.steven.entity.User]: No defau nested exception is java.lang.NoSuchMethodException: com.steven.entity.User.() at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateBean(AbstractAutowireCapableBeanFactory.java:1013) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:959) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:490) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:461) at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:295) at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:223) at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:292) at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:194) at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:626) at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:932) at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:479) at org.springframework.context.support.ClassPathXmlApplicationContext.(ClassPathXmlApplicationContext.java:139) at org.springframework.context.support.ClassPathXmlApplicationContext.(ClassPathXmlApplicationContext.java:83) at com.steven.test.SpringTest.testGetUser(SpringTest.java:36) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41) at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20) at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28) at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:73) at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:46) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41) at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173) at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28) at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31) at org.junit.runners.ParentRunner.run(ParentRunner.java:220) at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46) at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)Caused by: org.springframework.beans.BeanInstantiationException: Could not instantiate bean class [com.steven.entity.User]: No defau nested exception is java.lang.NoSuchMethodException: com.steven.entity.User.() at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:83) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.instantiateBean(AbstractAutowireCapableBeanFactory.java:1006) ... 37 moreCaused by: java.lang.NoSuchMethodException: com.steven.entity.User.() at java.lang.Class.getConstructor0(Class.java:2706) at java.lang.Class.getDeclaredConstructor(Class.java:1985) at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:78) ... 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 &?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.2.xsd">
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
classpath:jdbc.properties
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
com.steven
org.hibernate.dialect.MySQLDialect
org.springframework.orm.hibernate4.SpringSessionContext
此时将不再需要hibernate.cfg.xml的配置文件，但这时候添加了jdbc.properties的资源文件，项目结构图如图8所示： 图8 jdbc.properties的内容如下： jdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc/:mysql/://localhost/:3306/stevenjdbc.username=rootjdbc.password=mysqladmin 到底是否已经将hibernate.cfg.xml配置文件取代，此时可以通过测试查看，在SpringTest.java中添加如下的测试方法:@Test /**
* 通过spring配置文件替代hibernate配置文件，测试是否成功
*/ public void testUser() {
//获取spring容器上下文
ApplicationContext ac = new ClassPathXmlApplicationContext(
"applicationContext.xml");
//获取配置文件中的session工厂(通过Spring的控制反转)
SessionFactory sessionFactory = (SessionFactory) ac
.getBean("sessionFactory");
//获取session(连接)
Session session = sessionFactory.openSession();
//通过hibernate方式的获取
User user = (User) session.get(User.class, 1);
//打印获取信息F
System.out.println(user); } 然后执行JUnit测试，此时的执行效果如下所示：……………………………………………………………………………………Hibernate: select user0_.userId as userId0_0_, user0_.age as age0_0_, user0_.birthday as birthday0_0_, user0_.isVip as isVip0_0_, user0_.userName as userName0_0_ from t_user user0_ where user0_.userId=?用户信息： [年龄是1, 生日是 20:39:16.0, 用户编号是1, 用户名是Steven, 是会员] 所以此时可以断定，SessionFactory已经通过Spring容器获取，而Hibernate的配置文件已经被Spring配置文件替代，所以这个时候可以说是Hibernate已经和Spring整合。 既然Hibernate已经整合进了Spring，那么就可以利用Spring的控制反转来替代Hibernate时候对于Dao类编写时候不必要的冗余代码。 在实现Hibernate和Spring的完全整合的时候，可以通过注解的方式进行，此时需要在applicationContext.xml中后添加一句，既是注解方式注入对象的时候寻找Spring容器产生的对象是在包的范围下面寻找，此时配置文件添加为：
下面将实施将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 package com.steven.dao.import java.util.Limport org.hibernate.Qimport org.hibernate.Simport org.hibernate.SessionFimport org.springframework.beans.factory.annotation.A/** * 集成hibernate3和spring的时候， * spring的ORM包里提供了HibernateSupport和HibernateTemplate这两个辅助类， * 建议使用HibernateTemplate。 不过在Hibernate4里，spring不再提供这种辅助类，将使用hibernate4的原生API * http://blog.csdn.net/dlutxie/article/details/8771371 *
* @author Steven *
*/public abstract class BaseDao implements IBaseDao { // 具体到哪个实体类的DAO功能 private Class entityC // 自动注入 @Autowired private SessionFactory sessionF /**
* 通过Spring注入的sessionFactory获取session
*/ public Session getSession() {
return this.sessionFactory.getCurrentSession(); } /**
* 当前进行操作的类的实例
* @param entityClass
*/ public BaseDao(Class entityClass) {
this.entityClass = entityC } /**
* 删除操作
*/ public void delete(T t) {
this.getSession().delete(t); } /**
* 获取所有的对象集合
*/ @SuppressWarnings("unchecked") public List getAll() {
String hql = "from " + entityClass.getSimpleName();
Query query = this.getSession().createQuery(hql);
return query.list(); } /**
* 根据Id获取对象的操作
*/ @SuppressWarnings("unchecked") public T getById(int id) {
return (T) this.getSession().get(this.entityClass, id); } /**
* 插入对象操作
*/ public void insert(T t) {
this.getSession().save(t); } /**
* 更新操作
*/ public void update(T t) {
this.getSession().update(t); }} UserDao.java package com.steven.dao.import org.springframework.stereotype.Rimport com.steven.dao.iface.BaseDimport com.steven.dao.iface.IUserDimport com.steven.entity.U/** * UserDao已经继承了BaseDao，其中的所有方法均已经被BaseDao实现 *
* @author Steven *
*///@Component("userDao")@Repository//一定要实现IUserDao这个接口public class UserDao extends BaseDao implements IUserDao { public UserDao() {
super(User.class); }}IUserService.javapackage com.steven.service.import java.util.Limport com.steven.entity.U/** * 业务层 *
* @author Steven *
*/public interface IUserService { /**
* 新增一个用户业务操作
* @param user
*/ public void addUser(User user); /**
* 根据用户Id获取用户操作
* @param userId
*/ public User getUserById(int userId); /**
* 获取所有的用户集合
*/ public List getAll();}UserService.java package com.steven.service.import java.util.Limport org.springframework.beans.factory.annotation.Aimport org.springframework.stereotype.Simport com.steven.dao.iface.IUserDimport com.steven.entity.Uimport com.steven.service.iface.IUserS/** * 具体的业务层实现 */@Servicepublic class UserService implements IUserService { @Autowired private IUserDao userD public void addUser(User user) {
userDao.insert(user); } public User getUserById(int userId) {
return userDao.getById(userId); } public List getAll() {
return userDao.getAll(); }}在上面的代码中用到了几个注解，这里将进行详细讲解 @Repository代表仓库. 一般注解在DAO实现类上, 只要看到这个注解, 就知道这个类是一个跟数据存储有关的类. @Service代表业务实现. 一般注解在Service实现类上. 如果你的类不是以上类型(数据存储类, 业务类), 可以笼统的使用@Component
@Autowire是注入对象的方式，自动注入，默认是按照类型的，此时就是需要，自动在这个包下面进行搜索，搜索不到将会报错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，
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
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 &?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.2.xsd">
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
classpath:jdbc.properties
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
com.steven
org.hibernate.dialect.MySQLDialect
org.springframework.orm.hibernate4.SpringSessionContext
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
这个时候的SpringTest.java如下所示： SpringTest.java package com.steven.import java.util.Dimport java.util.Limport org.hibernate.Simport org.hibernate.SessionFimport org.junit.Timport org.junit.runner.RunWimport org.springframework.beans.factory.annotation.Aimport org.springframework.context.ApplicationCimport org.springframework.context.support.ClassPathXmlApplicationCimport org.springframework.context.support.FileSystemXmlApplicationCimport org.springframework.test.context.ContextCimport org.springframework.test.context.junit4.SpringJUnit4ClassRimport org.springframework.transaction.annotation.Timport com.steven.dao.iface.IUserDimport com.steven.entity.Uimport com.steven.service.iface.IUserS/** * 用来进行Spring的测试类 *
* @author Steven *
*/// 需要额外添加spring-test包// 这个包代表在spring容器中进行测试@RunWith(SpringJUnit4ClassRunner.class)// 这个包代表引入test/com/steven/test/applicationContext.xml文件@ContextConfiguration(locations = "applicationContext.xml")// 这个包代表开启事物，这样可以阻止No Session found for current thread的异常出现@Transactionalpublic class SpringTest { @Autowired private IUserDao userD @Autowired private IUserService userS @Test /**
* 用来测试是否Spring导入成功，配置成功
*/ public void testSpring() {
// ApplicationContext appContext = new
// ClassPathXmlApplicationContext("applicationContext.xml");
ApplicationContext appContext = new FileSystemXmlApplicationContext(
new String[] { "applicationContext.xml" });
System.out.println(appContext); } @Test /**
* 通过IOC方式进行获取Spring容器代理生成的User对象
*/ public void testGetUser() {
ApplicationContext ac = new ClassPathXmlApplicationContext(
"applicationContext.xml");
User user = (User) ac.getBean("user");
System.out.println(user); } @Test /**
* 通过spring配置文件替代hibernate配置文件，测试是否成功
*/ public void testUser() {
// 获取spring容器上下文
ApplicationContext ac = new ClassPathXmlApplicationContext(
"applicationContext.xml");
// 获取配置文件中的session工厂(通过Spring的控制反转)
SessionFactory sessionFactory = (SessionFactory) ac
.getBean("sessionFactory");
// 获取session(连接)
Session session = sessionFactory.openSession();
// 通过hibernate方式的获取
User user = (User) session.get(User.class, 1);
// 打印获取信息F
System.out.println(user); } @Test /**
* 用来测试是否可以自动将UserDao对象注入，而且获取所有人的集合的方法是正确的
*/ public void testUserDao() {
List list = userDao.getAll();
for (User user : list) {
System.out.println(user);
} } @Test /**
* 用来测试业务层的代码是否正确，UserService是否已经成功注入
*/ public void testUserService() {
User user = new User("song", 1, new Date(), false);
userService.addUser(user); }} 然后进行测试，这里有个好处，在模拟的Spring容器中测试对数据库的操作都会进行回滚，其结果如下所示： testUserDao()
………………Hibernate: select user0_.userId as userId0_, user0_.age as age0_, user0_.birthday as birthday0_, user0_.isVip as isVip0_, user0_.userName as userName0_ from t_user user0_用户信息： [年龄是1, 生日是 20:39:16.0, 用户编号是1, 用户名是Steven, 是会员]用户信息： [年龄是1, 生日是 21:24:08.0, 用户编号是2, 用户名是Lily, 不是会员]用户信息： [年龄是1, 生日是 21:24:23.0, 用户编号是3, 用户名是Tom, 不是会员]………… testUserService()…………Hibernate: insert into t_user (age, birthday, isVip, userName) values (?, ?, ?, ?) 12:54:08 org.springframework.test.context.transaction.TransactionalTestExecutionListener endTransaction信息: 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 &?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.2.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.2.xsdhttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
classpath:jdbc.properties
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
com.steven
org.hibernate.dialect.MySQLDialect
org.springframework.orm.hibernate4.SpringSessionContext
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<aop:pointcut expression="execution(public * com.steven.service.impl.*.*(..))"
id="userPointCut" />
如果此时就运行testUserDao()测试方法，会有以下异常抛出 java.lang.IllegalStateException: Failed to load ApplicationContext at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContext(CacheAwareContextLoaderDelegate.java:99) at org.springframework.test.context.TestContext.getApplicationContext(TestContext.java:122) at org.springframework.test.context.web.ServletTestExecutionListener.setUpRequestContextIfNecessary(ServletTestExecutionListener.java:105) at org.springframework.test.context.web.ServletTestExecutionListener.prepareTestInstance(ServletTestExecutionListener.java:74) at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:312) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.createTest(SpringJUnit4ClassRunner.java:211) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner$1.runReflectiveCall(SpringJUnit4ClassRunner.java:288) at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.methodBlock(SpringJUnit4ClassRunner.java:284) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:231) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:88) at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180) at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41) at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173) at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28) at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61) at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31) at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:71) at org.junit.runners.ParentRunner.run(ParentRunner.java:220) at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:174) at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46) at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390) at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)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 at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(XmlBeanDefinitionReader.java:412) at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:334) at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions(XmlBeanDefinitionReader.java:302) at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:174) at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:209) at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:180) at org.springframework.beans.factory.support.AbstractBeanDefinitionReader.loadBeanDefinitions(AbstractBeanDefinitionReader.java:243) at org.springframework.test.context.support.AbstractGenericContextLoader.loadBeanDefinitions(AbstractGenericContextLoader.java:233) at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:117) at org.springframework.test.context.support.AbstractGenericContextLoader.loadContext(AbstractGenericContextLoader.java:60) at org.springframework.test.context.support.AbstractDelegatingSmartContextLoader.delegateLoading(AbstractDelegatingSmartContextLoader.java:100) at org.springframework.test.context.support.AbstractDelegatingSmartContextLoader.loadContext(AbstractDelegatingSmartContextLoader.java:248) at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContextInternal(CacheAwareContextLoaderDelegate.java:64) at org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContext(CacheAwareContextLoaderDelegate.java:91) ... 25 moreCaused by: java.lang.NoClassDefFoundError: org/aopalliance/intercept/MethodInterceptor at java.lang.ClassLoader.defineClass1(Native Method) at java.lang.ClassLoader.defineClass(ClassLoader.java:621) at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:124) at java.net.URLClassLoader.defineClass(URLClassLoader.java:260) at java.net.URLClassLoader.access$000(URLClassLoader.java:56) at java.net.URLClassLoader$1.run(URLClassLoader.java:195) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(URLClassLoader.java:188) at java.lang.ClassLoader.loadClass(ClassLoader.java:307) at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301) at java.lang.ClassLoader.loadClass(ClassLoader.java:252) at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320) at org.springframework.transaction.config.TxAdviceBeanDefinitionParser.getBeanClass(TxAdviceBeanDefinitionParser.java:72) at org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser.parseInternal(AbstractSingleBeanDefinitionParser.java:66) at org.springframework.beans.factory.xml.AbstractBeanDefinitionParser.parse(AbstractBeanDefinitionParser.java:59) at org.springframework.beans.factory.xml.NamespaceHandlerSupport.parse(NamespaceHandlerSupport.java:73) at org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseCustomElement(BeanDefinitionParserDelegate.java:1438) at org.springframework.beans.factory.xml.BeanDefinitionParserDelegate.parseCustomElement(BeanDefinitionParserDelegate.java:1428) at org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.parseBeanDefinitions(DefaultBeanDefinitionDocumentReader.java:185) at org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.doRegisterBeanDefinitions(DefaultBeanDefinitionDocumentReader.java:139) at org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader.registerBeanDefinitions(DefaultBeanDefinitionDocumentReader.java:108) at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.registerBeanDefinitions(XmlBeanDefinitionReader.java:493) at org.springframework.beans.factory.xml.XmlBeanDefinitionReader.doLoadBeanDefinitions(XmlBeanDefinitionReader.java:390) ... 38 moreCaused by: java.lang.ClassNotFoundException: org.aopalliance.intercept.MethodInterceptor at java.net.URLClassLoader$1.run(URLClassLoader.java:200) at java.security.AccessController.doPrivileged(Native Method) at java.net.URLClassLoader.findClass(URLClassLoader.java:188) at java.lang.ClassLoader.loadClass(ClassLoader.java:307) at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301) at java.lang.ClassLoader.loadClass(ClassLoader.java:252) at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320) ... 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..cn/download/explain.php?fileid=)两个jar包，主要在Spring AOP时候所要用到的包。然后在执行测试方法，就不会抛出异常了。 下面可以通过一个实例来讲解AOP的具体效果，因为我们有了Service层，为什么要有此层，项目中大家经常会遇到一个场景，就是在进行处理正常的业务逻辑的时候，需要添加一些固定的项目日志，大家可以认为，最多就在每个处理类中写日志不就行了吗，但如果项目很大，而且日志都是冗余的，也就是说日志内容都是规定的，那么在这个过程中除了白费力气，而且浪费很多的时间写日志，而AOP的思想就是，通过动态代理机制，日志只要写完一遍当做模板，以后所有的处理类中，都可以进行复用，而且都可以在处理操作的过程前，后，过程中添加日志，这样就好似你去酒店住宿，在之前之后都会有人帮你清扫房间，而这些都是与你有关，而不是你所控制的，都是酒店分配好了。这里也是，在处理类执行前先执行日志，然后处理完的时候在执行日志，代码还是原来的代码，但执行的效果却增加了日志处理的操作，就是在你正常的业务操作中切入了日志的操作，这就是AOP(面向切面编程)的简单理解。其本质就是动态代理机制。 AOP面向切面可以通过两种方式实现，同样是配置和注解，我给出两种方式，都可以进行，下面给出手动配置的时候需要在applicationContext中添加的配置内容
<aop:pointcut expression="execution(public * com.steven.service.impl.*.*(..))"
id="allMethod" />
<aop:after-returning method="afterReturn"
pointcut-ref="allMethod" />
<aop:after-throwing method="afterThrowing"
pointcut-ref="allMethod" />
或者可以进行如下配置：
<aop:pointcut
expression="execution(public * com.steven.service.impl.*.*(..))" />
此时的切面类LogAspect.java如下所示： LogAspect.java package com.steven.import org.aspectj.lang.JoinPimport org.aspectj.lang.ProceedingJoinP/** * 日志切面类 *
* @author Steven *
*/public class LogAspect { // 定义切入点，提供一个方法，这个方法的名字就是改切入点的id @SuppressWarnings("unused") private void allMethod() { } // 任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型 public void before(JoinPoint call) {
String clazz = call.getTarget().getClass().getName();
// 获取目标对象上正在执行的方法名
String methodName = call.getSignature().getName();
System.out.println("前置通知:" + clazz + "类的" + methodName + "方法开始了..."); } // 访问命名切入点来应用后置通知 public void afterReturn() {
System.out.println("后置通知:方法正常结束..."); } // 应用最终通知 public void after() {
System.out.println("最终通知:不管方法有没有正常执行完成，一定会返回的..."); } // 应用异常抛出后通知 public void afterThrowing() {
System.out.println("异常抛出后通知:方法执行时出现异常..."); } // 应用周围通知 // @Around("allMethod()") // 用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型 public Object doAround(ProceedingJoinPoint call) throws Throwable {
Object result =
this.before(call);// 相当于前置通知
result = call.proceed();
this.afterReturn(); // 相当于后置通知
} catch (Throwable e) {
this.afterThrowing(); // 相当于异常抛出后通知
} finally {
this.after(); // 相当于最终通知
}} 如果全部用注解的方式，则只要添加如下配置：
这个时候对应的LogAspectAnnotation.java代码如下： LogAspectAnnotation.java
package com.steven.import org.aspectj.lang.JoinPimport org.aspectj.lang.ProceedingJoinPimport org.aspectj.lang.annotation.Aimport org.aspectj.lang.annotation.AfterRimport org.aspectj.lang.annotation.AfterTimport org.aspectj.lang.annotation.Aimport org.aspectj.lang.annotation.Bimport org.aspectj.lang.annotation.P/** * 日志切面类 *
* @author Steven *
*/@Aspectpublic class LogAspectAnnotation { // 定义切入点，提供一个方法，这个方法的名字就是改切入点的id @SuppressWarnings("unused") @Pointcut("execution(* com.steven.service.impl.*.*(..))") private void allMethod() { } // 任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型 @Before("execution(* com.steven.service.impl.*.*(..))") public void before(JoinPoint call) {
String clazz = call.getTarget().getClass().getName();
// 获取目标对象上正在执行的方法名
String methodName = call.getSignature().getName();
System.out.println("前置通知:" + clazz + "类的" + methodName + "方法开始了..."); } // 访问命名切入点来应用后置通知 @AfterReturning("allMethod()") public void afterReturn() {
System.out.println("后置通知:方法正常结束..."); } // 应用最终通知 @After("allMethod()") public void after() {
System.out.println("最终通知:不管方法有没有正常执行完成，一定会返回的..."); } // 应用异常抛出后通知 @AfterThrowing("allMethod()") public void afterThrowing() {
System.out.println("异常抛出后通知:方法执行时出现异常..."); } // 应用周围通知 // @Around("allMethod()") // 用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型 public Object doAround(ProceedingJoinPoint call) throws Throwable {
Object result =
this.before(call);// 相当于前置通知
result = call.proceed();
this.afterReturn(); // 相当于后置通知
} catch (Throwable e) {
this.afterThrowing(); // 相当于异常抛出后通知
} finally {
this.after(); // 相当于最终通知
}} 此时的项目结构图如图11所示： 图11 这个时候在执行testUserService()方法的时候，控制台出现以下结果： ……………………前置通知:com.steven.service.impl.UserService类的addUser方法开始了...Hibernate: insert into t_user (age, birthday, isVip, userName) values (?, ?, ?, ?)最终通知:不管方法有没有正常执行完成，一定会返回的...后置通知:方法正常结束...………………………… 说明面向切面的日志切面已经成功起作用。 这个时候就完成了IOC和AOP的完全降解，下面将对Struts，Hibernate，Spring进行全方位的整合。 下面对UserAction.java通过注入Ioc的方式注入UserService对象， UserAction.java package com.steven.import java.util.Limport java.util.Mimport org.apache.struts2.interceptor.RequestAimport org.springframework.beans.factory.annotation.Aimport com.opensymphony.xwork2.ActionSimport com.steven.entity.Uimport com.steven.service.iface.IUserS/** * 通过继承ActionSupport获得Struts2的已有功能， * 通过实现RequestAware获取request(这种方式常用，还有其他三种方式，这里不再赘述) * 四种获取request方式请参照http://blog.csdn.net/ms2146/article/details/5406004 *
* @author Steven *
*/public class UserAction extends ActionSupport implements RequestAware { private static final long serialVersionUID = 1L; private Map // private UserDao userDao = new UserDao(); @Autowired private IUserService userS @Override public String execute() throws Exception {
// userDao.insert(new User("Lily", 1, new Date(), false));
// userDao.insert(new User("Tom", 1, new Date(), false));
// 创建一个用户集合
List userList = userService.getAll();
// 创建用户并添加到用户集合中
// userList.add(new User("Steven", 1, new Date(), true));
// userList.add(new User("Lily", 1, new Date(), false));
// userList.add(new User("Tom", 1, new Date(), false));
// 将用户存储到ActionContext中(可以通过ognl表达式获取)
request.put("userList", userList);
return SUCCESS; } public void setRequest(Map request) {
this.request = }} 这个时候就可以启动服务器，然后看看加上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 &?xml version="1.0" encoding="UTF-8"?><web-app version="2.4" xmlns="/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="/xml/ns/j2ee /xml/ns/j2ee/web-app_2_4.xsd">
org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter
org.springframework.web.context.ContextLoaderListener
contextConfigLocation
WEB-INF/classes/applicationContext.xml
这个时候进行重新启动服务器，打开首页后，点击这里，就可以出现以下界面了,如图13所示：
图13 此时后台的运行结果为： 前置通知:com.steven.service.impl.UserService类的getAll方法开始了...Hibernate: select user0_.userId as userId0_, user0_.age as age0_, user0_.birthday as birthday0_, user0_.isVip as isVip0_, user0_.userName as userName0_ from t_user user0_最终通知:不管方法有没有正常执行完成，一定会返回的...后置通知:方法正常结束... 到此，SSH已经全部整合完成。
再来回顾一下整个整合过程，Struts2用来对整个请求和相应的处理，Hibernate对数据库的关系和对象的映射，Spring对全局bean的管理和事务机制，对model进行控制。在这个过程中遇到异常是很正常的现象，但如果能够知道异常产生的原因和解决的方法，那么就可以在使用中随心所欲的使用这SSH带来的好处，但其弊端也很明显，配置太麻烦，效率都要自己进行把关。在开发中SSH的使用很普遍，但仅仅使用Spring或者Hibernate也是存在的，Struts2依赖web容器，而Spring，Hibernate没有这个问题，可以单独使用，所以项目中具体如何搭配，都要看具体的问题具体的分析。
在此恭祝大家学习愉快！
最新教程周点击榜
微信扫一扫}
我要回帖
更多关于 st320lt007 的文章
更多推荐
- ·高考要求口语的专业口语考什么？
- ·福建南平八中是怎样的学校第四届学生会主席选举
- ·框架每平米建筑面积填充1立方砌块砌墙多少平方多少方？
- ·对于大学文科生有什么专业毕业生找工作难的问题，北京积云教育的新媒体影视课程如何？
- ·景德镇陶瓷市场哪个好大学的定制公交车现在还有吗？
- ·上饶市语文赣新杯2011年noi2011获奖名单单
- ·孩子对英语一点兴都没有，注会复习前面忘记了刚教完后面就忘记了，怎样做才能让孩子
- ·三金片和复方石韦胶囊囊能和脑萎缩药一起吃吗
- ·我患有子宫肌瘤月经不调，但月经很少发黑是怎么回事
- ·宁波奉化银泰城切削液
- ·怎么快速写完暑假作业的写完10遍春
- ·急淋高危白血病m5a白血病一定得做移植吗
- ·负xe的负x的平方的原函数结果一定是什么
- ·西工大附中物理党斌物理初赛多少人
- ·喝酒后可以做c14呼气试验正常值?
- ·减法简便方法计算算:755方减255方
- ·我是小学生廉洁小故事200卫士讲演稿200字
- ·我国第二大河是什么河的第一大河,也是世界上的第什么大河
- ·河北保定大唐房地产臧亚杰臧师傅培训学校学费吃住多少，实操能学多少东西
- ·2十3十4=320则<1=
- ·求推荐40004000点以下不发新股手提电脑，主要用于应付大学计算机考试，打LOL。
- ·秋天是什么季节为什么是个宁静的季节
- ·谁知道这些英文怎么写怎么写
- ·可以带螺丝刀工具套装，虎钳等工具吗
- ·2016年7月1日以后2016网上报考驾照照的不能约考吗，驾校说因为科目三增加了课时，河北邢台的
- ·新生儿败血症好治吗是怎么造成的？ 宝宝知道
- ·做引产有什么危险危险么？
- ·延安尖锐湿早期怎么治犹早期的症状表现是什么?仁油
- ·9.8促排，9.16排尿时有来月经前褐色分泌物物，什么原因 宝宝知道
- ·先煎的药要浸泡吗没有先煎可以喝吗
- ·怎样能知道是伤经或是伤治摔伤股骨头坏死
- ·狗嘴里有肝炎病毒性肝炎有哪些吗?
- ·资中人民医院做巧克力囊肿多大要手术手术怎么样
- ·山茨菇体外碎石对肾伤害大吗有伤害吗
