Spring AOP底层原理和使用_integrationroleservice roleservice = new integrati-优快云博客

本文介绍了AOP（面向切面编程）的概念和技术原理，包括如何利用预编译方式和运行期动态代理实现统一维护程序功能，降低业务逻辑耦合度，提升代码可重用性和扩展性。详细探讨了基于JDK动态代理和CGLIB字节码增强两种方式实现AOP的具体方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

AOP面向切面编程

通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率，提供了程序的扩展性。

总结

AOP是在不修改源码的情况下，对功能进行横向扩展。

AOP是通过创建目标对象的代理对象，在代理对象调用方法时，进行增强，从而实现了功能的扩展。

JDK的动态代理：只能代理生成实现过接口的实例。

字节码的动态代理：可以代理生成任何类的实例。

基于JDK动态代理的缺陷：

spring提供了两种代理方式：

1、基于JDK的动态代理

当目标对象实现过接口时，在使用AOP时使用JDK的动态代理来生成代理对象。

2、基于字节码的增强

AOP常用概念

①目标类（target）

需要进行功能扩展的类

②连接点（joinPoint）

目标类中的所有方法的称为连接点。

③切入点（pointCut）

连接点中需要增强的方法称为切入点。

④增强/通知（advise）

需要进行扩展的功能。

⑤织入（weaving）

将增强应用到切入点的过程。

⑥代理对象（proxy）

织入完成后生成的代理对象。

⑦切面（aspect）

多个切入点组成切面。

AOP底层原理

基于JDK动态代理(写法)

注意：没有实现过结果的类，不能通过JDK动态代理来生成代理对象。

①确定目标类，实现了接口

public class RoleServiceImpl implements RoleService{

	@Override
	public void save() {
		// TODO Auto-generated method stub
		System.out.println("RoleServiceImp的save方法");
	}

	@Override
	public void delete() {
		// TODO Auto-generated method stub
		System.out.println("RoleServiceImp的delete方法");
	}

	@Override
	public void update() {
		// TODO Auto-generated method stub
		System.out.println("RoleServiceImp的update方法");
	}
	
}

②连接点（所有个方法）

③切入点（你要增强的方法）

④增强（用于增强的类）

public class TransactionUtil {
	public static void begin() {
		System.out.println("开启事务");
	}
	public static void commit() {
		System.out.println("提交事务");
	}
}

⑤创建工厂类，用于生成目标对象的代理对象，并且在代理对象中使用增强的方法。

public class ProxyBeanFactory {
	public static RoleService getRoleServiceProxy(RoleService roleService) {
		/**
		 * 参数1，类加载器：自定义类，所有的自定义类都使用的是同一种类加载器
		 * 参数2，目标类实现的接口的类对象数组
		 * 参数3，InvocationHandler 对目标对象的方法的回调
		 */
		RoleService proxy=(RoleService) Proxy.newProxyInstance(RoleService.class.getClassLoader(), 
				roleService.getClass().getInterfaces(), 
				new InvocationHandler() {
					
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						// 确定切入点
						String methodName=method.getName();//获取到方法名
						if("save".equals(methodName)) {
							TransactionUtil.begin();
						}
						//目标方法的执行并获取返回值
						Object obj=method.invoke(roleService, args);
						if("save".equals(methodName)) {
							TransactionUtil.commit();
						}
						return obj;
					}
				});
		return proxy;
	}
}

⑥测试

创建RoleService的实例，调用save方法，看执行情况。再通过工厂类，调用静态方法生成RoleService对象的代理对象，再去调用save方法，看执行情况。

public class Main3 {
	
	@Test
	public void testSave() {
		RoleService service =new RoleServiceImpl();
		service.save();
		service.delete();
		
		RoleService proxy=ProxyBeanFactory.getRoleServiceProxy(service);
		
		//判断proxy是不是RoleService类型
		System.out.println(proxy instanceof RoleService);
		proxy.save();
		proxy.delete();
	}
}

执行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9lqqBd4s-1606466041503)(C:\Users\stad\AppData\Roaming\Typora\typora-user-images\image-20200824164901985.png)]

⑦隐藏测试类中代码

public class ProxyBeanFactory {
	public static RoleService getRoleServiceProxy(RoleService roleService) {
		/**
		 * 将本应该写在测试类中的生成对象写在了工厂类中
		 * 下面就可以直接使用这个对象
		 * 参数直接传入null
		 * 执行结果是相同的
		 */
		RoleService service =new RoleServiceImpl();
		
		/**
		 * 参数1，类加载器：自定义类，所有的自定义类都使用的是同一种类加载器
		 * 参数2，目标类实现的接口的类对象数组
		 * 参数3，InvocationHandler 对目标对象的方法的回调
		 */
		RoleService proxy=(RoleService) Proxy.newProxyInstance(RoleService.class.getClassLoader(), 
				service.getClass().getInterfaces(), 
				new InvocationHandler() {
					
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						// 确定切入点
						String methodName=method.getName();//获取到方法名
						if("save".equals(methodName)) {
							TransactionUtil.begin();
						}
						//目标方法的执行并获取返回值
						Object obj=method.invoke(service, args);
						if("save".equals(methodName)) {
							TransactionUtil.commit();
						}
						return obj;
					}
				});
		return proxy;
	}
}

**注意：**上面代码中通过工厂方法生成的RoleService对象已经变成了$Proxy类型的，不再是RoleServiceImpl了。

基于cglib字节码增强

cglib作为字节码增强的框架，早期的Hibernate就使用了cglib。一般使用cglib我们需要下载cglib的依赖。在高版本spring中已经将cglib的依赖打包在spring-core.jar中，所以可以直接去使用。

基于aspectj的AOP

需要加入aspectj的依赖包。

一般在自定义增强时使用aspectj。

xml

确定目标类

确定连接点

确定切入点

确定增强（可以是普通的Java类）

注解

① 开启注解驱动

<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

② 开启组件扫描

<context:component-scan base-package="com"></context:component-scan>

③ 将目标类交给Spring管理

@Service
public class RoleServiceImpl implements RoleService{

	@Override
	public void saveUser() {
		System.out.println("save方法");
	}
}

④ 在增强类上使用@Aspects注解标识

@Component("ddo")
@Aspect
public class Ddo {

	@Before(value = "execution(* com.service.impl.*.saveUser())")
	public void before() {
		System.out.println("开始");
	}
	
	@After(value = "execution(* com.service.impl.*.saveUser())")
	public void after() {
		System.out.println("结束");
	}
}

⑤ 在增强类方法上加入注解指定增强类型

	@Before(value = "execution(* com.service.impl.*.saveUser())")
	public void before() {
		System.out.println("开始");
	}

⑥ 测试类中调用

@ContextConfiguration(locations = "classpath:applicationContext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class Test {
	@Autowired
	private RoleServiceImpl roleServiceImpl;
	
	@org.junit.Test
	public void test1() {
		roleServiceImpl.saveUser();
		System.out.println(1);
	}
}