AOP目标

让我们专注于业务功能处理

AOP原理

将复杂的需求分解出不同方面，将不同对象、不同模块之间的共同业务集中解决
通过动态代理的方式，把抽离出来的共性代码”织入”到业务代码中，实现对原有代码的增强处理

AOP相关术语

Aspect（切面）	可以理解成，就是一个特殊的类（包含的都是增强核心业务的代码），切面 = 切入点 + 增强处理，通俗点就是：在什么时机，什么地方，做什么增强！
Advice（增强处理）	拦截到Joinpoint之后要做的事情,即对切入点增强内容
Pointcut（切入点）	就是被选中的连接点，可以通过execution来确定选中的连接点有哪些
Join Point（连接点）	通俗理解就是整个系统的所有方法都可以称为连接点
Target Objec（目标对象）	指代理的目标对象
AOP proxy（AOP 代理）	指生成的目标对象
Weaving（织入）	把切面加入到对象，并创建出代理对象的过程。（由 Spring 来完成）

SpringAop增强处理

before(前置增强)	切入的方法执行前
after(后置增强)	切入的方法后执行,不一定会被执行,当出现异常的情况
after-returning(最后增强)	一定会执行的增强
after-throwing(抛出异常增强)	在方法出现异常的时候执行
around(环绕增强)	最强大的一个增强,前后织入代码,能获取返回值,能捕获异常,还能觉得方法是否执行

/*SpringContext.xml*/


<!--导入aop-->
<beans  xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
    http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop.xsd">


<aop:config>
        <!--切入点-->
        <aop:pointcut id="loggerPointcut"
                      expression="execution(public void print(..))"/>
        <aop:aspect ref="sysLogger">

            <!--前置增强-->
            <aop:before method="boforeLogger" pointcut-ref="loggerPointcut"></aop:before>

            <!--后置增强-->
            <aop:after-returning method="afterReturning" pointcut-ref="loggerPointcut" returning="obj"></aop:after-returning>

            <!--异常增强-->
            <aop:after-throwing method="afterException" pointcut-ref="loggerPointcut" throwing="e"></aop:after-throwing>

            <!--环绕增强-->
            <aop:around method="around" pointcut-ref="loggerPointcut" ></aop:around>

            <!--最后增强-->
            <aop:after method="after" pointcut-ref="loggerPointcut"></aop:after>
        </aop:aspect>
    </aop:config>

/*定义一个增强类,要切入执行的方法*/


    //前置增强   切入的方法执行钱
    public void boforeLogger(JoinPoint jp){
        System.out.println("类名"+jp.getTarget());
        System.out.println("方法"+jp.getSignature().getName());
        System.out.println("参数"+ Arrays.toString(jp.getArgs()));
    }

    //后置增强   切入的方法后执行,不一定会被执行,当出现异常的情况
    public void afterReturning(JoinPoint jp,Object obj){
        System.out.println("后置增强");
    }

    //异常增强   在方法出现异常的时候执行
    public void afterException(JoinPoint jp,Exception e){
        System.out.println("异常增强");
    }

    //环绕增强   最强大的一个增强,前后织入代码,能获取返回值,能捕获异常,还能觉得方法是否执行
    public Object around(ProceedingJoinPoint pjq){
        Object result=null;
        try{
            System.out.println("------------");
            result=pjq.proceed();
            System.out.println("************");
        }catch(Throwable e){
            e.printStackTrace();
        }
        return result;
    }

    //最后增强  一定会执行的增强
    public void after(JoinPoint jp){
        System.out.println("最后增强");
    }

/*java的实体方法*/

public void print(){
       System.out.println("我也是一个打印方法");
}

<!--aop依赖1：aspectjrt -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.5</version>
</dependency>
 
<!--aop依赖2： aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/161202.html