AspectJ通知

前置通知

@Before 前面已经实例过了，略

后置通知

后置通知方法实现切面功能：
1.公共方法
2.方法没有返回值
3.方法名称自定义
4.方法可以有参数，推荐是Object,参数名称自定义

@AfterReturning后置通知
属性：
1、value切入点表达式
2、returning自定义的变量，表示目标方法的返回值的
自定义变量名必须和通知方法的形参一样

特点：
1、在目标方法后执行
2、能够获取到目标方法的返回值，可以根据这个返回值做不同的处理功能
3、可以修改这个返回值

    @AfterReturning(
            value = "execution(public void org.example.Hello.sayHello(String))",
            returning = "res"
    )
    public void after(Object res){
        //Object res:是目标方法执行后的返回值，根据返回值做你的切面的功能处理

        //功能代码
        System.out.println("切面功能，执行之后"+new Date());
    }

后置通知修改目标方法返回值

@AfterReturning
如果要用JoinPoint也可以，但必须写在第一个参数
此时给hello一个返回值

 public String sayHello(String name){
        System.out.println(name+":pasaki");
        return name;
    }

在切面方法中利用后置通知修改返回值

    @AfterReturning(
            value = "execution(public String org.example.Hello.sayHello(String))",
            returning = "res"
    )
    public void after(Object res){
        //Object res:是 目标方法执行后的返回值，根据返回值做你的切面的功能处理
        if(res!=null){
            res="yongen";
        }
        //功能代码
        System.out.println("切面功能，执行之后"+new Date());
    }

测试

//1、指定spring配置文件的名称
        String config="spring_total" + ".xml";
        //2、创建表示spring容器的对象，ApplicationContext
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(config);
        //3、通过容器获取对象
        HelloInterface hello = (HelloInterface) context.getBean("hello");
        String result=hello.sayHello("yasuo");
        System.out.println(result);

然后我们发现他并没有变！！！！
因为这个执行相当于是执行
hello.sayHello(String name)
然后把name当作参数传递到我的 after(String name)

name是一个String类型
如果参数是一个对象的引用类呢？

假设有个Student对象

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

现在在Hello里创建一个学生把他作为返回对象

    public Student sayHello(String name){
        Student riven=new Student("riven",18);

        System.out.println(name+":pasaki");
        return riven;
    }

在切面类中修改返回对象

    @AfterReturning(
            value = "execution(public Student org.example.Hello.sayHello(String))",
            returning = "res"
    )
    public void myBefore(Object res){
        //Object res:是 目标方法执行后的返回值，根据返回值做你的切面的功能处理
        if(res!=null){
            ((Student) res).setName("liliya");
            ((Student) res).setAge(23);
        }
        //功能代码
        System.out.println("切面功能，执行之后"+new Date());
    }

测试

        //1、指定spring配置文件的名称
        String config="spring_total" + ".xml";
        //2、创建表示spring容器的对象，ApplicationContext
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(config);
        //3、通过容器获取对象
        HelloInterface hello = (HelloInterface) context.getBean("hello");
        Student result=hello.sayHello("yasuo");
        System.out.println(result);

变成liliya了，嘿嘿！

综上：
我们的String没有改变是因为String类型是不可变的，变的是引用，改变了后不是同一个对象
但是！！！
把对象引用作为参数后，他们的引用指向同一个对象，修改后，那当然原对象被修改啦，也就能看到改变

环绕通知

环绕通知方法实现切面功能：
1.公共方法
2.方法必须有返回值，推荐使用Object
3.方法名称自定义
4.方法可以有参数，固定参数ProceedingJoinPoint

特点：
1、是功能最强的通知
2、在目标方法的前后都能增强功能
3、控制目标方法是否被调用执行
4、修改原来的目标方法的执行结果。影响最后的调用结果

环绕通知等用于Jdk的动态代理，invocationHandler接口
参数： ProceedingJoinPoint等同于Method
返回值： 目标方法的执行结果，可以修改

    @Around(value = "execution(public Student org.example.Hello.sayHello(String))")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Object result=null;
        System.out.println("环绕通知：在方法执行之前："+new Date());
        //1、目标方法调用
        result=point.proceed();//method.invoke
        System.out.println("环绕通知：在方法执行之后："+new Date());
        //修改
        ((Student)result).setName("liliya");
        return result;
    }

环绕通知强大之处在于可以决定切面方法在什么情况下需要执行，什么情况下不需要执行
例如用ProceedingJoinPoint获取到方法的参数，通过参数判断是否需要执行目标方法。

    @Around(value = "execution(public Student org.example.Hello.sayHello(String))")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        String name="";
        //获取第一个参数值
        Object args[]=point.getArgs();
        if(args!=null && args.length>=1){
            Object arg=args[0];
            name=(String)arg;
        }
        System.out.println(name);
        Object result=null;
        System.out.println("环绕通知：在方法执行之前："+new Date());
        //判断是否需要目标方法调用
        if(name.equals("yasuo")){
            result=point.proceed();//method.invoke
        }

        System.out.println("环绕通知：在方法执行之后："+new Date());

        return result;
    }

这个时候只有参数是"yasuo"的时候才能调用目标方法。

环绕通知修改返回值

环绕通知强大在可以修改String

    public String sayHello(String name){
        System.out.println(name+":pasaki");
        return name;
    }

修改result

    @Around(value = "execution(public String org.example.Hello.sayHello(String))")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        Object result=null;
        System.out.println("环绕通知：在方法执行之前："+new Date());
        //1、目标方法调用
        result=point.proceed();//method.invoke
        result="hhhhhhhhhhhhhh";
        System.out.println("环绕通知：在方法执行之后："+new Date());

        return result;
    }

    public void shouldAnswerWithTrue()
    {
        //1、指定spring配置文件的名称
        String config="spring_total" + ".xml";
        //2、创建表示spring容器的对象，ApplicationContext
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(config);
        //3、通过容器获取对象
        HelloInterface hello = (HelloInterface) context.getBean("hello");
        String  result=hello.sayHello("yasuo");
        System.out.println(result);
    }

==这里调用的sayHello实际上被代理替换成了around方法，所以最后得到的是around里的result，区别于AfterReturning ==

异常通知

异常通知：发生异常时才执行，不发生异常不执行
相当于执行try{ ……}catch{……}

异常通知方法实现切面功能：
1.公共方法
2.没有返回值
3.方法名称自定义
4.方法可以没有参数，有就是JpinPoint

@AfterThrowing异常通知
属性：
1、value切入点表达式
2、throwing:自定义变量，表示目标方法抛出的异常对象
变量名必须和方法的参数名一样

特点：
1、在目标方法抛出异常时执行的
2、可以做异常的监控程序，监控目标方法执行时是不是有异常。
如果有异常，可以发送邮件，短信进行通知

在目标方法中抛出一个异常

    public String sayHello(String name){
        System.out.println(name+":pasaki"+10/0);
        return name;
    }

异常通知接收异常

    @AfterThrowing(value = "execution(public String org.example.Hello.sayHello(String))",throwing="ex")
    public void afterThrowing(Exception ex){
        System.out.println("异常通知：方法发生异常时执行"+ex.getMessage());

    }

最终通知

最终通知方法实现切面功能：
1.公共方法
2.没有返回值
3.方法名称自定义
4.方法可以没有参数，有就是JpinPoint

特点：
1、总会执行(无论是否有异常)
2、在目标方法之后执行的
相当于try{}catch{}finally{}

一般做资源的清除工作

    @After(value = "execution(public String org.example.Hello.sayHello(String))")
    public void after(){
        System.out.println("最终通知");

    }

复用切入点表达式

@Pointcut: 定义和管理切入点的，项目中有多个切入点表达式需要复用
特点：
当使用@Pointcut定义在一个方法的上面，此时这个方法的名称就是切入点表达式的别名
其他通知中，value属性就可以使用这个方法名称，代替切入点表达式了

 //此时cut就是切入点表达式的别名
    @Pointcut("execution(public String org.example.Hello.sayHello(String))\"")
    public void cut(){}

    @After(value = "cut()")
    public void after(){
        System.out.println("最终通知");

    }

    @Before(value = "cut()")
    public void before(){
        System.out.println("前置通知");

    }