首页 / JAVA / java反射基础与动态编译
java反射基础与动态编译
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了java反射基础与动态编译，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6999字，纯文字阅读大概需要10分钟。
内容图文
获取Class对象
反射常见作用
bean.User
package bean;
public class User {
private int id;
private int age;
private String uname;
public User(){
}
public User(int id, int age, String uname) {
this.id = id;
this.age = age;
this.uname = 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;
}
}
package reflect;
// 测试各种类型(class,interface,enum,annotation,primitive type,void)对应的java.lang.Class对象的获取方式
public class Demo01 {
public static void main(String[] args) {
String path = "bean.User";
try {
Class clz = Class.forName(path);
// 对象是表示和封装一些数据, 一个类被加载后,JVM会创建一个对应类的Class对象, 类的整个结构信息会放到对应的Class对象中
// 这个Class对象就像一面镜子一样, 通过这面镜子可以看到类的全部信息
System.out.println(clz);
Class strClz = String.class;
Class strClz2 = "".getClass(); // 对象.getClass();
System.out.println(strClz == strClz2); // true
Class intClass = int.class;
int[] arr01 = new int[10];
int[] arr02 = new int[30];
int[][] arr03 = new int[30][3];
double[] arr04 = new double[10];
System.out.println(arr01.getClass().hashCode());
System.out.println(arr02.getClass().hashCode());
System.out.println(arr03.getClass().hashCode());
System.out.println(arr04.getClass().hashCode());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
应用反射的API, 获取类的信息(类的名字, 属性, 构造器等)
package reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* 应用反射的API, 获取类的信息(类的名字, 属性, 构造器等)
*/
public class Demo02 {
public static void main(String[] args) {
String path = "bean.User";
try {
Class clz = Class.forName(path);
// 获取类的名字
System.out.println(clz.getName()); // 获取包名+类名
System.out.println(clz.getSimpleName()); // 获取类名
// 获取属性信息
Field[] fields = clz.getFields(); // 只能获取public的field
fields = clz.getDeclaredFields(); // 获得所有的field
Field field = clz.getDeclaredField("uname"); // 获取指定的field
System.out.println(fields.length);
for (Field temp: fields) {
System.out.println("属性: " + temp);
}
// 获取方法信息
Method[] methods = clz.getDeclaredMethods();
// 如果方法有参数, 则必传参数类型对应的Class对象
Method m01 = clz.getDeclaredMethod("getUname", null);
// 方法名, 参数类型对象的Class对象(防止重载)
Method m02 = clz.getDeclaredMethod("setUname", String.class);
for (Method m: methods) {
System.out.println("方法: " + m);
}
// 获得构造方法信息
Constructor[] constructors = clz.getDeclaredConstructors();
Constructor c = clz.getDeclaredConstructor(null);
c = clz.getDeclaredConstructor(int.class, int.class, String.class);
System.out.println(c);
for (Constructor temp: constructors) {
System.out.println("构造方法: " + temp);
}
}catch (Exception e){
e.printStackTrace();
}
}
}
通过反射API动态的操作:构造器,方法,属性
package reflect;
import bean.User;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* 通过反射API动态的操作:构造器,方法,属性
*/
public class Demo03 {
public static void main(String[] args) {
String path = "bean.User";
try {
Class clz = Class.forName(path);
// 通过动态调用构造方法,构造对象
User u = (User) clz.getDeclaredConstructor().newInstance();
System.out.println(u);
// 有参数构造
Constructor<User> c = clz.getDeclaredConstructor(int.class, int.class, String.class);
User u2 = c.newInstance(1001, 19, "xiaobo");
System.out.println(u2.getUname());
// 通过反射API调用普通方法
User u3 = (User)clz.newInstance();
Method method = clz.getDeclaredMethod("setUname", String.class);
method.invoke(u3, "xiaoli"); // u3.setUname("xiaoli");
System.out.println(u3.getUname());
// 通过反射API操作属性
User u4 = (User)clz.newInstance();
Field f = clz.getDeclaredField("uname");
f.setAccessible(true); // 这个属性不需要做安全检查了,可以直接访问
f.set(u4, "xiaomei"); // 通过反射直接写属性
System.out.println(u4.getUname());
System.out.println(f.get(u4)); // 通过反射直接读属性
}catch (Exception e){
e.printStackTrace();
}
}
}
反射机制性能
反射操作泛型
package reflect;
import bean.User;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
/**
* 通过反射获取泛型信息
*/
public class Demo04 {
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 = Demo04.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 = Demo04.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();
}
}
}
反射操作注解(annotation)
动态编译
JavaComplier动态编译
动态运行
package dynamicCompiler;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import java.io.*;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
public class Demo01 {
public static void main(String[] args) throws IOException {
// 通过IO流操作,将字符串存储成一个临时文件(Hi.java), 然后调用动态编译方法
String str = "public class Hi{public static void main(String[] args){System.out.println(\"Hello World\");}}";
FileOutputStream os = new FileOutputStream("Hi.java");
os.write(str.getBytes());
os.flush();
os.close();
// 获得java编译器
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
// int result = compiler.run(null, null, null, "/home/sweetheart/eclipse-workspace/Test01/src/HelloWorldAWT.java");
int result = compiler.run(null, null, null, "./Hi.java");
System.out.println(result==0? "编译成功": "编译失败");
// 通过Runtime调用执行类
Runtime run = Runtime.getRuntime();
Process process = run.exec("java -cp ./ Hi");
InputStream in = process.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
String info = "";
while ((info=reader.readLine())!=null){
System.out.println(info);
}
// 通过反射进行加载调用
try {
URL[] urls = new URL[]{new URL("file:/" + "home/sweetheart/IdeaProjects/annotation/")};
URLClassLoader loader = new URLClassLoader(urls);
Class c = loader.loadClass("Hi");
// 调用加载类的main方法
Method m = c.getMethod("main", String[].class);
m.invoke(null, (Object)new String[]{"aa", "bb"});
// 不加Object强转相当于这样调用
// public static void main("aa", "bb"){..};
}catch (Exception e){
e.printStackTrace();
}
}
}
内容总结
以上是互联网集市为您收集整理的java反射基础与动态编译全部内容，希望文章能够帮你解决java反射基础与动态编译所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】