java之 javassist简单使用

0x01、javassist介绍

什么是javassist,这个词一听起来感觉就很懵,对吧~

public void DynGenerateClass() {
     ClassPool pool = ClassPool.getDefault();
     CtClass ct = pool.makeClass("com.ideaGenerateClass");//创建类
     ct.setInterfaces(new CtClass[]{pool.makeInterface("java.lang.Cloneable")});//让类实现Cloneable接口
     try {
         CtField f= new CtField(CtClass.intType,"id",ct);//获得一个类型为int,名称为id的字段
         f.setModifiers(AccessFlag.PUBLIC);//将字段设置为public
         ct.addField(f);//将字段设置到类上
         //添加构造函数
         CtConstructor constructor=CtNewConstructor.make("public GeneratedClass(int pId){this.id=pId;}",ct);
         ct.addConstructor(constructor);
         //添加方法
         CtMethod helloM=CtNewMethod.make("public void hello(String des){ System.out.println(des);}",ct);
         ct.addMethod(helloM);

         ct.writeFile();//将生成的.class文件保存到磁盘

         //下面的代码为验证代码
         Field[] fields = ct.toClass().getFields();
         System.out.println("属性名称:" + fields[0].getName() + "  属性类型:" + fields[0].getType());
     } catch (CannotCompileException e) {
         e.printStackTrace();
     } catch (IOException e) {
         e.printStackTrace();
     } catch (NotFoundException e) {
         e.printStackTrace();
     }
 }

参考该篇文章java编程-javassist

0x02 Javassist 使用

这里主要讲一下主要的几个类:

1、ClassPool

ClassPool是CtClass对象的容器,它按需读取类文件来构造CtClass对象,并且保存CtClass对象以便以后使用。

从实现的角度来看,ClassPool 是一个存储 CtClass 的 Hash 表,类的名称作为 Hash 表的 key。ClassPool 的 get() 函数用于从 Hash 表中查找 key 对应的 CtClass 对象。如果没有找到,get() 函数会创建并返回一个新的 CtClass 对象,这个新对象会保存在 Hash 表中。

需要注意的是ClassPool会在内存中维护所有被它创建过的CtClass,当CtClass数量过多时,会占用大量的内存,API中给出的解决方案是重新创建ClassPool 或 有意识的调用CtClass的detach()方法以释放内存。

常用方法:

//返回默认的ClassPool,一般通过该方法创建我们的ClassPool;
static ClassPool	getDefault()

//在搜索路径的开头插入目录或jar(或zip)文件。
ClassPath	insertClassPath(java.lang.String pathname)	

//ClassPath在搜索路径的开头插入一个对象。
ClassPath	insertClassPath(ClassPath cp)


    
//获取类加载器toClass(),getAnnotations()在 CtClass等
java.lang.ClassLoader	getClassLoader()	

//从源中读取类文件,并返回对CtClass 表示该类文件的对象的引用。
CtClass	get(java.lang.String classname)	

//将ClassPath对象附加到搜索路径的末尾。
ClassPath	appendClassPath(ClassPath cp)	
    
//创建一个新的public类
CtClass	makeClass(java.lang.String classname)

2、CtClass

CtClass类表示一个class文件,每个CtClass对象都必须从ClassPool中获取,CtClass需要关注的方法:

常用方法:

//更改超类,除非此对象表示接口。
void	setSuperclass(CtClass clazz)

//将此类转换为java.lang.Class对象。
java.lang.Class<?>	toClass(java.lang.invoke.MethodHandles.Lookup lookup)	
    
//将该类转换为类文件。
byte[]	toBytecode()	

//将由此CtClass 对象表示的类文件写入当前目录。
void	writeFile()	

//将由此CtClass 对象表示的类文件写入本地磁盘。
void	writeFile(java.lang.String directoryName)	

//在当前类中创建了一个静态代码块
CtConstructor	makeClassInitializer()	
freeze:冻结一个类,使其不可修改;
isFrozen:判断一个类是否已被冻结;
defrost:解冻一个类,使其可以被修改;
prune:删除类不必要的属性,以减少内存占用。调用该方法后,许多方法无法将无法正常使用,慎用;
detach:将该class从ClassPool中删除;
writeFile:根据CtClass生成.class文件;
toClass:通过类加载器加载该CtClass;
addField,removeField:添加/移除一个CtField;
addMethod,removeMethod:添加/移除一个CtMethod;
addConstructor,removeConstructor:添加/移除一个CtConstructor。

3、CtMethod

CtMethod:表示类中的方法。

insertBefore:在方法的起始位置插入代码;
insterAfter: 在方法的所有 return 语句前插入代码以确保语句能够被执行,除非遇到exception;
insertAt:	 在指定的位置插入代码;
setBody:	 将方法的内容设置为要写入的代码,当方法被abstract修饰时,该修饰符被移除;
make:		 创建一个新的方法。

4、CtConstructor

CtConstructor的实例表示一个构造函数。它可能代表一个静态构造函数(类初始化器)。可以通过CtConstructor.make方法创建

常用方法

//设置构造函数主体。
void	setBody(java.lang.String src)	

//从另一个构造函数复制一个构造函数主体。
void	setBody(CtConstructor src, ClassMap map)	

//复制此构造函数并将其转换为方法。
CtMethod	toMethod(java.lang.String name, CtClass declaring)	

5、ClassPath

该类作用是用于通过 getResourceAsStream() 在 java.lang.Class 中获取类文件的搜索路径。

构造方法:

//创建一个搜索路径。
ClassClassPath(java.lang.Class<?> c)	

常见方法:

//获取指定类文件的URL。
java.net.URL	find (java.lang.String classname)	

//通过获取类文getResourceAsStream()。
java.io.InputStream	openClassfile(java.lang.String classname)	

代码实例:

ClassPool pool = ClassPool.getDefault();

在默认系统搜索路径获取ClassPool对象。

如果需要修改类搜索的路径需要使用insertClassPath方法进行修改。

pool.insertClassPath(new ClassClassPath(this.getClass()));

将本类所在的路径插入到搜索路径中

6、oBytecode

package com.demo;

import javassist.*;


import java.io.IOException;
import java.util.Arrays;

public class testssit {
    public static void main(String[] args) throws NotFoundException, CannotCompileException, IOException {
        ClassPool pool = ClassPool.getDefault();
        pool.insertClassPath(new ClassClassPath(demo.class.getClass()));
        CtClass ctClass = pool.get("com.demo.test");
        ctClass.setSuperclass(pool.get("com.demo.test"));
//        System.out.println(ctClass);
        byte[] bytes = ctClass.toBytecode();
        String s = Arrays.toString(bytes);
        System.out.println(s);
    }

}

7、toClass

toClass:将修改后的CtClass加载至当前线程的上下文类加载器中,CtClass的toClass方法是通过调用本方法实现。

Hello类:
public class Hello {
    public void say() {
        System.out.println("Hello");
    }
}
Test 类
public class Test {
    public static void main(String[] args) throws Exception {
        ClassPool cp = ClassPool.getDefault();//在默认系统搜索路径获取ClassPool对象。
        CtClass cc = cp.get("com.demo.Hello");  //获取hello类的
        CtMethod m = cc.getDeclaredMethod("say"); //获取hello类的say方法
        m.insertBefore("{ System.out.println(\"Hello.say():\"); }");//在正文的开头插入字节码
        Class c = cc.toClass();//将此类转换为java.lang.Class对象
        Hello h = (Hello)c.newInstance(); //反射创建对象并进行强转
        h.say();调用方法say
    }
}

0x03、创建Class文件

public class App {
 public static void main(String[] args) {
  try {
   createPerson();
  } catch (Exception e) {
   e.printStackTrace();
  }
 }

 private static void createPerson() throws Exception {
  ClassPool pool = ClassPool.getDefault();

  // 1. 创建一个空类
  CtClass cc = pool.makeClass("com.hearing.demo.Person");

  // 2. 新增一个字段 private String name = "hearing";
  CtField param = new CtField(pool.get("java.lang.String"), "name", cc);
  param.setModifiers(Modifier.PRIVATE);
  cc.addField(param, CtField.Initializer.constant("hearing"));

  // 3. 生成 getter、setter 方法
  cc.addMethod(CtNewMethod.setter("setName", param));
  cc.addMethod(CtNewMethod.getter("getName", param));

  // 4. 添加无参的构造函数
  CtConstructor cons = new CtConstructor(new CtClass[]{}, cc);
  cons.setBody("{name = \"hearing\";}");
  cc.addConstructor(cons);

  // 5. 添加有参的构造函数
  cons = new CtConstructor(new CtClass[]{pool.get("java.lang.String")}, cc);
  // $0=this / $1,$2,$3... 代表方法参数
  cons.setBody("{$0.name = $1;}");
  cc.addConstructor(cons);

  // 6. 创建一个名为printName方法,无参数,无返回值,输出name值
  CtMethod ctMethod = new CtMethod(CtClass.voidType, "printName", new CtClass[]{}, cc);
  ctMethod.setModifiers(Modifier.PUBLIC);
  ctMethod.setBody("{System.out.println(name);}");
  cc.addMethod(ctMethod);

  //这里会将这个创建的类对象编译为.class文件
  cc.writeFile("../");
 }
}

创建的class文件如下

public class Person {
	private String name = "hearing";

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

	public String getName() {
		return this.name;
 	}

 	public Person() {
  		this.name = "hearing";
 	}

 	public Person(String var1) {
  		this.name = var1;
 	}

 	public void printName() {
  		System.out.println(this.name);
 	}
}

0x04、调用生成的类对象

1.通过反射的方式调用:

Object person = cc.toClass().newInstance();
Method setName = person.getClass().getMethod("setName", String.class);
setName.invoke(person, "hearing1");
Method execute = person.getClass().getMethod("printName");
execute.invoke(person);

2.通过读取class文件的方式调用:

ClassPool pool = ClassPool.getDefault();
// 设置类路径
pool.appendClassPath("../");
CtClass ctClass = pool.get("com.hearing.demo.Person");
Object person = ctClass.toClass().newInstance();
// 下面和通过反射的方式一样去使用
posted @ 2021-02-10 17:15  0X7e  阅读(989)  评论(0编辑  收藏  举报