AOP (Aspect Oriented Programming)

1、AOP介绍

什么是AOP

面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码。
经典应用：事务管理、性能监视、安全检查、缓存、日志等。
Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码。
AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入。

2、AOP实现原理

aop底层将采用代理机制进行实现。
接口 + 实现类：spring采用 jdk 的动态代理Proxy。
实现类：spring 采用 cglib字节码增强。

AOP术语【掌握】

target：目标类，需要被代理的类。例如：UserService.
Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法.
PointCut 切入点：已经被增强的连接点。例如：addUser().
advice 通知/增强，增强代码。例如：after、before.
Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.
proxy 代理类.
Aspect(切面): 是切入点pointcut和通知advice的结合.
- 一个线是一个特殊的面。
- 一个切入点和一个通知，组成成一个特殊的面。

2、AOP

2.1 手动方式

JDK动态代理

JDK动态代理对“装饰者”设计模式简化。使用前提：必须有接口

目标类：接口 + 实现类
切面类：用于存通知 MyAspect
工厂类：编写工厂生成代理

目标类
public interface UserService {
	public void addUser();
	public void updateUser();
	public void deleteUser();
}

切面类
public class MyAspect {
	public void before(){
		System.out.println("鸡首");
	}
	public void after(){
		System.out.println("牛后");
	}
}

工厂
public class MyBeanFactory {
	
	public static UserService createService(){
		//1 目标类
		final UserService userService = new UserServiceImpl();
		//2切面类
		final MyAspect myAspect = new MyAspect();
		/* 3 代理类：将目标类（切入点）和 切面类（通知） 结合 --> 切面
		 * 	Proxy.newProxyInstance
		 * 		参数1：loader ，类加载器，动态代理类 运行时创建，任何类都需要类加载器将其加载到内存。
		 * 			一般情况：当前类.class.getClassLoader();
		 * 					目标类实例.getClass().get...
		 * 		参数2：Class[] interfaces 代理类需要实现的所有接口
		 * 			方式1：目标类实例.getClass().getInterfaces()  ;注意：只能获得自己接口，不能获得父元素接口
		 * 			方式2：new Class[]{UserService.class}   
		 * 			例如：jdbc 驱动  --> DriverManager  获得接口 Connection
		 * 		参数3：InvocationHandler  处理类，接口，必须进行实现类，一般采用匿名内部
		 * 			提供 invoke 方法，代理类的每一个方法执行时，都将调用一次invoke
		 * 				参数31：Object proxy ：代理对象
		 * 				参数32：Method method : 代理对象当前执行的方法的描述对象（反射）
		 * 					执行方法名：method.getName()
		 * 					执行方法：method.invoke(对象，实际参数)
		 * 				参数33：Object[] args :方法实际参数
		 * 
		 */
		UserService proxService = (UserService)Proxy.newProxyInstance(
								MyBeanFactory.class.getClassLoader(), 
								userService.getClass().getInterfaces(), 
								new InvocationHandler() {
									
									@Override
									public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
										
										//前执行
										myAspect.before();
										
										//执行目标类的方法
										Object obj = method.invoke(userService, args);
										
										//后执行
										myAspect.after();
										
										return obj;
									}
								});
		return proxService;
	}
}

CGLIB字节码增强

没有接口，只有实现类。
采用字节码增强框架 cglib，在运行时创建目标类的子类，从而对目标类进行增强。
导入jar包：
4. 核心：hibernate-distribution-3.6.10.Final\lib\bytecode\cglib\cglib-2.2.jar
5. 依赖：struts-2.3.15.3\apps\struts2-blank\WEB-INF\lib\asm-3.3.jar

public class MyBeanFactory {
	public static UserServiceImpl createService(){
		//1 目标类
		final UserServiceImpl userService = new UserServiceImpl();
		//2切面类
		final MyAspect myAspect = new MyAspect();
		// 3.代理类 ，采用cglib，底层创建目标类的子类
		//3.1 核心类
		Enhancer enhancer = new Enhancer();
		//3.2 确定父类
		enhancer.setSuperclass(userService.getClass());
		/* 3.3 设置回调函数 , MethodInterceptor接口 等效 jdk InvocationHandler接口
		 * 	intercept() 等效 jdk  invoke()
		 * 		参数1、参数2、参数3：以invoke一样
		 * 		参数4：methodProxy 方法的代理
		 * 		
		 * 
		 */
		enhancer.setCallback(new MethodInterceptor(){
			@Override
			public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
				//前
				myAspect.before();
				
				//执行目标类的方法
				Object obj = method.invoke(userService, args);
				// * 执行代理类的父类 ，执行目标类 （目标类和代理类 父子关系）
				methodProxy.invokeSuper(proxy, args);
				//后
				myAspect.after();
				return obj;
			}
		});
		//3.4 创建代理
		UserServiceImpl proxService = (UserServiceImpl) enhancer.create();
		return proxService;
	}
}

2.2 半自动方式

AOP联盟通知类型

AOP联盟为通知Advice定义了org.aopalliance.aop.Advice。
Spring按照通知Advice在目标类方法的连接点位置，可以分为5类。
- 前置通知 org.springframework.aop.MethodBeforeAdvice
  - 在目标方法执行前实施增强
- 后置通知 org.springframework.aop.AfterReturningAdvice
  - 在目标方法执行后实施增强
- 环绕通知 org.aopalliance.intercept.MethodInterceptor
  - 在目标方法执行前后实施增强
- 异常抛出通知 org.springframework.aop.ThrowsAdvice
  - 在方法抛出异常后实施增强
- 引介通知 org.springframework.aop.IntroductionInterceptor
  - 在目标类中添加一些新的方法和属性

环绕通知，必须手动执行目标方法
try{
   //前置通知
   //执行目标方法
   //后置通知
} catch(){
   //抛出异常通知
}

目标类

public interface UserService {
	public void updateUser();
	public void deleteUser();
}


切面类

/**
 * 切面类中确定通知，需要实现不同接口，接口就是规范，从而就确定方法名称。
 * * 采用“环绕通知” MethodInterceptor
 *
 */
public class MyAspect implements MethodInterceptor {

	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		
		System.out.println("前3");
		
		//手动执行目标方法
		Object obj = mi.proceed();
		
		System.out.println("后3");
		return obj;
	}
}

Spring 配置

<!-- 1 创建目标类 -->
<bean id="userServiceId" class="com.itheima.b_factory_bean.UserServiceImpl"></bean>
<!-- 2 创建切面类 -->
<bean id="myAspectId" class="com.itheima.b_factory_bean.MyAspect"></bean>

<!-- 3 创建代理类 
	* 使用工厂bean FactoryBean ，底层调用 getObject() 返回特殊bean
	* ProxyFactoryBean 用于创建代理工厂bean，生成特殊代理对象
		interfaces : 确定接口们
			通过<array>可以设置多个值
			只有一个值时，value=""
		target : 确定目标类
		interceptorNames : 通知 切面类的名称，类型String[]，如果设置一个值 value=""
		optimize :强制使用cglib
			<property name="optimize" value="true"></property>
	底层机制
		如果目标类有接口，采用jdk动态代理
		如果没有接口，采用cglib 字节码增强
		如果声明 optimize = true ，无论是否有接口，都采用cglib
-->
<bean id="proxyServiceId" class="org.springframework.aop.framework.ProxyFactoryBean">
	<property name="interfaces" value="com.itheima.b_factory_bean.UserService"></property>
	<property name="target" ref="userServiceId"></property>
	<property name="interceptorNames" value="myAspectId"></property>
</bean>

测试类

public void demo01(){
	String xmlPath = "com/itheima/b_factory_bean/beans.xml";
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
	
	//获得代理类
	UserService userService = (UserService) applicationContext.getBean("proxyServiceId");
	userService.addUser();
	userService.updateUser();
	userService.deleteUser();
}

2.3 Spring aop编程：全自动【掌握】

<!-- 1 创建目标类 -->
<bean id="userServiceId" class="com.itheima.c_spring_aop.UserServiceImpl"></bean>
<!-- 2 创建切面类（通知） -->
<bean id="myAspectId" class="com.itheima.c_spring_aop.MyAspect"></bean>
<!-- 3 aop编程 
	3.1 导入命名空间
	3.2 使用 <aop:config>进行配置
			proxy-target-class="true" 声明时使用cglib代理
		<aop:pointcut> 切入点 ，从目标对象获得具体方法
		<aop:advisor> 特殊的切面，只有一个通知 和 一个切入点
			advice-ref 通知引用
			pointcut-ref 切入点引用
	3.3 切入点表达式
		execution(* com.itheima.c_spring_aop.*.*(..))
		选择方法         返回值任意   包             类名任意   方法名任意   参数任意
	
-->
<aop:config proxy-target-class="true">
	<aop:pointcut expression="execution(* com.itheima.c_spring_aop.*.*(..))" id="myPointCut">
	<aop:advisor advice-ref="myAspectId" pointcut-ref="myPointCut">
</aop:advisor></aop:pointcut></aop:config>

3、AspectJ

3.1 介绍

spectJ是一个基于Java语言的AOP框架，Sring2.0以后新增了对AspectJ切点表达式支持，@AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面

新版本Spring框架，建议使用AspectJ方式来开发AOP。主要用途：自定义开发。

3.2 切入点表达式【掌握】

execution() 用于描述方法【掌握】
- 语法：execution(修饰符返回值包.类.方法名(参数) throws异常)
  - 修饰符，一般省略
    - public 公共方法
    - * 任意
  - 返回值，不能省略
    - void 返回没有值
    - String 返回值字符串
    - * 任意
  - 包，[省略]
    - com.itheima.crm 固定包
    - com.itheima.crm.*.service crm包下面子包任意（例如：com.itheima.crm.staff.service）
    - com.itheima.crm.. crm包下面的所有子包（含自己）
    - com.itheima.crm.*.service.. crm包下面任意子包，固定目录service，service目录任意包
  - 类，[省略]
    - UserServiceImpl 指定类
    - *Impl 以Impl结尾
    - User* 以User开头
    - * 任意
  - 方法名，不能省略
    - addUser 固定方法
    - add* 以add开头
    - *Do 以Do结
    - * 任意
  - (参数)
    - () 无参
    - (int) 一个整型
    - (int ,int) 两个
    - (..) 参数任意
  - throws ,可省略，一般不写。

综合一：execution(* com.itheima.crm.*.service..*.*(..))
综合二：<aop:pointcut expression="execution(* com.itheima.*WithCommit.*(..)) || execution(* com.itheima.*Service.*(..))" id="myPointCut">

within:匹配包或子包中的方法(了解) within(com.itheima.aop..*)
this:匹配实现接口的代理对象中的方法(了解) this(com.itheima.aop.user.UserDAO)
target:匹配实现接口的目标对象中的方法(了解) target(com.itheima.aop.user.UserDAO)
args:匹配参数格式符合标准的方法(了解) args(int,int)
bean(beanId) 对指定的bean所有的方法(了解) bean('userServiceId')

3.3 AspectJ 通知类型

aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称。spectj 通知类型，只定义类型名称。已经方法格式。个数：6种，知道5种，掌握1中。

before: 前置通知(应用：各种校验)
- 在方法执行前执行，如果通知抛出异常，阻止方法运行
afterReturning: 后置通知(应用：常规数据处理)
- 方法正常返回后执行，如果方法中抛出异常，通知无法执行
- 必须在方法执行后才执行，所以可以获得方法的返回值。
around: 环绕通知(应用：十分强大，可以做任何事情)
- 方法执行前后分别执行，可以阻止方法的执行
- 必须手动执行目标方法
afterThrowing: 抛出异常通知(应用：包装异常信息)
- 方法抛出异常后执行，如果方法没有抛出异常，无法执行
after: 最终通知(应用：清理现场)
- 方法执行完毕后执行，无论方法中是否出现异常

环绕
try{
     //前置：before
    //手动执行目标方法
    //后置：afterRetruning
} catch(){
    //抛出异常 afterThrowing
} finally{
    //最终 after
}

3.4 基于xml

目标类：接口 + 实现。
切面类：编写多个通知，采用aspectj 通知名称任意（方法名任意）。
aop编程，将通知应用到目标类。

/**
 * 切面类，含有多个通知
 */
public class MyAspect {
	
	public void myBefore(JoinPoint joinPoint){
		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
	}
	
	public void myAfterReturning(JoinPoint joinPoint,Object ret){
		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
	}
	
	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("前");
		//手动执行目标方法
		Object obj = joinPoint.proceed();
		
		System.out.println("后");
		return obj;
	}
	
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
		System.out.println("抛出异常通知 ： " + e.getMessage());
	}
	
	public void myAfter(JoinPoint joinPoint){
		System.out.println("最终通知");
	}

}


Spring XML 配置
<!-- 1 创建目标类 -->
<bean id="userServiceId" class="com.itheima.d_aspect.a_xml.UserServiceImpl"></bean>
<!-- 2 创建切面类（通知） -->
<bean id="myAspectId" class="com.itheima.d_aspect.a_xml.MyAspect"></bean>


<!-- 3 aop编程 
	<aop:aspect> 将切面类 声明“切面”，从而获得通知（方法）
		ref 切面类引用
	<aop:pointcut> 声明一个切入点，所有的通知都可以使用。
		expression 切入点表达式
		id 名称，用于其它通知引用
-->
<aop:config>
	<aop:aspect ref="myAspectId">
	
		<aop:pointcut expression="execution(* com.itheima.d_aspect.a_xml.UserServiceImpl.*(..))" id="myPointCut">
		
		<!-- 3.1 前置通知 
			<aop:before method="" pointcut="" pointcut-ref=""/>
				method : 通知，及方法名
				pointcut :切入点表达式，此表达式只能当前通知使用。
				pointcut-ref ： 切入点引用，可以与其他通知共享切入点。
			通知方法格式：public void myBefore(JoinPoint joinPoint){
				参数1：org.aspectj.lang.JoinPoint  用于描述连接点（目标方法），获得目标方法名等
			例如：
		<aop:before method="myBefore" pointcut-ref="myPointCut"/>
		-->
		
		<!-- 3.2后置通知  ,目标方法后执行，获得返回值
			<aop:after-returning method="" pointcut-ref="" returning=""/>
				returning 通知方法第二个参数的名称
			通知方法格式：public void myAfterReturning(JoinPoint joinPoint,Object ret){
				参数1：连接点描述
				参数2：类型Object，参数名 returning="ret" 配置的
			例如：
		<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />
		-->
		
		<!-- 3.3 环绕通知 
			<aop:around method="" pointcut-ref=""/>
			通知方法格式：public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
				返回值类型：Object
				方法名：任意
				参数：org.aspectj.lang.ProceedingJoinPoint
				抛出异常
			执行目标方法：Object obj = joinPoint.proceed();
			例如：
		<aop:around method="myAround" pointcut-ref="myPointCut"/>
		-->
		
		<!-- 3.4 抛出异常
			<aop:after-throwing method="" pointcut-ref="" throwing=""/>
				throwing ：通知方法的第二个参数名称
			通知方法格式：public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
				参数1：连接点描述对象
				参数2：获得异常信息，类型Throwable ，参数名由throwing="e" 配置
			例如：
		<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointCut" throwing="e"/>
		-->
		
		<!-- 3.5 最终通知 -->			
		<aop:after method="myAfter" pointcut-ref="myPointCut">
</aop:after></aop:pointcut></aop:aspect></aop:config>

3.5 基于注解

开启 aop 注解。

<!-- 1.扫描 注解类 -->
<context:component-scan base-package="com.itheima.d_aspect.b_anno"></context:component-scan>
<!-- 2.确定 aop注解生效 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

注解。

切面类
- @Aspect 声明切面，修饰切面类，从而获得通知。需 @Component 注入Spring容器。
切入点
- @Pointcut 拦截的切入点方法，注解的在方法级别之上，但是不执行方法体，只表示切入点的入口。通知可以通过方法名应引用切入点（共用的）。execution切入点只针对当前方法。
通知
- @Before 前置，是在切入点之前执行方法。
- @AfterReturning 后置，返回拦截方法的返回值。
- @AfterThrowing 抛出异常，拦截的方法如果抛出异常加执行此方法 throwing="ex" 将异常返回到参数列表。
- @After 最终，在之上方法执行后执行结束操作。
- @Around 环绕，判断是否执行以上的拦截，第一个参数必须ProceedingJoinPoint。

/**
 * 切面类，含有多个通知
 */
@Component
@Aspect
public class MyAspect {
	
	//声明公共切入点
	@Pointcut("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")
	private void myPointCut(){
	}
	
	//切入点当前有效
	@Before("execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))")
	public void myBefore(JoinPoint joinPoint){
		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
	}
	

	@AfterReturning(value="myPointCut()" ,returning="ret")
	public void myAfterReturning(JoinPoint joinPoint,Object ret){
		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
	}
	
	@Around(value = "myPointCut()")
	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("前");
		//手动执行目标方法
		Object obj = joinPoint.proceed();
		
		System.out.println("后");
		return obj;
	}
	
	@AfterThrowing(value="execution(* com.itheima.d_aspect.b_anno.UserServiceImpl.*(..))" ,throwing="e")
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
		System.out.println("抛出异常通知 ： " + e.getMessage());
	}
	
	@After("myPointCut()")
	public void myAfter(JoinPoint joinPoint){
		System.out.println("最终通知");
	}

}

posted @ 2021-07-28 16:41 光后的影子阅读(241) 评论(0) 收藏举报

刷新页面返回顶部

光后的影子

AOP (Aspect Oriented Programming)

1、AOP介绍

什么是AOP

2、AOP实现原理

AOP术语【掌握】

2、AOP

2.1 手动方式

JDK动态代理

CGLIB字节码增强

2.2 半自动方式

AOP联盟通知类型

2.3 Spring aop编程：全自动【掌握】

3、AspectJ

3.1 介绍

3.2 切入点表达式【掌握】

3.3 AspectJ 通知类型

3.4 基于xml

3.5 基于注解

公告