AOP的使用xml和注解方式

一.Aop 是什么？

Aspect Oriented Programing 面向切面编程，相比较 oop 面向对象编程来说，Aop 关注的不再是程序代码中某个类，某些方法，而 aop 考虑的更多的是一种面到面的切入 即层与层之间的一种切入，所以称之为切面。

二.Aop 能做什么？

AOP 主要应用于日志记录，性能统计，安全控制,事务处理等方面，实现公共功能性的重复使用。

三.Aop 带来的好处

1. 降低模块与模块之间的耦合度，提高业务代码的聚合度。（高内聚低耦合）
2. 提高了代码的复用性。
3. 提高系统的扩展性。

四.Aop 基本概念

1.Joinpoint(连接点)
被拦截到的每个点， spring 中指被拦截到的每一个方法， spring aop 一个连接点即代表一个方法的执行。

2.Pointcut(切入点)
对连接点进行拦截的定义（匹配规则定义 规定拦截哪些方法， 对哪些方法进行处理） ， spring 这块有专门的表达式语言定义。

3.Advice（通知）
拦截到每一个连接点即（每一个方法） 后所要做的操作
i. 前置通知 （前置增强） –before() 执行方法前通知
ii.返回通知（返回增强）–afterReturn 方法正常结束返回后的通知
iii.异常抛出通知（异常抛出增强）–afetrThrow()
iv.最终通知—after 无论方法是否发生异常，均会执行该通知。
v.环绕通知—around 包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

4.Aspect(切面)
切入点与通知的结合， 决定了切面的定义， 切入点定义了要拦截哪些类的哪些方法， 通知则定义了拦截过方法后要做什么， 切面则是横切关注点的抽象，与类相似， 类是对物体特征的抽象， 切面则是横切关注点抽象。

5.Target(目标对象)
被代理的目标对象

6.Weave(织入)
将切面应用到目标对象并生成代理对象的这个过程即为织入。

7.Introduction(引入)
在不修改原有应用程序代码的情况下， 在程序运行期为类动态添加方法或者字段的过程称为引入。

五. 使用 Aop 解决日志处理问题

Aop 配置有两种方式 注解方式 与 xml 方式
1. jar 包坐标引入

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.9</version>
</dependency>

1. beans.xml 配置
   添加命名空间

xmlns:aop="http://www.springframework.org/schema/aop"

http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

配置 aop 代理

<aop:aspectj-autoproxy/>

1. 编写业务方法
2. 编写 aop 实现类

package com.shsxt.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
/**
 * 声明切面组件
 */
@Component
@Aspect
public class LogCut {
    /**
     * 定义切入点 匹配方法规则定义
     * 匹配规则表达式含义 拦截 com.shsxt.service 包下 以及子包下 所有类
       的所有方法
     */
    @Pointcut("execution (* com.shsxt.service..*.*(..))")
    public void cut(){
    }
    /**
     * 声明前置通知 并将通知应用到定义的切入点上
     * 目标泪方法执行前 执行该通知
     */
    @Before(value="cut()")
    public void before(){
        System.out.println("前置通知.....");
    } 
    /**
     * 声明返回通知 并将通知应用到切入点上
     * 目标类方法执行完毕执行该通知
     */

    @AfterReturning(value="cut()")
    public void afterReturning(){
        System.out.println("返回通知....");
    } 
    /**
     * 声明最终通知 并将通知应用到切入点上
     * 目标类方法执行过程中是否发生异常 均会执行该通知 相当于异常中的finally
     */
    @After(value="cut()")
    public void after(){
        System.out.println("最终通知....");
    } 
    /**
     * 声明异常通知 并将通知应用到切入点上
     * 目标类方法执行时发生异常 执行该通知
     */
     @AfterThrowing(value="cut()",throwing="e")
     public void afterThrowing(Exception e){
         System.out.println("异常通知....方法执行异常时执行:"+e);
     } 
    /**
     * 声明环绕通知 并将通知应用到切入点上
     * 方法执行前后 通过环绕通知定义相应处理
     */
    @Around(value="cut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕前置...");
        System.out.println("环绕通知");
        System.out.println(pjp.getTarget()+"--"+pjp.getSignature());
        Object result=pjp.proceed();
        System.out.println("环绕后置...");
        return result;
    }
}

xml 配置实现
1. 声明 aop 代理
2. 配置切面、 切入点、 通知

<!-- aop 相关配置 -->
<aop:config>
    <!-- aop 切面配置 -->
    <aop:aspect ref="logCut">
        <!-- 定义 aop 切入点 -->
        <aop:pointcut expression="execution (*com.shsxt.service..*.*(..))" id="cut"/>
        <!-- 配置前置通知 指定前置通知方法名 并引用切入点定义 -->
        <aop:before method="before" pointcut-ref="cut"/>
        <!-- 配置返回通知 指定返回通知方法名 并引用切入点定义 -->
        <aop:after-returning method="afterReturning" pointcutref="cut"/>
        <!-- 配置异常通知 指定异常通知方法名 并引用切入点定义 -->
        <aop:after-throwing method="afterThrowing" throwing="e" pointcut-ref="cut"/>
        <!-- 配置最终通知 指定最终通知方法名 并引用切入点定义 -->
        <aop:after method="after" pointcut-ref="cut"/>
        <!-- 配置环绕通知 指定环绕通知方法名 并引用切入点定义 -->
        <aop:around method="around" pointcut-ref="cut"/>
    </aop:aspect>
</aop:config>

3.定义 bean

package com.shsxt.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.stereotype.Component;
/**
 * 声明切面组件
 */
@Component
public class LogCut {
    public void before(){
        System.out.println("前置通知.....");
    } 
    public void afterReturning(){
        System.out.println("返回通知....");
    } 
    public void after(){
        System.out.println("最终通知....");
    } 
    public void afterThrowing(Exception e){
        System.out.println("异常通知....方法执行异常时执行:"+e);
    } 
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("环绕前置...");
        System.out.println("环绕通知");
        System.out.println(pjp.getTarget()+"--"+pjp.getSignature());
        Object result=pjp.proceed();
        System.out.println("环绕后置...");
        return result;
    }
}

总结

1. 代理模式实现三要素
   i.接口定义
   ii.目标对象 与代理对象必须实现统一接口
   iii.代理对象持有目标对象的引用 增强目标对象行为

2. 代理模式实现分类以及对应区别
   静态代理：手动为目标对象制作代理对象，即在程序编译阶段完成代理对象的创建
   动态代理：在程序运行期动态创建目标对象对应代理对象。
   jdk 动态代理：被代理目标对象必须实现某一或某一组接口 实现方式 通过回调创建代理对象。
   cglib 动态代理：被代理目标对象可以不必实现接口，继承的方式实现。动态代理相比较静态代理，提高开发效率，可以批量化创建代理，提高代码复率。

3. Aop 理解
   i． 面向切面，相比 oop 关注的是代码中的层或面
   ii． 解耦，提高系统扩展性
   iii. 提高代码复用
4. Aop 关键词
   
   1. 连接点:每一个方法
   2. 切入点:匹配的方法集合
   3. 切面：连接点与切入点的集合决定了切面，横切关注点的抽象
   4. 通知:几种通知
   5. 目标对象:被代理对象
   6. 织入：程序运行期将切面应用到目标对象 并生成代理对象的过程
   7. 引入:在不修改原始代码情况下，在程序运行期为程序动态引入方法或字段的过程