Spring框架之-环绕增强

环绕增强的功能比较强大

环绕增强的特点：

　　目标方法前后都可织入增强处理

　　功能最强大的增强处理

　　可获取或修改目标方法的参数、返回值，可对他进行异常处理，甚至可以决定目标方法是否执行。

<aop:around> 定义坏绕增强

还是接着上一个案例的代码进行改造

UserServiceLogger.java

 1     //环绕增强
 2     public void aroundLogger(ProceedingJoinPoint joinPoint) {
 3         //下面是目标方法的前面执行的处理
 4         logger.info("调用" + joinPoint.getTarget() + "的"
 5                 + joinPoint.getSignature() + "方法，方法参数是："
 6                 + Arrays.toString(joinPoint.getArgs()));
 7         Object result;//这个相当于是目标方法  
 8         try {
 9             //下面是目标方法之后进行的处理
10                 result = joinPoint.proceed();
11                 logger.info("调用"+joinPoint.getTarget()+"的"+joinPoint.getSignature()+"方法，方法返回值："+result);
12             
13         } catch (Throwable e) {
14             logger.error(joinPoint.getSignature().getName()+"方法发生异常"+e);
15             e.printStackTrace();
16         } finally{
17             
18         }
19     }

UserDaoImpl.java

 1 package dao.impl;
 2 
 3 import dao.UserDao;
 4 import entity.User;
 5 
 6 /**
 7  * 用户DAO类，实现IDao接口，负责User类的持久化操作
 8  */
 9 public class UserDaoImpl implements UserDao {
10 
11     public void save(User user) {
12         // 这里并未实现完整的数据库操作，仅为说明问题
13         System.out.println("保存用户信息到数据库");
14         //throw new RuntimeException("为了测试程序异常");
15     }
16 }

UserServiceImpl.java

 1 package service.impl;
 2 
 3 import service.UserService;
 4 import dao.UserDao;
 5 import entity.User;
 6 
 7 /**
 8  * 用户业务类，实现对User功能的业务管理
 9  */
10 public class UserServiceImpl implements UserService {
11 
12     // 声明接口类型的引用，和具体实现类解耦合
13     private UserDao dao;
14 
15     
16 
17     // 生成无参构造方法
18     public UserServiceImpl() {
19 
20     }
21 
22     // 带参数构造方法   为dao进行赋值
23     public UserServiceImpl(UserDao dao) {
24         this.dao = dao;
25     }
26 
27 
28     public UserDao getDao() {
29         return dao;
30     }
31 
32     // dao 属性的setter访问器，会被Spring调用，实现设值注入
33     public void setDao(UserDao dao) {
34         this.dao = dao;
35     }
36 
37     public void addNewUser(User user) {
38         // 调用用户DAO的方法保存用户信息
39         dao.save(user);
40         System.out.println("注入进去的user对象的信息是："+user.toString());
41     }
42 }

在核心配置文件中配置环绕增强

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans
 5     http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
 6     http://www.springframework.org/schema/aop
 7     http://www.springframework.org/schema/aop/spring-aop-3.2.xsd">
 8     <!--以上是Spring框架的头信息 使用p命名空间注入 -->
 9     <bean id="dao" class="dao.impl.UserDaoImpl"></bean>
10     <bean id="service" class="service.impl.UserServiceImpl">
11         <property name="dao" ref="dao"></property>
12     </bean>
13     <!-- 声明增强方法所在的Bean -->
14     <bean id="theLogger" class="aop.UserServiceLogger"></bean>
15     <aop:config>
16         <!--定义切入点 -->
17         <aop:pointcut expression="execution(public void addNewUser(entity.User))"
18             id="pointcut" />
19         <aop:aspect ref="theLogger">
20             <aop:around method="aroundLogger"
21                 pointcut-ref="pointcut"  />
22         </aop:aspect>
23     </aop:config>
24 </beans>

编写测试方法

 1 public class AopTest {
 2 
 3     @Test
 4     public void aopTest() {
 5         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
 6         UserService a = (UserService) ctx.getBean("service");
 7         User user=new User();
 8         user.setUsername("丫丫");
 9         a.addNewUser(user);
10     }
11 
12 }

运行结果：

12-30 18:14:52[INFO]aop.UserServiceLogger
-调用service.impl.UserServiceImpl@460d0a57的void service.UserService.addNewUser(User)方法，方法参数是：[entity.User@36c88a32]
保存用户信息到数据库
注入进去的user对象的信息是：entity.User@36c88a32
12-30 18:14:52[INFO]aop.UserServiceLogger
-调用service.impl.UserServiceImpl@460d0a57的void service.UserService.addNewUser(User)方法，方法返回值：null