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字节码动态自动生成的方式可能性能是最好的。
