AOP面向切面编程

1.什么是AOP

AOP 指的是面向切面编程——针对业务过程中的切面(相同代码)进行提取，面对的是处理过程中的某一步骤或阶段

2.AOP作用

AOP 关注点是共同处理，可以通过配置将其作用到某一个或多个目标对象上。好处是实现组件重复利用，改善程序结构，提高灵活性。将共通组件与目标对象解耦。

AOP主要用在处理共通逻辑，如性能统计、日志记录、事务处理、异常处理等，利用AOP可以将这些共通逻辑从普通的业务逻辑代码中分离处理。如果要修改这些逻辑也不会影响普通业务逻辑代码。

3.基本概念及原理

切面（Aspect）：封装共通代码的组件，可以作用到其他目标组件的方法上。

目标（target）：一个或多个方面所作用的对象

切入点（Pointcut）：用于指定哪些组件哪些方法使用切面组件，Spring提供表达式来实现该指定

方法限定表达式：execution(返回值类型 方法名(参数))

通知（Advice）：用于指定组件作用到目标组件的具体位置

4.AOP实现原理：基于动态代理技术

5.AOP开发步骤

xml配置方式：

A.创建切面组件类

B.spring配置文件中申明切面组件

C.spring配置文件中使切面组件作用到目标组件的方法上

    <aop:config>
    <!-- aop:pointcut 设置切入点   即哪些类的哪些方法需要使用切面组件切入功能 
        expression：通过设置切入点表达式来控制切入点
        按类型匹配的切入点表达式
        within(包名.类名)
        a.匹配到具体的类 如  within(com.rong.web.service.EmpServiceImpl)   
    -->
        <aop:pointcut expression="within(com.rong.web.service.EmpServiceImpl)" id="myPointcut"/>
        <!-- 
        aop:aspect 设置切面功能   ref用来指定哪个切面类
         -->
        <aop:aspect id="" ref="myLogger">
            <!-- 设置通知类型 -->
            <!-- aop:before  前置通知，在目标方法执行前来执行切面操作
                method:指定切面类哪个方法进行切面操作
                pointcut-ref:设置上面定义好的切入点对象  
             -->
            <!-- <aop:before method="doBefore"   pointcut-ref="myPointcut"/> -->
            <!--后置通知-->
            <aop:after method="doAfter" pointcut-ref="myPointcut"/>
            <!-- 环绕通知 -->
            <!-- <aop:around method="doAound" pointcut-ref="myPointcut"/> -->
            <!-- 异常通知 
            throwing:需要指定当前的异常对象  需要与切面类的异常通知方法中的参数名对应
            -->
            <aop:after-throwing method="doException" throwing="e" pointcut-ref="myPointcut" />
            <aop:after-returning method="doAfterReturning" pointcut-ref="myPointcut"/>
        </aop:aspect>
    </aop:config>

通知类型：

前置通知（before）：先执行切面功能再执行目标功能

后置通知（after）：先执行目标功能再执行切面功能(无异常情况)

最终通知(after-returning)：先执行目标功能再执行切面功能（有无异常都执行切面）

异常通知（after-throwing）：先执行目标，捕获抛出异常后执行切面

环绕通知（around）：先执行切面前置部分，然后执行目标，最后再执行切面后置部分

切入点表达式：

类匹配： 语法within(包名.类名)

　　　　 匹配到具体的类

方法匹配：

　　　　execution(返回值类型  包名.类名.方法名(参数类型,参数类型..))

注解方式实现AOP：

A.xml配置文件中开启组件扫描和注解功能

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

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

B.目标组件注解

C.切面组件注解

@Component：声明普通、一般组件

@Aspect：声明切面组件

@Before("within(com..UserBizImpl)")：设置前置通知

@AfterReturning("within(com..UserBizImpl)")：设置后置通知

@Around("within(com..UserBizImpl)")：设置环绕通知

@AfterThrowing(pointcut="within(com..UserBizImpl)",throwing="e")：设置异常通知

@After("within(com..UserBizImpl)")：设置最终通知

/**
 * 切面组件类   定义共通的业务逻辑
 * 
 * @Aspect: 声明当前bean为切面组件bean 
 * @Before(切入点表达式):声明当前方法为前置通知
 * 
 * 
 * within:按类型匹配
 * within(包名.类名)：给某个具体类的所有方法进行aop切面编程
 * within(包名.*): 给当前包下(不包括子包)下的所有类切面编程
 * within(包名..*):给当前包下(包括子包)下的所有类切面编程
 * 
 * execution：按方法匹配    
 * execution(返回值类型 包名.类名.方法名(参数类型,参数类型,...))
 * execution(* com.rong.web.service..*.find*(..)):
 *  第一个*是表示任意的方法返回值类型   
 *  service..*表示service包和子包下的任意类
 *  find*：表示任意以find开头的方法
 *  (..)表示方法中的参数任意
 * 
 * @author 容杰龙
 */
//@Aspect
//@Component//声明组件bean注解

public class MyLogger {
    
    //定义前置通知   在方法执行前执行
    //@Before("within(com.rong.web.service.*)")
    public void doBefore(){
        System.out.println("日志记录前置操作。。。。。。");
    }
    
    
    @After("within(com..*)")
    //后置通知
    public void doAfter(){
        System.out.println("日志记录后置通知操作。。。。");
    }
    
    /**
     * 
     * 给程序中的所有的find开头的方法添加环绕通知
     * 
     * ProceedingJoinPoint  :  封装了目标组件信息的类
     * @param joinPoint
     */
    
//    @Around("execution(* com.rong.web.service..*.find*(..))")
    public void doAound(ProceedingJoinPoint joinPoint){
        //getSignature()获取目标方法
        String methodName = joinPoint.getSignature().getName();
        String className = joinPoint.getTarget().getClass().getName();//获取目标组件类名
        
        //环绕通知前置功能
        System.out.println(className+"的"+methodName+"开始执行......");
        long start = System.currentTimeMillis();
        
        try {
            //执行目标组件的方法
            Object proceed = joinPoint.proceed();// 等同于empService.findAll()
        } catch (Throwable e) {
            e.printStackTrace();
        }
        
        //环绕通知后置功能
        System.out.println(className+"的"+methodName+"执行完成......");
        long end = System.currentTimeMillis();
        System.out.println("当前方法总执行时间"+(end-start));
    }
    
    /**
     * service和子包所有类中的方法生效
     * 异常通知调用的切面方法
     * 当发生当前参数类型指定的异常的时候会引发调用，需要注意比当前参数类型大的异常无法引发调用
     * 
     * pointcut:切入点表达式
     * throwing：对应方法中的参数
     */
    @AfterThrowing(pointcut="execution(* com.rong.web.service..*.*(..))",throwing="e")
    public void doException(Exception e){
        System.out.println("异常通知调用。。。。。。。。");
        e.printStackTrace();
    }
    
    /**
     * service包下包括子包的所有方法都执行
     * 返回通知    在执行完目标方法返回之前执行  
     */
    @AfterReturning("execution(* com.rong.web.service..*.*(..))")
    public void doAfterReturning(){
        System.out.println("返回通知执行......");
    }
}