java 动态性之反射机制 详解 案例
【摘要】
1、反射机制
2、动态编译
3、动态执行javassript代码
4、动态字节码操作
动态语言
程序运行时，可以改变程序结构或变量类型。典型的语言：
1):Python、ruby、javascript等。
2):如下javascript代码:
funtion test(){ var s ="var...
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);
-
}
4):JAVA的动态性让编程更加灵活！
1、反射机制
1):指的是可以于运行时加载、探知、使用编译期间完全未知的类。
2):程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个已加载的类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能调用它的任意一个方法和属性
<strong><span style="font-size:18px;">Class c = Class.forName("com.lyy.test.User");</span></strong>
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");
-
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{}
文章来源: muxiaonong.blog.csdn.net，作者：牧小农，版权归原作者所有，如需转载，请联系作者。
原文链接：muxiaonong.blog.csdn.net/article/details/51598611
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）