复习之spring基础（二）——Spring的AOP思想及其应用（XML和注解方式）

谁践踏了优雅 2022-05-07 03:50 199阅读 0赞

## AOP （面向切面编程） ##

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

### AOP 可以进行权限校验,日志记录,性能监控,事务控制. ###

### 代理机制: Spring 的 AOP 的底层用到两种代理机制： ###

*  JDK 的动态代理 :针对实现了接口的类产生代理。
 *  Cglib 的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术 生成当前类 的子类对象。

### AOP 的开发中的相关术语: ###

*  Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只  
    支持方法类型的连接点。

*  Pointcut(切入点):所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
 *  Advice(通知/增强):所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知.通知分为前置通知,后置  
    通知,异常通知,最终通知,环绕通知(切面要完成的功能)
 *  Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类  
    动态地添加一些方法或 Field.
 *  Target(目标对象):代理的目标对象
 *  Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.
 *  spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装在期织入 Proxy（代理）:一个类被 AOP织入增强后，就产生一个结果代理类
 *  Aspect(切面): 是切入点和通知（引介）的结合

## XML 的方式 ##

### 接口 ###

public interface OrderDao { 
     public void save(); 
     public void update(); 
      public void delete();  
      public void find();
       }

### 实现类 ###

public class OrderDaoImpl implements OrderDao { 
     
     @Override  public void save() { 
      System.out.println("保存订单...");  } 
     
     @Override  public void update() { 
      System.out.println("修改订单...");  } 
     
     @Override  public void delete() { 
      System.out.println("删除订单...");  } 
     
     @Override  public void find() { 
      System.out.println("查询订单...");  } 
     
    }

### 通知类 ###

*  前置通知：目标方法运行之前调用
 *  后置通知(如果出现异常不会调用)：在目标方法运行之后调用
 *  环绕通知：在目标方法之前和之后都调用
 *  异常拦截通知：如果出现异常,就会调用
 *  后置通知(无论是否出现 异常都会调用)：在目标方法运行之后调用

--------------------

public class MyAdvice {
    	
    	//前置通知
    	public void before(){
    		System.out.println("这是前置通知!!");
    	}
    	//后置通知
    	public void afterReturning(){
    		System.out.println("这是后置通知(如果出现异常不会调用)!!");
    	}
    	//环绕通知
    	public Object around(ProceedingJoinPoint pjp) throws Throwable {
    		System.out.println("这是环绕通知之前的部分!!");
    		Object proceed = pjp.proceed();//调用目标方法
    		System.out.println("这是环绕通知之后的部分!!");
    		return proceed;
    	}
    	//异常通知
    	public void afterException(){
    		System.out.println("出事啦!出现异常了!!");
    	}
    	//后置通知
    	public void after(){
    		System.out.println("这是后置通知(出现异常也会调用)!!");
    	}
    }

### 目标类的配置 ###

### 配置通知对象 ###

### 配置将通知织入目标对象 ###

\[方法访问修饰符\] 方法返回值 包名.类名.方法名(方法的参数)

配置切入点
    	public void  top.maniy.service.UserServiceImpl.save() 
    			void  top.maniy.service.UserServiceImpl.save()
    			*  top.maniy.service.UserServiceImpl.save()
    			*  top.maniy.service.UserServiceImpl.*()
    			
    			* top.maniy.service.*ServiceImpl.*(..)
    			* top.maniy.service..*ServiceImpl.*(..)

<aop:config>
    		
    		<aop:pointcut expression="execution(* top.maniy.service.*ServiceImpl.*(..))" id="pc"/>
    		<aop:aspect ref="myAdvice" >
    			
    			<aop:before method="before" pointcut-ref="pc" />
    			
    			<aop:after-returning method="afterReturning" pointcut-ref="pc" />
    			
    			<aop:around method="around" pointcut-ref="pc" />
    			
    			<aop:after-throwing method="afterException" pointcut-ref="pc"/>
    			
    			<aop:after method="after" pointcut-ref="pc"/>
    		</aop:aspect>
    	</aop:config>

## 注解方式 ##

### 开启使用注解 ###

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

### 通知类 ###

@Aspect
    //表示该类是一个通知类
    public class MyAdvice {
    	@Pointcut("execution(*top.maniy.service.*ServiceImpl.*(..))")
    	public void pc(){}
    	//前置通知
    	//指定该方法是前置通知,并制定切入点
    	@Before("MyAdvice.pc()")
    	public void before(){
    		System.out.println("这是前置通知!!");
    	}
    	//后置通知
    	@AfterReturning("execution(* top.maniy.service.*ServiceImpl.*(..))")
    	public void afterReturning(){
    		System.out.println("这是后置通知(如果出现异常不会调用)!!");
    	}
    	//环绕通知
    	@Around("execution(* top.maniy.*ServiceImpl.*(..))")
    	public Object around(ProceedingJoinPoint pjp) throws Throwable {
    		System.out.println("这是环绕通知之前的部分!!");
    		Object proceed = pjp.proceed();//调用目标方法
    		System.out.println("这是环绕通知之后的部分!!");
    		return proceed;
    	}
    	//异常通知
    	@AfterThrowing("execution(* top.maniy.service.*ServiceImpl.*(..))")
    	public void afterException(){
    		System.out.println("出事啦!出现异常了!!");
    	}
    	//后置通知
    	@After("execution(* top.maniy.service.*ServiceImpl.*(..))")
    	public void after(){
    		System.out.println("这是后置通知(出现异常也会调用)!!");
    	}
    }