Spring框架学习(二)——AOP

于 2019-01-21 11:13:19 发布
阅读量149 收藏
点赞数 1
分类专栏： javaWeb 文章标签： aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41936805/article/details/86554456
版权

文章目录

三、AOP概述

1.AOP

  1. AOP(Aspect-Oriented Programming，面向切面编程)：是一种新的方法论，是对传
    统 OOP(Object-Oriented Programming，面向对象编程)的补充。
  2. AOP编程操作的主要对象是切面(aspect)，而切面模块化横切关注点。
  3. 在应用AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能应用在哪里，以什么方式应用，并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的类里——这样的类我们通常称之为“切面”。
  4. AOP的好处：
    ① 每个事物逻辑位于一个位置，代码不分散，便于维护和升级
    ② 业务模块更简洁，只包含核心业务代码
    ③ AOP图解
    在这里插入图片描述

2.环境搭建

https://mvnrepository.com/
通过此网站分别下载对应自己spring版本的jar包，我是
com.springsource.net.sf.cglib-2.2.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
com.springsource.org.aopalliance-1.0.0.jar
spring-aspects-4.3.18.RELEASE.jar
spring-aop-4.3.18.RELEASE.jar
然后添加到lib文件夹内，然后add as libaray即可配置完成

3.AOP术语

  • 横切关注点
    从每个方法中抽取出来的同一类非核心业务。

  • 切面
    封装横切关注点信息的类，每个关注点体现为一个通知方法。

  • 目标
    被通知的对象

  • 代理
    向目标对象应用通知之后创建的代理对象

  • 连接点
    横切关注点在程序代码中的具体体现，对应程序执行的某个特定位置。例如：类某个方法调用前、调用后、方法捕获到异常后等。
    在应用程序中可以使用横纵两个坐标来定位一个具体的连接点：

  • 切入点：
    定位连接点的方式。每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物。如果把连接点看作数据库中的记录，那么切入点就是查询条件——AOP可以通过切入点定位到特定的连接点。切点通过org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

  • 通知(切面必须要完成的各个具体工作)
    ① @Before：前置通知，在方法执行之前执行
    ② @After：后置通知，在方法执行之后执行
    ③ @AfterRunning：返回通知，在方法返回结果之后执行
    ④ @AfterThrowing：异常通知，在方法抛出异常之后执行
    ⑤ @Around：环绕通知，围绕着方法执行

4.Aspect的五种通知详解

<1>前置通知

1.首先先准备一个实现四则运算的接口和实现类,并且对xml文件进行组件扫描和aspect标识

<!--组件扫描-->
    <context:component-scan base-package="aop"></context:component-scan>

    <!--开启基于注解的aspectJ:主要作用是为满足切面中通知能作用到的目标类生成代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

interface ArithmeticCaculator {
    public int add(int i,int j);
    public int sub(int i,int j);
    public int mul(int i,int j);
    public int div(int i,int j);
}
public class ArimeticCaculatorImpl implements ArithmeticCaculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        return result;
    }
}

2.创建一个Logging类，作日志切面
3.为了让我们创建的类能被IOC识别到，所以我们要把他标识成一个Component组件

@Component//标识为一个组件
public class Logging {
}

4.因为Logging是一个切面，所以他包含很多通知，在这里我们把它命名为前置通知。
Before里面的参数是为了确定在哪个方法之前添加一个前置通知

@Component//标识为一个组件
@Aspect//标识为一个切面
public class Logging {
    /**
     * 前置通知：在目标方法(连接点)执行之前执行。
     */
    @Before("execution(public int aop.ArimeticCaculatorImpl.add(int,int))")//切入点表达式
    public void beforemethod(){
        System.out.println("loggingAspect ==> The method begin with[x,y]");
    }
}

5.创建一个测试类来验证结果

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aspectJ.xml");
        ArithmeticCaculator ac = ctx.getBean("arimeticCaculatorImpl", ArithmeticCaculator.class);
        System.out.println(ac.add(12,3));
    }
}
//output:loggingAspect ==> The method begin with[x,y]
//loggingAspect ==> addArgs are[12, 3]
//15

此时的ac是接口实例其实现方法的代理对象，虽然我们对接口进行了实例化，但是却得到了能实现其接口实现类的实例，这是因为

<!--开启基于注解的aspectJ:主要作用是为满足切面中通知能作用到的目标类生成代理-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

之后，Before内部标记的类，会生成其代理，而获取代理对象的时候getBean内的类是被aop切面通知切作用过的，所以返回了代理对象，当代理对象调用代理方法的时候就会立刻在之前先执行Before所产生的前置通知。而又因为ac是代理对象，所以无法由接口实现类实例化生成。

<2>后置通知
    /**
     * 后置通知：在目标方法执行之后执行，不管目标方法有没有抛出异常，不能获取方法的结果
     * 也可以写为@After("execution(public int aop.ArimeticCaculatorImpl.*(..))")
     * 表示对于所有这个包下这个类返回int值的方法都进行后置通知
     * 也可以把public int写为* ，表示不管返回什么值，这包下的这个类所有方法都进行后置通知
     *
     * 连接点对象：JoinPoint
     */
    @After("execution(public int aop.ArimeticCaculatorImpl.*(int ,int ))")
    public void afterMethod(JoinPoint joinPoint){
//        获取连接点方法的名字
        String name = joinPoint.getSignature().getName();
//        获取连接点方法的参数
        Object[] objects = joinPoint.getArgs();
        System.out.println("loggingAspect ==> "+name + "Args are" + Arrays.asList(objects));
    }

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aspectJ.xml");
        ArithmeticCaculator ac = ctx.getBean("arimeticCaculatorImpl", ArithmeticCaculator.class);
        System.out.println(ac.add(12,3));
        System.out.println(ac.div(12,3));
        System.out.println(ac.div(12,0));
    }
}
/**output:
 * loggingAspect ==> The method begin with[x,y]
 * loggingAspect ==> addArgs are[12, 3]
 * 15
 * loggingAspect ==> divArgs are[12, 3]
 * 4
 * loggingAspect ==> divArgs are[12, 0]
 * Exception in thread "main" java.lang.ArithmeticException: / by zero
 */
<3>返回通知
    /**
     * 返回通知：在目标方法正常执行后执行，可以获取到方法的返回值
     *
     * 获取返回值的方法，通过returning来指定一个名字，必须要与方法的一个形参名保持一致
     */
    @AfterReturning(value = "execution(public int aop.ArimeticCaculatorImpl.*(..))",returning = "result")
    public void afterReturnMethod(JoinPoint joinPoint , Object result){
//        方法的名字
        String nameAfter = joinPoint.getSignature().getName();
        System.out.println("LoggingAspect ==>" + nameAfter + " end with:" + result);
    }

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aspectJ.xml");
        ArithmeticCaculator ac = ctx.getBean("arimeticCaculatorImpl", ArithmeticCaculator.class);
        System.out.println(ac.add(12,3));
    }
}
/**
 * loggingAspect ==> The method begin with[x,y]
 * loggingAspect ==> add Args are[12, 3]
 * LoggingAspect ==>add end with:15
 * 15
 */
<4>异常通知
    /**
     * 异常通知：在目标方法抛出异常后执行
     */
    @AfterThrowing(value = "execution(public int aop.ArimeticCaculatorImpl.*(..))",throwing = "tw")
    public void afterThrowing(JoinPoint joinPoint,Exception tw){
//        方法的名字
        String nameAfterThrowing = joinPoint.getSignature().getName();
        System.out.println("LoggingAspect ==>" + nameAfterThrowing+"throwing"+tw);
    }

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aspectJ.xml");
        ArithmeticCaculator ac = ctx.getBean("arimeticCaculatorImpl", ArithmeticCaculator.class);
        System.out.println(ac.add(12,3));
        System.out.println(ac.div(12,0));
    }
}
/**output:
 * loggingAspect ==> The method begin with[x,y]
 * loggingAspect ==> add Args are[12, 3]
 * LoggingAspect ==>add end with:15
 * 15
 * loggingAspect ==> div Args are[12, 0]
 * LoggingAspect ==>divthrowingjava.lang.ArithmeticException: / by zero
 */
<5>环绕通知
    /**
     * 环绕通知：环绕着目标方法执行。可以理解为是前置 后置 返回 异常的结合体，更像是动态代理的整个过程
     */
    @Around("execution(public int aop.ArimeticCaculatorImpl.*(..))")
    public Object aroundMethod(ProceedingJoinPoint pj){
        try {
            System.out.println("前置");
//            前置
            Object result = pj.proceed();
//            返回
            return result;
        } catch (Throwable throwable) {
//            异常
            throwable.printStackTrace();
        }finally {
//            后置
            System.out.println("后置");
        }
        return 0;
    }

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aspectJ.xml");
        ArithmeticCaculator ac = ctx.getBean("arimeticCaculatorImpl", ArithmeticCaculator.class);
        System.out.println(ac.add(12,3));
        System.out.println(ac.div(12,0));
    }
}
/**output:
 * 前置
 * java.lang.ArithmeticException: / by zero
 * 后置
 * 15
 * 前置
 * 后置
 * 0
 */

5.切面的优先级

当我们在两个方法中都对另一个方法设定了相同位置通知的时候，就会产生先后顺序的问题，这时我们就需要调整优先级来让程序按照我们制定的顺序去执行。
这是没有调整优先级的程序：

/**
 * 验证切面
 */
@Component
@Aspect
public class ValidationAspect {
    @Before("execution(public int aop.*.*(..))")
    public void BeforeMethod(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        Object[] objects = joinPoint.getArgs();
        System.out.println("ValidationAspect" + name + Arrays.asList(objects));
    }
}

然后和之前所编写的方法同时运行

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-aspectJ.xml");
        ArithmeticCaculator ac = ctx.getBean("arimeticCaculatorImpl", ArithmeticCaculator.class);
        System.out.println(ac.add(12,3));
//        System.out.println(ac.div(12,0));
    }
}
/**output:
 * 前置
 * loggingAspect ==> The method begin with[x,y]
 * ValidationAspectadd[12, 3]
 * 后置
 * loggingAspect ==> add Args are[12, 3]
 * LoggingAspect ==>add end with:15
 * 15
 */

这时我们发现输出的前三行都是之前编写的程序所设定的前置通知，现在我们想让他们按照我们决定的顺序去执行，就应该添加@Order注解，然后给予一个int类型的值，值越小，优先级越大，默认为Int的最大值。

/**
 * 验证切面
 */
@Component
@Aspect
@Order(1)
public class ValidationAspect {
    @Before("execution(public int aop.*.*(..))")
    public void BeforeMethod(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        Object[] objects = joinPoint.getArgs();
        System.out.println("ValidationAspect" + name + Arrays.asList(objects));
    }
}

现在我们把刚才最后输出的方法优先级调到最高
然后用执行main验证得到

/**
 * 验证切面
 */
@Component
@Aspect
@Order(1)
public class ValidationAspect {
    @Before("execution(public int aop.*.*(..))")
    public void BeforeMethod(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        Object[] objects = joinPoint.getArgs();
        System.out.println("ValidationAspect" + name + Arrays.asList(objects));
    }
}
/**
 * ValidationAspectadd[12, 3]
 * 前置
 * loggingAspect ==> The method begin with[x,y]
 * 后置
 * loggingAspect ==> add Args are[12, 3]
 * LoggingAspect ==>add end with:15
 * 15
 */

由此得知，当多个相同的通知给予到一个方法的时候，可以通过设置Order的参数给前置通知，令优先级可以手动进行改变。

6.重用切入量表达式

我们经常在定义通知的注解的时候要设置相同的切入量表达式，所以，可以在类中使用@PointCut定义一个共同可以使用的切入量表达式，例如：

    @Pointcut("execution(public int aop.*.*(..))")
    public void pointcut(){}

    @Before("pointcut()")
    public void BeforeMethod(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        Object[] objects = joinPoint.getArgs();
        System.out.println("ValidationAspect" + name + Arrays.asList(objects));
    }

通过@PointCut定义好的切入量表达式，令其余的通知可以直接将方法名作为参数填入，就可以定义好切入量表达式了。

2NaCl
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值