spring AOP底层分析
动态代理
AOP的实现离不开动态代理。
代理模式的解释:为其他对象提供一种代理以控制对这个对象的访问,增强一个类中的某个方法,对程序进行扩展。
动态代理实现方式一般有两种cglib和jdk的动态代理
cglib
public class BookService {
public void test(){
System.out.println("BookService ------test()-----------");
}
public static void main(String[] args) {
BookService target = new BookService();
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(BookService.class);
//定义额外的代理逻辑
enhancer.setCallback(new MethodInterceptor(){
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("before...");
Object result = methodProxy.invoke(target, objects);
System.out.println("after...");
return result;
}
});
//得到代理对象
BookService bookService = (BookService)enhancer.create();
bookService.test();
}
}
上面是通过cglib来实现的代理对象的创建,是基于父子类的,被代理类(BookService)是父类,代理类是子类,代理对象就是代理类的实例对象,代理类是由cglib创建的,对于程序员来说不用关心。
jdk动态代理
public interface BookInterface {
void test();
}
public class BookService implements BookInterface{
public void test(){
System.out.println("BookService ------test()-----------");
}
public static void main(String[] args) {
BookService target = new BookService();
Object proxy = Proxy.newProxyInstance(BookService.class.getClassLoader(), new Class[]{BookInterface.class},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("before...");
Object result = method.invoke(target, args);
System.out.println("after...");
return result;
}
});
BookInterface bookInterface = (BookInterface)proxy;
bookInterface.test();
}
}
jdk动态代理的类型是接口类型,由于这个限制,所以产生的代理对象的类型是BookInterface,而不是BookService,这是需要注意的。
spring AOP
上面介绍了两种动态代理技术,那么在Spring中进行了封装,封装出来的类叫做ProxyFactory,表示是创建代理对象的一个工厂,使用起来会比上面的更加方便,比如
public class BookService implements BookInterface{
public void test(){
System.out.println("BookService ------test()-----------");
}
public static void main(String[] args) {
BookService target = new BookService();
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.addAdvice(new MethodInterceptor() {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("before...");
Object result = invocation.proceed();
System.out.println("after...");
return result;
}
});
BookInterface bookInterface = (BookInterface)proxyFactory.getProxy();
bookInterface.test();
}
}
通过ProxyFactory,我们可以不再关心到底是用cglib还是jdk动态代理了,ProxyFactory会帮我们去判断,如果BookService实现了接口,那么ProxyFactory底层就会用jdk动态代理,如果没有实现接口,就会用cglib技术,上面的代码,就是由于BookService实现了BookInterface接口,所以最后产生的代理对象是BookInterface类型。
Advice的分类
Before Advice:方法之前执行
After returning advice:方法return后执行
After throwing advice:方法抛异常后执行
After (finally) advice:方法执行完finally之后执行,这是最后的,比return更后
Around advice:这是功能最强大的Advice,可以自定义执行顺序
public class MyBeforeAdvice implements MethodBeforeAdvice {
@Override
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println("MyBeforeAdvice---------------");
}
}
public class MyAfterAdvice implements AfterReturningAdvice {
@Override
public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
System.out.println("MyAfterAdvice---------------");
}
}
public class MyAroundAdvice implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
System.out.println("MyAroundAdvice ----- init");
Object proceed = methodInvocation.proceed();
System.out.println("MyAroundAdvice ----- after");
return proceed;
}
}
public class MyThrowAdvice implements ThrowsAdvice {
public void afterThrowing(Method method, Object[] args, Object target, Exception ex){
System.out.println("方法抛出异常后执行");
};
}
测试:
BookService target = new BookService();
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.addAdvice(new MyBeforeAdvice());
proxyFactory.addAdvice(new MyAfterAdvice());
proxyFactory.addAdvice(new MyAroundAdvice());
BookInterface bookInterface = (BookInterface)proxyFactory.getProxy();
bookInterface.test();
Advisor
跟Advice类似的还有一个Advisor的概念,一个Advisor是有一个Pointcut和一个Advice组成的,通过Pointcut可以指定要需要被代理的逻辑,比如一个BookService类中有两个方法,按上面的例子,这两个方法都会被代理,被增强,那么我们现在可以通过Advisor,来控制到具体代理哪一个方法,比如:
public class BookService {
public void test(){
System.out.println("BookService ------test()-----------");
}
public void book(){
System.out.println("BookService ------book()-----------");
}
public static void main(String[] args) {
BookService target = new BookService();
//spring Advisor
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(target);
proxyFactory.addAdvisor(new PointcutAdvisor() {
@Override
public Pointcut getPointcut() {
return new StaticMethodMatcherPointcut(){
@Override
public boolean matches(Method method, Class<?> aClass) {
return method.getName().equals("book");
}
};
}
@Override
public Advice getAdvice() {
return new MyAroundAdvice();
}
@Override
public boolean isPerInstance() {
return false;
}
});
BookService bookService = (BookService)proxyFactory.getProxy();
bookService.book();
}
}
创建代理对象的方式
上面介绍了Spring中所提供了ProxyFactory、Advisor、Advice、PointCut等技术来实现代理对象的创建,但是我们在使用Spring时,我们并不会直接这么去使用ProxyFactory,比如说,我们希望ProxyFactory所产生的代理对象能直接就是Bean,能直接从Spring容器中得到BookService的代理对象,而这些,Spring都是支持的,只不过,作为开发者肯定得告诉Spring,那些类需要被代理,代理逻辑是什么。
@Configuration
public class AopConfig {
@Bean
public ProxyFactoryBean bookServiceProxy(){
BookService target = new BookService();
ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
proxyFactoryBean.setTarget(target);
proxyFactoryBean.addAdvisors(bookPointcutAdvisor());
return proxyFactoryBean;
}
@Bean
public PointcutAdvisor bookPointcutAdvisor(){
return new PointcutAdvisor() {
@Override
public Pointcut getPointcut() {
return new StaticMethodMatcherPointcut(){
@Override
public boolean matches(Method method, Class<?> aClass) {
return method.getName().equals("book");
}
};
}
@Override
public Advice getAdvice() {
return new MyAroundAdvice();
}
@Override
public boolean isPerInstance() {
return false;
}
};
}
}
//测试
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
BookService proxy = (BookService)context.getBean("bookServiceProxy");
proxy.book();
}
BeanNameAutoProxyCreator
ProxyFactoryBean得自己指定被代理的对象,那么我们可以通过BeanNameAutoProxyCreator来通过指定某个bean的名字,来对该bean进行代理
@Bean
public BeanNameAutoProxyCreator beanNameAutoProxyCreator(){
BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
//模糊匹配 满足这个命名规则的bean都会成为代理对象
beanNameAutoProxyCreator.setBeanNames("bookSer*");
beanNameAutoProxyCreator.setProxyTargetClass(true);
beanNameAutoProxyCreator.setInterceptorNames("bookPointcutAdvisor");
return beanNameAutoProxyCreator;
}
//测试
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
BookService proxy = (BookService)context.getBean("bookService");
proxy.book();
}
通过BeanNameAutoProxyCreator可以对批量的Bean进行AOP,并且指定了代理逻辑,指定了一个InterceptorName,也就是一个Advise,前提条件是这个Advise也得是一个Bean,这样Spring才能找到的,但是BeanNameAutoProxyCreator的缺点很明显,它只能根据beanName来指定想要代理的Bean。
DefaultAdvisorAutoProxyCreator
@Bean
public DefaultPointcutAdvisor defaultPointcutAdvisor(){
NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
pointcut.addMethodName("book");
//这里的切点表示所有的bean执行了book方法名的方法就会执行代理逻辑
DefaultPointcutAdvisor defaultPointcutAdvisor = new DefaultPointcutAdvisor();
defaultPointcutAdvisor.setPointcut(pointcut);
defaultPointcutAdvisor.setAdvice(new MyAroundAdvice());
return defaultPointcutAdvisor;
}
@Bean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
return new DefaultAdvisorAutoProxyCreator();
}
通过DefaultAdvisorAutoProxyCreator会直接去找所有Advisor类型的Bean,根据Advisor中的PointCut和Advice信息,确定要代理的Bean以及代理逻辑。
但是,我们发现,通过这种方式,我们得依靠某一个类来实现定义我们的Advisor,或者Advise,或者Pointcut,那么这个步骤能不能更加简化一点呢?对的,就是通过注解!
上述代码可以改变为
@EnableAspectJAutoProxy
@Configuration
public class AopConfig {}
@Component
@Aspect
public class MyAspect {
@Before("execution(public void aop.BookService.book())")
public void myBefore(JoinPoint joinPoint) {
System.out.println("myBefore --- BookService init");
}
}
AOP 的概念
Aspect:表示切面,比如被@Aspect注解的类就是切面,可以在切面中去定义Pointcut、Advice等等
Join point:表示连接点,表示一个程序在执行过程中的一个点,比如一个方法的执行,比如一个异常的处理,在Spring AOP中,一个连接点通常表示一个方法的执行。
Advice:表示通知,表示在一个特定连接点上所采取的动作。Advice分为不同的类型,后面详细讨论,在很多AOP框架中,包括Spring,会用Interceptor拦截器来实现Advice,并且在连接点周围维护一个Interceptor链
Pointcut:表示切点,用来匹配一个或多个连接点,Advice与切点表达式是关联在一起的,Advice将会执行在和切点表达式所匹配的连接点上
Introduction:可以使用@DeclareParents来给所匹配的类添加一个接口,并指定一个默认实现
Target object:目标对象,被代理对象
AOP proxy:表示代理工厂,用来创建代理对象的,在Spring Framework中,要么是JDK动态代理,要么是CGLIB代理
Weaving:表示织入,表示创建代理对象的动作,这个动作可以发生在编译时期(比如Aspejctj),或者运行时,比如Spring AOP
Advice在Spring AOP中对应API
上面说到的Aspject中的注解,其中有五个是用来定义Advice的,表示代理逻辑,以及执行时机:
@Before
@AfterReturning
@AfterThrowing
@After
@Around
前面也提到过,Spring自己也提供了类似的执行实际的实现类:
接口MethodBeforeAdvice,继承了接口BeforeAdvice
接口AfterReturningAdvice
接口ThrowsAdvice
接口AfterAdvice
接口MethodInterceptor
Spring会把五个注解解析为对应的Advice类:
@Before:AspectJMethodBeforeAdvice,实际上就是一个MethodBeforeAdvice
@AfterReturning:AspectJAfterReturningAdvice,实际上就是一个AfterReturningAdvice
@AfterThrowing:AspectJAfterThrowingAdvice,实际上就是一个MethodInterceptor
@After:AspectJAfterAdvice,实际上就是一个MethodInterceptor
@Around:AspectJAroundAdvice,实际上就是一个MethodInterceptor
springAOP案例
//定义注解
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface AopDemo {
}
//代理类
@Component
public class MyProxyDemo {
@AopDemo
public void devOpen(AopEntity aopEntity){
System.out.println("--BookService:devOpen----数据:"+aopEntity.toString());
}
public AopEntity aopTest(String name,Integer age){
System.out.println("--BookService:aopTest----数据:"+name+age);
return new AopEntity(name,age);
}
}
//定义切面
@Component
@Aspect
public class MyAspect {
//通过判断注解决定是否执行切面
@Pointcut(value = "@annotation(AopDemo))")
public void pointCut(){};
@Before("pointCut()")
public void testBefore(JoinPoint joinPoint){
System.out.println("----------------------------前置通知---");
//方法入参
Object[] args = joinPoint.getArgs();
for (Object arg : args) {
System.out.println(arg);
}
}
//<修饰符模式>?<返回类型模式> <方法名模式>(<参数模式>)<异常模式>?
//不限定参数类型 (..)
//returning = "obj" 定义方法返回值
@AfterReturning(value = "execution(public * aop.*.aopTest(String,Integer))",returning = "obj")
public void testAfterReturning(JoinPoint joinPoint,Object obj){
System.out.println("----------------------------后置通知---");
//输出返回值
System.out.println(obj.toString());
}
@Around(value = "execution(public * aop.*.aopTest(String,Integer))")
public void testAround(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("----------------------------环绕通知开始---");
//获取入参
Object[] args = joinPoint.getArgs();
for (Object arg : args) {
System.out.println(arg);
}
//获取代理方法名
MethodSignature signature = (MethodSignature)joinPoint.getSignature();
String name = signature.getName();
//获取代理对象
Object target = joinPoint.getTarget();
//获取代理方法 注解 属性等
Class<?> aClass = target.getClass();
Method method = aClass.getMethod(name, signature.getParameterTypes());
Annotation[] annotations = method.getAnnotations();
//获取方法返回值
Object proceed = joinPoint.proceed();
System.out.println(proceed.toString());
System.out.println("----------------------------环绕通知结束---");
}
}
测试:
public class Test {
public static void main(String[] args) {
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
MyProxyDemo proxy = (MyProxyDemo)context.getBean("myProxyDemo");
proxy.devOpen(new AopEntity("中国",18));
proxy.aopTest("aa",18);
}
}