Spring 学习总结五

AOP面向切面编程

增加功能，导致的问题

在源代码中，业务方法中增加的功能。
1）源代码可能改动的比较多
2）重复代码比较多。
3）代码难于维护。

AOP概念

1、什么是AOP：
AOP（Aspect Orient Programming）：面向切面编程
Aspect：表示切面，给业务方法增加的功能，叫做切面。切面一般都是非业务功能，而且切面功能一般都是可以重复使用的，例如 日志功能、事务功能，权限检查，参数检查，统计信息等等。
Orient：面对，对着
Programming：编程

怎么理解面向切面编程？
1）设计项目时，找出切面的功能。
2）安排切面的执行时间，执行的位置。

2、AOP作用
1）让切面功能复用
2）让开发人员专注业务逻辑，提高开发效率
3）实现业务功能和其他非业务功能解耦合
4）给存在的业务方法，增加功能，不用修改原来的代码

3、AOP中术语
1）Aspect：切面，给业务方法增加的功能。
2）joinPoint：连接点，连接切面的业务方法，在这个业务方法执行时，会同时执行切面的功能。
3）Pointcut：切入点，是一个或多个连接点集合，表示这些方法执行时，都能增加切面的功能，表示切面执行的位置。
4）target：目标对象，给那个对象增加切面的功能，这个对象就是目标对象。
5）Advice：通知（增强），表示切面的执行时间，在目标方法之前执行切面，还是在目标方法之后执行切面。

AOP中重要的三个要素：Aspect，Pointcut，Advice。这个概念的理解是：在Advice的时间，在Pointcut的位置，执行Aspect。

AOP是一个动态的思想，在程序运行期间，创建代理（ServiceProxy），使用代理执行方法时，增加切面的功能。这个代理对象是存在内存中的。

4、什么时候你想用AOP
你想给某些方法，增加相同的一些功能，源代码不能改，给业务功能增加非业务功能，也可以使用AOP

5、AOP技术思想的实现
使用框架实现AOP，实现AOP的框架有很多，有名的两个
1）Spring：Spring框架实现ＡＯＰ思想中的部分功能。Ｓｐｒｉｎｇ框架实现ＡＯＰ的操作比较繁琐，笨重
２）Aspectｊ：独立的框架，专门是ＡＯＰ，属于Eｃｌｉｐｓｅ

６、使用ＡｓｐｅｃｔＪ框架实现ＡＯＰ
AspectＪ框架可以使用注解和ｘｍｌ配置文件两种方式实现ＡＯＰ
１）通知
AspectJ　表示切面的执行时间，用的通知（Advice）。这个通知可以表示使用注解表示。将５个注解，表示切面的５个执行时间，这些注解叫做通知注解。

• ＠Before：前置通知
• ＠AfterRetunring：后置通知
• ＠Around：环绕通知
• ＠AfterThrowing：异常通知
• ＠After：最终通知

２）Pointcut位置
Pointcut　用来表达切面执行的位置，使用Aspectｊ中切入点表达式。
切入点表达式语法：execution（访问权限　方法返回值　方法声明（参数）异常类型）

通配符：

例子说明：

3）前置通知@Before

@Aspect
public class MyAspect {
    //定义方法，表示切面的具体功能
    /*
      前置通知方法的定义
      1）方法是public
      2）方法是void
      3）方法名称自定义
      4）方法可以有参数，如果有是JoinPoint，也可以没有
     */
    /*
        @Before:前置通知
           属性：value 切入点表达式，表示切面的执行位置
                在这个方法时，会同时执行切面的功能
           位置：在方法的上面

        特点：
        1）执行时间：在目标方法之前先执行的
        2）不会影响目标方法的执行。
        3）不会修改目标方法的执行结果
     */
    /*
    @Before(value = "execution(public void com.demo.service.Impl.SomeServiceImpl.dosome(String,Integer))")
    public void myBefore(){
        //切面的代码
        System.out.println("前置通知，切面的功能，在目标方法之前先执行："+new Date());
    }


    @Before(value = "execution(void com.demo.service.Impl.SomeServiceImpl.dosome(String,Integer))")
    public void myBefore1(){
        //切面的代码
        System.out.println("前置通知，切面的功能，在目标方法之前先执行："+new Date());
    }
    */


    /*
    切面类中的通知方法，可以有参数
    JoinPoint 必须时他

    JoinPiont：表示正在执行的业务方法，相当于反射中的Method
      使用要求：必须是参数列表中第一个
      作用：获取方法执行时的信息，例如方法名称，方法的参数集合
     */
    @Before(value = "execution(* *..SomeServiceImpl.do*(..))")
    public void myBefore(JoinPoint joinPoint){
        //切面的代码
        System.out.println("前置通知，切面的功能，在目标方法之前先执行："+new Date());
        //获取方法的定义
        System.out.println("前置通知中获取目标方法的定义信息："+joinPoint.getSignature());
        System.out.println("前置通知中获取目标方法的定义信息："+joinPoint.getSignature().getName());
        //获取方法执行时的参数
        Object args[] = joinPoint.getArgs(); //数组中存放的是方法的所有参数
        for (Object obj:args){
            System.out.println("前置通知获取的方法参数："+obj);
        }

        String methodName = joinPoint.getSignature().getName();
        if("dosome".equals(methodName)){
            System.out.println("++++++++++");
        }else if ("doOther".equals(methodName)){
            System.out.println("==========");
        }
    }
}

4）后置通知@AfterReturning
@AfterReturning：在目标方法之后执行的

@Aspect
public class MyAspect {
    //定义方法，表示切面的具体功能
    /*
      后置通知方法的定义
      1）方法是public
      2）方法是void
      3）方法名称自定义
      4）方法可以有参数，推荐使用Object类型
     */

    /*
    @AfterReturning：后置通知
        属性：value 切入点表达式
             returning 自定义的变量，表示目标方法的返回值的。
                       自定义变量名称必须和通知方法的形参名一样
        位置：在方法的上面

    特点：
    1、在目标方法之后执行的
    2、能获取到目标方法的执行结果
    3、不会影响方法的执行

    方法的参数：
    Object res ：表示目标方法的返回值，使用res接收doOther的调用结果
    Object res = doOther（）；

    后置通知执行顺序
    Object res = SomeServiceImpl。doOther（。。）；
    myAfterReturning(res)；

    思考：
    1、doOther方法返回是String，Integer，Long等基本类型，在后置通知中，修改返回值，是不会影响目标方法最后调用结果的。
    2、doOther返回的结果是对象类型，例如Student。在后置通知方法中，修改这个Student对象的属性值，会不会影响最后的调用结果？

     */
    @AfterReturning(value = "execution(* com.demo1.service.Impl.SomeServiceImpl.doOther(..))",returning = "res")
    public void myAfterReturning(JoinPoint joinPoint,Object res){
        System.out.println("后置通知 ，执行结果="+res);

        //修改目标返回值不会改变
        //Object res有什么用
        if("abcd".equals(res)){
            System.out.println("不同的增强功能");
        }else if ("add".equals(res)){
            System.out.println("备份");
        }
    }

}

5）@Around 环绕通知
@Around（value = “切入点表达式”）

使用环绕通知时，就是调用切面类中的方法

@Aspect
public class MyAspect {
    //定义方法，表示切面的具体功能
    /*
      环绕通知方法的定义
      1）方法是public
      2）方法是必须有返回值，推荐使用Object类型
      3）方法名称自定义
      4）方法必须有ProceedingJoinPoint参数
     */

    /**
     * @Around:环绕通知
     *    属性：value 切入点表达式
     *    位置：在方法定义的上面
     *
     * 返回值：Object，表示调用目标方法希望得到的执行结果（不一定是目标方法自己的返回值）
     * 参数：ProceedingJoinPoint ，相当于反射中的Method。
     *     作用：执行目标方法的，等于Method.invoke().
     *
     * 特点：
     * 1、在目标方法的前和后都能增强功能
     * 2、控制目标方法是否执行
     * 3、修改目标方法的执行结果
     */
    @Around(value = "execution(* *..demo2.service.Impl.SomeServiceImpl.doFirst(..))")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        //获取方法执行时的参数值
        Object args [] = proceedingJoinPoint.getArgs();
        String name = "";
        if (args != null && args.length >0){
            Object arg = args[0];
            if(arg != null){
                name = (String) arg;
            }
        }
        System.out.println("执行了环绕通知的myAround方法");

        System.out.println("执行了环绕通知，在目标方法之前，输出时间："+new Date());
        //执行目标方法 proceedingJoinPoint，表示doFirst
        if("lisi".equals(name)) {
            Object methodReturn = proceedingJoinPoint.proceed(); //method.invoke()，表示执行doFirst（）方法本身
        }
        System.out.println("执行了环绕通知，在目标方法之后，提交时间："+new Date());
        return "Hello Around，不是靠目标方法的执行结果";
        //返回原来方法的执行结果，没有修改的
        //return methodReturn;
    }
}

6）@AfterThrowing异常通知（了解）
语法@AfterThrowing（value = “切入点表达式”，throwing = “自定义变量”）

@Aspect
public class MyAspect {
    //定义方法，表示切面的具体功能
    /*
      异常通知方法的定义
      1）方法是public
      2）方法是没有返回值，是void
      3）方法名称自定义
      4）方法有参数是Exception
     */

    /**
     * @AfterThrowing:异常通知
     *    属性：value 切入点表达式
     *        throwing 自定义变量，表示目标方法抛出的异常。
     *                 变量名必须和通知方法的形参名一样
     *    位置：在方法定义的上面
     *
     * 特点：
     * 1、在目标方法抛出异常后执行的，没有异常不执行
     * 2、能获取到目标方法的异常信息
     * 3、不是异常处理程序。可以得到发生异常的通知，可以发生邮件，短信通知开发人员。
     *    看作是目标方法的监控程序
     *
     * 异常通知的执行
     * try{
     *     SomeServiceImpl.doSecond(..)
     * }catch（Exception e）{
     *     myAfterthrowing（e）;
     * }
     */
    @AfterThrowing(value = "execution(* *..demo3.service.Impl.SomeServiceImpl.doSecond(..))",throwing = "ex")
    public void myAfterthrowing(Exception ex){
        System.out.println("异常通知，在目标方法抛出异常时执行，异常原因是="+ex.getMessage());
        /*
        异常发生时可以做：
        1、记录异常时间、位置等信息
        2、发生邮件，短信通知开发人员
         */
    }
}

7）@After 最终通知（了解）
语法：@After（value = “切入点表达式”）

@Aspect
public class MyAspect {
    //定义方法，表示切面的具体功能
    /*
      最终通知方法的定义
      1）方法是public
      2）方法是没有返回值，是void
      3）方法名称自定义
      4）方法没有参数
     */
    /*
    @After：最终通知
        属性：value 切入点表达式
        位置：在方法的上面

     特点：
     1、在目标方法之后执行
     2、总是会被执行
     3、可以用来做程序最后的收尾工作，例如清除临时数据，变量，清理内存

     最终通知
     try{
        SomeServiceImpl。doThird（，，）
     }finally{
        myAfter（）
     }

     */

    @After(value = "execution(* *..demo4.service.Impl.SomeServiceImpl.doThird(..))")
    public void myAfter(){
        System.out.println("最终通知,总会被执行");
    }
}

8）@Pointcut定义和管理切入点注解
@Pointcut（value= ”切入点表达式“）

@Aspect
public class MyAspect {

    @Before(value = "mypt()")
    public void myBefore(){
        System.out.println("前置通知");
    }

    @After(value = "mypt()")
    public void myAfter(){
        System.out.println("最终通知,总会被执行");
    }

    /**
     * @Pointcut：定义和管理切入点，不是通知注解
     *   属性：value 切入点表达式
     *   位置：在一个自定义方法的上面，这个方法看作是切入点表达式的别名
     *        其他的通知注解中，可以使用方法名称，就表达使用了这个切入点表达式了
     */

    @Pointcut("execution(* *..demo5.service.Impl.SomeServiceImpl.doThird(..))")
    private void mypt(){
        //无需代码
    }
}

AOP总结

AOP是一种动态的技术思想，目的是实现业务功能和非业务功能的解耦合。业务功能是独立的模块，其他功能也是独立的模块，例如事务功能，日志等等，让这些事务，日志功能是可以被复用的。

当目标方法需要一些功能时，可以在不修改，不能修改源代码的情况下，使用aop技术在程序执行期间，生成代理对象，通过代理执行业务方法，同时增加功能。