反射,在开发项目时, 需要使用DBUtils,好奇心的驱使之下, 阅读了一下DBUtils的源码, 发现在将数据库结果集转换为JavaBean
就是通过反射实现的,但对反射没有一个较深入的了解!
一. 反射的概念
反射是指程序可以访问、检测和修改它本身状态或行为的一种能力,允许以编程方式访问有关加载类的字段,方法和构造函数的信息,
以及在安全限制内使用反射的字段,方法和构造函数对其底层进行操作。
反射是JDK 1.1引入的机制, 便于创建高度灵活的代码, 代码可以运行时装配,但是如果使用不当, 使用成本会很高,建议阅读DBUtils
源码先小试牛刀, 如果有兴趣, 可以继续阅读spring源码。
注意: 不要和内省的概念相混淆, 内省用于在运行时检测某个对象的类型和其包含的属性; 而反射除了检测还可以修改, 如C++只支
持内省, 但是不支持反射。
二. 反射机制的作用
1. 反编译: class文件反编译为Java文件
2. 通过反射机制访问bean的属性、方法、构造方法; 可以动态的根据传入的数据选择正确的类型接收处理;修改
构造函数、方法、属性的可见性;例如在Struts框架中, 框架确定处理请求的Action类之后, 就是通过反射机制来实现
的Action类的加载。
三、反射类
java.lang.Class
java.lang.reflect.Constructor
java.lang.reflect.Field
java.lang.reflect.Method
java.lang.reflect.Modifier
很多对象中的方法、属性等操作这四个类中查询。API才是成就霸业的军师。
四、实例
public class User {
private int id;
private int age;
private String username;
private String password;
}
1. 通过反射机制从对象获取类
// 方式1
Class userClass1 = Class.forName("User");
// 方式2
Class userClass2 = User.class;
// 方式3
Class userClass3 = new User().getClass();
2. 从已有对象创建新对象
User user01 = new User();
User user02 = user01.getClass().newInstance();
3. 获取对象所有属性
public static void main(String[] args) throws ClassNotFoundException,
InstantiationException, IllegalAccessException {
Class c = Class.forName("java.lang.String");
Field[] fs = c.getDeclaredFields();
StringBuffer sb = new StringBuffer();
sb.append(Modifier.toString(c.getModifiers()) + " class "
+ c.getSimpleName() + "{\n");
for (Field field : fs) {
sb.append("\t");//tab
sb.append(Modifier.toString(field.getModifiers()) + " ");
sb.append(field.getType().getSimpleName() + " ");// 属性的类型
sb.append(field.getName() + ";\n");// 属性名
}
sb.append("}");
System.out.println(sb);
}
4. 获取对象单个属性
public static void main(String[] args) throws NoSuchFieldException,
SecurityException, ClassNotFoundException, InstantiationException,
IllegalAccessException {
Class c = Class.forName("User");
Field username = c.getDeclaredField("username");
Object user = c.newInstance();
username.setAccessible(true); // 使用反射机制可以打破封装性,导致了java对象的属性不安全。
// username属性赋值"harry"
username.set(user, "harry");
System.out.println(username.get(user));
}
5. 获取对象方法及调用方法(有参和无参)
public class MyReflect {
public static void main(String[] args) {
Method method;
Task t = new Task();
try {
// 1. 获取带参数的方法
method = t.getClass().getMethod("setAll", new Class<?>[]{int.class, String.class});
// 2. 调用带参数的方法
method.invoke(t, 10, "update");
// 1. 获取无参方法
method = t.getClass().getMethod("print", new Class<?>[0]);
// 2. 调用无参方法
method.invoke(t);
// 1. 获取无参方法
method = t.getClass().getMethod("getTaskComment", new Class<?>[0]);
//method = t.getClass().getMethod("getTaskComment", null); // 使用这种方式时, 会产生警告
// 2. 调用方法并获取返回值
Object comment = method.invoke(t);
System.out.println(comment);
} catch (Exception e) {
e.printStackTrace();
}
}
private static class Task {
private int taskId;
private String taskComment;
public int getTaskId() {
return taskId;
}
public void setTaskId(int taskId) {
this.taskId = taskId;
}
public String getTaskComment() {
return taskComment;
}
public void setTaskComment(String taskComment) {
this.taskComment = taskComment;
}
public void print() {
System.out.println(this.taskId + " " + this.taskComment);
}
public void setAll(int taskId, String taskComment) {
this.taskComment = taskComment;
this.taskId = taskId;
}
}
}
6. 从类名字符串创建对象
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class<?> clazz = Class.forName("com.main.User");
User user = (User)clazz.newInstance();
user.print();
}
7. 获取构造方法并从构造方法创建对象
public static void main(String[] args) throws ClassNotFoundException,
InstantiationException, IllegalAccessException,
NoSuchMethodException, SecurityException, IllegalArgumentException,
InvocationTargetException {
Class<?> clazz = Student.class;
// 1. 从带参构造方法获取实例
Constructor<?> conMethod = clazz.getConstructor(new Class<?>[] {
int.class, String.class });
Object o = conMethod.newInstance(20, "harry");
Method print = clazz.getMethod("print", new Class<?>[0]);
print.invoke(o);
// 2. 从无参构造方法获取实例
Constructor<?> conMethod1 = clazz.getConstructor(new Class<?>[0]);
Object o1 = conMethod1.newInstance();
clazz.getMethod("setUsername", String.class).invoke(o1, "natasha");
System.out.println(clazz.getMethod("getUsername").invoke(o1));
// 3. 获取所有构造方法
Constructor<?> cons[] = clazz.getConstructors();
// 获取参数个数
System.out.println(cons[0].getParameterCount());
// 获取参数类型
System.out.println(cons[1].getParameters()[1]);
// 通过构造方法创建对象, 并使用对象调用方法
Student s1 = (Student) cons[0].newInstance();
Student s2 = (Student) cons[1].newInstance(30, "joenas");
s2.print();
}
private static class Student {
private int id;
private String username;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public Student() {
}
public Student(int id, String username) {
this.id = id;
this.username = username;
}
public void print() {
System.out.println(this.id + " " + this.username);
}
}
8. 获取 实现的接口、父类、声明的属性等
public static void main(String[] args) throws NoSuchFieldException, SecurityException {
Class<?> clazz = Student.class;
// 1. 获取实现的接口
Class<?> inters[] = clazz.getInterfaces();
System.out.println(inters[0]);
// 2. 获取父类
Class<?> parent = clazz.getSuperclass();
System.out.println(parent);
// 3. 获取所有属性
Student stu = new Student();
Field fileds[] = clazz.getFields();
fileds = stu.getClass().getFields();
for (Field s : fileds) {
System.out.println(s.getName());
}
// 4. 获取单个属性
Field field = clazz.getField("username");
System.out.println(field.getName());
// 此行代码将报错, 不能获取private属性
field = clazz.getField("id");
}
private static class Student implements Serializable{
private int id;
public String username;
public Student() {
}
public Student(int id, String username) {
this.id = id;
this.username = username;
}
public void print() {
System.out.println(this.id + " " + this.username);
}
}
9. 使用反射修改数组大小
public static void main(String[] args) {
int[] intArray = { 1, 2, 3, 4, 5 };
int[] newIntArray = (int[]) changeArraySize(intArray, 8);
print(newIntArray);
String[] atr = { "a", "b", "c", "d", "e" };
String[] str1 = (String[]) changeArraySize(atr, 8);
print(str1);
}
/*
* 修改数组大小, 原理为
* 1. 获取原数组的类型
* 2. 按照原类型新长度创建数组
* 3. 将原数组中数据赋值到新数组中
*/
public static Object changeArraySize(Object obj, int len) {
// 获取数组元素类型
Class<?> type = obj.getClass().getComponentType();
Object newArray = Array.newInstance(type, len);
// 复制数组
int count = Array.getLength(obj);
System.arraycopy(obj, 0, newArray, 0, count);
return newArray;
}
// 输出数组内容
public static void print(Object obj) {
Class<?> c = obj.getClass();
if (!c.isArray()) {
return;
}
System.out.println("Array length: " + Array.getLength(obj));
System.out.print("[");
for (int index = 0; index < Array.getLength(obj); index++) {
System.out.print(Array.get(obj, index) + ",");
}
System.out.println("]");
}
当然、反射所能做的事情不限于如上所列, 还可以实现很多功能, 比如获取方法返回值类型,参数类型等; 在动态加载配置时反射也可以发挥大作用。
文章如有错误, 欢迎指正。