spring-101-springAOP
spring-101-springAOP
haoran_10 发表于1年前
spring-101-springAOP
  • 发表于 1年前
  • 阅读 9
  • 收藏 1
  • 点赞 0
  • 评论 0

腾讯云 技术升级10大核心产品年终让利>>>   

前言:

在很多场景下有一个共同的业务模块。比如用户在网站购物时,加入商品到购物车,下单,支付,等等,但是所有的业务都需要打日志,但是每个业务重写一遍日志又比较麻烦。此时springAOP可以适用这样的情况。

AOP(Aspect Oriented Programming),即面向切面编程(也叫面向方面编程,面向方法编程)。其主要作用是,在不修改源代码的情况下给某个或者一组操作添加额外的功能。像日志记录,事务处理,权限控制等功能,都可以用AOP来“优雅”地实现,使这些额外功能和真正的业务逻辑分离开来,软件的结构将更加清晰。

springAOP概念较多,但是最为关键的有2个:

  • Advice

        通知,多个业务模块都用到一个共同的功能,那么这个共同的功能,比如打日志,这个就是通知。
  • Pointcut

        切入点,多个业务模块都用到一个共同的功能,那么这个多个业务模块,比如加入商品到购物车,这个就是切入点。

spring为了方便,对这两个进行了组合

  • Advisor

        这个其实是Advice和Pointcut的组合,Advice和Pointcut组成的独立的单元。
    也就是说,多个业务模块都用到一个共同的功能,那么这个整体就叫Advisor

就依用户网站购物,加入商品到购物车,下单,支付都用到了加入日志为例子做一个DEMO。

1.用户多业务场景

用户在网站购物三个业务模块,加入商品到购物车,下单,支付代码,如下,代码清单1:

package wang.conge.springdemo.aop.service;

import org.springframework.stereotype.Component;

import wang.conge.springdemo.aop.annotation.AopLogAnnotation;

@Component
public class UserService {
    
    @AopLogAnnotation
    public void addCar() {
        System.out.println("加入购物车");
    }
    
    @AopLogAnnotation
    public void createOrder() {
        System.out.println("下单");
    }
    
    @AopLogAnnotation
    public void pay() {
        System.out.println("付款");
    }
}

代码清单1 用到了注解作为切入点的最小单元,先列出来,下面说明,代码清单2:

package wang.conge.springdemo.aop.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AopLogAnnotation {
    String value() default "";
}

2.共同业务模块

用户在网站购物三个业务模块,加入商品到购物车,下单,支付代码,但是都用到了加入日志,如下,代码清单3:

package wang.conge.springdemo.aop.service;

import java.lang.reflect.Method;
import java.util.Optional;

import org.aopalliance.aop.Advice;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.Pointcut;
import org.springframework.aop.support.AbstractPointcutAdvisor;
import org.springframework.aop.support.StaticMethodMatcherPointcut;
import org.springframework.stereotype.Component;

import wang.conge.springdemo.aop.annotation.AopLogAnnotation;

@Component
public class CommonLogAdvisor extends AbstractPointcutAdvisor{
    private static final long serialVersionUID = 1L;
    
    @Override
    public Pointcut getPointcut() {
        return new StaticMethodMatcherPointcut() {
            
            @Override
            public boolean matches(Method method, Class<?> targetClass) {
                //TODO matches targetClass 
                //if(targetClass matches AopTargetClass) return true;
                
                //TODO matches method 
                //if(method matches AopMethod) return true;
                
                if(method.isAnnotationPresent(AopLogAnnotation.class)) {
                    return true;
                }
                
                return false;
            }
            
        };
    }

    @Override
    public Advice getAdvice() {
        return new MethodInterceptor() {
            @Override
            public Object invoke(MethodInvocation invocation) throws Throwable {
                Object ret = null;
                try {
                    //TODO before
                    System.out.println("=====SpringAopAdvisor-调用前before逻辑===");
                    
                    ret = invocation.proceed();
                    
                    //TODO after
                    System.out.println("=====SpringAopAdvisor-调用后after逻辑===");
                    
                    return ret;
                } catch (Exception e) {
                    //TODO throw
                    System.out.println("=====SpringAopAdvisor-调用异常throw逻辑===");
                    return Optional.empty();
                } finally {
                    //TODO finally
                    System.out.println("=====SpringAopAdvisor-调用最终结束逻辑===");
                }
            }
        };
    }
    
}

下面对代码说明,为整个DEMO中核心代码:

  • public Advice getAdvice() ;该方法就是返回共同的业务所做的事情,在业务调用时就会在合适的逻辑之前,或之后,或发生异常,去完成相应的共同逻辑处理。
  • public Pointcut getPointcut() ; 该方法返回拦截业务的规则,事实上,加入商品到购物车,下单,支付并不是切入点,而加入商品到购物车,下单,支付这几个业务怎样在哪里加入共同日志的方式,或者规则,才叫切入点。方法里利用注解的方式,如果方法上注解了AopLogAnnotation,就会拦截,否则不拦截。也可以进进一步从类的Class做拦截的规则,这个看具体业务拦截的方式了。

3.配置代码

剩下的代码则是对上述代码进行组织运行了。
配置代码,启用EnableAspectJAutoProxy支持。代码清单4:

package wang.conge.springdemo.aop.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass=true)
@ComponentScan("wang.conge.springdemo.aop.service")
public class AppConfig {
    
}

运行主代码,代码清单5:

package wang.conge.springdemo.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import wang.conge.springdemo.aop.config.AppConfig;
import wang.conge.springdemo.aop.service.UserService;

public class AppStart {

    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        
        UserService myService = applicationContext.getBean(UserService.class);
        myService.addCar();
        
        myService.createOrder();
    }

}

OK,整个DEMO就结束了,紧紧抓住AOP的主题思想:

  • 多个业务有共同功能,多个业务切入点,也就是被拦截的地方,或者拦截这些多个业务的规则
  • 多个业务共同的功能,也就是该共同功能所做的事情。

上述代码是以springAOP做实例,事实上spring也支持aspectj ,但是运行的方式还是根据代理的形式。
而spring实现AOP的技术,主要分为两大类:

一是采用动态代理技术,利用截取消息的方式,对该消息进行装饰,以取代原有对象行为的执行;
二是采用静态织入的方式,引入特定的语法创建“方面”,从而使得编译器可以在编译期间织入有关“方面”的代码。


如果要是原生的aspectj 还是比较复杂,牵扯到织入的细节。aspectj是aop的Java实现方案。下面是几点关于aspectj的描述:

  • AspectJ是一个代码生成工具(CodeGenerator),其中AspectJ语法就是用来定义代码生成规则的语法。基于自己的语法编译工具,编译的结果是Java Class文件,运行的时候classpath需要包含AspectJ的一个jar文件(Runtime lib),支持编译时织入切面,即所谓的CTW机制,可以通过一个Ant或Maven任务来完成这个操作。
  • AspectJ有自己的类装载器,支持在类装载时织入切面,即所谓的LTW机制。使用AspectJ LTW有两个主要步骤,第一,通过JVM的-javaagent参数设置LTW的织入器类包,以代理JVM默认的类加载器;第二,LTW织入器需要一个 aop.xml文件,在该文件中指定切面类和需要进行切面织入的目标类
  • AspectJ同样也支持运行时织入,运行时织入是基于动态代理的机制。(默认机制)

附录1,AOP详细概念:

附录2,spring aop官方网站介绍资料:http://docs.spring.io/spring/docs/current/spring-framework-reference/html/aop.html

共有 人打赏支持
粉丝 27
博文 88
码字总数 80846
×
haoran_10
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: