Spring AOP
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程
日志记录，性能统计，安全控制，事务处理，异常处理等等
AOP与OOP区别
OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。
而AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。这两种设计思想在目标上有着本质的差异。
AOP相关术语
目标对象target:指的是需要被增强的对象，由于spring aop是通过代理模式实现，从而这个对象永远是被代理对象。
连接点(join point):所谓连接点是指那些被拦截到的点，在spring中这些点指的是方法，因为spring只支持方法类型的连接点
切入点(pointcut):简单说切入点是指我们要对哪些连接点进行拦截的定义
通知(advice):所谓通知是指拦截到连接点之后所要做的事情就是通知，通知分为前置通知，后置通知，异常通知，最终通知，环绕通知
Advice 定义了在 pointcut 里面定义的程序点具体要做的操作
引介introduction:引介是一种特殊的通知，在不修改类代码的前提下，introduction可以在运行期为类动态地添加一些方法或属性
切面aspect:是切入点和通知的结合
织入weaving:织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在编译期，类装载期，运行期进行。
Spring采用动态织入，而aspectj采用静态织入
代理Proxy:一个类被AOP织入增强后，就产生一个结果代理类
AOP底层:
JDK动态代理:在运行 ，在JVM内部动态生成class字节码对象(Class对象)
Jdk动态代理只针对于接口操作
newProxyInstance的三个参数:
第一个参数:目标类的类加载器对象
第二个参数:目标类的实现接口的Class[]
第三个参数:InvocationHandler它是一个接口，它的作用是是代理实例的调用处理程序 实现的接口，接口中定义了一个方法
下面举个例子:
public class ProxyFactory implements InvocationHandler{ private Object target; //在创建对象时,传入代理目标对象 public ProxyFactory(Object target){ this.target = target; } //创建代理对象 public Object createProxy() { //使用proxy创建代理对象 /* * 准备类加载器 * 准备实现接口的class[] * 实现invocationHandler * */ ClassLoader classLoader = target.getClass().getClassLoader(); Class [] interfaces = target.getClass().getInterfaces(); return Proxy.newProxyInstance(classLoader, interfaces, this); } //在代理对象上处理方法并返回结果 /** * 参数1就是代理对象 * 参数2就是调用方法的method对象 * 参数3调用方法的参数 * */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("日志操作"); return method.invoke(target, args); } }
@Service(value="userServiceImpl") public class UserServiceImpl implements UserService { @Override public void login(String username, String password) { System.out.println("登录操作!....."); } @Override public void regist() { System.out.println("注册操作!....."); } }
<context:component-scan base-package="com.learn"></context:component-scan>
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations="classpath:applicationContext.xml") public class TestProxy { //准备目标对象 @Autowired private UserService us; @Test public void test1() { //创建代理工厂 ProxyFactory pf = new ProxyFactory(us); //返回代理对象赋值给目标对象 us = (UserService) pf.createProxy(); us.regist(); } }
CGLIB动态代理
CGLIB(Code Generation Library)是一个开源项目,它可以在运行期扩展Java类与实现Java接口。
CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类
注意:jdk的动态代理只可以为接口去完成操作，而cglib它可以为没有实现接口的类去做代理，也可以为实现接口的类去做代理。
举个例子:
public class CGLIBFactory implements MethodInterceptor{ //准备目标对象 private Object target; //构造方法 public CGLIBFactory(Object target) { this.target = target; } //创建代理对象 public Object createProxy() { //创建Enhancer Enhancer enhancer = new Enhancer(); //传递目标对象的class enhancer.setSuperclass(target.getClass()); //设置回调操作 enhancer.setCallback(this); return enhancer.create(); } @Override public Object intercept(Object arg0, Method method, Object[] arg2, MethodProxy arg3) throws Throwable { System.out.println("日志操作"); return method.invoke(target, arg2); } }
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations="classpath:applicationContext.xml") public class TestCGLB { //准备非接口目标对象 @Autowired private UserServiceImpl usi; @Test public void test() { //创建代理类对象,传递目标对象 CGLIBFactory cf = new CGLIBFactory(usi); //获得代理类对象重新赋值给usi usi = (UserServiceImpl) cf.createProxy(); usi.regist(); } }
setCallback传递的参数是Callback类型，我们使用的是MethodInterceptor
注意:cglib它可以为没有实现接口的类做代理，也可以为接口类做代理.
spring采用的是哪一种动态机制:
如果目标对象，有接口，优先使用jdk动态代理
如果目标对象，无接口，使用cglib动态代理。
Spring AOP编程
在传统的spring aop开发中它支持增强(advice)有五种:
1. 前置通知 目标方法执行前增强 org.springframework.aop.MethodBeforeAdvice
2. 后置通知 目标方法执行后增强 org.springframework.aop.AfterReturningAdvice
3. 环绕通知 目标方法执行前后进行增强 org.aopalliance.intercept.MethodInterceptor
4. 异常抛出通知 目标方法抛出异常后的增强 org.springframework.aop.ThrowsAdvice
5. 引介通知 在目标类中添加一些新的方法或属性(不做介绍)org.springframework.aop.IntroductionInterceptor
下面举个最古老的spring AOP
//准备目标对象 public class OrderServiceImpl implements OrderService { @Override public void add() { System.out.println("add方法执行了....."); } @Override public void update() { System.out.println("update方法执行了......."); } }
<?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" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- 目标target --> <bean id="orderService" class="com.learn.service.impl.OrderServiceImpl"></bean> <!-- 通知advice --> <bean id="orderServiceAdvice" class="com.learn.utils.OrderHelper"></bean> <!-- 定义切点 --> <bean id="orderServicePointCut" class="org.springframework.aop.support.NameMatchMethodPointcut"> <property name="mappedNames"> <list> <!-- 配置需要拦截的方法 --> <value>add</value> <value>update</value> </list> </property> </bean> <!-- 配置切面aspect=pointCut+advice --> <bean id="orderServiceAspect" class="org.springframework.aop.support.DefaultPointcutAdvisor"> <property name="advice" ref="orderServiceAdvice"></property> <property name="pointcut" ref="orderServicePointCut"></property> </bean> <!-- 配置代理 --> <bean id="orderServiceProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <property name="target" ref="orderService"></property> <property name="interceptorNames" value="orderServiceAspect"></property> <property name="proxyInterfaces" value="com.learn.service.OrderService"></property> </bean> </beans>
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations="classpath:applicationContext.xml") public class Aop1Test { @Autowired @Qualifier("orderServiceProxy") private OrderService os; @Test public void test() { os.update(); } }
在原有的基础上修改的Spring AOP编程
//准备目标对象 public class OrderServiceImpl implements OrderService { @Override public void add() { System.out.println("add方法执行了....."); } @Override public void update() { System.out.println("update方法执行了......."); } }
<?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" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd" > <!-- 配置目标对象 --> <bean id="orderService" class="order"></bean> <!-- 配置通知 --> <bean id="orderServiceAdvice" class="com.learn.utils.OrderHelper"></bean> <!-- aop来描述切面和切点 --> <aop:config> <!-- 定义切点 --> <aop:pointcut expression="execution(* com.learn.service..*(..))" id="orderServicePointCut"/> <!-- 配置切面 --> <aop:advisor advice-ref="orderServiceAdvice" pointcut-ref="orderServicePointCut"/> </aop:config> </beans>
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations="classpath:applicationContext.xml") public class aop2Test { @Autowired @Qualifier("orderService") private OrderService os; @Test public void test() { os.update(); } }
基于aspectJ切点传统开发
@Service("customerService")
public class CustomerServiceImpl implements CustomerService{
@Override
public void add() {
System.out.println("add.........");
}
@Override
public String login() {
System.out.println("login........");
return "你好";
}
}
<?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" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd" > <!-- target --> <bean id="userService" class="com.learn.service.impl.UserServiceImpl"></bean> <!-- advice --> <bean id="userServiceAdvice" class="com.learn.utils.UserHelper"></bean> <!-- aspectj配置切面 --> <aop:config proxy-target-class="true"> <aop:aspect ref="userServiceAdvice"> <aop:pointcut expression="execution(* com.learn.service..*(..))" id="delPointCut"/> <aop:before method="before" pointcut-ref="delPointCut"/> <aop:before method="before1" pointcut-ref="delPointCut"/> <aop:after-returning method="afterReturning" pointcut-ref="delPointCut"/> <aop:after-throwing method="afterThrowing" pointcut-ref="delPointCut"/> </aop:aspect> </aop:config> </beans>
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations="classpath:applicationContext.xml") public class AspectjTest { @Autowired @Qualifier("userService") private UserService us; @Test public void test() { us.regist(); } }
spring框架默认情况下，会对有接口的类使用proxy代理。没有接口的类使用cglib代理
Proxy-target-class的值默认是false,它代表有接口使用proxy代理
问题：如果现在对目标要使用cglib代理,只需要将proxy-target-class设置为true.
<aop:config>来声明要对aop进行配置
<aop:pointcut>它是用于声明切点(简单说就是对哪些方法进行拦截)
<aop:advisor> 定义传统的aop的切面,传统的aop切面它只能包含一个切点与一个增强
<aop:aspect>定义aspectj框架的切面.,它可以包含多个切点与多个通知
关于切点表达式的写法:
关于execution语法常用:
1. execution(public * *()) 所有的public的方法
2. execution(* cn.itheima.aop.*(..)) 所有的aop包下的所有类的方法(不包含子包)
3. execution(* cn.itheima.aop..*(..)) 所有的aop包及其子包下的所有类的方法
4. execution(* cn.itheima.aop.IOrderService.*(..)) IOrderService接口中定义的所有方法
5. execution(* cn.itheima.aop.IOrderService+.*(..)) 匹配实现特定接口所有类的方法
6. execution(* save*(..)) 区配所有的以save开头的方法
AspectJ框架它定义的通知类型有6种
1. 前置通知Before 相当于BeforeAdvice
2. 后置通知AfterReturning 相当于AfterReturningAdvice
3. 环绕通知 Around 相当于MethodInterceptor
4. 抛出通知AfterThrowing 相当于ThrowAdvice
5. 引介通知DeclareParents 相当于IntroductionInterceptor
6. 最终通知After 不管是否异常，该通知都会执行相比spring 的传统AOP Advice多了一个最终通知
下面举例用注解配置aop
@Service("customerService")
public class CustomerServiceImpl implements CustomerService{
@Override
public void add() {
System.out.println("add.........");
}
@Override
public String login() {
System.out.println("login........");
return "你好";
}
}
//声明一个实体 @Component("customerServiceAdvice") //声明为一个bean的切面 @Aspect public class AnnotationCustomerHelper { //声明前置通知 @Before("execution(* com.learn.service..*(..))") public void before() { System.out.println("前置通知"); } //声明后置通知 @AfterReturning(value="execution(* com.learn.service..*(..))",returning="value") public void afterReturning(JoinPoint jp,Object value) { System.out.println("后置通知,目标方法的返回是="+value); } //声明环绕通知 @Around(value="execution(* com.learn.service..*(..))") public Object around(ProceedingJoinPoint pjp) throws Throwable{ System.out.println("环绕前置通知"); Object value = pjp.proceed(); System.out.println("环绕后置通知"); return value; } //声明异常抛出通知 @AfterThrowing(value="execution(* com.learn.service..*(..))",throwing="exception") public void afterThrowing(JoinPoint jp,Throwable exception) { System.out.println("出问题了"+exception); } //声明最终通知 @After("execution(* com.learn.service..*(..))") public void after() { System.out.println("最终通知"); } }
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations="classpath:applicationContext.xml") public class AnnotationAopTest { @Autowired @Qualifier("customerService") private CustomerService cs; @Test public void test1() { //cs.add(); cs.login(); } }