Spring基于注解TestContext 测试框架使用详解

概述

Spring 2.5 相比于 Spring 2.0 所新增的最重要的功能可以归结为以下 3 点：

1.基于注解的 IoC 功能； 
2.基于注解驱动的 Spring MVC 功能； 
3.基于注解的 TestContext 测试框架。

Spring 推荐开发者使用新的基于注解的 TestContext 测试框架，本文我们将对此进行详细的讲述。

低版本的 Spring 所提供的 Spring 测试框架构在 JUnit 3.8 基础上扩展而来，它提供了若干个测试基类。而 Spring
2.5 所新增的基于注解的 TestContext 测试框架和低版本的测试框架没有任何关系。它采用全新的注解技术可以让 POJO 成为
Spring 的测试用例，除了拥有旧测试框架所有功能外，TestContext 还添加了一些新的功能，TestContext 可以运行在
JUnit 3.8、JUnit 4.4、TestNG 等测试框架下。

直接使用 JUnit 测试 Spring 程序存在的不足

在拙作《精通 Spring 2.x — 企业应用开发详解》一书中，笔者曾经指出如果直接使用 JUnit 测试基于 Spring 的程序，将存在以下 4 点明显的不足：

1.导致 Spring 容器多次初始化问题：根据 JUnit
测试用例的调用流程，每执行一个测试方法都会重新创建一个测试用例实例并调用其 setUp() 方法。由于在一般情况下，我们都在 setUp()
方法中初始化 Spring 容器，这意味着测试用例中有多少个测试方法，Spring 容器就会被重复初始化多少次。 
2.需要使用硬编码方式手工获取 Bean：在测试用例中，我们需要通过 ApplicationContext.getBean() 的方法从 Spirng 容器中获取需要测试的目标 Bean，并且还要进行造型操作。 
3.数据库现场容易遭受破坏：测试方法可能会对数据库记录进行更改操作，破坏数据库现场。虽然是针对开发数据库进行测试工作的，但如果数据
操作的影响是持久的，将会形成积累效应并影响到测试用例的再次执行。举个例子，假设在某个测试方法中往数据库插入一条 ID 为 1 的 t_user
记录，第一次运行不会有问题，第二次运行时，就会因为主键冲突而导致测试用例执行失败。所以测试用例应该既能够完成测试固件业务功能正确性的检查，又能够
容易地在测试完成后恢复现场，做到踏雪无迹、雁过无痕。 
4.不容易在同一事务下访问数据库以检验业务操作的正确性：当测试固件操作数据库时，为了检测数据操作的正确性，需要通过一种方便途径在测试方法相同的事务环境下访问数据库，以检查测试固件数据操作的执行效果。如果直接使用 JUnit 进行测试，我们很难完成这项操作。

Spring 测试框架是专门为测试基于 Spring 框架应用程序而设计的，它能够让测试用例非常方便地和 Spring 框架结合起来，以上所有问题都将迎刃而解。

一个需要测试的 Spring 服务类 
在具体使用 TextContext 测试框架之前，我们先来认识一下需要测试的 UserService 服务类。UserService 服务类中拥有一个处理用户登录的服务方法，其代码如下所示：

清单1. UserService.java 需要测试的服务类

Java代码

  1. package com.baobaotao.service;
  2. import com.baobaotao.domain.LoginLog;
  3. import com.baobaotao.domain.User;
  4. import com.baobaotao.dao.UserDao;
  5. import com.baobaotao.dao.LoginLogDao;
  6. public class UserService{
  7. private UserDao userDao;
  8. private LoginLogDao loginLogDao;
  9. public void handleUserLogin(User user) {
  10. user.setCredits( 5 + user.getCredits());
  11. LoginLog loginLog = new LoginLog();
  12. loginLog.setUserId(user.getUserId());
  13. loginLog.setIp(user.getLastIp());
  14. loginLog.setLoginTime(user.getLastVisit());
  15. userDao.updateLoginInfo(user);
  16. loginLogDao.insertLoginLog(loginLog);
  17. }
  18. //省略get/setter方法
  19. }

UserService 需要调用 DAO 层的 UserDao 和 LoginLogDao 以及 User 和 LoginLog 这两个 PO
完成业务逻辑，User 和 LoginLog分别对应 t_user 和 t_login_log 这两张数据库表。

在用户登录成功后调用 UserService 中的 handleUserLogin() 方法执行用户登录成功后的业务逻辑：

登录用户添加 5 个积分（t_user.credits）； 
登录用户的最后访问时间（t_user.last_visit）和 IP（t_user.last_ip）更新为当前值； 
在日志表中（t_login_log）中为用户添加一条登录日志。 
这是一个需要访问数据库并存在数据更改操作的业务方法，它工作在事务环境下。下面是装配该服务类 Bean 的 Spring 配置文件：

清单2. applicationContext.xml：Spring 配置文件，放在类路径下

Xml代码

  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"
  4. xmlns:p="http://www.springframework.org/schema/p"
  5. xmlns:tx="http://www.springframework.org/schema/tx"
  6. xmlns:aop="http://www.springframework.org/schema/aop"
  7. xmlns:context="http://www.springframework.org/schema/context"
  8. xsi:schemaLocation="http://www.springframework.org/schema/beans
  9. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
  10. http://www.springframework.org/schema/tx
  11. http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
  12. http://www.springframework.org/schema/aop
  13. http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
  14. <!-- 配置数据源  -->
  15. <bean id="dataSource"
  16. class="org.apache.commons.dbcp.BasicDataSource"
  17. destroy-method="close"
  18. p:driverClassName="com.mysql.jdbc.Driver"
  19. p:url="jdbc:mysql://localhost/sampledb"
  20. p:username="root"
  21. p:password="1234"/>
  22. <!-- 配置Jdbc模板  -->
  23. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
  24. p:dataSource-ref="dataSource"/>
  25. <!-- 配置dao  -->
  26. <bean id="loginLogDao"class="com.baobaotao.dao.LoginLogDao"
  27. p:jdbcTemplate-ref="jdbcTemplate"/>
  28. <bean id="userDao" class="com.baobaotao.dao.UserDao"
  29. p:jdbcTemplate-ref="jdbcTemplate"/>
  30. <!-- 事务管理器 -->
  31. <bean id="transactionManager"
  32. class="org.springframework.jdbc.datasource.DataSourceTransactionManager"
  33. p:dataSource-ref="dataSource"/>
  34. <bean id="userService" class="com.baobaotao.service.UserService"
  35. p:userDao-ref="userDao" p:loginLogDao-ref="loginLogDao"/>
  36. <!-- 使用aop/tx命名空间配置事务管理,这里对service包下的服务类方法提供事务-->
  37. <aop:config>
  38. <aop:pointcut id="jdbcServiceMethod"
  39. expression= "within(com.baobaotao.service..*)" />
  40. <aop:advisor pointcut-ref="jdbcServiceMethod" advice-ref="jdbcTxAdvice" />
  41. </aop:config>
  42. <tx:advice id="jdbcTxAdvice" transaction-manager="transactionManager">
  43. <tx:attributes>
  44. <tx:method name="*"/>
  45. </tx:attributes>
  46. </tx:advice>
  47. </beans>

UserService 所关联的 DAO 类和 PO 类都比较简单，请参看本文附件的程序代码。在着手测试 UserSerivce 之前，需要将创建数据库表，你可以在附件的 schema 目录下找到相应的 SQL 脚本文件。

编写 UserService 的测试用例 
下面我们为 UserService 编写一个简单的测试用例类，此时的目标是让这个基于 TestContext 测试框架的测试类运行起来，我们将在后面逐步完善这个测试用例。

清单3.TestUserService.java: 基于注解的测试用例

Java代码

  1. package com.baobaotao.service;
  2. import org.springframework.test.context.junit4.
  3. AbstractTransactionalJUnit4SpringContextTests;
  4. import org.springframework.test.context.ContextConfiguration;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.junit.Test;
  7. import com.baobaotao.domain.User;
  8. import java.util.Date;
  9. @ContextConfiguration  //①
  10. public class TestUserService extends
  11. AbstractTransactionalJUnit4SpringContextTests {
  12. @Autowired  //②
  13. private UserService userService;
  14. @Test  //③
  15. public void handleUserLogin(){
  16. User user = new User();
  17. user.setUserId(1);
  18. user.setLastIp("127.0.0.1");
  19. Date now = new Date();
  20. user.setLastVisit(now.getTime());
  21. userService.handleUserLogin(user);
  22. }
  23. }

这里，我们让 TestUserService 直接继承于 Spring 所提供的
AbstractTransactionalJUnit4SpringContextTests
的抽象测试类，稍后本文将对这个抽象测试类进行剖析，这里你仅须知道该抽象测试类的作用是让 TestContext 测试框架可以在 JUnit
4.4 测试框架基础上运行起来就可以了。

在 ① 处，标注了一个类级的 @ContextConfiguration 注解，这里 Spring 将按 TestContext 契约查找
classpath:/com/baobaotao/service/TestUserService-context.xml 的 Spring
配置文件，并使用该配置文件启动 Spring 容器。@ContextConfiguration 注解有以下两个常用的属性：

1. locations：可以通过该属性手工指定 Spring 配置文件所在的位置，可以指定一个或多个 Spring 配置文件。如下所示：

Java代码

  1. @ContextConfiguration(locations={“xx/yy/beans1.xml”,"xx/yy/beans2.xml”})

2. inheritLocations：是否要继承父测试用例类中的 Spring 配置文件，默认为 true。如下面的例子：

Java代码

  1. @ContextConfiguration(locations={"base-context.xml"})
  2. public class BaseTest {
  3. // ...
  4. }
  5. @ContextConfiguration(locations={"extended-context.xml"})
  6. public class ExtendedTest extends BaseTest {
  7. // ...
  8. }

如果 inheritLocations 设置为 false，则 ExtendedTest 仅会使用 extended-context.xml
配置文件，否则将使用 base-context.xml 和 extended-context.xml 这两个配置文件。

② 处的 @Autowired 注解让 Spring 容器自动注入 UserService 类型的 Bean。而在 ③ 处标注的 @Test
注解则让 handleUserLogin() 方法成为一个 JUnit 4.4 标准的测试方法， @Test 是 JUnit 4.4
所定义的注解。

在运行 TestUserService 测试类之前，让我们先看一下 TestUserService-context.xml 配置文件的内容：

清单 4.TestUserService 所引用的 Spring 配置文件

Xml代码

  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"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
  6. <!-- ① 引入清单1定义的Spring配置文件 -->
  7. <import resource="classpath:/applicationContext.xml"/>
  8. </beans>

在 ① 处引入了清单 1 中定义的 Spring 配置文件，这样我们就可以将其中定义的 UserService Bean 作为测试固件注入到 TestUserService 中了。

在你的 IDE 中（Eclipse、JBuilder、Idea 等），将 JUnit 4.4 类包引入到项目工程中后，在
TestUserService 类中点击右键运行该测试类，将发现 TestUserService 已经可以成功运行了，如 图 1 所示：

图 1. 在 Eclipse 6.0 中运行 TestUserService 
 
TestUserService 可以正确运行，说明其 userService 这个测试固件已经享受了 Spring
自动注入的功能。在运行该测试用例后，到数据库中查看 t_user 表和 t_login_log
表，你会发现表数据和测试前是一样的！这说明虽然我们在清单 3 的 handleUserLogin() 测试方法中执行了
userService.handleUserLogin(user) 的操作，但它并没有对数据库现场造成破坏：这是因为 Spring
的在测试方法返回前进行了事务回滚操作。

虽然 TestUserService.handleUserLogin() 测试方法已经可以成功运行，但是它在测试功能上是不完善的，读者朋友可以已经发现了它存在以下两个问题：

1. 我们仅仅执行了 UserService#handleUserLogin(user) 方法，但验证该方法执行结果的正确性。 
2. 在测试方法中直接使用 ID 为 1 的 User 对象进行测试，这相当于要求在数据库 t_user 表必须已经存在 ID 为 1 的记录，如果 t_user 中不存在这条记录，将导致测试方法执行失败。

准备测试数据并检测运行结果

在这节里，我们将着手解决上面所提出的两个问题，在测试用例中准备测试数据并到数据库中检测业务执行结果的正确性。

准备测试数据

相比于在测试方法中直接访问预定的数据记录，在测试方法执行前通过程序准备一些测试数据，然后在此基础上运行测试方法是比较好的策略，因为后者不需要对数
据库的状态做假设。在 TestContext 中，你可以通过使用 JUnit 4.4 的 @Before 注解达到这个目的，请看下面的代码：

清单5. 为测试方法准备数据

Java代码

  1. package com.baobaotao.service;
  2. import java.sql.Connection;
  3. import java.sql.PreparedStatement;
  4. import java.sql.SQLException;
  5. import java.util.Date;
  6. import org.junit.Before;
  7. import org.junit.Test;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.jdbc.core.PreparedStatementCreator;
  10. import org.springframework.jdbc.support.GeneratedKeyHolder;
  11. import org.springframework.jdbc.support.KeyHolder;
  12. import org.springframework.test.context.ContextConfiguration;
  13. import org.springframework.test.context.junit4.
  14. AbstractTransactionalJUnit4SpringContextTests;
  15. import com.baobaotao.dao.UserDao;
  16. import com.baobaotao.domain.User;
  17. @ContextConfiguration
  18. public class TestUserService
  19. extends AbstractTransactionalJUnit4SpringContextTests {
  20. @Autowired
  21. private UserService userService;
  22. @Autowired
  23. private UserDao userDao;
  24. private int userId;
  25. @Before //① 准备测试数据
  26. public void prepareTestData() {
  27. final String  sql = "insert into t_user(user_name,password) values(‘tom‘,‘1234‘)";
  28. simpleJdbcTemplate.update(sql);
  29. KeyHolder keyHolder = new GeneratedKeyHolder();
  30. simpleJdbcTemplate.getJdbcOperations().update(
  31. new PreparedStatementCreator() {
  32. public PreparedStatement createPreparedStatement(Connection conn)
  33. throws SQLException {
  34. PreparedStatement ps = conn.prepareStatement(sql);
  35. return ps;
  36. }
  37. }, keyHolder);
  38. userId = keyHolder.getKey().intValue();//①－1 记录测试数据的id
  39. }
  40. @Test
  41. public void handleUserLogin(){
  42. User user = userDao.getUserById(userId); //② 获取测试数据
  43. user.setLastIp("127.0.0.1");
  44. Date now = new Date();
  45. user.setLastVisit(now.getTime());
  46. userService.handleUserLogin(user);
  47. }
  48. }

JUnit 4.4 允许通过注解指定某些方法在测试方法执行前后进行调用，即是 @Before 和 @After 注解。在 Spring
TestContext 中，标注 @Before 和 @After
的方法会在测试用例中每个测试方法运行前后执行，并和测试方法运行于同一个事务中。在 清单 5 中 ① 处，我们给
prepareTestData() 标注上了 @Before 注解，在该方法中准备一些测试数据，以供 TestUserService
中所有测试方法使用（这里仅有一个 handleUserLogin() 测试方法）。由于测试方法运行后，整个事务会被回滚，在
prepareTestData() 中插入的测试数据也不会持久化到数据库中，因此我们无须手工删除这条记录。

标注 @Before 或 @After
注解的方法和测试方法运行在同一个事务中，但有时我们希望在测试方法的事务开始之前或完成之后执行某些方法以便获取数据库现场的一些情况。这时，可以使用
Spring TestContext 的 @BeforeTransaction 和 @AfterTransaction
注解来达到目录（这两个注解位于 org.springframework.test.context.transaction 包中）。

虽然大多数业务方法都会访问数据库，但也并非所有需要测试的业务方法都需要和数据库打交道。而在默认情况下，继承于
AbstractTransactionalJUnit4SpringContextTests
测试用例的所有测试方法都将工作于事务环境下，你可以显式地通过 @NotTransactional 注解，让测试方法不工作于事务环境下。

prepareTestData() 方法中使用到了 simpleJdbcTemplate 对象访问操作数据库，该对象在
AbstractTransactionalJUnit4SpringContextTests 抽象类中定义，只要 Spring
容器有配置数据源，simpleJdbcTemplate 就会被自动创建。同时该抽象类中还拥有一个 Spring
容器引用：applicationContext，你可以借助该成员变量访问 Spring 容器，执行获取 Bean，发布事件等操作。

此外，AbstractTransactionalJUnit4SpringContextTests 还提供了若干个访问数据库的便捷方法，说明如下：

protected int countRowsInTable(String tableName) ：计算数据表的记录数。 
protected int deleteFromTables(String... names)：删除表中的记录，可以指定多张表。 
protected void executeSqlScript(String sqlResourcePath, boolean continueOnError)：执行 SQL 脚本文件，在脚本文件中，其格式必须一个 SQL 语句一行。

在测试方法 handleUserLogin() 的 ② 处，我们通过 userDao 获取 prepareTestData()
添加的测试数据，测试方法在测试数据的基础上执行业务逻辑。使用这种测试方式后，在任何情况下运行 TestUserService
都不会发生业务逻辑之外的问题。

检验业务逻辑的正确性

到目前为此，TestUserService 的 handleUserLogin() 测试方法仅是简单地执行
UserService#handleUserLogin()
业务方法，但并没有在业务方法执行后检查执行结果的正确性，因此这个测试是不到位的。也就是说，我们必须访问数据库以检查业务方法对数据更改是否成功：这
包括积分(credits)、最后登录时间(last_visit)、最后登录
IP(last_ip)以及登录日志表中的登录日志记录(t_login_log)。下面，我们补充这项重要的检查数据正确性的工作：

清单5. 检验业务方法执行结果的正确性

Java代码

  1. @Test
  2. public void handleUserLogin(){
  3. User user = userDao.getUserById(userId);
  4. user.setLastIp("127.0.0.1");
  5. Date now = new Date();
  6. user.setLastVisit(now.getTime());
  7. userService.handleUserLogin(user);
  8. //------------------以下为业务执行结果检查的代码---------------------
  9. User newUser = userDao.getUserById(userId);
  10. Assert.assertEquals(5, newUser.getCredits()); //①检测积分
  11. //①检测最后登录时间和IP
  12. Assert.assertEquals(now.getTime(), newUser.getLastVisit());
  13. Assert.assertEquals("127.0.0.1",newUser.getLastIp());
  14. // ③检测登录记录
  15. String sql = "select count(1) from t_login_log where user_id=? "+
  16. “ and login_datetime=? and ip=?";
  17. int logCount =simpleJdbcTemplate.queryForInt(sql, user.getUserId(),
  18. user.getLastVisit(),user.getLastIp());
  19. Assert.assertEquals(1, logCount);
  20. }

在业务方法执行后，我们查询数据库中相应记录以检查是否和期望的效果一致，如 ① 和 ② 所示。在 ③ 处，我们使用 SimpleJdbcTemplate 查询 t_login_log，以检查该表中是否已经添加了一条用户登录日志。

注意：由于我们的 DAO 层采用 Spring JDBC 框架，它没有采用服务层缓存技术，所以可以使用 DAO 类返回数据库中的数据。如果采用
Hibernate 等 ORM 框架，由于它们采用了服务层缓存的技术，为了获取数据库中的相应数据，需要在业务方法执行后调用
HibernateTemplate.flush() 方法，将缓存中的对象同步到数据库中，这时才可以通过 SimpleJdbcTemplate
在数据库中访问业务方法的执行情况。

小结

我们通过对一个典型的涉及数据库访问操作的 UserService 服务类的测试，讲述了使用 Spring 2.5 TestContext
测试框架进行集成测试的各项问题，这包括测试固件的自动注入、事务自动回滚、通过 SimpleJdbcTemplate
直接访问数据库以及测试数据准备等问题。

在通过一个实际例子的学习后，我们对如何使用 TestContext 测试框架有了一个具体的认识，在此基础上我们对 Spring
TestContext 测试框架体系结构进行了分析，然后剖析了 Spring 为 TestContext 嫁接到 JUnit 4.4
测试框架上所提供的两个抽象测试用例类。

Spring 的 TestContext 测试框架不但可以整合到 JUnit 4.4 测试框架上，而且还可以整合到 JUnit 3.8 以及
TestNG 等测试框架上。目前已经提供了对 JUnit 3.8 以及 TestNG 的支持，你可以分别在
org.springframework.test.context.junit38 和
org.springframework.test.context.testng 包下找到整合的帮助类。

转自（http://www.ibm.com/developerworks/cn/java/j-lo-spring25-test/?S_TACT=105AGX52&S_CMP=techcsdn）

时间： 2024-10-27 17:00:47

Spring基于注解TestContext 测试框架使用详解的相关文章

Spring基于注解TestContext 测试框架使用问题

import cn.itcast.mybatis.pojo.User; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.c

测试框架mochajs详解

测试框架mochajs详解 章节目录 关于单元测试的想法 mocha单元测试框架简介 安装mocha 一个简单的例子 mocha支持的断言模块 同步代码测试 异步代码测试 promise代码测试 不建议使用箭头函数 钩子函数 钩子函数的描述参数 异步的钩子函数 全局钩子 延迟启动测试 测试用例TODO 仅执行一个用例集/用例 跳过哪些用例集/用例 重新执行用例 动态生成用例 测试时间 测试超时 用例集执行超时 用例执行超时 钩子函数超时 diff差异比较功能 mocha使用命令和参数 mocha

Spring TestContext测试框架

1.基于注解的TestContext测试框架,它采用注解技术可以让POJO成为Spring的测试用例,可以运行在Junit3.8 Junit4.4 TestNG等测试框架之下 2.直接使用Junit测试Spring程序存在的不足 1).导致Spring容器多次初始化问题 根据JUnit测试用例的调用流程,每执行一个测试方法都会重新创建一个测试用例实例并调用其setUp() 方法. 由于在一般情况下,我们都在setUp() 方法中初始化Spring 容器,这意味着测试用例中有多少个测试方法,Spr

Spring TestContext测试框架搭建

同样是测试,JUnit和Spring TestContext相比,Spring TestContext优势如下: 1.Spring TestContext可以手动设置测试事务回滚,不破坏数据现场 2.在测试类中不用手动装配bean,只要一个@Autowired即可自动装配 ----------------分割线--------------------------- 本文记录web project和java project如何使用TestContext测试框架,首先介绍web project 现总

S2SH框架集成详解(Struts 2.3.16 + Spring 3.2.6 + Hibernate 3.6.10)

近期集成了一次较新版本的s2sh,出现了不少问题,网上资料也是良莠不齐,有的甚至就是扯淡,简单的把jar包扔进去就以为是集成成功了,在这里整理一下详细的步骤,若哪位有什么不同看法,可以留言,欢迎批评改正. 首先说下集成的环境,Eclipse 4.4,Tomcat 7.0.54,Struts2.3.16,Hibernate3.6.10,Spring3.2.6 相关JAR包已上传至百度云:http://pan.baidu.com/s/1pJluA5l 搭建Struts2框架 1. 创建Java We

spring基于注解的IOC（2）

spring第二天:spring基于注解的IOC以及IoC的案例1.spring中ioc的常用注解 用于创建对象的:Component.Controller.Service.Repository 用于注入数据的:Autowired.Qualifier.Resource.Value 用于改变作用范围的:Scope . 和生命周期相关:PreDestroy .PostConstruct 2.案例使用xml方式和注解方式实现单表的CRUD操作 持久层技术选择:dbutils3.改造基于注解的ioc案例

结合项目（Spring+(基于注解的)SpringMVC和Mybatis+uploadify文件上传）--poi解析Excel文件

poi解析Excel文件 1.上传文件至服务器 2.解析Excel文件并返回数据集合 3.将数据保存到服务器 框架======Spring+(基于注解的)SpringMVC和Mybatis===== 第一步: 前台: jsp文件采用的是uploadify <div id="fileQueue"></div> <input type="file" id="brandFile"> js: <script ty

阶段3 2.Spring_08.面向切面编程 AOP_9 spring基于注解的AOP配置

复制依赖和改jar包方式 src下的都复制过来. 复制到新项目里了 bean.xml里面复制上面一行代码到下面.把aop改成context. 配置spring容器创建时要扫描的包 Service的配置这里就可以删除了 配置注解 使用@Service注解 开始AOP配置 把通知类交给Spring来管理 在Logger上加注解.之类注意,@Service和@Repository都不合适.因为logger属于三层 所以这里用@Component这个注解来配置 写完上面的@Component的注解后.b

spring在IoC容器中装配Bean详解

1.Spring配置概述 1.1.概述 Spring容器从xml配置.java注解.spring注解中读取bean配置信息,形成bean定义注册表: 根据bean定义注册表实例化bean: 将bean实例放入bean缓存池: 应用程序使用bean. 1.2.基于xml的配置 (1)xml文件概述 xmlns------默认命名空间 xmlns:xsi-------标准命名空间,用于指定自定义命名空间的schema文件 xmlns:xxx="aaaaa"-------自定义命名空间,xx