spring之旅第五篇-AOP详解

释放双眼,带上耳机,听听看~!

一、什么是AOP?

Aspect oritention programming(面向切面编程),AOP是一种思想,高度概括的话是“横向重复,纵向抽取”,如何理解呢?举个例子:访问页面时需要权限认证,如果每个页面都去实现方法显然是不合适的,这个时候我们就可以利用切面编程。

每个页面都去实现这个方法就是横向的重复,我们直接从中切入,封装一个与主业务无关的权限验证的公共方法,这样可以减少系统的重复代码,降低模块之间的耦合度,简单的示意图如下:

二、应用场景

AOP用来封装横切关注点,具体可以在下面的场景中使用:

Authentication 权限

Caching 缓存

Context passing 内容传递

Error handling 错误处理

Lazy loading 懒加载

Debugging  调试 l

ogging, tracing, profiling and monitoring 记录跟踪 优化 校准

Performance optimization 性能优化

Persistence  持久化

Resource pooling 资源池

Synchronization 同步 T

ransactions 事务

三、相关概念

1.连接点(Joinpoint) 所谓连接点是指那些可能被拦截到的方法。例如:所有可以增加的方法

2.切点(Pointcut) 已经被增强的连接点

3.增强(Advice) 增强的代码

4.目标对象(Target) 目标类,需要被代理的类

5.织入(Weaving) 是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程

6.代理(Proxy) 一个类被AOP织入增强后,就产生出了一个结果类,它是融合了原类和增强逻辑的代理类。

7.切面(Aspect)切入点+通知

通知类型:Spring按照通知Advice在目标类方法的连接点位置,可以分为5类

  • 前置通知 (在目标方法执行前实施增强)

  • 后置通知(在目标方法执行后实施增强)

  • 环绕通知(在目标方法执行前后实施增加)

  • 异常抛出通知(在方法跑出异常时通知)

  • 引介通知(在目标类中添加一些新的方法和属性)

四、实现原理

AOP的实现关键在于AOP框架自动创建的AOP代理。AOP代理主要分为两大类:

静态代理:使用AOP框架提供的命令进行编译,从而在编译阶段就可以生成AOP代理类,因此也称为编译时增强;静态代理一Aspectj为代表。

动态代理:在运行时借助于JDK动态代理,CGLIB等在内存中临时生成AOP动态代理类,因此也被称为运行时增强,Spring AOP用的就是动态代理。

4.1 静态代理

例子:在增加员工和删除员工时增加事务处理

//员工类
public class Employee {
    private Integer uid;

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public Integer getUid() {

        return uid;
    }

    private Integer age;

    private String name;

    public Integer getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }
}

员工接口:

//员工接口
public interface EmployeeService {
    //新增方法
    void addEmployee(Employee employee);
    //删除方法
    void deleteEmployee(Integer uid);
}

员工实现:

//员工方法实现
public class EmployeeServiceImpl implements EmployeeService {
    @Override
    public void addEmployee(Employee employee) {
        System.out.println(\"新增员工\");
    }

    @Override
    public void deleteEmployee(Integer uid) {
        System.out.println(\"删除员工\");

    }
}

事务类:

//事务类
public class MyTransaction {
    //开启事务
    public void before(){
        System.out.println(\"开启事务\");
    }
    //提交事务
    public void after(){
        System.out.println(\"提交事务\");
    }
}

代理类:

//代理类
public class ProxyEmployee implements EmployeeService {
    //
    private EmployeeService employeeService;

    private MyTransaction myTransaction;

    public ProxyEmployee(EmployeeService employeeService,MyTransaction myTransaction)
    {
       this.employeeService=employeeService;
       this.myTransaction=myTransaction;
    }
    @Override
    public void addEmployee(Employee employee) {
         myTransaction.before();
         employeeService.addEmployee(employee);
         myTransaction.after();
    }

    @Override
    public void deleteEmployee(Integer uid) {
         myTransaction.before();
         employeeService.deleteEmployee(uid);
         myTransaction.after();
    }
}

测试:

@Test
    public void fun1(){
        MyTransaction transaction = new MyTransaction();
        EmployeeService EmployeeService = new EmployeeServiceImpl();
        //产生静态代理对象
        ProxyEmployee proxy = new ProxyEmployee(EmployeeService, transaction);
        proxy.addEmployee(null);
        proxy.deleteEmployee(0);
    }

结果:

这是静态代理的实现方式,静态代理有明显的缺点:

1、代理对象的一个接口只服务于一种类型的对象,如果要代理的方法很多,势必要为每一种方法都进行代理,静态代理在程序规模稍大时就无法胜任了。

2、如果接口增加一个方法,比如 EmployeeService增加修改 updateEmployee()方法,则除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度。

4.2 动态代理

动态代理就不要自己手动生成代理类了,我们去掉 ProxyEmployee.java 类,增加一个 ObjectInterceptor.java 类

public class ObjectInterceptor implements InvocationHandler {

    //目标类
    private Object target;
    //切面类(这里指事务类)
    private MyTransaction transaction;

    //通过构造器赋值
    public ObjectInterceptor(Object target,MyTransaction transaction){
        this.target = target;
        this.transaction = transaction;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        this.transaction.before();
        method.invoke(target,args);
        this.transaction.after();
        return  null;
    }
}

测试:

@Test
public void fun2(){
    //目标类
    Object target = new EmployeeServiceImpl ();
    //事务类
    MyTransaction transaction = new MyTransaction();
    ObjectInterceptor proxyObject = new ObjectInterceptor(target, transaction);
    /**
     * 三个参数的含义:
     * 1、目标类的类加载器
     * 2、目标类所有实现的接口
     * 3、拦截器
     */
    EmployeeService employeeService = (EmployeeService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
            target.getClass().getInterfaces(), proxyObject);
    employeeService.addEmployee(null);
    employeeService.deleteEmployee(0);
}

结果:

 五、spring的处理AOP的方式

spring 有两种方式实现AOP的:一种是采用声明的方式来实现(基于XML),一种是采用注解的方式来实现(基于AspectJ)

5.1 xml配置

<?xml version=\"1.0\" encoding=\"UTF-8\"?>
<beans xmlns=\"http://www.springframework.org/schema/beans\"
       xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
       xmlns:context=\"http://www.springframework.org/schema/context\"
       xmlns:aop=\"http://www.springframework.org/schema/aop\"
       xsi:schemaLocation=\"http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd\">

     <!--目标类-->
     <bean name=\"employeeService\" class=\"com.yuanqinnan.aop.EmployeeServiceImpl\"></bean>
     <bean name=\"transaction\" class=\"com.yuanqinnan.aop.MyTransaction\"></bean>
     <aop:config>
          <aop:aspect ref=\"transaction\">
               <aop:pointcut id=\"pointcut\" expression=\"execution(* com.yuanqinnan.aop.EmployeeServiceImpl..*(..))\"/>
               <!-- 配置前置通知,注意 method 的值要和 对应切面的类方法名称相同 -->
               <aop:before method=\"before\" pointcut-ref=\"pointcut\"></aop:before>
               <!--配置后置通知,注意 method 的值要和 对应切面的类方法名称相同-->
               <aop:after-returning method=\"after\" pointcut-ref=\"pointcut\"/>
          </aop:aspect>
     </aop:config>

</beans>

测试:

@Test
public void fun3(){
    ApplicationContext context = new ClassPathXmlApplicationContext(\"META-INF/applicationContext.xml\");
    EmployeeService employeeService = (EmployeeService) context.getBean(\"employeeService\");
    employeeService.addEmployee(null);
}

结果:

补充:

1.aop:pointcut如果位于aop:aspect元素中,则命名切点只能被当前aop:aspect内定义的元素访问到,为了能被整个aop:config元素中定义的所有增强访问,则必须在aop:config下定义切点。

2.如果在aop:config元素下直接定义aop:pointcut,必须保证aop:pointcutaop:aspect之前定义。aop:config下还可以定义aop:advisor,三者在aop:config中的配置有先后顺序的要求:首先必须是aop:pointcut,然后是aop:advisor,最后是aop:aspect。而在aop:aspect中定义的aop:pointcut则没有先后顺序的要求,可以在任何位置定义。

aop:pointcut:用来定义切入点,该切入点可以重用;

aop:advisor:用来定义只有一个通知和一个切入点的切面;

aop:aspect:用来定义切面,该切面可以包含多个切入点和通知,而且标签内部的通知和切入点定义是无序的;和advisor的区别就在此,advisor只包含一个通知和一个切入点。

3.在使用spring框架配置AOP的时候,不管是通过XML配置文件还是注解的方式都需要定义pointcut\"切入点\" 例如定义切入点表达式 execution(* com.sample.service.impl...(..)) execution()是最常用的切点函数,其语法如下所示:

整个表达式可以分为五个部分: (1)、execution(): 表达式主体。

(2)、第一个号:表示返回类型,号表示所有的类型。

(3)、包名:表示需要拦截的包名,后面的两个句点表示当前包和当前包的所有子包,com.sample.service.impl包、子孙包下所有类的方法。

(4)、第二个号:表示类名,号表示所有的类。

(5)、(..):最后这个星号表示方法名,号表示所有的方法,后面括弧里面表示方法的参数,两个句点表示任何参数。

5.2 注解配置

新建注解类:

@Component
@Aspect
public class AopAspectJ {
    /**
     * 必须为final String类型的,注解里要使用的变量只能是静态常量类型的
     */
    public static final String EDP=\"execution(* com.yuanqinnan.aop.EmployeeServiceImpl..*(..))\";

    /**
     * 切面的前置方法 即方法执行前拦截到的方法
     * 在目标方法执行之前的通知
     * @param jp
     */
    @Before(EDP)
    public void doBefore(JoinPoint jp){

        System.out.println(\"=========执行前置通知==========\");
    }


    /**
     * 在方法正常执行通过之后执行的通知叫做返回通知
     * 可以返回到方法的返回值 在注解后加入returning
     * @param jp
     * @param result
     */
    @AfterReturning(value=EDP,returning=\"result\")
    public void doAfterReturning(JoinPoint jp,String result){
        System.out.println(\"===========执行后置通知============\");
    }

    /**
     * 最终通知:目标方法调用之后执行的通知(无论目标方法是否出现异常均执行)
     * @param jp
     */
    @After(value=EDP)
    public void doAfter(JoinPoint jp){
        System.out.println(\"===========执行最终通知============\");
    }

    /**
     * 环绕通知:目标方法调用前后执行的通知,可以在方法调用前后完成自定义的行为。
     * @param pjp
     * @return
     * @throws Throwable
     */
    @Around(EDP)
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable{

        System.out.println(\"======执行环绕通知开始=========\");
        // 调用方法的参数
        Object[] args = pjp.getArgs();
        // 调用的方法名
        String method = pjp.getSignature().getName();
        // 获取目标对象
        Object target = pjp.getTarget();
        // 执行完方法的返回值
        // 调用proceed()方法,就会触发切入点方法执行
        Object result=pjp.proceed();
        System.out.println(\"输出,方法名:\" + method + \";目标对象:\" + target + \";返回值:\" + result);
        System.out.println(\"======执行环绕通知结束=========\");
        return result;
    }

    /**
     * 在目标方法非正常执行完成, 抛出异常的时候会走此方法
     * @param jp
     * @param ex
     */
    @AfterThrowing(value=EDP,throwing=\"ex\")
    public void doAfterThrowing(JoinPoint jp,Exception ex) {
        System.out.println(\"===========执行异常通知============\");
    }
}

xml配置

<?xml version=\"1.0\" encoding=\"UTF-8\"?>
<beans xmlns=\"http://www.springframework.org/schema/beans\"
       xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"
       xmlns:context=\"http://www.springframework.org/schema/context\"
       xmlns:aop=\"http://www.springframework.org/schema/aop\"
       xsi:schemaLocation=\"http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd\">
    <context:component-scan base-package=\"com.yuanqinnan.aop\" ></context:component-scan>
    <!-- [email protected] -->
    <aop:aspectj-autoproxy/>
    <!--目标类-->
    <bean name=\"employeeService\" class=\"com.yuanqinnan.aop.EmployeeServiceImpl\"></bean>
</beans>

测试:

@Test
public void fun4(){
    ApplicationContext act =  new ClassPathXmlApplicationContext(\"META-INF/applicationContext.xml\");
    EmployeeService employeeService = (EmployeeService) act.getBean(\"employeeService\");
    employeeService.addEmployee(null);
}

结果:

pringAOP的知识就总结到这里

 

人已赞赏
站长资讯

Cookiecutter: 更好的项目模板工具:(1)简介及可用资源汇总

2020-11-9 3:41:48

站长资讯

浏览器数据存储方式总结

2020-11-9 3:41:50

0 条回复 A文章作者 M管理员
    暂无讨论,说说你的看法吧
个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索