- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

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

牧小农发表于 2022/05/25 22:57:29 2022/05/25

2.7k+ 0 0

【摘要】 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);
      		}

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");


      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

点赞
收藏
关注作者

作者其他文章

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

开发者空间

了解空间

工作台

开发工具

实战案例

空间活动

空间论坛

开发平台

软件开发生产线 CodeArts

AI平台ModelArts

数据治理中心 DataArts Studio

数字内容生产线 MetaStudio

精选服务

云数据库 GaussDB

云数据库 RDS for MySQL

MapReduce服务 MRS

数据仓库服务 DWS

分布式缓存服务Redis版

分布式消息服务 DMS

华为云实时音视频 SparkRTC

媒体处理 MPC

主机迁移服务 SMS

对象存储迁移服务 OMS

云消息服务 KooMessage

云手机服务 KooPhone

企业搜索服务 KooSearch

云地图服务 KooMap

更多开放能力

开发工具

API生态

CodeArts API

API Explorer

Terraform Explorer

KooCLI

API 中心

SDK 中心

开发服务

Codelabs

DevStar

低代码平台Astro

CodeArts IDE

Huawei Cloud Toolkit

Classroom

开发资源

开源镜像站

开源资源

开发语言

开发实践

入门精选

分发资源

企业应用中心

企业通用专区

教育专区

华为应用专区

政务云专区

硬件云服务商城

医疗健康专区

跳蚤市场

华为云开发者日

直播专区

开发者精品活动

DTSE Tech Talk

加入HCDE

加入HCDG

加入HCSD

加入HCWD

鲁班会

沃土云创计划·企业

沃土云创计划·高校

沃土云创计划·个人

沃土云创计划·开源共创

博客

论坛

专题

开发者榜单

学习路径

在线课程

动手实验

考试认证

培训服务

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