Spring框架学习笔记2：AOP及其相关概念和使用示例
1.AOP及其相关概念
1)AOP 面向切面(方面)编程
主要解决共通处理问题.可以将共通处理部分单独用一个组件封装起来,然后利用SpringAOP机制作用到某一批目标对象上面.从而降低共通处理对象和目标对象之间关联.
AOP与OOP关系,OOP面向对象编程,侧重于对象的封装；AOP面向切面编程是以OOP为基础,侧重于对共通处理的操作.改善程序结构,提高灵活性.
2)切面(方面)Aspect
指的是共通处理部分的代码.也称为关注点的实现.
3)连接点Joinpoint
指的是作用在目标对象上的位置.例如方法调用,异常发生后等
4)切入点Pointcut
指的是连接点的集合,对应一个切入点表达式.
5)目标对象Target Object
指的是使用切面功能的对象.需要在Spring容器中.
6)通知 Advice
指的是连接点作用的时机.例如方法调用前,方法调用后执行切面功能等.
7)动态代理AutoProxy
采用AOP之后,Spring会为每一个目标对象创建一个代理对象,该代理对象相当于切面和目标对象功能的结合体.
Spring采用两种方式:
a.JDK Proxy方式
适用于目标对象有接口.
b.CGLIB方式
适用于目标对象没有接口.
2.AOP使用示例
UserDAO.java:
1 2 3 4 5 6 7 |
package com.weishuzhai.target;
public interface UserDAO {
public void save();
public void findByEmail(String email);
} |
实现类UserDAOImpl.java:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
package com.weishuzhai.target;
public class JDBCUserDAOImpl implements UserDAO {
public void findByEmail(String email) {
System.out.println("采用JDBC技术保存用户信息");
}
public void save() {
System.out.println("采用JDBC技术查询用户信息");
}
} |
UserService.java:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
package com.weishuzhai.user;
import org.junit.Test;
import com.weishuzhai.target.UserDAO;
public class UserService {
public UserDAO userDao;
public void setUserDao(UserDAO userDao) {
this.userDao = userDao;
}
/**
* 注册业务方法
*
*/
public void regist() {
// System.out.println("-- 欢迎使用该功能 --");
System.out.println("数据保存成功！谢谢使用！");
userDao.save();
}
/**
* 登录业务方法
*
*/
public void login() {
System.out.println("登录成功，谢谢使用!");
userDao.findByEmail("Tom");
}
} |
1)示例步骤
a.引入jar包
aspectjweaver.jar
aspectjrt.jar
cglib-nodep-2.1_3.jar
commons-logging.jar
spring.jar
b.寻找关注点,采用切面组件封装.
切面组件MyAspect.java：
1 2 3 4 5 6 7 8 9 10 11 |
package com.weishuzhai.aspect;
public class MyAspect {
public void myAspectBefore() {
System.out.println("-- 欢迎使用该功能 --");
}
public void myAspectAfter() {
System.out.println("-- 功能使用结束！谢谢使用 --");
}
} |
c.在spring配置中添加AOP配置
添加aop命名空间
指定切面
1 |
<aop:aspect /> |
定义切入点
1 |
<aop:pointcut /> |
指定切入点采用哪种类型的通知
1 |
<aop:before /> |
spring配置文件applicationContext.xml:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
< ?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:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd" default-lazy-init="true"> <bean id="userDAO" class="com.weishuzhai.target.JDBCUserDAOImpl"/> <bean id="userService" class="com.weishuzhai.user.UserService"> <property name="userDao" ref="userDAO"></property> </bean> <!-- AOP配置 --> <bean id="myAspect" class="com.weishuzhai.aspect.MyAspect"/> <aop:config> <!-- 将myAspect Bean组件指定为切面组件 --> <aop:aspect id="aspectEx" ref="myAspect"> <!-- 切入点,匹配UserService类中的所有方法 --> <aop:pointcut id="servicePointcut" expression="execution(* com.weishuzhai.user.UserService.*(..))"></aop:pointcut> <!-- 定义前置通知.指定切面组件中的myAspectbefore方法,在切入点之前调用 --> <aop:before pointcut-ref="servicePointcut" method="myAspectBefore"></aop:before> <!-- 定义最终通知,指定切面组件中的myAspectAfter方法,在切入点之后调用 --> <aop:after pointcut-ref="servicePointcut" method="myAspectAfter"></aop:after> </aop:aspect> </aop:config> </beans> |
d.测试执行TestUserService.java:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.weishuzhai.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.weishuzhai.user.UserService;
public class TestUserService {
@Test
public void test() {
ApplicationContext ac = new ClassPathXmlApplicationContext(
"applicationContext.xml");
UserService service = (UserService) ac.getBean("userService");
service.regist();
service.login();
}
} |
运行结果：
3.通知类型
1)前置通知
1 |
<aop:before /> |
目标对象方法调用前执行.
2)后置通知
1 |
<aop:after -returning/> |
目标对象方法成功调用之后执行.
3)最终通知
1 |
<aop:after /> |
目标对象方法调用之后执行,不论是成功还是失败.
4)环绕通知
1 |
<aop:around /> |
目标对象方法调用之前和之后执行.
5)异常通知
1 |
<aop:after -throwing/> |
目标对象方法调用出现异常后执行.
try{
前置通知
环绕通知1
目标对象方法
环绕通知1
后置通知
}catch(){
异常通知
}finally{
最终通知
}
4.切入点表达式
*1)方法限定execution
示例1:任意公共方法的执行
execution (public * *(..))
示例2:任何一个名字以“set”开始的方法的执行
execution (* set*(..))
示例3:AccountService中定义的任意方法的执行
execution (* service.AccountService.*(..))
示例4:在service包中定义的任意方法的执行
execution (* service.*.*(..))
示例5:在service包或其子包中定义的任意方法的执行
execution (* service..*.*(..))
*2)类型限定within
示例1:AccountService中定义的任意方法的执行
within (service.AccountService)
示例2:在service包中定义的任意类型的任意方法
within (service.*)
示例3:在service包或其子包中定义的任意类型的任意方法
within (service..*)
*3)Bean对象名限定bean
示例:匹配所有的id或name名字以Service结束的组件
bean(*Service)
4)特定类型限定this或target
this指的是限定特定的代理类型
target指的是限定特定的目标对象类型
示例1:实现了AccountService的代理对象
this (service.AccountService)
示例2:实现了AccountService的目标对象
target (service.AccountService)
5)方法参数限定args
示例:匹配方法有一个String参数的
args (java.lang.String)
—————————–