初学反射基本原理

反射：框架设计的灵魂

* 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
* 反射：将类的各个组成部分封装为其他对象，这就是反射机制
	* 好处：
		1. 可以在程序运行过程中，操作这些对象。
		2. 可以解耦，提高程序的可扩展性。

Class类

* 获取Class类的方式：
	1. Class.forName("全类名")：将字节码文件加载进内存，返回Class类
		* 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
	2. 类名.class：通过类名的属性class获取
		* 多用于参数的传递
	3. 对象.getClass()：getClass()方法在Object类中定义着。
		* 多用于对象的获取字节码的方式

	* 结论：
		同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

public class People {
    public void sleep(){
        System.out.println("睡觉");
    }
}
public class User {
    private String name;
    private int age;
    public String address;
    public User() {
    }
    public User(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    public String getName() {
        System.out.println("haha");
        return name;
    }
    public String getName(String value) {
        System.out.println("haha"+value);
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void eat(){
        System.out.println("吃饭饭");
    }
}

public class ReflectClass {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取Class类的 3 种方式
        Class<?> class1 = Class.forName("reflect.entity.User");

        Class<User> class2 = User.class;

        User user = new User();
        Class<? extends User> class3 = user.getClass();

        User user1 = new User();
        Class<? extends User> class4 = user1.getClass();

        System.out.println(class1);
        System.out.println(class2);
        System.out.println(class3);
        System.out.println(class4);
        //都是true 说明是同一份 *.class 文件
        System.out.println(class1==class2);//true
        System.out.println(class1==class3);//true
        System.out.println(class3==class4);//true

    }
}

* Class对象功能：
	* 获取功能：
		1. 获取成员变量们
			* Field[] getFields() ：获取所有public修饰的成员变量
			* Field getField(String name)   获取指定名称的 public修饰的成员变量

			* Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
			* Field getDeclaredField(String name)  
		2. 获取构造方法们
			* Constructor<?>[] getConstructors()  
			* Constructor<T> getConstructor(类<?>... parameterTypes)  

			* Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  
			* Constructor<?>[] getDeclaredConstructors()  
		3. 获取成员方法们：
			* Method[] getMethods()  
			* Method getMethod(String name, 类<?>... parameterTypes)  

			* Method[] getDeclaredMethods()  
			* Method getDeclaredMethod(String name, 类<?>... parameterTypes)  

		4. 获取全类名	
			* String getName()  

Field类

* Field：成员变量
	* 操作：
		1. 设置值
			* void set(Object obj, Object value)  
		2. 获取值
			* get(Object obj) 

		3. 忽略访问权限修饰符的安全检查
			* setAccessible(true):暴力反射

public class ReflrctField {
    public static void main(String[] args) throws Exception {
        //0. 获取User 的 Class对象
        Class<User> userClass = User.class;

        /**
         * getFields()：只获取所有 被public 修饰的成员变量
         * getField()：只获取指定名称的 被public 修饰的成员变量
         */
        //1.获取成员变量们（public） 
        Field[] fields = userClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        //2、获取指定成员变量（public）
        Field address = userClass.getField("address");
        
        User user = new User();
        //get 返回所表示的字段的值,指定的对象上
        Object value = address.get(user);
        System.out.println(value);
        //set 将指定对象参数上 此字段设置为指定的新值
        address.set(user,"广州");
        System.out.println(user);
        System.out.println("=====================");

        /**
         * getDeclaredFields()获取所有成员变量(不考虑修饰符)  Declared：声明过的
         * getDeclaredField() 获取某个属性值( publick )
         */
        //3、getDeclaredFields()获取所有成员变量(不考虑修饰符)  Declared：声明过的
        Field[] declaredFields = userClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

        //4、getDeclaredField 获取某个属性值(publick)
        Field age = userClass.getDeclaredField("age");
        //忽略访问权限修饰符安全检查
        age.setAccessible(true);//暴力反射
        System.out.println(age.get(user));

    }
}

Constructor类

* Constructor:构造方法
	* 创建对象：
		* T newInstance(Object... initargs)  

		* 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

public class ReflecConstructor {
    public static void main(String[] args) throws Exception {
        Class userClass = User.class;

        //获取构造方法 getConstructor(),根据传入数据类型重载
        Constructor constructor = userClass.getConstructor();
        System.out.println(constructor);
        //创建对象
        Object user = constructor.newInstance();
        System.out.println(user);

        Constructor constructor1 = userClass.getConstructor(String.class, int.class,String.class);
        System.out.println(constructor1);
        Object user1 = constructor1.newInstance("hua", 19,"gua");
        System.out.println(user1);
    }
}

Method类

* Method：方法对象
	* 执行方法：
		* Object invoke(Object obj, Object... args)  

	* 获取方法名称：
		* String getName:获取方法名

public class ReflectMethod {

    public static void main(String[] args) throws Exception {
        Class<User> userClass = User.class;
        //获取指定名称方法
        Method nameMethod1 = userClass.getMethod("getName");
        User user = new User();
        //执行方法
        nameMethod1.invoke(user);

        //根据传入的参数类型 获取重载的方法
        Method nameMethod2 = userClass.getMethod("getName", String.class);
        nameMethod2.invoke(user,"huahuahua");

        //获取所有 public 方法（包括父类的）
        Method[] methods = userClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            //method.setAccessible(true);
        }
        System.out.println("=========================");
        //获取所有 public 方法（不包括父类的）
        Method[] methods2 = userClass.getDeclaredMethods();
        for (Method method : methods2) {
            System.out.println(method);
        }

        //获取类名
        String userClassName = userClass.getName();
        System.out.println(userClassName);
    }
}

案例

* 案例：
	* 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
		* 实现：
			1. 配置文件
			2. 反射
		* 步骤：
			1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
			2. 在程序中加载读取配置文件
			3. 使用反射技术来加载类文件进内存
			4. 创建对象
			5. 执行方法
		
在src目录下新建文件 pro.properties,内容如下
className=reflect.entity.People
methodName=sleep

//例子：不能改变类的任何代码，可以创建任意类对象，执行任意方法
public class ReflectTest {
    public static void main(String[] args) throws Exception {
        /* 以下操作 是用反射 替代这两个的其中一个
        User user = new User();
        user.eat();

        People people = new People();
        people.sleep();*/

        //1、加载配置文件
        //创建Properties对象
        Properties properties = new Properties();
        //通过类加载器（可以加载src目录下任意文件）加载
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("user.properties");
        properties.load(is);

        //2、获取配置文件中定义的数据
        String className = properties.getProperty("className");
        String methodName = properties.getProperty("methodName");
        //3、加载该类进内存
        Class<?> cls = Class.forName(className);
        //4、创建对象
        Object obj = cls.newInstance();
        //5、获取方法对象
        Method method = cls.getMethod(methodName);
        //执行方法需指定对象
        method.invoke(obj);
    }
}