反射

Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。在运行时调用任意一个对象的方法；生成动态代理。对于反射肯定会涉及到类加载和动态代理这些，这些我将在今后继续讲解。今天我们就单纯的理解一些反射

在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的方法

比如我们使用的jdbc就是一个反射的列子：想必这个jdbc获取driver的代码都记得吧。

Class.forName("com.mysql.jdbc.Driver");

在这行代码中就涉及了反射，以及类加载。

Java反射机制的实现要借助于4个类：Class，Constructor，Field，Method；

其中Class代表的是类对象，Constructor－类的构造器对象，Field－类的属性对象，Method－类的方法对象，通过这四个对象我们可以粗略地看到一个类的各个组成部分。其中最核心的就是Class类，它是实现反射的基础，它包含的方法我们在第一部分已经进行了基本的阐述。应用反射时我们最关心的一般是一个类的构造器、属性和方法，下面我们主要介绍Class类中针对这三个元素的方法:

1、得到构造器的方法

// 获得使用特殊的参数类型的公共构造函数， 
Constructor getConstructor(Class[] params) 

// -- 获得类的所有公共构造函数 
Constructor[] getConstructors() 

// -- 获得使用特定参数类型的构造函数(与接入级别无关) 
Constructor getDeclaredConstructor(Class[] params) 

// -- 获得类的所有构造函数(与接入级别无关) 
Constructor[] getDeclaredConstructors() 

2、获得字段信息的方法

// -- 获得命名的公共字段 
Field getField(String name) 
// -- 获得类的所有公共字段 
Field[] getFields()
// -- 获得类声明的命名的字段 
Field getDeclaredField(String name)
//-- 获得类声明的所有字段 
Field[] getDeclaredFields() 

3、获得方法信息的方法

// -- 使用特定的参数类型，获得命名的公共方法 
Method getMethod(String name, Class[] params) 

// -- 获得类的所有公共方法
Method[] getMethods()  

//-- 使用特写的参数类型，获得类声明的命名的方法 
Method getDeclaredMethod(String name, Class[] params) 

//- 获得类声明的所有方法 
Method[] getDeclaredMethods()

在程序开发中使用反射并结合属性文件，可以达到程序代码与配置文件相分离的目的

如果我们想要得到对象的信息，一般需要“引入需要的‘包.类’的名称——通过new实例化——取得实例化对象”这样的过程。使用反射就可以变成“实例化对象——getClass()方法——得到完整的‘包.类’名称”这样的过程。

正常方法是通过一个类创建对象，反射方法就是通过一个对象找到这个类

package com.doc.config;
/**
 * @user:
 * @date:2021/1/18
 * @Description:
 */
public class Fruits {
    private String color;
    private double price;
    private String size;
    public  String  obs;
    public String getObs() {
        return obs;
    }
    public void setObs(String obs) {
        this.obs = obs;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public String getSize() {
        return size;
    }
    public void setSize(String size) {
        this.size = size;
    }
}
/// 测试代码
package com.doc.config;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * @user: kaysanshi
 * @date:2021/1/18
 * @Description: 测试反射的列子
 */
public class TestReflection {
    public static void main(String [] args) throws Exception {
        // 正常的使用
        Fruits fruits = new Fruits();
        fruits.setPrice(10);
        System.out.println(fruits.getPrice());
        // 使用反射
        Class<?> aClass = Class.forName("com.doc.config.Fruits");
        // 获取命名的公共方法
        Method setPrice = aClass.getMethod("setPrice", double.class);
        // 获取所有的公共属性getFields()(无法获取私有属性)
        System.out.println("获取共有属性");
        Field[] fields = aClass.getFields();
        for(Field field : fields) {
            System.out.println(field.getName());
        }
        System.out.println("获取私有属性");
        // getDeclaredFields()(获取私有属性)
        Field[] dfields = aClass.getDeclaredFields();
        for(Field field : dfields){
            System.out.println(field.getName());
        }
        // 获取构造器
        Constructor fruitsConstructor = aClass.getConstructor();
        // 通过构造器的newInstance()获取反射类对象
        Object obj = fruitsConstructor.newInstance();
        // 利用 invoke方法进行调用方法
        setPrice.invoke(obj,13);
    }
}

比如下面一个方法名为diff的函数，输入参数为两个同类的对象。输出为一个List，其中存放了两个对象的不同的属性的属性名称。

假设User对象，包含name\age\phone三个参数。

// 不使用反射
    List<String> diff(User user1,User user2){
        List<String> result  = new ArrayList<>();
        if(user1.getName() == null && user2.getName() !=null || !user1.getName().equals(user2.getName())){
            result.add("name");
        }
        if(user1.getAge() == null && user2.getAge() !=null || !user1.getAge().equals(user2.getAge())){
            result.add("age");
        }
        if(user1.getPhone() == null && user2.getPhone() !=null || !user1.getPhone().equals(user2.getPhone())){
            result.add("phone");
        }
    }
    // 使用反射
    List<String> diff(Object obj1,Object obj2){
        try{
            Class<?> clazz1 = obj1.getClass();
            Class<?> clazz2 = obj2.getClass();
            if(clazz1.equals(clazz2)){
                List<String> result = new ArrayList<>();
                for(Field feild: clazz1.getDeclaredFields()){
                    feild.setAccessible(true);
                    Object obj1= feild.get(obj1);
                    Object obj2=feild.get(obj2);
                    if(value1==null && value2!=null || !value1.equals(value2)){
                        result.add(feild.getName());
                    }
                }
                return result;
            }
            return null;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

该方法的优点是可以处理任何类的两个对象，而不需要关心它的属性，十分通用

反射如何创建对象

1.通过获取构造器 getConstructor() 然后 通过构造器的newInstance()获取反射类对象。

2.通过类对象调用newInstance()方法。例如

// 使用反射
Class<?> aClass = Class.forName("com.doc.config.Fruits");
Object o = aClass.newInstance();
System.out.println(o);

这样有了这个对象我们在运行时就可以做我们想做的事情了。在spring中运用反射的是比较多的，比如bean的生成就是通过反射进行。

好了这就是今天我们要说的java的反射的基本的用法，喜欢的点个赞。分享一下