你真的了解反射吗？

2.获取简单类名：不包括包名

getSimpleName()

Class userClass = Class.forName("com.xxl.model.User");
String simpleName = userClass.getSimpleName();
System.out.println(simpleName); 复制代码

打印结果：

4. 属性

4.1 获取属性

1.获取所有公有属性：public 修饰

getFields()

Class userClass = Class.forName("com.xxl.model.User");
Field[] fields = userClass.getFields(); for (Field field : fields) {
    System.out.println(field);
} 复制代码

打印结果：

2.获取单个公有属性

getField("属性名")

Class userClass = Class.forName("com.xxl.model.User");
Field field = userClass.getField("sex");
System.out.println(field); 复制代码

打印结果：

3.获取所有属性：公有+私有

getDeclaredFields()

Class userClass = Class.forName("com.xxl.model.User");
Field[] fields = userClass.getDeclaredFields(); for (Field field : fields) {
    System.out.println(field);
} 复制代码

打印结果：

4.获取单个属性：公有或者私有

getDeclaredField("属性名")

Class userClass = Class.forName("com.xxl.model.User");
Field nameField = userClass.getDeclaredField("name");
nameField.setAccessible(true);
User user = new User();
nameField.set(user,"张无忌");
System.out.println(nameField.get(user)); 复制代码

打印结果：

5. 构造方法

1.获取所有公有构造方法

getConstructors()

Class userClass = Class.forName("com.xxl.model.User");
Constructor[] constructors = userClass.getConstructors(); for (Constructor constructor : constructors) {
    System.out.println(constructor);
} 复制代码

打印结果：

2.获取与参数类型匹配的构造方法

getConstructor(参数类型)

Class userClass = Class.forName("com.xxl.model.User");
Constructor constructor = userClass.getConstructor(String.class, String.class);
System.out.println(constructor); 复制代码

打印结果：

6. 成员方法

6.1获取成员方法

1.获取所有公共方法

getMethods()

Class userClass = Class.forName("com.xxl.model.User");
Method[] methods = userClass.getMethods(); for (Method method : methods) {
    System.out.println(method);
} 复制代码

打印结果：

我们发现，打印结果除了自定义的公共方法，还有继承自 Object 类的公共方法。

2.获取某个公共方法

getMethod("方法名", 参数类型)

Class userClass = Class.forName("com.xxl.model.User");
Method method = userClass.getMethod("setName", String.class);
System.out.println(method); 复制代码

打印结果：

3.获取所有方法：公有+私有

getDeclaredMethods()

Class userClass = Class.forName("com.xxl.model.User");
Method[] declaredMethods = userClass.getDeclaredMethods(); for (Method method : declaredMethods) {
    System.out.println(method);
} 复制代码

打印结果：

4.获取某个方法：公有或者私有

getDeclaredMethod("方法名", 参数类型)

Class userClass = Class.forName("com.xxl.model.User");
Method method = userClass.getDeclaredMethod("run");
System.out.println(method); 复制代码

打印结果：

6.2 执行成员方法

invoke(object,"方法参数")

Class userClass = Class.forName("com.xxl.model.User");
Method method = userClass.getDeclaredMethod("eat");
User user = new User();
method.invoke(user); 复制代码

打印结果：

注： 通过反射不能直接执行私有成员方法，但是可以设置允许访问。

设置允许执行私有方法：

method.setAccessible(true); 复制代码

7. 注解

1.判断类上或者方法上时候包含某个注解

isAnnotationPresent(注解名.class) 复制代码

例如：

Class userClass = Class.forName("com.xxl.model.User"); if(userClass.isAnnotationPresent(Component.class)){
    Component annotation = (Component)userClass.getAnnotation(Component.class);
    String value = annotation.value();
    System.out.println(value);
}; 复制代码

2.获取注解

getAnnotation(注解名.class) 复制代码

例如：

Class userClass = Class.forName("com.xxl.model.User"); // 获取类上的注解 Annotation annotation1 = userClass.getAnnotation(Component.class);
Method method = userClass.getMethod("eat"); // 获取方法上的某个注解 Annotation annotation2 = userClass.getAnnotation(Component.class); 复制代码

8. 创建类的实例

1.通过 Class 实例化对象

Class.newInstance()

Class userClass = Class.forName("com.xxl.model.User");
User user = (User)userClass.newInstance();
System.out.println("姓名："+user.getName()+" 性别："+user.getSex()); 复制代码

打印结果：

2.通过构造方法实例化对象

constructor.newInstance(参数值)

Class userClass = Class.forName("com.xxl.model.User");
Constructor constructor = userClass.getConstructor(String.class, String.class);
User user = (User)constructor.newInstance\("李诗情", "女"\);
System.out.println("姓名："+user.getName()+" 性别："+user.getSex()); 复制代码

打印结果：

9. 反射案例

有一天技术总监对张三说："张三，听说你最近学反射了呀。那你设计一个对象的工厂类给我看看。"

张三心想："哟，快过年了，领导这是要给我涨工资啊。这次我一定好好表现一次。"

5分钟过后，张三提交了代码：

public class ObjectFactory { public static User getUser() {
        
        User user = null; try {
            Class userClass = Class.forName("com.xxl.model.User");
            user = (User) userClass.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } return user;
    } public static UserService getUserService() {
        UserService userService = null; try {
            Class userClass = Class.forName("com.xxl.service.impl.UserServiceImpl");
            userService = (UserService) userClass.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } return userService;
    }
} 复制代码

技术总监瞄了一眼代码，对张三说："你这个工厂类存在两个问题。"

1.代码存在大量冗余。如果有一万个类，你是不是要写一万个静态方法？

2.代码耦合度太高。如果这些类存放的包路径发生改变，你再用 forName（）获取 Class 对象是不是就会有问题？你还要一个个手动改代码，然后再编译、打包、部署。。你不觉得麻烦吗？

“发散你的思维想一下，能不能只设计一个静态类，通过传参的方式用反射创建对象，传递的参数要降低和工厂类的耦合度。顺便提醒你一下，可以参考一下 JDBC 获取数据库连接参数的方式。”

张三一听："不愧是总监啊，醍醐灌顶啊！等我 10 分钟。"

10 分钟后，张三再次提交了代码：

object.properties

user=com.xxl.model.User userService=com.xxl.service.impl.UserServiceImpl 复制代码

ObjectFactory

public class ObjectFactory { private static Properties objectProperty = new Properties(); // 静态方法在类初始化时执行，且只执行一次 static{ try {
            InputStream inputStream = ObjectFactory.class.getResourceAsStream("/object.properties");
            objectProperty.load(inputStream);
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    } public static Object getObject(String key){
        Object object = null; try {
            Class objectClass = Class.forName(objectProperty.getProperty(key));
            object = objectClass.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        } return object;
    }
} 复制代码

测试方法：

@Test void testObject() {
      User user = (User)ObjectFactory.getObject("user");
      UserService userService = (UserService)ObjectFactory.getObject("userService");
      System.out.println(user);
      System.out.println(userService);
  } 复制代码

执行结果：

总监看后连连点头，笑着对张三说：“用 properties 文件存放类的全限定名降低了代码的耦合度，通过传参的方式使用反射创建对象又降低了代码的冗余性，这次改的可以。"

"好啦，今晚项目要上线，先吃饭去吧，一会还要改 bug。”

张三："..........好的总监。"

10. 反射的作用

我们或多或少都听说过设计框架的时候会用到反射，例如 Spring 的 IOC 就用到了工厂模式和反射来创建对象，BeanUtils 的底层也是使用反射来拷贝属性。所以反射无处不在。

尽管我们日常开发几乎用不到反射，但是我们必须要搞懂反射的原理，因为它能帮我们理解框架设计的原理。