深入AOP原理与应用

原创 2015年01月06日 18:33:07

AOP(Aspect Oriented Programming)就是面向切面编程,也是一种编程思想,接触了JAVA是Spring框架后我才了解AOP,在我的工作中会经常用到,举个存储分层的例子,就像硬盘、内存和CPU中的寄存器,对应的高性能应用系统会有普通数据库、Redis和本地内存:

那么这里的缓存操作我们可以抽出来统一做,这里我们就用到了AOP,切点就是对数据的存取方法,还有就是调用外部系统的接口获取数据时,我们也可以用AOP来实现统一的缓存操作,我们通常用的AOP的框架是aspectj,实现的原理是动态代理,动态代理的方案有JDK Proxy、cglib等,cglib是代码的动态生成技术,用asm提供的动态生成JAVA字节码的技术,而JDK的动态代理是一种设计模式,依懒接口的实现。写一个AOP简单如下

@Aspect
@Component
public class CacheUpdateProcessor {

    @Around("@annotation(com.xxx.xxx.cache.CacheUpdate)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {

        Object result = joinPoint.proceed();
        
        try {
            // 获取被切方法的所有入参
            Object[] methodArgs = joinPoint.getArgs();
            Signature signature = joinPoint.getSignature();
            if (signature instanceof MethodSignature) {

            }
        } catch (Exception e) {
            
        }
        return result;
    }

}
我们还在spring的XML配置文件中加上

<aop:aspectj-autoproxy proxy-target-class="true" />
表示使用cglib动态代理技术织入增强,利用cglib的好处是提高了系统的性能,利用注解让spring帮我们完成了自动代码织入,注解@Around中的参数就是织入的切点,around表示包围了整个方法,被切的代码的执行可以通过joinPoint(连接点)来调用,当然除了around的还有其他的织入方式,例如before和after,表示在被切方法前执行和被切方法后执行。

我们可以在around、before或after的方法里进行统一的缓存处理,而在需要进行此类操作的地方只需要加个被设置为切点的注解即可,如果还需要传方法参数以外的数据,可以对自定义的注解进行优化,例如我自定义的的作为切点的注解:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface CacheUpdate {
    
    CacheKeys key();
    
    Class<?> type();
    
}
获取注解中的参数方法如下:


                Method aopMethod = methodSignature.getMethod();
                CacheUpdate param = aopMethod.getAnnotation(CacheUpdate.class);
                // 获取参数的类
                Class clazz = param.type();
                CacheKeys keys = param.key();
对于@around、@before和@after中value的值有个专业的名词:pointcut expression(切点表达式)

Aspectj的源码中是这样说明的:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Around {

    /**
     * The pointcut expression where to bind the advice
     */
    String value();
    
    /**
     * When compiling without debug info, or when interpreting pointcuts at runtime,
     * the names of any arguments used in the advice declaration are not available.
     * Under these circumstances only, it is necessary to provide the arg names in 
     * the annotation - these MUST duplicate the names used in the annotated method.
     * Format is a simple comma-separated list.
     */
    String argNames() default "";

}
pointcut expression的作用就是为了说明切点是什么,在哪,比如是某个注解、是某个方法或某个类中的所有方法等等。

接下来说明AOP是如何实现代码织入的,织入是在类加载前的环节,当某个类被加载时,如果发现有切面,这时会生成一个新的类,这个新的类会被动态地址增加一些JAVA的指令操作,然后加载这个新的类。这个织入的操作其实就像人为的修改class文件一样,如果对java虚拟机的汇编指令熟悉,完全可以手动修改,然而现在只是有专门的程序帮我们完成的这个操作而矣,这个专门的程序熟悉JAVA的指令集,它就是asm,而具体的要把代码加在什么位置,怎么加,则是由具体的上层代码指定,像@around、@before和@after。

ASM中有一个ClassReader和一个ClassWriter,见名就知其义了,前者是用来解析class文件的,而后者是用来写入class文件的,ASM主要的设计思想是Visitor访问者模式,与迭代器模式不同的是访问者模式的访问逻辑是由实现类来决定的,ASM的上层是ClassVisitor,而ClassWriter就是其的一个实现,还有其它的一些实现:

下面是我用ASM写的简单的代码动态生成的例子:

测试类,只有一个名为out的方法

public class Test {

    public void out(String data){
        
        System.out.println("method out : " + data);
        
    }

}
动态生成代码,先输出原字节码,分隔符下是新生成的代码

public class AsmTest {

    public static void main(String[] args) throws Exception {
        
        ClassReader cr = new ClassReader(Test.class.getName());
        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);
        
        System.out.println(new String(cw.toByteArray(),"utf-8"));
        
        cr.accept(new ClassAdapter(cw){
            
            @Override
            public MethodVisitor visitMethod(int access, String name, String desc,
                    String signature, String[] exceptions) {
                
                if("out".equals(name)){
                    
                    MethodVisitor visitor = cv.visitMethod(Opcodes.ACC_PUBLIC, "out", "(Ljava/lang/String;)V", null, null);
                    visitor.visitLdcInsn("Before execute");
                    visitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
                    visitor.visitEnd();
                    return visitor;
                }
                
                return cv.visitMethod(access, name, desc, signature, exceptions);
            }
            
        }, 0);
        System.out.println("---------分隔符---------");
        System.out.println(new String(cw.toByteArray(),"utf-8"));
    }
}
测试的结果如下:


如果想要了解ASM的,可以要多看看JVM和其指令集了,也就是JAVA的汇编

最后总结一下,其实AOP重要的是思想,至于如何实现AOP,可以有很多种方式,只是在众多方式中,利用ASM的JAVA字节码动态自动生成的方式可能性能是最好的。

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Spring AOP 实现原理

什么是AOP AOP(Aspect-OrientedProgramming,面向方面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善。OOP引入...
  • MoreeVan
  • MoreeVan
  • 2013年09月24日 15:23
  • 330877

Aop实现原理详解

一、什么是 AOP AOP(Aspect-OrientedProgramming,面向切面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善。...

简单理解IOC和AOP的原理

IOC,依赖倒置的意思, 所谓依赖,从程序的角度看,就是比如A要调用B的方法,那么A就依赖于B,反正A要用到B,则A依赖于B。 所谓倒置,你必须理解如果不倒置,会怎么着,因为A必须要有B,才可以调...

aop实现原理(自学)

什么是AOP AOP(Aspect-OrientedProgramming,面向方面编程),可以说是OOP(Object-Oriented Programing,面向对象编程)的补充和完善。OO...

Spring AOP实现原理

在Spring AOP框架中学习了动态AOP的几种实现方式,本篇重点来学习一下动态AOP的实现原理。 Spring AOP是利用代理模式,在运行时生成一个目标对象的代理,并且使用代理代替目标对象,整个...

菜鸟学SSH(十四)——Spring容器AOP的实现原理——动态代理

之前写了一篇关于IOC的博客——《Spring容器IOC解析及简单实现》,今天再来聊聊AOP。大家都知道Spring的两大特性是IOC和AOP,换句话说,容器的两大特性就是IOC和AOP。IOC负责将...

对Spring Aop的理解和应用场景

场景一:Aop与事物 场景二:Aop与日志 场景三:Aop与缓存

AOP概念理解

Spring AOP概念理解 1.我所知道的aop      初看aop,上来就是一大堆术语,而且还有个拉风的名字,面向切面编程,都说是OOP的一种有益补充等等。一下子让你不知所措,心想着:怪不得...

AOP的实现机制

1 AOP各种的实现 AOP就是面向切面编程,我们可以从几个层面来实现AOP。 在编译器修改源代码,在运行期字节码加载前修改字节码或字节码加载后动态创建代理类的字节码,以下是各种实现机制的比较...

关于spring,IOC和AOP的解析原理和举例

先从IOC说起,这个概念其实是从我们平常new一个对象的对立面来说的,我们平常使用对象的时候,一般都是直接使用关键字类new一个对象,那这样有什么坏处呢?其实很 显然的,使用new那么就表示当前模块...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深入AOP原理与应用
举报原因:
原因补充:

(最多只允许输入30个字)