Java框架（六）之Spring(AOP)

1.介绍

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

2.AOP实现原理

aop底层将采用代理机制进行实现。

• jdk的动态代理方式（spring的aop底层默认使用的是jdk动态代理） spring底层默认使用该方式创建代理对象
• cglib方式 spring 可以使用cglib字节码增强 实现aop 。

3.AOP术语

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

4.实现AOP的方式

（1）.jdk动态代理代码

目标类

 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 代理类：将目标类（切入点）和 切面类（通知） 结合 --> 切面
				 * 		参数1：loader ，类加载器，动态代理类 运行时创建，任何类都需要类加载器将其加载到内存。
		 * 			
		 * 		参数2：Class[] interfaces 代理类需要实现的所有接口
		 * 			方式1：目标类实例.getClass().getInterfaces()  ;注意：只能获得自己接口，不能获得父元素接口
		 * 			
          参数3：InvocationHandler  处理类，接口，必须进行实现类，一般采用匿名内部
		 */
		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;
	}
}

（2）.cglib代码

• 没有接口，只有实现类。
• 采用字节码增强框架 cglib，在运行时 创建目标类的子类，从而对目标类进行增强。
• 导入jar包

创建工厂类

UserServiceImpl userServiceImpl = new UserServiceImpl();
		//2,创建切面对象
		MyAspect myAspect = new MyAspect();
		//3,在目标类方法的前后增加代码
		Enhancer enhancer = new Enhancer();
		//1,设置父类对象
		enhancer.setSuperclass(userServiceImpl.getClass());
		//2,设置回调函数
		enhancer.setCallback(new MethodInterceptor() {
			@Override
			public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
				myAspect.before();
				Object object =  arg1.invoke(userServiceImpl, arg2);
				myAspect.after();
				return object;
			}
		});//执行目标类的方法的
		return (UserServiceImpl) enhancer.create

注意：两者原理详见------代理模式
https://blog.csdn.net/xueer_z/article/details/82848217

5.AOP联盟通知类型

(1).AOP联盟为通知Advice定义了org.aopalliance.aop.Advice 接口

(2).Spring按照通知Advice在目标类方法的连接点位置，可以分为5类

	•	前置通知 `org.springframework.aop.MethodBeforeAdvice`
	•	在目标方法执行前实施增强
	•	后置通知 `org.springframework.aop. AfterReturningAdvice`
	•	在目标方法执行后实施增强
	•	环绕通知 `org.aopalliance.intercept.MethodInterceptor` 
	•	在目标方法执行前后实施增强
	•	异常抛出通知 `org.springframework.aop.ThrowsAdvice`
	•	在方法抛出异常后实施增强
	•	引介通知 `org.springframework.aop.IntroductionInterceptor`
	•	在目标类中添加一些新的方法和属性

( 3).环绕通知伪代码

try{
   //前置通知
   //执行目标方法
   //后置通知
} catch(){
   //抛出异常通知
}

6.spring 半自动

（1）BookService 接口类

public interface BookService {
	void add();
	void delete();
	void update();
	void updateType();
	void deleteByName();
	void updateByName();
}

（2）BookServiceImpl实现类

public class BookServiceImpl implements BookService {
	@Override
	public  void add() {
		//开启事务
	
		System.out.println("add");
		//int  i = 10/0;//模拟断电
		//提交事务
		
		//回滚事务
		//}
	}
	@Override
	public  void delete() {
		//开启事务
		try {
		System.out.println("delete");
		//提交事务
		}catch (Exception e) {
			//回滚事务
		}
	}
	@Override
	public  void update() {
		//开启事务
		try {
		System.out.println("update");
		//提交事务
		}catch (Exception e) {
			//回滚事务
		}
		
	}
	@Override
	public  void updateType() {
		//开启事务
		try {
		System.out.println("updateType");
		//提交事务
		}catch (Exception e) {
			//回滚事务
		}
	}
	@Override
	public  void deleteByName() {
		//开启事务
				try {
				System.out.println("deleteByName");
				//提交事务
				}catch (Exception e) {
					//回滚事务
				}
	}
	@Override
	public  void updateByName() {
		//开启事务
		try {
		System.out.println("updateByName");
		//提交事务
		}catch (Exception e) {
			//回滚事务
		}
	}
}

（3）通知类

 public class MyAdvice  implements  MethodInterceptor,MethodBeforeAdvice,AfterReturningAdvice{
	@Override
	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		System.out.println("afterReturning  后置通知");
	}

	/**
	 * 环绕通知  调用目标方法前后都会执行
	 * 是否放行（调用）
	 * @param invocation
	 * @return
	 * @throws Throwable
	 */
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		System.out.println("环绕通知------前置通知");
		//调用目标方法
		Object o = 	invocation.proceed();
		System.out.println("环绕通知------后置通知");

		return o;
	}
	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		System.out.println("before 前置通知");
	}
}

（4）spring配置

<!-- 目标类 -->
  <bean id="bookService" class="com.itqf.banzidong.BookServiceImpl"></bean>
  <!-- 通知类的对象 -->
  <bean id="myAdvice" class="com.itqf.banzidong.MyAdvice"></bean>
  
  <!-- 使用spring的ProxyFactoryBean类创建代理对象
  interfaces :被代理对象实现的接口列表
  target:目标对象的引用
  interceptorNames:增强类的引用
  默认：底层使用的是jdk的动态代理
  
   -->
   <bean id="myProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
   <!-- setOptimize 设置为true，则底层会使用cglib创建代理对象 -->
   		<property name="optimize" value="true"></property>
   		<property name="interfaces" value="com.itqf.banzidong.BookService"></property>
   		<property name="target" ref="bookService"></property>
   		<property name="interceptorNames" value="myAdvice"></property>
   </bean>

7.全自动 【掌握】

spring配置

<!-- 目标类 -->
  		<bean id="bookService" class="com.itqf.quanzidong.BookServiceImpl"></bean>
 
 		<!-- 增强类 -->
 		<bean id="myAdvice" class="com.itqf.quanzidong.MyAdvice"></bean>
 		
 		<!-- 全自动配置
 			解析到aop节点  会为com.itqf.quanzidong.BookServiceImpl 目标类创建代理对象
 		 -->
 		<aop:config>
 			<!-- 切入点表达式 -->
 			<aop:pointcut expression="execution(* com.itqf.quanzidong.*Impl.*(..))" id="mypointcut"/>
 			<!-- 把增强织入到满足切入点表达式的方法中 -->
 			<aop:advisor advice-ref="myAdvice" pointcut-ref="mypointcut"/>
 		</aop:config>

注意：和半自动一样

8.aspectj

（1）介绍

• AspectJ是一个基于Java语言的AOP框架
• Spring2.0以后新增了对AspectJ切点表达式支持
• @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面
  新版本Spring框架，建议使用AspectJ方式来开发AOP
• 主要用途：自定义开发

（2）切入点表达式【重点】

.execution() 用于描述方法 @annotation() 描述注解
语法：execution(修饰符返回值包.类.方法名(参数) throws异常

• 修饰符，一般省略

名称	解释
public	公共方法
*	任意

• 返回值，不能省略

名称	解释
void	返回没有值
String	返回值字符串
*	任意

• 包，[省略]

名称	解释
com.qf.crm	固定包
com.qf.crm.*.service	crm包下面子包任意包下的service包（例如：com.qf.crm.staff.service）
com.qf.crm…	crm包下面的所有子包（含自己）
com.qf.crm.*.service…	crm包下面任意子包，固定目录service，service目录任意包
com.qf.crm.*	crm包下面任意包

• 类，[省略]

名称	解释
UserServiceImpl	指定类
*Impl	以Impl结尾
User*	以User开头
*	任意

• 方法名，不能省略

名称	解释
addUser	固定方法
add*	以add开头
*Do	以Do结尾
*	任意

• (参数)

名称	解释
()	无参
(int)	一个整型
(int ,int)	两个
(…)	参数任意

• throws ,可省略，一般不写。
  eg: service.impl包下的所有类所有方法 execution(* com.itqf.service.impl..(…))

（3）AspectJ 通知类型

**A.**aspectj 通知类型，只定义类型名称。已知方法格式。
B. 个数：6种，知道5种，掌握1种（环绕）。
before:前置通知(应用：各种校验)
在方法执行前执行，如果通知抛出异常，阻止方法运行
afterReturning:后置通知(应用：常规数据处理)
方法正常返回后执行，如果方法中抛出异常，通知无法执行
必须在方法执行后才执行，所以可以获得方法的返回值。
around:环绕通知(应用：十分强大，可以做任何事情)
方法执行前后分别执行，可以阻止方法的执行
必须手动执行目标方法
afterThrowing:抛出异常通知(应用：包装异常信息)
方法抛出异常后执行，如果方法没有抛出异常，无法执行
after:最终通知(应用：清理现场)
方法执行完毕后执行，无论方法中是否出现异常
eg:

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

（4）代码实例

（1）基于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配置

<!-- 1 创建目标类 -->
	<bean id="userServiceId" class="com.qf.d_aspect.a_xml.UserServiceImpl"></bean>
	<!-- 2 创建切面类（通知） -->
	<bean id="myAspectId" class="com.qf.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.qf.d_aspect.a_xml.UserServiceImpl.*(..))" id="myPointCut"/>
			
					method : 通知，及方法名
					pointcut :切入点表达式，此表达式只能当前通知使用。
					pointcut-ref ： 切入点引用，可以与其他通知共享切入点。
				<aop:around method="" pointcut-ref=""/>
				通知方法格式：public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
					返回值类型：Object
					方法名：任意
					参数：org.aspectj.lang.ProceedingJoinPoint
					抛出异常
				执行目标方法：Object obj = joinPoint.proceed();
				<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"/> 
		</aop:aspect>
	</aop:config>

spring的全自动和aspectj方式实现的aop

1）spring全自动的增强类需要实现aop联盟提供的几个接口：MethodInterceptor（环绕）,MethodBeforeAdvice(前置),AfterReturningAdvice(后置) spring配置文件使用的是：<aop:advisor>节点配置
2)aspectj方式：
增强类不需要实现任何接口，只需要提供几个用于增强的方法即可
注意：如果是环绕增强的方法必须传递参数：ProccedingJoinpoint 其他增强可传入JoinPoint参数(aspect包下的)，该参数可获得目标方法的基本信息 在spring配置文件中使用<aop:aspect>节点配置

（2） 基于注解

替换bean

<!-- 1 创建目标类 -->
	<bean id="userServiceId" class="com.qf.d_aspect.b_anno.UserServiceImpl"></bean>
	<!-- 2 创建切面类（通知） -->
	<bean id="myAspectId" class="com.qf.d_aspect.b_anno.MyAspect"></bean>

扫描

<!-- 1.扫描 注解类 -->
	<context:component-scan base-package="com.qf.d_aspect.b_anno"></context:component-scan>

替换aop

<!-- 2.确定 aop注解生效
  切面自动代理
 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

声明切面

//声明公共切入点
	@Pointcut("execution(* com.qf.d_aspect.b_anno.UserServiceImpl.*(..))")
	private void myPointCut(){
	}
	@AfterReturning(value="myPointCut()" ,returning="ret")
	public void myAfterReturning(JoinPoint joinPoint,Object ret){
		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
	}
<aop:around method="myAround" pointcut-ref="myPointCut"/>
@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.qf.d_aspect.b_anno.UserServiceImpl.*(..))" ,throwing="e")
	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
		System.out.println("抛出异常通知 ： " + e.getMessage());
	}

spring配置

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