反射的概念
当程序运行时，程序中的每一个类都会被加载到堆内存中。生成且尽每个类仅生成一个Class对象。这个对象保存了整个类的结构信息，包括这个类的所有属性与方法甚至注解。就像一面镜子一样。所以我们称之为反射。
当我们说反射时，说的就是Class类与java.lang.reflect包中的类
每个类对应一个Class对象
java.lang.Class类保存了每一类的唯一一个对象。如下，当我们使用Class.forName()创建两个Class引用时，它们指向同一个对象。
每一个类包括基础数据类型的八大类及String、各基础数据类型对应的数组，枚举、接口、甚至Annotation注解。
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
String path = "_20200103_reflection.Test";
Class c1 = Class.forName(path);
Class c2 = Class.forName(path);
System.out.println(c1.hashCode());
System.out.println(c2.hashCode());
}
}
//运行结果
705927765
705927765
获取Class对象的三种方式
public class Demo01 {
public static void main(String[] args) throws ClassNotFoundException {
String path = "_20200103_reflection.User";
User u = new User();
//获取Class对象的三种方式：
//1.Class.forName(包名.类名)
Class<?> c1 = Class.forName(path);
//2.已知类，直接：类.class
Class<?> c2 = _20200103_reflection.User.class;
//3.已知实例。实例.getClass()
Class<?> c3 = u.getClass();
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
}
}
//运行结果
class _20200103_reflection.User
class _20200103_reflection.User
class _20200103_reflection.User
反射的常用方法
以下代码完整代码将在文末贴出。
一个Class对象包含了一个类的结构信息，包括：类名、参数、属性、方法、构造器、注解等等。我们来一一获取它们。
以下运行结果可能与最终代码运行结果有不同，因为我是边写此文边写代码的。
获取类名
String path = "_20200104_review.User";
//反射获得Class对象
Class<?> clz = Class.forName(path);
//获取类名
System.out.println("类名:"+clz.getName());
获取构造方法
- getConstructors()获取public修饰的构造器数组
- getDeclaredConstructors()获取所有的构造器数组
//获取构造方法
//获取无参构造
Constructor<?> cons1 = clz.getConstructor(null);
//获取有参构造
Constructor<?> cons2 = clz.getConstructor(int.class,String.class,String.class);
获取实例
Object user1 = cons2.newInstance(18,"1002","小明");
获取方法
- getMethods获取包括继承来的所有public方法
- getDeclaredMethods获取所有该类声明的方法，包括private修饰的
- 获取指定的方法 getMethod(String methodName,Class parameterClass) ，按指定参数获取方法，参数为：方法名，参数对应的Class对象，如String.class ， int.class等等
System.out.println("----获取方法-------");
//获取所有的public方法,包括继承来的
Method[] methods = clz.getMethods();
System.out.println(methods.length);
//获取所有的声明的方法：包括私有方法，不包括继承来和构造方法
Method[] methods1 = clz.getDeclaredMethods();
System.out.println(methods1.length);
//获取指定的方法:getId方法
Method method = clz.getDeclaredMethod("getId",null);
Method method1 = clz.getDeclaredMethod("test02", int.class);
Method method2 = clz.getDeclaredMethod("test01", Map.class);
获取属性
System.out.println("----获取属性-------");
//获取所有public修饰的属性,不包括继承来的
Field[] fields = clz.getFields();
System.out.println(fields.length);
//获取所有声明的属性，包括私有的
Field[] fields2 = clz.getDeclaredFields();
System.out.println(fields2.length);
//获取指定声明的属性
Field field = clz.getDeclaredField("name");
System.out.println(field);
//获取指定的公开的属性
Field field2 = clz.getField("id");
System.out.println(field2);
获取属性值
注意：如果使用 反射属性.get(反射实例) 的方式获取属性值，需要在前面写一句：反射属性.setAccessible(true)
同样地，当使用反射直接调用一个private修饰的方法时，也需要写：反射方法.setAccessible(true);
//读取属性值 //方法一：通过反射属性.get(反射Class对象) field2.setAccessible(true); System.out.println(field2.get(user1)); //方法二：通过反射实例向下转型调用类中的getId方法 System.out.println(((User)user1).getId());
读取方法的参数类型
//读取参数类型
System.out.println("----获取参数类型----");
Class<?>[] parameters = method1.getParameterTypes();
for(Class p : parameters) {
System.out.println("参数："+p);
}
读取方法的返回值类型
//读取返回值类型 Class<?> returnType = method.getReturnType(); System.out.println(returnType);
读取方法的泛型参数类型与泛型参数的实参的类型
//获取方法的泛型参数类型
Type[] genericTypes = method2.getGenericParameterTypes();
for(Type parameter : genericTypes) {
System.out.println("泛型参数："+parameter);
//获取方法的泛型参数的实参类型
if(parameter instanceof ParameterizedType) {
Type[] argumentsType = ((ParameterizedType)parameter).getActualTypeArguments();//parameter表示形参，argument表示实参
for(Type argumentType : argumentsType) {
System.out.println("泛型的实参类型为："+argumentType);
}
}
}
读取方法的泛型返回值类型的实参的类型
//读取泛型返回值类型
Type returnGenericType = method2.getGenericReturnType();
System.out.println(returnGenericType);
//读取泛型返回值类型之实参类型
if(returnGenericType instanceof ParameterizedType){
Type[] actualtp = ((ParameterizedType) returnGenericType).getActualTypeArguments();
for(Type acp : actualtp) {
System.out.println("返回值泛型参数的实参类型："+acp);
}
}
获取注解
思路：
- 反射获取Class对象
- Class对象调用getAnnotations获取注解数组
- 或调用GetAnnottation(具体注解的Class对象)
System.out.println("---获取类注解---");
Annotation[] annos = clz.getAnnotations();
for(Annotation a : annos) {
System.out.println("类注解的值为："+a);
}
System.out.println("----获取属性注解----");
for(Field f : fields2) {
UserField a= f.getAnnotation(UserField.class);
System.out.println("columnName:"+a.columnName()+" tpe:"+a.type()+" length:"+a.length());
}
扩展内容
ParameterizedType是最常用的关于泛型的一个类，其他还有不常用的如下：
运行结果
类名:_20200104_review.User ----获取方法------- 17 9 ----获取属性------- 1 3 private java.lang.String _20200104_review.User.name public java.lang.String _20200104_review.User.id 1002 1002 ----获取参数类型---- 参数：int ----获取返回值类型----- class java.lang.String ----获取泛型参数及参数的实参类型---- 泛型参数：java.util.Map<java.lang.String, java.lang.Integer> 泛型的实参类型为：class java.lang.String 泛型的实参类型为：class java.lang.Integer ----读取泛型返回值类型---- java.util.List<java.lang.String> 返回值泛型参数的实参类型：class java.lang.String ---获取类注解--- 类注解的值为：@_20200104_review.UserTable(value=user_table) ----获取属性注解---- columnName:age tpe:varchar length:5 columnName:id tpe:int length:10 columnName:name tpe:carchar length:10
完整代码
User类
package _20200104_review;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@UserTable("user_table")
public class User extends Person{
@UserField(columnName="age",type="varchar",length=5)
private int age;
@UserField(columnName="id",type="int",length=10)
public String id;
@UserField(columnName="name",type="carchar",length=10)
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public User(int age, String id, String name) {
super();
this.age = age;
this.id = id;
this.name = name;
}
public User() {
super();
}
private List<String> test01(Map<String,Integer> map) {
System.out.println("我是私有方法test01");
return null;
}
public void test02(int num) {
System.out.println("我是公有方法test"+num);
}
public static void main(String[] args) {
User u = new User();
}
}
注解类：UserTable
package _20200104_review;
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 UserTable {
String value();
}
注解类：UserField
package _20200104_review;
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 UserField {
String columnName();
String type();
int length();
}
测试类
package _20200104_review;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;
/**
* 读取User类的信息
* @author TEDU
*
*/
public class ReflectionTest {
public static void main(String[] args) throws Exception{
String path = "_20200104_review.User";
//反射活得Class对象
Class<?> clz = Class.forName(path);
//获取类名
System.out.println("类名:"+clz.getName());
//获取构造方法
//获取无参构造
Constructor<?> cons1 = clz.getConstructor(null);
//获取有参构造
Constructor<?> cons2 = clz.getConstructor(int.class,String.class,String.class);
//获取实例
Object user1 = cons2.newInstance(18,"1002","小明");
//读取方法
System.out.println("----获取方法-------");
//获取所有的public方法,包括继承来的
Method[] methods = clz.getMethods();
System.out.println(methods.length);
//获取所有的声明的方法：包括私有方法，不包括继承来和构造方法
Method[] methods1 = clz.getDeclaredMethods();
System.out.println(methods1.length);
//获取指定的方法:getId方法
Method method = clz.getDeclaredMethod("getId",null);
Method method1 = clz.getDeclaredMethod("test02", int.class);
Method method2 = clz.getDeclaredMethod("test01", Map.class);
//读取属性
System.out.println("----获取属性-------");
//获取所有public修饰的属性,不包括继承来的
Field[] fields = clz.getFields();
System.out.println(fields.length);
//获取所有声明的属性，包括私有的
Field[] fields2 = clz.getDeclaredFields();
System.out.println(fields2.length);
//获取指定声明的属性
Field field = clz.getDeclaredField("name");
System.out.println(field);
//获取指定的公开的属性
Field field2 = clz.getField("id");
System.out.println(field2);
//读取属性值
//方法一：通过反射属性.get(反射Class对象)
field2.setAccessible(true);
System.out.println(field2.get(user1));
//方法二：通过反射实例向下转型调用类中的getId方法
System.out.println(((User)user1).getId());
//读取参数类型
System.out.println("----获取参数类型----");
Class<?>[] parameters = method1.getParameterTypes();
for(Class p : parameters) {
System.out.println("参数："+p);
}
System.out.println("----获取返回值类型-----");
//读取返回值类型
Class<?> returnType = method.getReturnType();
System.out.println(returnType);
//读取泛型参数及其实参类型
System.out.println("----获取泛型参数及参数的实参类型----");
//获取方法的泛型参数类型
Type[] genericTypes = method2.getGenericParameterTypes();
for(Type parameter : genericTypes) {
System.out.println("泛型参数："+parameter);
//获取方法的泛型参数的实参类型
if(parameter instanceof ParameterizedType) {
Type[] argumentsType = ((ParameterizedType)parameter).getActualTypeArguments();//parameter表示形参，argument表示实参
for(Type argumentType : argumentsType) {
System.out.println("泛型的实参类型为："+argumentType);
}
}
}
//读取泛型返回值类型
System.out.println("----读取泛型返回值类型----");
//读取泛型返回值类型
Type returnGenericType = method2.getGenericReturnType();
System.out.println(returnGenericType);
//读取泛型返回值类型之实参类型
if(returnGenericType instanceof ParameterizedType){
Type[] actualtp = ((ParameterizedType) returnGenericType).getActualTypeArguments();
for(Type acp : actualtp) {
System.out.println("返回值泛型参数的实参类型："+acp);
}
}
//读取注解
System.out.println("---获取类注解---");
Annotation[] annos = clz.getAnnotations();
for(Annotation a : annos) {
System.out.println("类注解的值为："+a);
}
System.out.println("----获取属性注解----");
for(Field f : fields2) {
UserField a= f.getAnnotation(UserField.class);
System.out.println("columnName:"+a.columnName()+" tpe:"+a.type()+" length:"+a.length());
}
}
}