spring-10.切入点表达式

1.execution切入点表达式

• execution(访问权限 方法返回值 方法申明（参数） 异常类型)
• 参数各部分用空格分隔开来，其中访问权限和异常类型可以省略
• 切入点表达式要匹配的对象为目标方法的方法名

 * 表示0至多个任意字符
 .. 用在方法参数中，表示任意多个参数，用在包名后，表示当前包及其子包路径
 + 用在类名后，表示当前类及其子类，用在接口后表示当前接口及其实现类

2.使用aspectj实现aop的基本步骤

1.新建maven项目

2.加入依赖
1）spring依赖
2）aspectj依赖
3）junit单元测试

3.创建目标类：接口和他的实现类，要做的是给类中的方法增加功能

4.创建切面类：普通类
1）在类的上面加入@Aspect
2）在类中定义方法，方法就是切面要执行的功能代码，在方法的上面加入aspectj中的通知注解，例如@Before，还需要指定切入点表达式execution()

5.创建spring的配置文件：声明对象，把对象交给容器统一管理，声明对象可以使用注解或者xml配置文件
1）声明目标对象
2）声明切面类对象
3）声明aspectj框架中的自动代理生成器标签
自动代理生成器：用来完成代理对象的自动创建功能的

6.创建测试类，从spring容器中获取目标对象（实际就是代理对象），通过代理执行方法，实现aop的功能增强

3.实例

1.pom配置文件

<!--spring依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>

<!--aspectj依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>

2.创建目标类

• 先定义一个接口

public interface SomeService {
    void doSome(String name,Integer age);
    void doOther();
}

• 实现接口，创建目标类

public class SomeServiceImpl implements SomeService {

    @Override
    public void doSome(String name, Integer age) {
        //给doSome方法增加一个功能，在doSome()执行之前，输出方法的执行时间
        System.out.println("目标方法doSome()");
    }

    @Override
    public void doOther() {

    }
}

• 创建切面类

/**
 * @Aspect表示当前类是切面类
 * 作用:表示当前类是切面类
 * 切面类：是用来给业务方法增加功能的类，在这个类中有切面的功能代码
 * 位置：在类定义的上面
 *
 */
@Aspect
public class MyAspect {
    /**
     * 定义方法，方法时实现切面功能的
     * 方法的定义要求：
     * 1.公共方法public
     * 2.方法没有返回值
     * 3.方法名称自定义
     * 4.方法可以有参数，也可以没有参数
     * 如果有参数，参数不是自定义的，有几个参数类型可以使用
     */

    /**
     * @Beafore 前置通知注解
     * 属性：value,是切入点表达式，表示切面的功能执行的位置
     * 位置：在方法的上面
     * 特点：1.在目标方法之前先执行
     *      2.不会改变目标方法的执行结果
     *      3.不会影响目标方法的执行
     */
    @Before("execution(public void com.chongqing.ba01.SomeServiceImpl.doSome(String,Integer))")
   public void myBefore(){
        System.out.println("前置通知，切面功能：在目标方法之前输出执行时间："+new Date());
    }

}

3.xml配置文件

<!-- 声明目标对象-->
    <bean id="someService" class="com.chongqing.ba08.SomeServiceImpl"/>
    <!-- 声明切面类对象-->
    <bean id="myAspect" class="com.chongqing.ba08.MyAspect"/>

    <!-- 声明自动代理生成器，使用aspectj框架内部的功能，创建目标对象的代理对象，创建代理对象是在内存中实现的，修改目标对象的内存中的结构，创建为代理对象，所以代理对象就是被修改后的目标对象
        aspectj-autoproxy:会把spring容器中所有的目标对象一次性都生成代理对象
    -->

    <aop:aspectj-autoproxy />

4.测试方法

public void test01(){
       String config="applicationContext.xml";
       ApplicationContext cts = new ClassPathXmlApplicationContext(config);
       //从容器中获取目标对象
       SomeService proxy =(SomeService) cts.getBean("someService");
       //通过代理的对象执行方法，实现目标方法执行时，增强了功能
        System.out.println("proxy:"+proxy.getClass().getName());
        proxy.doSome("aa",20);

   }

4.JoinPoint

 /**
     * 指定通知方法中的参数：JoinPoint
     * JoinPoint：业务方法，要加入切面功能的业务方法
     * 作用是：可以在通知方法中获取方法执行时的信息，例如方法名称，方法的实参
     * 如果切面功能中需要用到方法的信息，就加入JoinPoint
     * 这个JoinPoint参数的值是由框架赋予，必须为第一个位置的参数
     * @param jp
     */

    @Before("execution(* *..do*(..))")
    public void myBefore2(JoinPoint jp){
        System.out.println("4---前置通知，切面功能：在目标方法之前输出执行时间："+new Date());
        System.out.println("方法的签名"+jp.getSignature());
        System.out.println("方法的名称"+jp.getSignature().getName());
        Object args[]=jp.getArgs();
        for (Object arg:args){
            System.out.println("参数："+arg);
        }
    }

5.后置通知

 /**
     * 后置通知定义方法，方法时实现切面功能的
     * 方法的定义要求：
     * 1.公共方法public
     * 2.方法没有返回值
     * 3.方法名称自定义
     * 4.方法有参数，推荐是Object，参数名自定义
     */

    /**
     * @AfterReturning:后置通知
     *  属性：1.value 切入点表达式
     *      2.returning 自定义的变量，表示目标方法的返回值的，
     *      自定义变量名必须和通知方法的形参名一样
     *  位置：在方法定义的上面
     * 特点：
     * 1.在目标方法之后执行的
     * 2.获取到目标方法的返回值，可以根据这个返回值执行不同的处理功能
     * 3.可以修改这个返回值
     * @param res
     */
    @AfterReturning(value = "execution(* *..SomeServiceImpl.doOther(..))",returning = "res")
    public void myAfterReturing(Object res){
        //Object res:是目标方法执行后的返回值，根据返回值做你的切面的功能处理
        System.out.println("后面通知：在目标方法之后执行的，获取的返回值是"+res);
        if(res!=null){
            res="Hello";
        }
    }

6.环绕通知

• 创建接口

public interface SomeService {
    String doOther(String name, Integer age);
}

• 创建目标对象

public class SomeServiceImpl implements SomeService {
    @Override
    public String doOther(String name, Integer age) {
        System.out.println("目标方法doOther()");
        return "abcd";
    }

• 实现环绕通知功能

/**
 * @Aspect表示当前类是切面类
 * 作用:表示当前类是切面类
 * 切面类：是用来给业务方法增加功能的类，在这个类中有切面的功能代码
 * 位置：在类定义的上面
 */
@Aspect
public class MyAspect {
    /**
     * 环绕通知方法的定义格式
     * 1.public
     * 2.必须有一个返回值，返回值推荐使用Object
     * 3.方法名称自定义
     * 4.方法有参数，固定的参数ProceedingJoinPoint
     */
    /**
     * 环绕通知的特点
     * 1.功能最强的通知
     * 2.在目标的方法的前和后都能增强功能
     * 3.控制目标方法是否被调用执行
     * 4.修改原来的目标方法的执行结果，影响最后的调用结果
     *
     * 环绕通知等同于jdk动态代理invocationHandler接口
     * 参数：ProceedingJoinPoint等同于method
     *      作用：执行目标方法
     * 返回值：就是目标方法的执行结果，可以被修改
     *
     */
    @Around("execution(* *..SomeServiceImpl.doOther(..))")
    public Object myAround(ProceedingJoinPoint pjp) throws Throwable {

        String name="";
        //拿到方法的参数列表
        Object args[]=pjp.getArgs();
        if (args!=null && args.length>1){
            Object arg=args[0];
            name=(String)arg;
        }

        //实现环绕通知
        Object result=null;
        System.out.println("环绕通知，在目标方法之前");
        //1.目标方法调用
        if ("aa".equals(name)){
            result=pjp.proceed();//等同于method.invode
        }

        System.out.println("result为："+result);

        //2.在目标方法的前或者后加入功能
        System.out.println("环绕通知，在目标方法之后");
        result="aaaaaa";
        //System.out.println("result结果"+result);
        return result;

    }

}

• 测试

public void test01(){
       String config="applicationContext.xml";
       ApplicationContext cts = new ClassPathXmlApplicationContext(config);
       //从容器中获取目标对象
       SomeService proxy =(SomeService) cts.getBean("someService");
       //通过代理的对象执行方法，实现目标方法执行时，增强了功能
        System.out.println("proxy:"+proxy.getClass().getName());
        Object str=proxy.doOther("aa",20);
        System.out.println("后面通知执行后，获取的返回值是"+str);

   }

7.异常通知

@Aspect
public class MyAspect {
    /**
     * 异常通知方法的定义格式
     * 1.public
     * 2.没有返回值
     * 3.方法名称自定义
     * 4.方法有一个参数Excepetion，如果还有是JoinPoint
     */
    /**
     *@AfterThrowing异常通知
     * 属性：1.value切入点表达式
     *      2.throwing自定义变量，表示目标方法抛出的异常对象
     *      变量名必须和方法的参数名一致
     *  特点：
     *  1.在目标方法抛出异常时执行的
     *  2.可以做异常的监控程序，监控目标方法在执行时是不是有异常，
     *  如果有异常，可以发送短信邮件进行通知
     *
     *
     */
    /**
     try{
     SomeServiceImpl.doSecond(..)
     }catch(Exception e){
     myAfterThrowing(e);
     }

     */

    @AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",
            throwing = "ex")
    public void myAfterThrowing(Exception ex){

        System.out.println("异常通知：方法发生异常时，执行："+ex.getMessage());
    }

}

8.最终通知

@Aspect
public class MyAspect {
    /**
     * 最终通知方法的定义格式
     * 1.public
     * 2.没有返回值
     * 3.方法名称自定义
     * 4.方法没有参数，如果还有是JoinPoint
     */

    /**
     * @After:最终通知
     * 属性：value 切入点表达式
     * 位置：在方法的上面
     * 特点：
     * 1.总会执行
     * 2.在目标方法之后执行的
     *
     * try{
     *     SomeServiceImpl.doThird(..)
     * }catch(Exception e){
     *
     * }finally{
     *     myAfter()
     * }
     */
    @After(value = "execution(* *..SomeServiceImpl.doThird(..))")
    public void myAfter(){
        System.out.println("执行最终通知，总是会被执行的代码");
        //一般做资源清除工作
    }
}

9.Pointcut注解

@Aspect
public class MyAspect {
 
    /**
     * @Pointcut:定义和管理切入点，如果你的项目中有多个切入点表达式是重复的，可以复用的，
     * 可以使用@PointCut
     * 属性：value切入点表达式
     * 位置：在自定义的方法上面
     * 特点：
     *  当使用@PointCut定义在一个方法的上面，此时这个方法的名称就是切入点表达式的别名，
     *  在其他的通知中，value属性就可以使用这个方法名称，代替切入点表达式了
     */

    @After(value = "myot()")
    public void myAfter(){
        System.out.println("执行最终通知，总是会被执行的代码");
        //一般做资源清除工作
    }

    @Before(value = "myot()")
    public void myBefore(){
        System.out.println("前置通知，在目标方法之前先执行");
        //一般做资源清除工作
    }

    @Pointcut(value = "execution(* *..SomeServiceImpl.doThird(..))")
    private void myot(){
        //无需代码
    }
}

10.cglib动态代理

• 如果目标类没有接口，使用cglib动态代理，spring框架会自动应用cglib
• 如果目标类有接口，默认使用jdk动态代理，也可以使用cglib动态代理，需要修改配置文件

<!-- 如果你期望目标类有接口，使用cglib代理
         proxy-target-class="true"：告诉框架，要使用cglib动态代理
      -->
    <aop:aspectj-autoproxy proxy-target-class="true"/>