【Spring】Spring之AOP底层源码解析

这篇具有很好参考价值的文章主要介绍了【Spring】Spring之AOP底层源码解析。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目的

  • 理解Spring中AOP的实现原理
  • Spring中有关AOP功能的使用

动态代理

什么是动态代理:
其他对象提供一种代理以控制对这个对象的访问,增强一个类中的某个方法,对程序进行扩展。

如下一个service类,如果想不改变test方法代码的情况下,增加特定的逻辑,该怎么做呢?

public class UserService  {

    public void test() {
        System.out.println("test...");
    }

}

此时就可以用动态代理来实现了。

cglib动态代理

cglib是基于父子类的动态代理,被代理类(UserService)是父类,代理类是子类,代理对象就是代理类的实例,代理类是由cglib创建的,对于程序员来说不用关心。

UserService target = new UserService();

// 通过cglib技术
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserService.class);

// 定义额外逻辑,也就是代理逻辑
enhancer.setCallbacks(new Callback[]{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;
	}
}});

// 动态代理所创建出来的UserService对象
UserService userService = (UserService) enhancer.create();

// 执行这个userService的test方法时,就会额外会执行一些其他逻辑
userService.test();

jdk动态代理

jdk动态代理是基于接口的动态代理,UserService得先有一个接口才能利用jdk动态代理机制来生成一个代理对象。

定义接口:

public interface UserInterface {
	public void test();
}

public class UserService implements UserInterface {

	public void test() {
		System.out.println("test...");
	}

}

实现动态代理:

UserService target = new UserService();

// UserInterface接口的代理对象
Object proxy = Proxy.newProxyInstance(UserService.class.getClassLoader(), new Class[]{UserInterface.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;
	}
});

UserInterface userService = (UserInterface) proxy;
userService.test();

Spring选择代理方式

ProxyFactory在生成代理对象之前需要决定到底是使用JDK动态代理还是CGLIB技术。

源码如下:

// config就是ProxyFactory对象

// optimize为true,或proxyTargetClass为true,或用户没有给ProxyFactory对象添加interface
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
	Class<?> targetClass = config.getTargetClass();
	if (targetClass == null) {
		throw new AopConfigException("TargetSource cannot determine target class: " +
				"Either an interface or a target is required for proxy creation.");
	}
    // targetClass是接口,直接使用Jdk动态代理
	if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
		return new JdkDynamicAopProxy(config);
	}
    // 使用Cglib
	return new ObjenesisCglibAopProxy(config);
}
else {
    // 使用Jdk动态代理
	return new JdkDynamicAopProxy(config);
}

ProxyFactory

Spring中的ProxyFactory是对cglib和jdk动态代理的封装,表示是创建代理对象的一个工厂,使用起来会更加方便。

通过ProxyFactory实现动态代理:

UserService target = new UserService();

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

proxyFactory.addAdvice(new MethodBeforeAdvice() {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("MethodBeforeAdvice...");
    }
});

UserInterface userService = (UserInterface) proxyFactory.getProxy();
userService.test();

结果:

before...
MethodBeforeAdvice...
test...
after...

通过ProxyFactory,我们可以不再关系到底是用cglib还是jdk动态代理了,ProxyFactory会帮我们去判断,如果UserService实现了接口,那么ProxyFactory底层就会用jdk动态代理,如果没有实现接口,就会用cglib技术,上面的代码,就是由于UserService实现了UserInterface接口,所以最后产生的代理对象是UserInterface类型。

Advice

通过ProxyFactory#addAdvice()可以添加不同的Advice子类,比如MethodInvocation和MethodBeforeAdvice,以实现目标方法不同时机的增强逻辑。
Advice的分类:

  1. Before Advice:方法之前执行
  2. After returning advice:方法return后执行
  3. After throwing advice:方法抛异常后执行
  4. After (finally) advice:方法执行完finally之后执行,这是最后的,比return更后
  5. Around advice:这是功能最强大的Advice,可以自定义执行顺序

Advisor

Advice是控制某个类中的所有方法都有对应的增强逻辑,如何将增强逻辑关联到方法级别呢?通过Advisor,可以用来控制具体代理哪一个方法。
通过Advisor来判断指定增强逻辑的方法:

UserService target = new UserService();

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<?> targetClass) {
                // 增强的逻辑只有在方法testAbc中生效
                return method.getName().equals("testAbc");
            }
        };
    }

    @Override
    public Advice getAdvice() {
        return new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                System.out.println("before...");
                Object result = invocation.proceed();
                System.out.println("after...");
                return result;
            }
        };
    }

    @Override
    public boolean isPerInstance() {
        return false;
    }
});

UserInterface userService = (UserInterface) proxyFactory.getProxy();
userService.test();
userService.testAbc();

结果:

test... # test方法没有增强逻辑
before...
testAbc...
after...

创建代理对象的方式

使用Spring时,我们并不会直接通过ProxyFactory、Advice、Advisor、PointCut去使用ProxyFactory,而是告诉Spring,那些类需要被代理,代理逻辑是什么即可。

有如下几种方式。

ProxyFactoryBean

代码示例:

@Bean
public ProxyFactoryBean userServiceProxy(){
	UserService userService = new UserService();

	ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
    // 只能针对某一个Bean
	proxyFactoryBean.setTarget(userService);
	proxyFactoryBean.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;
		}
	});
	return proxyFactoryBean;
}

只能针对某一个Bean,它是一个FactoryBean,所以利用的就是FactoryBean技术,间接的将UserService的代理对象作为了Bean。

ProxyFactoryBean还有额外的功能,比如可以把某个Advice或Advisor定义成为Bean,然后在ProxyFactoryBean中进行设置。

@Bean
public MethodInterceptor FireAroundAdvice(){
	return new MethodInterceptor() {
		@Override
		public Object invoke(MethodInvocation invocation) throws Throwable {
			System.out.println("before...");
			Object result = invocation.proceed();
			System.out.println("after...");
			return result;
		}
	};
}

@Bean
public ProxyFactoryBean userService(){
	UserService userService = new UserService();
	
    ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
	proxyFactoryBean.setTarget(userService);
	proxyFactoryBean.setInterceptorNames("fireAroundAdvice");
	return proxyFactoryBean;
}

BeanNameAutoProxyCreator

通过BeanNameAutoProxyCreator可以批量指定bean的名字对bean进行代理,但是也只能根据bean的名字进行代理。

@Bean
public BeanNameAutoProxyCreator beanNameAutoProxyCreator() {
	BeanNameAutoProxyCreator beanNameAutoProxyCreator = new BeanNameAutoProxyCreator();
	beanNameAutoProxyCreator.setBeanNames("userSe*");
	beanNameAutoProxyCreator.setInterceptorNames("fireAroundAdvice");
	beanNameAutoProxyCreator.setProxyTargetClass(true);

    return beanNameAutoProxyCreator;
}

通过BeanNameAutoProxyCreator可以对批量的Bean进行AOP,并且指定了代理逻辑,指定了一个InterceptorName,也就是一个Advice,前提条件是这个Advice也得是一个Bean,这样Spring才能找到的,但是BeanNameAutoProxyCreator的缺点很明显,它只能根据beanName来指定想要代理的Bean。

DefaultAdvisorAutoProxyCreator

通过DefaultAdvisorAutoProxyCreator会直接去找所有Advisor类型的Bean,根据Advisor中的PointCut和Advice信息,确定要代理的Bean以及代理逻辑。

类中的方法上通过某些注解,来定义PointCut以及Advice,例如:

@Aspect // 定义需要解析的代理类
@Component
public class FireAspect {

    // 指定代理时机及被代理的具体方法
	@Before("execution(public void com.firechou.service.UserService.test())")
	public void FireBefore(JoinPoint joinPoint) {
		System.out.println("fireBefore");
	}

}

通过上面这个类,我们就直接定义好了所要代理的方法(通过一个表达式),以及代理逻辑(被**@Before** 修饰的方法),简单明了,这样对于Spring来说,它要做的就是来解析这些注解了,解析之后得到对应的Pointcut对象、Advice对象,生成Advisor对象,扔进ProxyFactory中,进而产生对应的代理对象,具体怎么解析这些注解就是**@EnableAspectJAutoProxy注解**所要做的事情了。

Spring AOP的理解

OOP表示面向对象编程,是一种编程思想,AOP表示面向切面编程,也是一种编程思想。而我们上面所描述的就是Spring为了让程序员更加方便的做到面向切面编程所提供的技术支持,换句话说,就是Spring提供了一套机制,可以让我们更加容易的来进行AOP,所以这套机制我们也可以称之为Spring AOP。

Spring实现AOP使用到的注解方式,Spring是依赖了AspectJ的。Spring直接把AspectJ中所定义的那些注解拿过来用,自己没有再重复定义,每个注解具体底层是怎么解析的,还是Spring自己做的。
在用Spring时,如果想用@Before、@Around等注解,是需要单独引入aspecj相关jar包。如下:

compile group: 'org.aspectj', name: 'aspectjrt', version: '1.9.5'
compile group: 'org.aspectj', name: 'aspectjweaver', version: '1.9.5'

AspectJ和Spring实现动态代理的不同方式:
AspectJ是在编译时对字节码进行了修改,是直接在UserService类对应的字节码中进行增强的,也就是可以理解为是在编译时就会去解析@Before这些注解,然后得到代理逻辑,加入到被代理的类中的字节码中去的,所以如果想用AspectJ技术来生成代理对象 ,是需要用单独的AspectJ编译器的。我们在项目中很少这么用,我们仅仅只是用了@Before这些注解,而我们在启动Spring的过程中,Spring会去解析这些注解,然后利用动态代理机制生成代理对象的。

AOP中的概念

上面我们已经提到Advisor、Advice、PointCut等概念了,还有一些其他的概念,首先关于AOP中的概念本身是比较难理解的,Spring官网上是这么说的:

Let us begin by defining some central AOP concepts and terminology. These terms are not Spring-specific. Unfortunately, AOP terminology is not particularly intuitive. However, it would be even more confusing if Spring used its own terminology

意思是,AOP中的这些概念不是Spring特有的,不幸的是,AOP中的概念不是特别直观的,但是,如果Spring重新定义自己的那可能会导致更加混乱

总的意思是,AOP的中概念是借鉴于其他(比如AspectJ)的组件,知识为了不让这些概念变的更加混乱。

如下:

  1. Aspect:表示切面,比如被@Aspect注解的类就是切面,可以在切面中去定义Pointcut、Advice等等
  2. Join point:表示连接点,表示一个程序在执行过程中的一个点,比如一个方法的执行,比如一个异常的处理,在Spring AOP中,一个连接点通常表示一个方法的执行
  3. Advice:表示通知,表示在一个特定连接点上所采取的动作。Advice分为不同的类型,后面详细讨论,在很多AOP框架中,包括Spring,会用Interceptor拦截器来实现Advice,并且在连接点周围维护一个Interceptor链
  4. Pointcut:表示切点,用来匹配一个或多个连接点,Advice与切点表达式是关联在一起的,Advice将会执行在和切点表达式所匹配的连接点上
  5. Introduction:可以使用@DeclareParents来给所匹配的类添加一个接口,并指定一个默认实现
  6. Target object:目标对象,被代理对象
  7. AOP proxy:表示代理工厂,用来创建代理对象的,在Spring Framework中,要么是JDK动态代理,要么是CGLIB代理
  8. Weaving:表示织入,表示创建代理对象的动作,这个动作可以发生在编译时期(比如Aspejctj),或者运行时,比如Spring AOP

Spring AOP对应API

Spring中的注解对应的类:

  • @Before

解析为AspectJMethodBeforeAdvice类,实际上就是一个MethodBeforeAdvice

  • @AfterReturning

解析为AspectJAfterReturningAdvice类,实际上就是一个AfterReturningAdvice

  • @AfterThrowing

解析为AspectJAfterThrowingAdvice类,实际上就是一个MethodInterceptor

  • @After

解析为AspectJAfterAdvice类,实际上就是一个MethodInterceptor

  • @Around

解析为AspectJAroundAdvice类,实际上就是一个MethodInterceptor

TargetSource的使用

在我们日常的AOP中,被代理对象就是Bean对象,是由BeanFactory给我们创建出来的,但是Spring AOP中提供了TargetSource机制,可以让我们用来自定义逻辑来创建被代理对象

比如之前所提到的@Lazy注解,当加在属性上时,会产生一个代理对象赋值给这个属性,产生代理对象的代码为:

protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {
		BeanFactory beanFactory = getBeanFactory();
		Assert.state(beanFactory instanceof DefaultListableBeanFactory,
				"BeanFactory needs to be a DefaultListableBeanFactory");
		final DefaultListableBeanFactory dlbf = (DefaultListableBeanFactory) beanFactory;

		TargetSource ts = new TargetSource() {
			@Override
			public Class<?> getTargetClass() {
				return descriptor.getDependencyType();
			}
			@Override
			public boolean isStatic() {
				return false;
			}
			@Override
			public Object getTarget() {
				Set<String> autowiredBeanNames = (beanName != null ? new LinkedHashSet<>(1) : null);
				Object target = dlbf.doResolveDependency(descriptor, beanName, autowiredBeanNames, null);
				if (target == null) {
					Class<?> type = getTargetClass();
					if (Map.class == type) {
						return Collections.emptyMap();
					}
					else if (List.class == type) {
						return Collections.emptyList();
					}
					else if (Set.class == type || Collection.class == type) {
						return Collections.emptySet();
					}
					throw new NoSuchBeanDefinitionException(descriptor.getResolvableType(),
							"Optional dependency not present for lazy injection point");
				}
				if (autowiredBeanNames != null) {
					for (String autowiredBeanName : autowiredBeanNames) {
						if (dlbf.containsBean(autowiredBeanName)) {
							dlbf.registerDependentBean(autowiredBeanName, beanName);
						}
					}
				}
				return target;
			}
			@Override
			public void releaseTarget(Object target) {
			}
		};

		ProxyFactory pf = new ProxyFactory();
        // 将自定义逻辑的TargetSource对象赋值给代理工厂
		pf.setTargetSource(ts);
		Class<?> dependencyType = descriptor.getDependencyType();
		if (dependencyType.isInterface()) {
			pf.addInterface(dependencyType);
		}
		return pf.getProxy(dlbf.getBeanClassLoader());
	}

代理对象创建过程

JdkDynamicAopProxy

  1. 在构造JdkDynamicAopProxy对象时,会先拿到被代理对象自己所实现的接口,并且额外的增加SpringProxy、Advised、DecoratingProxy三个接口,组合成一个Class[],并赋值给proxiedInterfaces属性
  2. 并且检查这些接口中是否定义了equals()、hashcode()方法
  3. 执行Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this),得到代理对象,JdkDynamicAopProxy作为InvocationHandler,代理对象在执行某个方法时,会进入到JdkDynamicAopProxy的**invoke()**方法中

ObjenesisCglibAopProxy

  1. 创建Enhancer对象
  2. 设置Enhancer的superClass为通过ProxyFactory.setTarget()所设置的对象的类
  3. 设置Enhancer的interfaces为通过ProxyFactory.addInterface()所添加的接口,以及SpringProxy、Advised、DecoratingProxy接口
  4. 设置Enhancer的Callbacks为DynamicAdvisedInterceptor
  5. 最后创建一个代理对象,代理对象在执行某个方法时,会进入到DynamicAdvisedInterceptor的intercept()方法中

代理对象执行过程

  1. 在使用ProxyFactory创建代理对象之前,需要往ProxyFactory先添加Advisor
  2. 代理对象在执行某个方法时,会把ProxyFactory中的Advisor拿出来和当前正在执行的方法进行匹配筛选
  3. 把和方法所匹配的Advisor适配成MethodInterceptor
  4. 把和当前方法匹配的MethodInterceptor链,以及被代理对象、代理对象、代理类、当前Method对象、方法参数封装为MethodInvocation对象
  5. 调用MethodInvocation的proceed()方法,开始执行各个MethodInterceptor以及被代理对象的对应方法
  6. 按顺序调用每个MethodInterceptor的invoke()方法,并且会把MethodInvocation对象传入invoke()方法
  7. 直到执行完最后一个MethodInterceptor了,就会调用invokeJoinpoint()方法,从而执行被代理对象的当前方法

各注解对应的MethodInterceptor:

  • @Before对应的是AspectJMethodBeforeAdvice,在进行动态代理时会把AspectJMethodBeforeAdvice转成MethodBeforeAdviceInterceptor
    • 先执行advice对应的方法
    • 再执行MethodInvocation的proceed(),会执行下一个Interceptor,如果没有下一个Interceptor了,会执行target对应的方法
  • @After对应的是AspectJAfterAdvice,直接实现了MethodInterceptor
    • 先执行MethodInvocation的proceed(),会执行下一个Interceptor,如果没有下一个Interceptor了,会执行target对应的方法
    • 再执行advice对应的方法
  • @Around对应的是AspectJAroundAdvice,直接实现了MethodInterceptor
    • 直接执行advice对应的方法,由@Around自己决定要不要继续往后面调用
  • @AfterThrowing对应的是AspectJAfterThrowingAdvice,直接实现了MethodInterceptor
    • 先执行MethodInvocation的proceed(),会执行下一个Interceptor,如果没有下一个Interceptor了,会执行target对应的方法
    • 如果上面抛了Throwable,那么则会执行advice对应的方法
  • @AfterReturning对应的是AspectJAfterReturningAdvice,在进行动态代理时会把AspectJAfterReturningAdvice转成AfterReturningAdviceInterceptor
    • 先执行MethodInvocation的proceed(),会执行下一个Interceptor,如果没有下一个Interceptor了,会执行target对应的方法
    • 执行上面的方法后得到最终的方法的返回值
    • 再执行Advice对应的方法

AbstractAdvisorAutoProxyCreator

DefaultAdvisorAutoProxyCreator的父类是AbstractAdvisorAutoProxyCreator。

AbstractAdvisorAutoProxyCreator非常强大以及重要,只要Spring容器中存在这个类型的Bean,就相当于开启了AOP,AbstractAdvisorAutoProxyCreator实际上就是一个BeanPostProcessor,所以在创建某个Bean时,就会进入到它对应的生命周期方法中,比如:在某个Bean初始化之后,会调用wrapIfNecessary()方法进行AOP,底层逻辑是,AbstractAdvisorAutoProxyCreator会找到所有的Advisor,然后判断当前这个Bean是否存在某个Advisor与之匹配(根据Pointcut),如果匹配就表示当前这个Bean有对应的切面逻辑,需要进行AOP,需要产生一个代理对象。

@EnableAspectJAutoProxy

这个注解主要就是往Spring容器中添加了一个AnnotationAwareAspectJAutoProxyCreator类型的Bean。
AnnotationAwareAspectJAutoProxyCreator.png
AspectJAwareAdvisorAutoProxyCreator继承了AbstractAdvisorAutoProxyCreator,重写了findCandidateAdvisors()方法,AbstractAdvisorAutoProxyCreator只能找到所有Advisor类型的Bean对象,但是AspectJAwareAdvisorAutoProxyCreator除开可以找到所有Advisor类型的Bean对象,还能把@Aspect注解所标注的Bean中的@Before等注解及方法进行解析,并生成对应的Advisor对象。

所以,我们可以理解@EnableAspectJAutoProxy,其实就是像Spring容器中添加了一个AbstractAdvisorAutoProxyCreator类型的Bean,从而开启了AOP,并且还会解析@Before等注解生成Advisor。文章来源地址https://www.toymoban.com/news/detail-630146.html

总结

  • 实现代理的方式有两种,jdk和cglib动态代理,如果被代理类实现了接口则通过jdk代理,否则通过cglib用父子类来实现动态代理
  • Spring AOP通过自动适配来选择jdk还是cglib
  • 可以通过Spring的ProxyFactory工厂类简化实现动态代理
  • 通过某些方式可以告知Spring哪些Bean需要动态代理,而不用手动设置
  • 通过注解来简化Spring识别哪些Bean需要动态代理
  • Spring中AOP相关概念是借鉴于AspectJ的,但是底层实现还是Spring的,这些概念(比如注解@Before)依赖于AspectJ包,所以使用Spring AOP功能是需要引入AspectJ相关包

到了这里,关于【Spring】Spring之AOP底层源码解析的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【微服务】Spring Aop原理深入解析

    目录 一、前言 二、aop概述 2.1 什么是AOP 2.2 AOP中的一些概念 2.2.1 aop通知类型

    2024年02月04日
    浏览(50)
  • 全面掌握Spring框架:深入解析IOC、AOP、事务管理与注解使用

    探索Spring框架的深层次知识,包括Spring IOC容器的初始化流程、AOP的实现机制、事务管理的细节、循环依赖问题的处理、条件注解的应用、JavaConfig的使用方法、PostProcessor的角色、@Autowired和@Value注解的高级应用,以及${}与#{}的区别。

    2024年03月13日
    浏览(196)
  • [SSM]Spring面向切面编程AOP

    目录 十五、面向切面编程AOP 15.1AOP介绍 15.2AOP的七大术语 15.3切点表达式 15.4使用Spring的AOP 15.4.1准备工作 15.4.2基于AspectJ的AOP注解式开发 15.4.3基于XML配置方式的AOP(了解) 15.5AOP的实际案例:事务处理 15.6AOP的实际案例:安全日志 IoC使软件组件松耦合。AOP让你能够捕捉系统中经

    2024年02月15日
    浏览(49)
  • Spring AOP(AOP概念、组成、Spring AOP实现及实现原理)

    学习 Spring AOP 之前,先要了解 AOP 是什么 AOP(Aspect Oriented Programming):面向切面编程,它和 OOP(面向对象编程)类似。 它是一种思想, 是对某一类事情的集中处理。 比如用户登录权限的效验,在学习 AOP 之前,在需要判断用户登录的页面,都要各自实现或调用用户验证的方

    2024年02月02日
    浏览(41)
  • Spring AOP(AOP概念,组成成分,实现,原理)

    目录 1. 什么是Spring AOP? 2. 为什么要用AOP? 3. AOP该怎么学习? 3.1 AOP的组成 (1)切面(Aspect) (2)连接点(join point) (3)切点(Pointcut) (4)通知(Advice)  4. Spring AOP实现 4.1 添加 AOP 框架支持 ​编辑  4.2 定义切面 4.3 定义切点 4.4 定义通知 4.5 切点表达式说明 AspectJ

    2024年02月13日
    浏览(45)
  • 9.spring aop 原理

    环境:spring boot 2.6.13 是对

    2024年01月18日
    浏览(38)
  • Spring AOP实现原理

    从入口  org.springframework.context.support.AbstractApplicationContext#refresh  开始看 找到Bean的创建方法进入: 再进入详细方法:  找到getBean(beanName): 找到doGetBean(xxx,xxx,xxx,xxx);   找到实际的Bean创建方法createBean(beanName, mdb, args);可以非常明显的看到,Bean就是通过Proxy的方式获取的。   继续

    2023年04月25日
    浏览(41)
  • Spring Aop原理

    AOP:将那些与业务无关,却与业务模块所共同调用的逻辑(例如事务处理,日志管理,权限管理等) 封装成一个可重用的模块,这个模块被称为\\\"切面\\\",便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可拓展性和可维护性。 如上举例所示:         如上图举例所

    2024年01月17日
    浏览(36)
  • 【Spring】Spring AOP入门及实现原理剖析

    AOP (Aspect-Oriented Programming) 是一种编程范式,它提供一种将程序中的横切关注点模块化的方式。横切关注点可以是日志、事务、安全等,它们不属于业务逻辑,但是又必须要与业务逻辑紧密耦合在一起。在 AOP 中,我们将这些横切关注点称为“切面”,它们独立于业务逻辑模块

    2024年02月17日
    浏览(46)
  • 【手撕Spring源码】AOP

    AOP 底层实现方式之一是代理,由代理结合通知和目标,提供增强功能 除此以外,aspectj 提供了两种另外的 AOP 底层实现: 第一种是通过 ajc 编译器在 编译 class 类文件时,就把通知的增强功能,织入到目标类的字节码中 第二种是通过 agent 在 加载 目标类时,修改目标类的字节

    2024年02月07日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包