Java的反射

反射

反射机制

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

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

Class c = Class.forName(com.abc.User)

加载完类之后，在堆内存中，就产生了一个Class类型的对象（一个类只胡一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射 。

反射机制的常见作用

• 动态加载类、动态获取类的信息（属性、方法、构造器）
• 动态构造对象
• 动态启用类和对象的任意方法、构造器。
• 动态调用和处理属性
• 获取泛型信息
• 处理注解

/**
 * 测试各种类型对应 的java.lang.Class对象的获取方式
 * @author ad
 *
 */
public class Demo01 {
	public static void main(String[] args) throws NoSuchFieldException, SecurityException {
		String path = "com.trf.bean.User";
		try {
			Class<?> clazz = Class.forName(path);
			//对象是表示或封闭一些数据。一个类被加载后，类的整个结构信息会放到对应的Class对象中。
			//这个Class对象就像一面镜子一样，通过这面镜子我们可以看到对应类的全部信息。
			System.out.println(clazz);
			Class clazz2 = Class.forName(path);
			System.out.println(clazz.hashCode());//一个类只对应一个Class对象
			System.out.println(clazz2.hashCode());
			Class strClazz = String.class;
			Class StrClazz2 = path.getClass();
			System.out.println(strClazz.hashCode());
			System.out.println(StrClazz2.hashCode());
			
			Class intClazz = int.class;
			
			int[] arr01 = new int[10];
			int[] arr02 = new int[30];
			int[][] arr03 = new int[30][];
			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) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

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

/**
 * 应用反射的API，获取类的信息(类的名字，属性，方法，构造器等)
 * @author ad
 *
 */
public class Demo02 {
	public static void main(String[] args) {
		String path = "com.trf.bean.User";
		try {
			Class<?> clazz = Class.forName(path);
			//获取类的名字
			System.out.println(clazz.getName());//获得包名+类名
			System.out.println(clazz.getSimpleName());//获得类名
			//获得属性信息
//			Field[] f = clazz.getFields();//只能获得public的属性
			Field[] fs = clazz.getDeclaredFields();
			Field f = clazz.getDeclaredField("name");
			
			System.out.println(fs.length);
			
			for (Field field : fs) {
				System.out.println("属性：" + field);
			}
			//获得方法信息
			Method[] methods = clazz.getDeclaredMethods();
			Method method = clazz.getDeclaredMethod("getName", null);
			//如果方法有参，则必须传递参数类型对应的Class对象
			Method method1 = clazz.getDeclaredMethod("setName", String.class);
			for (Method m : methods) {
				System.out.println("方法：" + m);
			}

			//获得构造方法的信息
			Constructor[] constructors = clazz.getDeclaredConstructors();
			Constructor constructor = clazz.getDeclaredConstructor(int.class,
					String.class, int.class);
			System.out.println("获得构造器：" + constructor);
			for (Constructor c : constructors) {
				System.out.println("构造方法：" + c);
			}
			
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		
		} catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

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

/**
 * 通过反射API动态的操作：构造器、方法、属性。
 * @author ad
 *
 */
public class Demo03 {
	public static void main(String[] args) {
		String path = "com.trf.bean.User";
		//动态操作构造器
		try {
			Class<User> clazz = (Class<User>)Class.forName(path);
			//通过反射API调用构造方法，构造对象
			User u = clazz.newInstance();//调用了User的无参构造方法
			System.out.println(u);
			
			Constructor<User> c = clazz.getDeclaredConstructor(int.class, String.class, int.class);
			System.out.println(c);
			User u2 = c.newInstance(1001, "非常", 19);
			System.out.println(u2.getName());
			
			//通过反射API调用普通方法
			User u3 = clazz.newInstance();
			Method method = clazz.getDeclaredMethod("setName", String.class); //u3.setName("张一");
			method.invoke(u3, "张一");
			System.out.println(u3.getName());
			
			//通过反射API操作属性
			Field f = clazz.getDeclaredField("name");
			User u4 = clazz.newInstance();
			f.setAccessible(true);//这个属性不用做安全检查了，可以直接访问
			f.set(u4, "张二");	//通过反射直接写属性的值
			System.out.println(u4.getName());//通过反射直接读属性的值
			System.out.println(f.get(u4));
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		
		}
	}
}

User类

public class User {
	private int id;
	private String name;
	private int age;
	public User() {
		super();
	}
	
	public User(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

反射机制性能问题

setAccessible

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

禁止安全检查，可以提高反射的运行速度。

可以考虑使用：cglib/javaassist字节码操作。

反射操作泛型

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.trf.bean.User;

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 (NoSuchMethodException | SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}