前言

AOP 也是 Spring 中一个较为重要的内容，相对于传统的 OOP 模式，AOP 有很多让人难以理解的地方，本篇文章将向大家介绍 AOP 的实现方法及其底层实现，内容包括：

• 初始 AOP
• AOP 的基本概念
• AOP（concepts）术语
• 动态代理
• 通知介绍（前置、后置、返回、异常、环绕）
• 基于注解的方式配置通知
• AOP的应用场景

一、什么是AOP

AOP(Aspect-Oriented Programming), 即 面向切面编程, 它与 OOP( Object-Oriented Programming, 面向对象编程) 相辅相成, 提供了与 OOP 不同的抽象软件结构的视角在 OOP 中, 我们以类(class)作为我们的基本单元, 而 AOP 中的基本单元是 Aspect(切面)

二、AOP的基本概念

AOP框架具有如下两个特征：

1. 多个步骤之间的良好隔离性。
2. 源代码无关性。

三、AOP concepts（AOP术语）

Aspect/Advisors（切面）

一个关注点的模块化，这个关注点可能会横切多个对象。在Spring AOP中，切面可以使用基于模式或者基于@Aspect注解的方式来实现。

Join point（连接点）

在程序执行期间的一点。在Spring AOP中，连接点总是表示方法执行。

Advice（通知）

在切面的某个特定的连接点上执行的动作。许多AOP框架（包括Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。

Pointcut（切入点）

查找连接点的条件。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行。

Introduction（引入）

给一个类型声明额外的方法或属性。Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。

Target object（目标对象）

被一个或者多个切面所通知的对象。也被称做被通知（advised）对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个被代理（proxied）对象。

AOP proxy

AOP框架创建的对象，用来实现切面契约（例如通知方法执行等等）。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。

Weaving（织入）

织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在编译期、类装载期、运行期进行。

Spring AOP

1、Spring AOP使用纯Java实现，它不需要专门的编译过程。Spring AOP不需要控制类加载器层次结构，因此适用于Servlet容器或应用程序服务器。

2、Spring AOP目前仅支持方法执行连接点。

3、Spring实现AOP的方法跟其他的框架不同。Spring并不是要提供最完整的AOP实现（尽管Spring AOP有这个能力），相反的，它其实侧重于提供一种AOP实现和Spring IoC容器之间的整合，用于帮助解决在企业级开发中的常见问题。

Tomcat源代码学习研究

zip 1星 超过10%的资源 8.40MB

下载

4、Spring AOP从来没有打算通过提供一种全面的AOP解决方案来与AspectJ竞争。我们相信无论是基于代理（proxy-based）的框架如Spring AOP或者是成熟的框架如AspectJ都是很有价值的，他们之间应该是互补而不是竞争的关系。

四、Spring框架的AOP的底层实现

 Srping框架的AOP技术底层也是采用的代理技术，代理的方式提供了两种

1、基于JDK的动态代理

必须是面向接口的，只有实现了具体接口的类才能生成代理对象

2、基于CGLIB动态代理

对于没有实现了接口的类，也可以产生代理，产生这个类的子类的方式

Spring的传统AOP中根据类是否实现接口，来采用不同的代理方式

• 如果实现类接口，使用JDK动态代理完成AOP
• 如果没有实现接口，采用CGLIB动态代理完成AOP

基于Spring的AOP简单实现

注意一下，在讲解之前，说明一点：使用Spring AOP，要成功运行起代码，只用Spring提供给开发者的jar包是不够的，请额外上网下载两个jar包：

1. aopalliance.jar
2. aspectjweaver.jar

五、通过配置的方式实现aop通知效果

xml配置

代理机制及AOP原理实现

zip 4星 超过75%的资源 685KB

下载

<bean id="logger" class="com.ahpome.company.utils.Logger" />
<aop:config>
	// 定义切面 aspect
	<aop:aspect id="loggerAspect" ref="logger"> 
		// 定义 切入点
		<aop:pointcut id="loggerRef" expression="execution(* com.ahpome.company..*.*(..)) and !bean(logger)" />
		// 通知 环绕通知 :around;前置通知 :before;后置通知:after;最终通知:after-returning;异常通知:after-throwing
		<aop:around method="record" pointcut-ref="loggerRef" />
	aop:aspect>
aop:config>

	public Object record(ProceedingJoinPoint pjp){
 
		Log log = new Log();
 
		try {
			log.setOperator("admin");
			String mname = pjp.getSignature().getName();
			log.setOperName(mname);
			Object[] args = pjp.getArgs();
			log.setOperParams(Arrays.toString(args));
 
			// 执行目标方法，返回的是目标方法的返回值，本例中 void
			Object obj = pjp.proceed();
			if(obj != null){
				log.setResultMsg(obj.toString());
			}else{
				log.setResultMsg(null);
			}
 
			log.setOperResult("success");
			System.out.println("1111");
 
			return obj;
		} catch (Throwable e) {
			log.setOperResult("failure");
			log.setResultMsg(e.getMessage());
		} finally{
			// logService.saveLog(log);
		}
		// 注意：这里如果是返回null即使你调用的时候返回是null，即使你的方法中含有返回值
		return null;
	}

JDK动态代理

	/*
	 * 接口
	 */
	public interface UserService {
		void save();
		int select();
	}

    /*
	 * 接口实现类
	 */
	public class UserServiceImpl implements UserService {
 
		@Override
		public void save() {
			System.out.println("保存用户信息成功");
		}
 
		@Override
		public int select() {
			System.out.println("查询用户信息成功");
			return 10;
		}
	}

 
	/*
	 * JDK动态代理工厂类
	 */
	public class JdkProxyFactory implements InvocationHandler {
		private Object target;
		public JdkProxyFactory(Object target) {
			this.target = target;
		}
 
		/**
		 * 获取代理对象，当前类继承InvocationHandler
		 */
		public Object getProxyObject() {
			return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
		}
 
		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			//添加功能
			System.out.println("增强代码，添加日志功能");
			//执行原有方法
			return method.invoke(target, args);
		}
	}

测试JDK动态代理​

	@Test
	public void JdkProxyTest() {
 
		// 创建目标对象
		UserService userService = new UserServiceImpl();
		//创建工厂对象
		JdkProxyFactory jdkProxyFactory = new JdkProxyFactory(userService);
		UserService proxy = (UserService) jdkProxyFactory.getProxyObject();
		proxy.save();
		System.out.println("=========================");
		proxy.select();
		
	}

六、AOP的应用场景

前面我们提到AOP主要应用一些非核心业务逻辑中，我们看看AOP常见的应用场景

• 监控
• 日志
• 缓存
• 鉴权
• 事务
• 异常处理
• 持久化

总结

以上就是我对Java开发大型互联网架构Spring AOP实现原理之Spring AOP底层实现问题的总结。