Java AOP利剑之ASM,真正的AOP

在前面有一篇博客中讲了如何通过Java的动态代理来实现AOP编程。之前也讲过其实动态代理并不能算代码层面的AOP编程,其实质是在运行时动态生成一个类然后以静态代理的方式来实现AOP编程的。

今天要讲的ASM是直接通过对代码进行修改没有使用代理来进行AOP编程的。

ASM简介

这篇博客主要是将如何使用ASM来实现AOP的,ASM不是重点,因此ASM在这里就只做一些简单的介绍。

ASM是一个用来生成字节码或者修改字节码的开源库。官网地址

org.objectweb.asm包是一些基本的ASM类型,比如ClassReader、ClassWritter都在这里面。依赖于ASM的访问者模式可以很轻易的就在ClassReader、ClassWritter之间添加新的访问者进行字节码的修改

org.objectweb.asm.tree包下类主要的作用是将输入的字节码以树的形式进行保存,这样做好处是可以很清晰地在对应的节点进行字节码的修改,用着也比直接中间插入访问者方便。

简单来说,第一种在ClassReader、ClassWritter的方式类似于xml的sax解析;而使用树形式则类似于dom解析。

这篇博客只会用到上面两个包下的类,其它的包有兴趣的可以自己去看一下这里就不一一介绍了。

更详细ASM的入门可以看Instrumenting Java Bytecode with ASM,里面介绍的例子是使用的ClassReader、ClassWritter之间夹访问者的方式。

本篇博客使用的树节点的方式进行字节码的修改实现AOP。

准备

首先去官网的这个地方asm和asm-tree目录下下载7.1版本的jar包。

代码结构

code_structure

common包下的代码就是前面中common包下一样的代码这里就不介绍了。

asm包下的代码会对LinuxPC、LinuxService的字节码进行修改,进行SS(由于简书貌似会屏蔽全称,这里使用简称)属性的添加以及代理的执行。

common

pc

package common.pc;

/**
 * 代表一台个人电脑
 */
public interface PC {

    void searchByGoogle();

}
package common.pc;

/**
 * Linux系统的个人电脑
 */
public class LinuxPC implements PC {

    @Override
    public void searchByGoogle() {
        System.out.println("Searching with Google by LinuxPC");
    }
    
}

service

package common.service;

/**
 * 代表一台服务器
 */
public interface Service {
    void searchByGoogle();
}
package common.service;

/**
 * 一台Linux服务器
 */
public class LinuxService implements Service {
    @Override
    public void searchByGoogle() {
        System.out.println("Searching with Google by LinuxService");
    }
}

SS

package common;

/**
 * 现实中SS是要分平台的,这里为了方便就想成全平台用一个SS。总之就想成服务端实现代理的一个软件吧。
 * 而且现实中不仅服务端需要安装SS,客户端也是需要的。这里客户端也忽略掉。
 */
public class SS {

    public void startProxy() {
        System.out.println("start proxy");
    }

    public void stopProxy() {
        System.out.println("stop proxy");
    }
}

asm

package asm;

import common.SS;
import org.objectweb.asm.*;
import org.objectweb.asm.tree.*;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.List;
import static org.objectweb.asm.Opcodes.*;

public class InstallSS {

    private static final String SS_DESCRIPTER = Type.getDescriptor(SS.class);
    private static final String SS = Type.getInternalName(SS.class);
    private static String FIELD_OWNER = "";

    public static void main(String[] args) {
        FIELD_OWNER = args[1].substring(0, args[1].length() - 6);
        // 其中arg[0]是源字节码文件,args[1]是目标字节码文件
        installSS(args[0], args[1]);
    }

    /**
     * 进行SS的安装
     * @param src 源字节码
     * @param dst 目标字节码
     */
    public static void installSS(String src, String dst) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            byte[] outputByteCode;
            fis = new FileInputStream(src);
            // ClassReader读入字节码
            ClassReader cr = new ClassReader(fis);
            // ClassNode将字节码以节点树的形式表示
            ClassNode cn = new ClassNode(ASM7);
            // SKIP_FRAMES用于避免访问帧内容,因为改变字节码的过程中帧内容会被改变,比如局部变量、操作数栈都可能改变。
            cr.accept(cn, ClassReader.SKIP_FRAMES);

            // 进行SS属性的添加
            addSSField(cn.fields);

            for (MethodNode methodNode : cn.methods) {
                if (methodNode.name.equals("<init>")) {
                    // 构造器中对SS属性进行初始化
                    initSSField(methodNode);
                } else if (methodNode.name.equals("searchByGoogle")) {
                    // searchByGoogle方法中添加SS的调用
                    addSSExecute(methodNode);
                }
            }
            // COMPUTE_FRAMES表示ASM会自动计算所有内容,visitFrame和visitMaxs方法都会被忽略掉
            // 还有一个COMPUTE_MAXS是会自定计算局部变量表和操作数栈的大小,visitMaxs会被忽略掉。
            ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
            cn.accept(cw);
            // 生成的字节码写入目标文件中
            outputByteCode = cw.toByteArray();
            fos = new FileOutputStream(dst);
            fos.write(outputByteCode);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 给src中的字节码添加SS的属性
     * @param fields
     */
    private static void addSSField(List<FieldNode> fields) {
        boolean isHaveSSFiled = false;
        for (FieldNode fieldNode : fields) {
            if (fieldNode.desc.equals(SS_DESCRIPTER)) {
                isHaveSSFiled = true;
                break;
            }
        }

        if (!isHaveSSFiled) {
            fields.add(new FieldNode(ACC_PRIVATE, "SS", SS_DESCRIPTER, null, null));
        }
    }

    /**
     * 在构造方法中对SS属性进行初始化
     * @param methodNode 表示该字节码一个方法节点的值
     */
    private static void initSSField(MethodNode methodNode) {
        AbstractInsnNode[] nodes = methodNode.instructions.toArray();
        int length = nodes.length;
        // 初始化相关的字节码指令
        InsnList insnList = new InsnList();
        insnList.add(new VarInsnNode(ALOAD, 0));
        insnList.add(new TypeInsnNode(NEW, SS));
        insnList.add(new InsnNode(DUP));
        insnList.add(new MethodInsnNode(INVOKESPECIAL, SS, "<init>", "()V", false));
        insnList.add(new FieldInsnNode(PUTFIELD, FIELD_OWNER, "SS", SS_DESCRIPTER));

        methodNode.instructions.insertBefore(nodes[length - 1], insnList);
    }

    /**
     * 在searchByGoogle方法调用中进行SS的startProxy和stopProxy调用。
     * @param methodNode 表示该字节码一个方法节点的值
     */
    private static void addSSExecute(MethodNode methodNode) {
        AbstractInsnNode[] nodes = methodNode.instructions.toArray();
        int length = nodes.length;
        // searchByGoogle方法前面添加上SS的startProxy方法调用
        InsnList startInsnList = new InsnList();
        startInsnList.add(new VarInsnNode(ALOAD, 0));
        startInsnList.add(new FieldInsnNode(GETFIELD, FIELD_OWNER, "SS", SS_DESCRIPTER));
        startInsnList.add(new MethodInsnNode(INVOKEVIRTUAL, SS, "startProxy", "()V", false));
        methodNode.instructions.insertBefore(nodes[0], startInsnList);

        // searchByGoogle方法的后面加上SS的stopProxy方法的调用
        InsnList endInsnList = new InsnList();
        endInsnList.add(new VarInsnNode(ALOAD, 0));
        endInsnList.add(new FieldInsnNode(GETFIELD, FIELD_OWNER, "SS", SS_DESCRIPTER));
        endInsnList.add(new MethodInsnNode(INVOKEVIRTUAL, SS, "stopProxy", "()V", false));
        methodNode.instructions.insertBefore(nodes[length - 1], endInsnList);
    }

}

字节码修改的过程这里就不详解了,重点注释已经写出来了。

这里对字节码的修改主要使用了的org.objectweb.asm.tree包下的内容,比如说ClassNode、MethodNode、FieldNode都是这个包下的。

当然也有org.objectweb.asm包下的,主要就是ClassReader、ClassWriter用于对字节码输入以及输出。

主包

import common.pc.LinuxPC;
import common.service.LinuxService;

public class Main {

    public static void main(String[] args) {
        LinuxPC linuxPC = new LinuxPC();
        LinuxService linuxService = new LinuxService();
        linuxPC.searchByGoogle();
        linuxService.searchByGoogle();
    }
}

很简单就是基本的调用。

然后主包下的两个jar包是在准备阶段的时候进行下载的。

编译执行

然后在主包下依次输入下面的命令:

# 编译两种不同类型的国外电脑
javac common/pc/LinuxPC.java
javac common/service/LinuxService.java

# 对上面编译出来的字节码做一个备份
cp common/pc/LinuxPC.class common/pc/LinuxPC.class.bak
cp common/service/LinuxService.class common/service/LinuxService.class.bak

# 对修改字节码进行SS添加并调用的类进行编译
javac -cp asm-tree-7.1.jar:asm-7.1.jar:. asm/InstallSS.java

# 执行InstallSS对LinuxPC、LinuxService字节码进行修改(从备份文件中读取修改的字节码方法对应的.class结尾的文件)
java -cp .:asm-7.1.jar:asm-tree-7.1.jar asm.InstallSS common/pc/LinuxPC.class.bak common/pc/LinuxPC.class
java -cp .:asm-7.1.jar:asm-tree-7.1.jar asm.InstallSS common/service/LinuxService.class.bak common/service/LinuxService.class

# 编译并调用Main
javac Main.java
java Main

执行之后可以看到如下执行结果:

start proxy
Searching with Google by LinuxPC
stop proxy
start proxy
Searching with Google by LinuxService
stop proxy

其实修改后的LinuxPC和LinuxService分别如下:

修改后的LinuxPC.java:

package common.pc;

import common.SS;

public class LinuxPC implements PC {

    private SS SS;

    public LinuxPC() {
        SS = new SS();
    }

    @Override
    public void searchByGoogle() {
        SS.startProxy();
        System.out.println("Searching with Google by LinuxPC");
        SS.stopProxy();
    }
}

修改后的LinuxService.java:

package common.service;

import common.SS;

public class LinuxService implements Service {
    
    private SS SS;

    public LinuxService() {
        SS = new SS();
    }

    @Override
    public void searchByGoogle() {
        SS.startProxy();
        System.out.println("Searching with Google by LinuxService");
        SS.stopProxy();
    }
}

可以看到使用ASM这里没有用静态代理或动态代理,而是通过直接修改字节码来实现了不同类型的类相同功能的添加。

总结

本篇博客就一个目标通过ASM使用树节点的形式来实现AOP编程

然后就是ASM修改字节码的两种方式:

  • 借助于访问者模式,在ClassReader、ClassWritter之间添加自己实现的ClassVisitor来实现。可以参考Instrumenting Java Bytecode with ASM中的例子
  • 通过树节点的形式来进行字节码修改的实现。本篇博客使用的方式。

然后两个方式的优缺点:

  • 添加ClassVisitor的方式比较简便,而且只用引org.objectweb.asm这一个jar包就行。但是修改起来逻辑不太清晰。
  • 通过树节点的方式,类、属性、方法等都被抽象为一个个树节点。要对某个方法、某个属性进行修改十分的清新,而且更好控制。不过需要引用org.objectweb.asm和org.objectweb.asm.tree两个jar,稍微麻烦点

推荐阅读更多精彩内容

  • 小编费力收集:给你想要的面试集合 1.C++或Java中的异常处理机制的简单原理和应用。 当JAVA程序违反了JA...
    八爷君阅读 3,098评论 1 116
  • ¥开启¥ 【iAPP实现进入界面执行逐一显】 〖2017-08-25 15:22:14〗 《//首先开一个线程,因...
    小菜c阅读 3,851评论 0 11
  • 一. Java基础部分.................................................
    wy_sure阅读 2,270评论 0 9
  • JAVA面试题 1、作用域public,private,protected,以及不写时的区别答:区别如下:作用域 ...
    JA尐白阅读 281评论 1 0
  • 家庭生活的失败是无法用事业的成功来弥补的。 ——本杰明·迪斯累利 是的,2018年我...
    柠檬和米花阅读 173评论 3 3