• spring5.3 十三：spring AOP分析

    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();
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    上面是通过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();
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    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();
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    通过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("方法抛出异常后执行");
	};
}

    • 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

    测试：

    		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();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    在这里插入图片描述
    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();
	}
}

    • 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
    • 33
    • 34
    • 35
    • 36

    创建代理对象的方式

    上面介绍了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();

	}

    • 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
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42

    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();

	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    通过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();
	}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    通过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");
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    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

  • 相关阅读:
    应用商店优化的好处有哪些？
    点击化学（Click chemistry） 叠氮-PEG4-NHS/Biotin-PEG-N3/Azid/DBCO-EPG-NHS/DBCO-NH2
    Doris Broker Load入门实战
    python opencv环境配置 保姆级教程
    【密码加密原则】
    基于Java实现的GRE(美国研究生入学考试)学习系统
    飞书-多维文档-计算时间差
    Redis 键值设计使用总结
    【GD32F427开发板试用】+demo的正确打开方式（一）
    Git基本使用
  • 原文地址：https://blog.csdn.net/admin522043032/article/details/126261658