反射都不会，还敢说本身会Java？----->(浅谈)

在谈反射以前，先思考一个问题，java中如何建立一个对象，有哪几种方式?

Java中建立对象大概有这几种方式：java

一、使用new关键字：这是咱们最多见的也是最简单的建立对象的方式数组

二、使用Clone的方法：不管什么时候咱们调用一个对象的clone方法，JVM就会建立一个新的对象，将前面的对象的内容所有拷贝进去安全

三、使用反序列化：当咱们序列化和反序列化一个对象，JVM会给咱们建立一个单独的对象mybatis

上边是Java中常见的建立对象的三种方式，其实除了上边的三种还有另一种方式，就是接下来咱们要讨论的 “反射”框架

一、反射概述

1.1什么是反射

在程序运行状态中，对于任意一个类或对象，都可以获取到这个类的全部属性和方法（包括私有属性和方法），这种动态获取信息以及动态调用对象方法的功能就称为反射机制。简单来说，经过反射，类对咱们是彻底透明的，想要获取任何东西均可以。函数

反射它把Java类中的各个部分，映射成一个个的Java对象，拿到这些对象后能够作一些事情。既然说反射是反射Java类中的各个组成部分，因此说咱们得知道一个类中有哪儿些部分？学习

例如，一个类有：成员变量，方法，构造方法，等信息，利用反射技术我们能够把这些组成部分映射成一个个对象。测试

1.二、反射能干什么

通常来讲反射是用来作框架的，或者说能够作一些抽象度比较高的底层代码，反射在平常的开发中用到的很少，可是咱们还必须搞懂它，由于搞懂了反射之后，能够帮助我们理解框架的一些原理。因此说有一句很经典的话：反射是框架设计的灵魂。this

1.3 反射的优势

能够在程序运行过程当中，操做这些对象；
能够解耦，提升程序的可扩展性。

在学习反射之前，咱们先来了解一下Java代码在计算机中所经历的三个阶段：编码

Source源代码阶段：.java被编译成*.class字节码文件。
Class类对象阶段：.class字节码文件被类加载器加载进内存，并将其封装成Class对象（用于在内存中描述字节码文件），Class对象将原字节码文件中的成员变量抽取出来封装成数组Field[],将原字节码文件中的构造函数抽取出来封装成数组Construction[]，将成员方法封装成数组Method[]。固然Class类内不止这三个，还封装了不少，咱们经常使用的就这三个。
RunTime运行时阶段：使用new建立对象的过程。

1.4 获取Class对象的三种方式

【Source源代码阶段】 Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象；
多用于配置文件，将类名定义在配置文件中，经过读取配置文件加载类。
【Class类对象阶段】类名.class：经过类名的属性class获取；
多用于参数的传递
【Runtime运行时阶段】对象.getClass()：此方法是定义在Objec类中的方法，所以全部的类都会继承此方法。
多用于对象获取字节码的方式

//方法演示
public class getClass {
    public static void main(String[] args) throws Exception {
    
        //方式一：Class.forName("全类名");
        Class class1 = Class.forName("com.czxy.mybatis_plus.test.Person");   //Person自定义实体类
        System.out.println("class1 = " + class1);

        //方式二：类名.class
        Class class2 = Person.class;
        System.out.println("class2 = " + class2);

        //方式三：对象.getClass();
        Person person = new Person();
        Class class3 = person.getClass();
        System.out.println("class3 = " + class3);

        //比较三个对象
        System.out.println(class1 == class2);    //true
        System.out.println(class1 == class3);    //true
    }
}

运行结果：

经过上述比较三个对象的结果能够得出一个结论：同一个字节码文件(*.class)在一次程序运行过程当中，只会被加载一次，不管经过哪种方式获取的Class对象都是同一个。

二、Class对象的功能

2.1 获取功能

这里只写出一些经常使用的，具体能够参看jdk的帮助文档。

获取成员变量

Field[] getFields()          //获取全部public修饰的成员变量
Field getField(String name)  //获取指定名称的public修饰的成员变量

Field[] getDeclaredFields()  //获取全部的成员变量，不考虑修饰符
Field getDeclaredField(String name)  //获取指定的成员变量，不考虑修饰符

2. 获取构造方法

Constructor<?>[] getConstructors() //获取全部public修饰的构造函数
Constructor<T> getConstructor(类<?>... parameterTypes)  //获取指定的public修饰的构造函数

Constructor<?>[] getDeclaredConstructors()  //获取全部的构造函数，不考虑修饰符
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  //获取指定的构造函数，不考虑修饰符

3. 获取成员方法

Method[] getMethods()           //获取全部public修饰的成员方法
Method getMethod(String name, 类<?>... parameterTypes) //获取指定名称的public修饰的成员方法

Method[] getDeclaredMethods()  //获取全部的成员方法，不考虑修饰符
Method getDeclaredMethod(String name, 类<?>... parameterTypes) //获取指定名称的成员方法，不考虑修饰符

4. 获取全类名

String getName()

2.2 Field：成员变量

（1）设置值 set(Object obj, Object value)
（2）获取值 get(Object obj)
（3）忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射

2.3 测试的实体类

import lombok.Data;
import lombok.ToString;


@Data
@ToString
public class Person {
    public String a;        //最大范围public
    protected String b;     //受保护类型
    String c;               //默认的访问权限
    private String d;       //私有类型

}

2.4 测试getFields和getField(String name)方法

/**
 *      获取成员变量
 *    * Field[] getFields()
 *    * Field getField(String name)
 *     @throws Exception
 */
public class reflectDemo{
    public static void main(String[] args) throws Exception {
    
        //获取Person的Class对象
        Class personClass = Person.class;

        //一、Field[] getFields()获取全部public修饰的成员变量
        Field[] fields = personClass.getFields();
        for(Field field : fields){
            System.out.println(field);
        }

        System.out.println("=============================");

        //2.Field getField(String name) 获取指定名称的public修饰的成员变量
        Field a = personClass.getField("a");
        //获取成员变量a的值 [也只能获取公有的，获取私有的或者不存在的字符会抛出异常]
        Person p = new Person();
        Object value = a.get(p);
        System.out.println("value = " + value);//由于在Person类中a没有赋值，因此为null

        //设置成员变量a的属性值
        a.set(p,"李四");
        System.out.println(p);
    }
}

运行结果：

2.5 测试 getDeclaredFields 和 getDeclaredField(String name)方法

/**
 *     Field[] getDeclaredFields()
 *     Field getDeclaredField(String name)
 *     @throws Exception
 */
public class reflectDemo1 {
    public static void main(String[] args) throws Exception {
    
        //获取Person的Class对象
        Class personClass = Person.class;

        //Field[] getDeclaredFields()：获取全部的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for(Field filed : declaredFields){
            System.out.println(filed);
        }

        System.out.println("===================================");

        //Field getDeclaredField(String name) //获取指定的成员变量，不考虑修饰符
        Field d = personClass.getDeclaredField("d"); //private String d;
        Person p = new Person();

        //Object value1 = d.get(p);  //若是直接获取会抛出异常，由于对于私有变量虽然能会获取到，但不能直接set和get，必须忽略访问权限修饰符的安全检查后才能够
        //System.out.println("value1 = " + value1); 

        //忽略访问权限修饰符的安全检查，又称为暴力反射
        d.setAccessible(true);
        Object value2 = d.get(p);
        System.out.println("value2 = " + value2);
    }
}

运行结果：

注意：若是没有忽略访问修饰符直接访问会抛出以下所示的异常

三、 Constructor:构造方法

3.1修改测试的实体类

import lombok.Data;
import lombok.ToString;


@Data
@ToString
public class Person {
    private String name;
    private Integer age;
    //无参构造函数
    public Person() {
    }
    //单个参数的构造函数，且为私有构造方法
    private Person(String name){
    }
    //有参构造函数
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

}

3.2 测试获取构造函数的方法

/**
 *    获取构造方法
 *    Constructor<?>[] getConstructors()
 *    Constructor<T> getConstructor(类<?>... parameterTypes)
 */
public class reflectDemo2{
    public static void main(String[] args) throws Exception {

        //获取Person的Class对象
        Class personClass = Person.class;

        //Constructor<?>[] getConstructors() //获取全部public修饰的构造函数
        Constructor[] constructors = personClass.getConstructors();
        for(Constructor constructor : constructors){   
            System.out.println(constructor);
        }

        System.out.println("==========================================");

        //获取无参构造函数   注意：Person类中必需要有无参的构造函数，否则抛出异常
        Constructor constructor1 = personClass.getConstructor(); 
        System.out.println("constructor1 = " + constructor1);
        //使用获取到的无参构造函数建立对象
        Object person1 = constructor1.newInstance();
        System.out.println("person1 = " + person1);


        System.out.println("==========================================");

        //获取有参的构造函数  //public Person(String name, Integer age) 参数类型顺序要与构造函数内一致，且参数类型为字节码文件类型
        Constructor constructor2 = personClass.getConstructor(String.class,Integer.class);
        System.out.println("constructor2 = " + constructor2);
        //使用获取到的有参构造函数建立对象
        Object person2 = constructor2.newInstance("zhangsan", 22);   //获取的是有参的构造方法，就必需要指定参数
        System.out.println(person2);

        System.out.println("=========================================");

        //对于通常的无参构造函数，咱们都不会先获取无参构造器以后在进行初始化,而是直接调用Class类内的newInstance()方法
        Object person3 = personClass.newInstance();
        System.out.println("person3 = " + person3);
    }
}

运行结果：

四、 Method：方法对象

4.1 执行方法：Object invoke(Object obj, Object… args)

import lombok.Data;
import lombok.ToString;


@Data
@ToString
public class Person {
    private String name;
    private Integer age;

    //无参构造函数
    public Person() {

    }
    //有参构造函数
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    //无参方法
    public void test(){
        System.out.println("test...");
    }

    //重载有参方法
    public void test(String food){
        System.out.println("test..."+food);
    }

}

4.2 测试获取成员方法的方法

/**
 *     获取成员方法
 *    * Method[] getMethods()
 *    * Method getMethod(String name, 类<?>... parameterTypes)
 */
public class reflectDemo3 {
    public static void main(String[] args) throws Exception {

        //获取Person的Class对象
        Class personClass = Person.class;

        //获取指定名称的方法
        Method method1 = personClass.getMethod("test");
        //执行方法
        Person person = new Person();
        Object rtValue = method1.invoke(person);//若是方法有返回值类型能够获取到，没有就为null
        //由于eat方法没有返回值，故输出null
        System.out.println("rtValue = " + rtValue);

        System.out.println("--------------------------------------------");

        //获取有参的函数，有两个参数：第一个参数为方法名，第二个参数是获取方法的参数类型的字节码文件
        Method method2 = personClass.getMethod("test", String.class);
        //执行方法
         method2.invoke(person,"嗨");

        System.out.println("============================================");

        //获取方法列表
        Method[] methods = personClass.getMethods();
        for(Method method : methods){     //注意：获取到的方法不只仅是Person类内本身的方法
            System.out.println(method);   //继承Object中的方法也会被获取到（固然前提是public修饰的）
        }
    }
}

运行结果：

咱们能够看出Person内的public方法都被打印出来了，此外Object中的public方法也都被打印出来了。

同以前的叙述同样，带有Declared关键字的方法这两个方法，能够获取到任意修饰符的方法。一样也提供了setAccessible(true)方法进行暴力反射。

综上所述：在反射面前没有公有私有，均可以经过暴力反射解决。

五、获取全类名

5.1 getName()方法获取的类名是全类名（带有路径）

public class getNameDemo {
    public static void main(String[] args) throws Exception {

        //获取Person的Class对象
        Class personClass = Person.class;
        //获取全类名
        String className = personClass.getName();
        System.out.println(className);
    }
}

运行结果：

六、反射机制的应用案例

6.1 需求

写一个"框架"，在不改变该类的任何代码的前提下，能够帮咱们建立任意类的对象，而且执行其中的任意方法。

6.2 实现

（1）配置文件
（2）反射机制

6.3 步骤

（1）将须要建立的对象的全类名和须要执行的方法定义在配置文件中
（2）在程序中加载读取配置文件
（3）使用反射技术把类文件加载进内存
（4）建立对象
（5）执行方法

6.4 代码实现须要的实体类

(1)Person类

public class Person {
    //无参方法
    public void test(){
        System.out.println("test...");
    }
}

(2)Student类

public class Student {
    //无参方法
    public void study(){
        System.out.println("I'm Student");
    }
}

6.5 编写配置文件

className = com.czxy.mybatis_plus.test.Person
methodName = test

6.6 实现框架

/**
  * 前提：不能改变该类的任何代码。能够建立任意类的对象，能够执行任意方法
  * 即：拒绝硬编码
  */
public class ReflectTest {
    public static void main(String[] args) throws Exception {
    
        //1.加载配置文件
        //1.1建立Properties对象
        Properties pro = new Properties();
        //1.2加载配置文件
        //1.2.1获取class目录下的配置文件(使用类加载器)
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream inputStream = classLoader.getResourceAsStream("pro.properties");
        pro.load(inputStream);

        //2.获取配置文件中定义的数据
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");

        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.建立对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
    }
}

运行结果:

6.7 修改配置文件，再次运行

className = com.czxy.mybatis_plus.test.Student 
methodName = study

运行结果:

总结：

对于框架来讲，已经对基础的代码进行了封装并提供相应的API。
在框架的基础上进行软件开发，能够简化编码。但若是咱们使用传统的new形式来实例化，那么当类更改时咱们就要修改Java代码，这是很繁琐的。
修改Java代码之后咱们还要进行从新编译、测试、发布等一系列的操做。
而若是咱们仅仅只是修改配置文件，而不须要修改Java代码就简单的多。
此外使用反射还能达到解耦的效果，若是咱们使用的是new这种形式进行对象的实例化。
此时若是在项目的某一个小模块中咱们的一个实例类丢失了，那么在编译期间就会报错，会致使整个项目没法启动。
而对于反射建立对象Class.forName(“全类名”)这种形式，咱们在编译期须要的仅仅只是一个字符串（全类名），在编译期不会报错，这样其余的模块就能够正常的运行，而不会由于一个模块的问题致使整个项目崩溃。

反射都不会，还敢说本身会Java？----->(浅谈)

在谈反射以前，先思考一个问题，java中如何建立一个对象，有哪几种方式?

一、反射概述

1.1什么是反射

1.二、反射能干什么

1.3 反射的优势

1.4 获取Class对象的三种方式

二、Class对象的功能

2.1 获取功能

2.2 Field：成员变量

2.3 测试的实体类

2.4 测试getFields和getField(String name)方法

2.5 测试 getDeclaredFields 和 getDeclaredField(String name)方法

三、 Constructor:构造方法

3.1修改测试的实体类

3.2 测试获取构造函数的方法

四、 Method：方法对象

4.1 执行方法：Object invoke(Object obj, Object… args)

4.2 测试获取成员方法的方法

五、获取全类名

5.1 getName()方法获取的类名是全类名（带有路径）

六、反射机制的应用案例

6.1 需求

6.2 实现

6.3 步骤

6.4 代码实现 须要的实体类

6.5 编写配置文件

6.6 实现框架

6.7 修改配置文件，再次运行

6.4 代码实现须要的实体类