java 动态性之反射机制 详解 案例

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/qq_14996421/article/details/51598611

1、反射机制

2、动态编译

3、动态执行javassript代码

4、动态字节码操作


动态语言

程序运行时,可以改变程序结构或变量类型。典型的语言:

1):Python、ruby、javascript等。

2):如下javascript代码:

	funtion test(){
			var s ="var a=3;var b=5;alert(a+b);";
			eval(s);
		}

3):C,C++,JAVA不是动态语言,JAVA可以称之为“准动态语言”。但是JAVA有一定的动态性,我们可以利用反射机制、字节码操作获得类似动态语言的特性

4):JAVA的动态性让编程更加灵活!


1、反射机制

1):指的是可以于运行时加载、探知、使用编译期间完全未知的类。

2):程序在运行状态中,可以动态加载一个只有名称的类,对于任意一个已加载的类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能调用它的任意一个方法和属性

<strong><span style="font-size:18px;">Class c = Class.forName("com.lyy.test.User");</span></strong>
3):加载完类之后,在堆内存中,就产生了一个Class类型的对象(一个类只有一个Class对象)这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的机构。这个对象就像一面镜子,透过这个镜子看到类的结构,所以,我们形象的称之为:反射。

1.1 Class类介绍

java.lang.Class类十分特殊,用来表示Java中类型(class/interface/enum/annotation/primitive type/void)本身

1.1.1):Class类的对象包含了某个被加载类的机构,一个被加载的类对应一个Class对象

1.1.2):当一个class被加载,或当加载器(class loader)的definaClass()被JVM调用,JVM便自动产生一个Class对象

1.1.3):Class类是Reflection的根源

针对任何你想动态加载、运行的类,唯有先获得相应的Class对象


1.2 反射机制的常见作用

1.2.1):动态加载类、动态获取类的信息(属性、方法、构造器)

1.2.2):动态构造对象

1.2.3):动态调用类和对象的任意方法、构造器

1.2.4):动态调用和处理属性

1.2.5):获取泛型信息

1.2.6):处理注解


1.3 Class类的对象如何获取?

1.3.1):运用 getClass()

1.3.2):运用Class.forName()(最常被使用)

1.3.3):运用 .class语法



 测试各种类型(class、interface、enum、annotaion,primitive type void void) 测试java.lang.Class对应的获取方式

package com.lyy.test;

/**
 * 测试各种类型(class、interface、enum、annotaion,primitive type void void) 测试java.lang.Class对应的获取方式
 * @author lyy
 *
 */
@SuppressWarnings("all")
public class Demo1 {
	public static void main(String[] args) {
		try {
			String path = "com.lyy.test.bean.User";
			Class<?> cls = Class.forName(path);
			//对象用来表示或封装一些数据 一个类加载后,JVM会创建一个对应该类的class对象,类的机构信息会放到对应的class对象中
			//class对象就像一面镜子一样,通过这面镜子可以看到对应的全部信息
			Class<?> clss = Class.forName(path);
			System.out.println(cls.hashCode());//一个类只对应一个Class对象
			System.out.println(clss.hashCode());
			
			Class strcls = String.class;
			Class strclass = path.getClass();
			System.out.println(strcls.equals(strclass));
			
			Class incls = int.class;
			
			int[] arr1 = new int[10];
			int[][] arr2 = new int[30][3];
			int[] arr3 = new int[30];
			double[] arr4 = new double[10];
			
			System.out.println(arr1.getClass().hashCode());
			System.out.println(arr2.getClass().hashCode());
			System.out.println(arr3.getClass().hashCode());
			System.out.println(arr4.getClass().hashCode());

		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
}


package com.lyy.test.bean;

public class User {
		private int id;
		private int age;
		private String uname;
		
		public int getId() {
			return id;
		}
		public void setId(int id) {
			this.id = id;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
		public String getUname() {
			return uname;
		}
		public void setUname(String uname) {
			this.uname = uname;
		}
		public void setUname() {
			this.uname = "lyy";
		}
		
		public User(int id, int age, String uname) {
			super();
			this.id = id;
			this.age = age;
			this.uname = uname;
		}
		//javabean必须要有无参构造方法
		public User() {
			super();
		}
	
		
		
}



应用反射API,获取类的信息(类的名字、属性、方法、构造器等)

package com.lyy.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 应用反射API,获取类的信息(类的名字、属性、方法、构造器等)
 * @author lyy
 *
 */
public class Demo2 {
	public static void main(String[] args) {
		String path = "com.lyy.test.bean.User";
		try {
			Class<?> cls = Class.forName(path);
			//获取类的名字
			System.out.println(cls.getName());//获得包名+类名
			System.out.println(cls.getSimpleName());// 类名 User
			
			//获取属性信息
//			Field[] field = cls.getFields(); //只能获取public下的field
			Field[] field = cls.getDeclaredFields();//获取所有的field
			Field f = cls.getDeclaredField("uname");
			System.out.println(field.length);
			for (Field temp : field) {
				System.out.println("属性:"+temp);
				
			}
			//获取方法信息
			Method[] method = cls.getDeclaredMethods();
			Method method1= cls.getDeclaredMethod("getUname",null);
			//如果方法有参数,则必须传递参数类型对应的Class对象
			Method method2= cls.getDeclaredMethod("setUname",String.class);
			for(Method m:method){
				System.out.println("方法:"+m);
			}
			
			//获取构造信息
			Constructor[] con = cls.getDeclaredConstructors();
			Constructor c =cls.getDeclaredConstructor(int.class,int.class,String.class);
			System.out.println("获取构造器:"+c);
			for(Constructor m:con){
				System.out.println("构造器:"+m);
			}
			
			
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}



通过反射动态的操作 构造器、方法、属性


package com.lyy.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import com.lyy.test.bean.User;

/**
 * 通过反射动态的操作 构造器、方法、属性
 * @author lyy
 *
 */
@SuppressWarnings("all")
public class Demo3 {

	public static void main(String[] args) {
		String path = "com.lyy.test.bean.User";
		try {
			Class<User> cls = (Class<User>) Class.forName(path);
			
			//通过反射API动态调用构造方法,构造对象
			User u = cls.newInstance();  //其实是调用了User的无参构造方法
			System.out.println(u);
			
			Constructor<User> c = cls.getDeclaredConstructor(int.class,int.class,String.class);
			
			User u1 = c.newInstance(1001,18,"lyy666");
			System.out.println(u1.getUname());
			
			//通过反射API 调用普通方法
			User u2 = cls.newInstance();
			Method method = cls.getDeclaredMethod("setUname",String.class);
			method.invoke(u2, "lyy而");//u2.setUname("lyy3");
			System.out.println(u2.getUname());
			
			//通过反射API操作属性
			User u4 = cls.newInstance();
			Field f = cls.getDeclaredField("uname");
			f.setAccessible(true);//这个属性不需要安全检查了,可以直接访问
			f.set(u4, "lyy4");//通过反射直接写属性
			System.out.println(u4.getUname());//通过反射直接读属性的值
			System.out.println(f.get(u4));
		} catch (Exception e) {
			e.printStackTrace();
		} 
		
	}
}






1.4 反射机制性能问题

1.4.1):启用和禁用访问安全检查的开关,值为true 则指示反射的对象在使用时应该取消java语言访问检查,值为false这指示反射的对象应该实施java语言的访问检查,并不是为true就能访问false就不能访问。

1.4.2):禁止安全检查,可以提高反射的运行速度

1.4.3):可以考虑使用:cglib/javaassist字节码操作


package com.lyy.test;

import java.lang.reflect.Method;
<strong style="font-size: 18px;">
</strong>import com.lyy.test.bean.User;


/**
 * 普通类调用 反射调用进行安全检查 反射调用不进行安全检查
 * @author lyy
 *
 */
public class Demo6 {
	
	public static void test01(){
		User u = new User();
		
		long startTime = System.currentTimeMillis();
		
		for (int i = 0; i < 1000000000L; i++) {
			u.getUname();
		}
		
		long endTime = System.currentTimeMillis();
		System.out.println("普通方法调用 ,执行10亿次,耗时为:"+(endTime-startTime)+"ms"); 
	}
	
	public static void test02() throws Exception{
		User u = new User();
		Class clazz = u.getClass();
		Method m = clazz.getDeclaredMethod("getUname", null);
//		m.setAccessible(true);
		
		long startTime = System.currentTimeMillis();
		
		for (int i = 0; i < 1000000000L; i++) {
			m.invoke(u, null);
		}
		
		long endTime = System.currentTimeMillis();
		System.out.println("反射动态方法调用 ,执行10亿次,耗时为:"+(endTime-startTime)+"ms");
	}
	
	public static void test03() throws Exception{
		User u = new User();
		Class clazz = u.getClass();
		Method m = clazz.getDeclaredMethod("getUname", null);
		m.setAccessible(true);	//不需要执行访问安全检查
		
		long startTime = System.currentTimeMillis();
		
		for (int i = 0; i < 1000000000L; i++) {
			m.invoke(u, null);
		}
		
		long endTime = System.currentTimeMillis();
		System.out.println("反射方法调用,跳过安全检查 ,执行10亿次,耗时为:"+(endTime-startTime)+"ms");
	}
	
	
	public static void main(String[] args) throws Exception {
		test01();
		test02();
		test03();
	}
}



1.5 反射操作泛型(Generic)

1.5.1):java采用泛型擦除的机制引入泛型。java中的泛型仅仅是给编译器javac使用的,确保数据的安全性和免去强制类型装换的麻烦。但是,一旦编译完成,所有和泛型有关的类型全部擦除

1.5.2):为了通过反射操作这些类型已迎合实际开发的需要,java就新增了ParameterizedType,GenericArrayType,TypeVariable和WildcardTyoe几种类型代表不能被归一到Class类中的类型但是又和原始类型齐名的类型

ParameterizedType:表示一种参数化的类型,比如Collection<String>

GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型

TypeVariable:是各种类型变量的公共父接口

WildcardTyoe:代表一种通配符类型表达式,比如:?,? extends Number ,? super Inter 



package com.lyy.test;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

import com.lyy.test.bean.User;


/**
 * 通过反射获取泛型信息
 * @author lyy
 *
 */

public class Demo4 {
	
	public void test01(Map<String,User> map,List<User> list){
		System.out.println("Demo04.test01()");
	}
	
	public Map<Integer,User> test02(){
		System.out.println("Demo04.test02()");
		return null;
	}
	
	public static void main(String[] args) {

		try {
			
			//获得指定方法参数泛型信息
			Method m = Demo4.class.getMethod("test01", Map.class,List.class);
			Type[] t = m.getGenericParameterTypes();//获取泛型信息
			for (Type paramType : t) {
				System.out.println("#"+paramType);
				if(paramType instanceof ParameterizedType){
					Type[] genericTypes = ((ParameterizedType) paramType).getActualTypeArguments();
					for (Type genericType : genericTypes) {
						System.out.println("泛型类型:"+genericType);
					}
				}
			}
			
			//获取指定方法返回值泛型信息
			Method m2 = Demo4.class.getMethod("test02", null);
			Type returnType = m2.getGenericReturnType();
			if(returnType instanceof ParameterizedType){
					Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();

					for (Type genericType : genericTypes) {
						System.out.println("返回值,泛型类型"+genericType);
					}
					
			}
			
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	
		
	
	}
}


package com.lyy.test.bean;

public class User {
		private int id;
		private int age;
		private String uname;
		
		public int getId() {
			return id;
		}
		public void setId(int id) {
			this.id = id;
		}
		public int getAge() {
			return age;
		}
		public void setAge(int age) {
			this.age = age;
		}
		public String getUname() {
			return uname;
		}
		public void setUname(String uname) {
			this.uname = uname;
		}
		public void setUname() {
			this.uname = "lyy";
		}
		
		public User(int id, int age, String uname) {
			super();
			this.id = id;
			this.age = age;
			this.uname = uname;
		}
		//javabean必须要有无参构造方法
		public User() {
			super();
		}
	
		
		
}





1.6 反射操作注解(annotation)

1.6.1):可以通过反射API:getAnnotations、getAnnotation获取相关的注解信息


package com.lyy.test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Field;

import com.lyy.test.annotation.SxtField;
import com.lyy.test.annotation.SxtTable;


/**
 *通过反射获取注解信息
 * @authorlyy
 *
 */
public class Demo5 {
	public static void main(String[] args) {

		try {
			Class clazz = Class.forName("com.lyy.test.annotation.SxtStudent");
			
			//获取所有类的所有有效注解
			Annotation[] annotations=clazz.getAnnotations();
			for (Annotation a : annotations) {
				System.out.println(a);
			}
			//获取类的指定的注解
			SxtTable st = (SxtTable) clazz.getAnnotation(SxtTable.class);
			System.out.println(st.value());
			
			//获得类的属性的注解
			Field f = clazz.getDeclaredField("studentName");
			SxtField sxtField = f.getAnnotation(SxtField.class);
			System.out.println(sxtField.columnName()+"--"+sxtField.type()+"--"+sxtField.length());

			//根据获取的表名、字段的信息、拼出DDL语句、然后,使用JDBC执行这个SQL,在数据库中生成相关的表
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	
	}
}

package com.lyy.test.annotation;

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

@Target(value={ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface SxtTable {
	String value();
}


package com.lyy.test.annotation;

@SxtTable("tb_student")
public class SxtStudent {
	
	@SxtField(columnName="id",type="int",length=10)
	private int id;
	@SxtField(columnName="sname",type="varchar",length=10)
	private String studentName;
	@SxtField(columnName="age",type="int",length=3)
	private int age;
	
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getStudentName() {
		return studentName;
	}
	public void setStudentName(String studentName) {
		this.studentName = studentName;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
}


package com.lyy.test.annotation;

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

@Target(value={ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface SxtField {
	String columnName();
	String type();
	int length();
}





反射的核心是class ,反射降低了运行效率,但是提高了开发效率


2、动态编译

2.1):JAVA 6.0 引入了动态编译机制

2.1.2):动态编译的应用场景:

2.1.2.1):可以做一个浏览器端编写Java代码,上传服务器编译和运行的在线评测系统

2.1.2.2):服务器动态加载某些类进行进行编译

2.1.3):动态编译的两种做法:

2.1.3.1):通过Rruntime调用javac,启动新的进程去操作


	Runtime tun = Runtime.getRuntime();
				Process process = run.exec("java -cp g:/myjava/ HelloWorld.java");

2.2):通过JavaCompiler动态编译

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
		int result = compiler.run(null, null, null, "E:/myjava/HelloWorld.java");
		System.out.println(result==0?"编译成功!":"编译失败!");

第一个参数:为Java编译器提供参数

第二个参数:得到java编译器的输出信息

第三个参数:接收编译器的错误信息

第四个参数:可变参数(是一个String数组)能传入一个或多个Java源文件

返回值:0表示编译成功,非0表示编译失败



package com.lyy.test;

import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;

public class Demo1 {

	public static void main(String[] args) throws Exception {
		
		//通过IO操作,将字符串存储成一个临时文件(Hi.java),然后调用动态编译方法!
		String str = "public class Hi{public static void main(String[] args){"
				+ "System.out.println(\"haha lyy\");}}";
		
		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
		int result = compiler.run(null, null, null, "E:/myjava/HelloWorld.java");
		System.out.println(result==0?"编译成功!":"编译失败!");
		
		
		//通过Runtime调用执行类
//		Runtime run = Runtime.getRuntime();
//		Process pro = run.exec("java -cp E:/myjava HelloWorld");
//		
//		InputStream in = pro.getInputStream();
//		BufferedReader reader = new BufferedReader(new InputStreamReader(in));
//		String info = "";
//		while((info=reader.readLine()) != null){
//			System.out.println(info);
//		}
		
		URL[] urls = new URL[]{new URL("file:/"+"E:/myjava/")};
		URLClassLoader loader = new URLClassLoader(urls);
		Class c = loader.loadClass("HelloWorld");
		//调用加载类的main方法
		 Method method = c.getMethod("main",String[].class);
		 method.invoke(null,(Object)new String[]{"aa","bb"});
		 //由于可变参数是5.0之后才有 method.invoke(null,"aa","bb") 会发生参数个数不匹配的问题
		 //因此,必须要加上(Object)转型,避免这个问题
		 
		 
		 //public static void main(String[] a,String[] b)
		
		
		
	}
}


3、动态执行javassript代码

3.1):JAVA脚本引擎是从JDK6.0之后添加的新功能

3.2):脚本引擎介绍:

使得java应用程序可以通过一套固定的接口与各种脚本引擎交互,从而达到在Java平台上调用各种脚本语言的目的。

java脚本API是连通java平台和脚本语言的桥梁。

可以把一些复杂异变的业务逻辑交给脚本语言处理,这又大大提高了开发效率

3.3):获取脚本引擎对象

		//获得脚本引擎对应
		ScriptEngineManager sem = new ScriptEngineManager();
		ScriptEngine engine = sem.getEngineByName("javascript");

3.4):java脚本API为开发者提供了如些功能:

获取本程序输入,通过脚本引擎运行脚本并返回运行结果,这是最核心的接口。

注意是:接口 。java可以使用各种不同的实现,从而通用的调用js、groovy、python等脚本

Rhino 是一种使用Java语言编写的javaScript的开源实现,原先由Mozilla开发,现在被集成进入JDK 6.0

通过脚本引擎的运行上下文在脚本和Java平台间交换数据

通过Java应用程序调用脚本函数


package com.lyy.test;

import java.io.FileReader;
import java.net.URL;
import java.util.List;

import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

/**
 * 测试脚本引擎执行javascript代码
 * @author lyy
 *
 */
public class Demo1 {
	public static void main(String[] args) throws Exception {
		
		//相当于Java和Js脚本语言的一个中介
		
		//获得脚本引擎对应
		ScriptEngineManager sem = new ScriptEngineManager();
		ScriptEngine engine = sem.getEngineByName("javascript");
		
		//定义变量 存储到引擎的上下文中
		engine.put("msg", "lyy is good man!");
		String str = "var user = {name:'lyy',age:18,schools:['清华大学','湖北大学']};";
		str +="println(user.age)";
		
		//执行脚本
		engine.eval(str);
		engine.eval("msg='lyy is goods !!!!!!'");
		System.out.println(engine.get("msg"));
		System.out.println("==============================================");
		
		//定义函数
		engine.eval("function add(a,b){var sum = a+b; return sum;}");
		//取得调用接口
		Invocable jsInvoke = (Invocable)engine;
		//执行脚本中定义的方法!
		Object obj=jsInvoke.invokeFunction("add", new Object[]{13,20});
		System.out.println(obj);
		
		//导入其他的Java包,使用其他包中的java类,如果需要了解,可以详细学习了解Rhino的语法
		String jsCode = "importPackage(java.util); var list = Arrays.asList([\"清华大学\",\"湖北工程学院\",\"湖北职业技术学院\"]);";
		engine.eval(jsCode);
		List<String> list2 = (List)engine.get("list");
		for (String temp :list2) {
			System.out.println(temp);
		}
	
		//执行一个js文件
		URL url = Demo1.class.getClassLoader().getResource("in.js");
		FileReader fr = new FileReader(url.getPath());
		engine.eval(fr);
		fr.close();
		
	}
}

in.js

//定义test方法
function test(){
	var a = 3;
	var b = 4;
	println("invoke js file:"+(a+b));
}

//执行test方法
test();






4、动态字节码操作

4.1):java动态性的两种常见实现方式:

4.1.1):字节码操作

4.2.1):反射

4.2):运行时操作字节码可以让我们实现如下功能:

4.2.1):动态生成新的类

4.2.2):动态改变某个类的结构(添加/删除/修改 新的属性/方法)

4.3):优势:

4.3.1):比反射开销小,性能高

4.3.2):JAVAssist性能高于反射,低于ASM


4.4):JAVAssist库的API详解

4.4.1):javassist的最外层的API和JAVA的反射包中的API颇为类型。

4.4.2):它主要由CtClass、CtMethod、以及CtField几个类组成。用以执行和JDK反射API中 java.lang.Class,java.lang.reflect.Method ,java.lang.reflect.Method.Field相同的操作



package com.lyy.test;

import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtField;
import javassist.CtMethod;
import javassist.NotFoundException;

/**
 * 测试使用Javasost生成一个新的类
 * @author lyy
 *
 */
public class Demo1 {
	public static void main(String[] args) throws Exception {
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.makeClass("com.lyy.test.Emp1");
		
		//创建属性
		CtField f1 = CtField.make("private int empno;", cc);
		CtField f2 = CtField.make("private String ename;", cc);
	
		cc.addField(f1);
		cc.addField(f2);
		
		//创建方法
		CtMethod c1 = CtMethod.make("public int getEmpno(){return empno;}", cc);
		CtMethod c2 =CtMethod.make("public void setEmpno(int empno){this.empno=empno;}", cc);
		cc.addMethod(c1);
		cc.addMethod(c2);
//		6228480799439345478
		//添加构造器
		CtConstructor constu = new CtConstructor(new CtClass[]{CtClass.intType,pool.get("java.lang.String")}, cc);
		constu.setBody("{this.empno=empno;this.ename=ename;}");
		cc.addConstructor(constu);
		cc.writeFile("E:/myjava");//将上面构造好的类写入到e:/myjava下
		System.out.println("sucess!");
	}
}



package com.lyy.test;

@Author(name="lyy", year=2016)
public class Emp {
	private int empno;
	private String ename;
	
	public void sayHello(int a){
		System.out.println("sayHello,"+a);
	}
	
	public int getEmpno() {
		return empno;
	}
	public void setEmpno(int empno) {
		this.empno = empno;
	}
	public String getEname() {
		return ename;
	}
	public void setEname(String ename) {
		this.ename = ename;
	}
	public Emp() {
		super();
	}
	public Emp(int empno, String ename) {
		super();
		this.empno = empno;
		this.ename = ename;
	}
	
	
}

package com.lyy.test;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;

import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtField;
import javassist.CtMethod;
import javassist.CtNewMethod;
import javassist.NotFoundException;

/**
 * 测试javassist的API
 * @author lyy
 *
 */
public class Demo2 {
	/**
	 * 处理类的基本用法
	 * @throws NotFoundException 
	 * @throws CannotCompileException 
	 * @throws IOException 
	 */
	public static void test1() throws NotFoundException, IOException, CannotCompileException{
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.get("com.lyy.test.Emp");
		
		byte[] bytes = cc.toBytecode();
		System.out.println(Arrays.toString(bytes));
		System.out.println(cc.getName());//获取类名
		System.out.println(cc.getSimpleName());//获取简要类名;
		System.out.println(cc.getSimpleName());//获取父类
		System.out.println(cc.getInterfaces());//获得接口
		
	}
	
	/**
	 * 测试产生新的方法
	 * @return
	 * @throws Exception 
	 */
	public static void test2() throws Exception{
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.get("com.lyy.test.Emp");
		
//		CtMethod ms = CtNewMethod.make("public int add(int a ,int b){return a+b;}", cc);
		
		CtMethod m = new CtMethod(CtClass.intType,"add",
			new	CtClass[]{CtClass.intType,CtClass.intType}, cc);
		
		m.setModifiers(Modifier.PUBLIC);
		m.setBody("{System.out.println(\"www.lyy.cm\");return $1+$2;}");

		cc.addMethod(m);
		
		//通过反射调用新生成的方法
		Class cls = cc.toClass();
		Object obj = cls.newInstance();//通过调用Emp无参构造器,创建新的Emp对象
		Method me = cls.getDeclaredMethod("add", int.class,int.class);
		Object result = me.invoke(obj, 200,300);
		System.out.println(result);
		
	}
	
	/**
	 * 修改已有的方法的信息,修改方法的内容
	 * @throws Exception
	 */
	public static void test3() throws Exception{
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.get("com.lyy.test.Emp");
		
		CtMethod cm = cc.getDeclaredMethod("sayHello",new CtClass[]{CtClass.intType});
		cm.insertBefore("System.out.println($1);System.out.println(\"Start!!!\");");
		cm.insertAt(8, "int b = 3;System.out.println(\"b=\"+b);");
		cm.insertAfter("System.out.println(\"and\");");
		
		//通过反射调用新生成的方法
		Class cls = cc.toClass();
		Object obj = cls.newInstance();//通过调用Emp无参构造器,创建新的Emp对象
		Method me = cls.getDeclaredMethod("sayHello", int.class);
		Object result = me.invoke(obj, 300);
//		System.out.println(result);
	}
	
	/**
	 * 属性的操作
	 * @throws Exception
	 */
	public static void test4() throws Exception{
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.get("com.lyy.test.Emp");
		
//		CtField fl = CtField.make("private int empno", cc);
		
		CtField f2 = new CtField(CtClass.intType,"salary",cc);
		
		f2.setModifiers(Modifier.PRIVATE);
		cc.addField(f2);
		
//		cc.getDeclaredField("ename");   //获取指定的属性
		
		//增加相应的set和get方法
		cc.addMethod(CtNewMethod.getter("getSalary", f2));
		cc.addMethod(CtNewMethod.getter("setSalary", f2));
		
	}
	
	/**
	 * 构造方法的操作
	 * @throws NotFoundException
	 */
	public static void test5() throws Exception{
		ClassPool pool = ClassPool.getDefault();
		CtClass cc = pool.get("com.lyy.test.Emp");
		
		CtConstructor[] cs = cc.getConstructors();
		for(CtConstructor c:cs){
			System.out.println(c.getLongName());
			c.insertAfter("System.out.println(\"666\");");
		}
		
	}
	
	public static void test6() throws Exception{
		CtClass cc =ClassPool.getDefault().get("com.lyy.test.Emp");
		Object[] all = cc.getAnnotations();
		Author a = (Author)all[0];
		String name = a.name();
		int year = a.year();
		System.out.println("name:"+name+",year:"+year);
		
		
	}
	
public static void main(String[] args) throws Exception {
//	test1();
	test6();
}
}

package com.lyy.test;

public @interface Author {
	String name();
	int year();
}







4.5):JAVAssist库的API的局限性

JDK 5.0的新语法不支持(包括泛型、枚举)不支持注解修改,但可以通过底层的javassist类解决,具体参考;javassist.bytecode.annotation

不支持数据的初始化,如String[]{"1","2"},除非数组的容易为1

不支持内部类和匿名类

不支持continue和break表达式

对于继承关系 有些不支持 例如

calss A{}

class B extends A{}

class C extends B{}



展开阅读全文

没有更多推荐了,返回首页