JavaSE--反射机制

一、反射机制

  java.lang.reflect.*;

1、反射机制的作用

  通过java语言中的反射机制可以操作字节码文件，可以读和修改字节码文件。

  通过反射机制可以操作代码片段（class文件）

2、反射机制相关的类

  java.lang.Class：代表整个字节码，代表一个类型，代表整个类

  java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法

  java.lang.reflect.Constructor：代表字节码中的构造方法字节码。代表类中的构造方法

  java.lang.reflect.Field：代表字节码中的属性字节码。代表类中的成员变量（静态变量+实例变量）

二、反射Class字节码文件

1、获取一个了类的字节码文件

  1）Class c = Class.forName("完整类名带包名");

    静态方法；方法的参数是一个字符串；字符串需要的是一个完整类名；完整类名必须带有包名。java.lang包也不能省略。

    Class.forName("完整类名带包名");这个方法的执行会导致类加载，类加载时静态代码块会执行

Class c1 = null;
Class c2 = null;
Class c3 = null;
Class c4 = null;
try {
    c1 = Class.forName("java.lang.String"); // c1代表String.class文件，或者说c1代表String类型。
    c2 = Class.forName("java.util.Date"); // c2代表Date类型
    c3 = Class.forName("java.lang.Integer"); // c3代表Integer类型
    c4 = Class.forName("java.lang.System"); // c4代表System类型
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

  2）Class c = 对象.getClass();

// java中任何一个对象都有一个方法：getClass()
String s = "abc";
Class x = s.getClass(); // x代表String.class字节码文件，x代表String类型
 
Date time = new Date();
Class y = time.getClass();

  3）Class c = 任何类型.class;

Class z = String.class; // z代表String类型
Class k = Date.class; // k代表Date类型
Class f = int.class; // f代表int类型
Class e = double.class; // e代表double类型

2、通过反射机制实例化对象

// User类
public class User{
    private String name;
    public User(){
        System.out.println("无参构造");
    }
    public User(String s){
        
    }
} 

public class ReflectTest02 {
    public static void main(String[] args) {
 
        // 以反射机制的方式创建对象
        try {
            // 通过反射机制，获取Class，通过Class来实例化对象
            Class c = Class.forName("com.bean.User"); // c代表User类型
 
            // newInstance() 这个方法会调用User这个类的无参数构造方法，完成对象的创建
            // 重点是：newInstance()调用的是无参构造，必须保证无参构造是存在的
            Object obj = c.newInstance();
 
            System.out.println(obj);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

3、小插曲：获取文件的路径（前提是在类路径下的文件）

public class AboutPath {
    public static void main(String[] args) throws Exception{
        // 接下来说一种比较通用的一种路径。即使代码换位置了，这样编写仍然是通用的。
        // 注意：使用以下通用方式的前提是：这个文件必须在类路径下。
        // 什么是类路径下：在src下的都是类路径下
        // src是类的根路径
        /*
            Thread.currentThread() 当前线程对象
            getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象
            getResource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源
         */
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo2.properties").getPath(); // 这种方式获取文件绝对路径是通用的。
        System.out.println(path);
        
        // 直接以流的形式返回
        InputStream reader = Thread.currentThread().getContextClassLoader().getResourceAsStream("classinfo2.properties");
 
        // 获取db.properties文件的绝对路径（从类的根路径下作为起点开始）
        String path2 = Thread.currentThread().getContextClassLoader()
                .getResource("com/bean/db.properties").getPath();
        System.out.println(path2);
 
    }
}

4、小插曲：资源绑定器

   java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容

  使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下

public class ResourceBundleTest {
    public static void main(String[] args) {
        // 资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下。文件扩展名也必须是properties
        // 并且在写路径的时候，路径后面的扩展名不能写
        //ResourceBundle bundle = ResourceBundle.getBundle("classinfo2");
 
        ResourceBundle bundle = ResourceBundle.getBundle("com/bean/db");
 
        String className = bundle.getString("className");
        System.out.println(className);
 
    }
}

 

三、反射Field属性

1、获取Field属性

public class Student {
    // 4个Field，分别采用了不同的访问控制权限修饰符
    private String name; // 这一整个就是一个Field对象
    protected int age;
    boolean sex;
    public int no;
    public static final double MATH_PI = 3.1415926;
}

  1）获取类名getName、getSimpleName

// 获取整个类
Class studentClass = Class.forName("com.bean.Student");
 
// 获取完整的类名com.bean.Student
String className = studentClass.getName();
 
// 获取简类名Student
String simpleName = studentClass.getSimpleName();

  2）获取类中public修饰的Field属性 getFields

Field[] fields = studentClass.getFields();

   3）获取所有属性getDeclareFields

Field[] fs = studentClass.getDeclaredFields();

  4）获取属性的修饰符列表getModifiers

// 获取所有Field
Field[] fs = studentClass.getDeclaredFields();
// 遍历
for(Field field : fs){
    // 获取属性的修饰符列表
    int i = field.getModifiers(); // 返回的修饰符是一个数字，每个数字是修饰符的代号
    System.out.println(i);
    // 将这个“代号”数字转换成“字符串”
    String modifierString = Modifier.toString(i);
    System.out.println(modifierString);
}

   5）获取属性的类型

// 获取所有Field
Field[] fs = studentClass.getDeclaredFields();
// 遍历
for(Field field : fs){
    // 获取属性的类型
    Class fieldType = field.getType();
    //String fName = fieldType.getName();
    // 获取类型简类名
    String fName = fieldType.getSimpleName();
    System.out.println(fName);
}

  6）获取属性的名字

// 获取所有Field
Field[] fs = studentClass.getDeclaredFields();
// 遍历
for(Field field : fs){
    // 获取属性的名字
    System.out.println(field.getName());
}

 2、通过反射机制给属性赋值

public class ReflectTest07 {
    public static void main(String[] args) throws Exception{
        // 使用反射机制，访问一个对象的属性
 
        Class studentClass = Class.forName("com.bjpowernode.java.bean.Student");
        Object obj = studentClass.newInstance();// 底层调用无参构造，obj就是一个Student对象
 
        // 获取no属性（根据属性的名称来获取Field）
        Field noFiled = studentClass.getDeclaredField("no");
        noFiled.set(obj, 12333); // 给obj对象的no属性赋值12333
        // 读取属性的值 获取obj对象的no属性的值。
        System.out.println(noFiled.get(obj));
 
        // 访问私有的属性
        Field nameField = studentClass.getDeclaredField("name");
        // 打破封装（反射机制的缺点：打破封装，可能会给不法分子留下机会）
        // 这样设置完之后，在外部也是可以访问private的
        nameField.setAccessible(true);
        // 给name属性赋值
        nameField.set(obj, "jackson");
        // 获取name属性的值
        System.out.println(nameField.get(obj));
    }
}

四、反射Method

1、获取方法

  1）获取所有的方法

// 获取类
Class userServiceClass = Class.forName("com.service.UserService");
 
// 获取所有的Method（包括私有的）
Method[] methods = userServiceClass.getDeclaredMethods();

  2）获取修饰符列表

// 遍历Method
for(Method method : methods){
    // 获取修饰符列表method.getModifiers()
    System.out.println(Modifier.toString(method.getModifiers()));
}

  3）获取返回值类型

// 遍历Method
for(Method method : methods){
    // 获取方法的返回值类型method.getReturnType()
    System.out.println(method.getReturnType().getSimpleName());
}

  4）获取方法名

// 遍历Method
for(Method method : methods){
    // 获取方法名
    System.out.println(method.getName());
}

  5）获取参数列表

// 遍历Method
for(Method method : methods){
    // 方法的修饰符列表（一个方法的参数可能会有多个）
    // method.getParameterTypes()
    Class[] parameterTypes = method.getParameterTypes();
    for(Class parameterType : parameterTypes){
        System.out.println(parameterType.getSimpleName());
    }
}

2、使用反射机制调用方法执行

// 用户业务类
public class UserService {
 
    /**
     * 登录方法
     * @param name 用户名
     * @param password 密码
     * @return true表示登录成功，false表示登录失败
     */
    public boolean login(String name,String password){
        if("admin".equals(name) && "123".equals(password)){
            return true;
        }
        return false;
    }
 
    // 还有一个同名login方法
    // java中怎么区分一个方法，依靠方法名和参数列表
    public void login(int i){
 
    }
 
    /**
     * 退出系统的方法
     */
    public void logout(){
        System.out.println("系统已经安全退出！");
    }
}

public class ReflectTest10 {
    public static void main(String[] args) throws Exception{
        // 使用反射机制来调用一个对象的方法
        
        Class userServiceClass = Class.forName("com.service.UserService");
        // 创建对象
        Object obj = userServiceClass.newInstance();
        // 获取Method
        // 后面的参数就是方法的类型.class
        // 就是通过参数的类型以及参数的多少来判断是哪个方法，（因为有方法重载）
        Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class);
        //Method loginMethod = userServiceClass.getDeclaredMethod("login", int.class);
        
        // 调用方法
        Object retValue = loginMethod.invoke(obj, "admin","123123");
        System.out.println(retValue);
    }
}

 五、反射机制构造方法Constructor

1、使用反射机制调用构造方法

public class ReflectTest12 {
    public static void main(String[] args) throws Exception{
 
        Class c = Class.forName("com.bean.Vip");
        // 直接调用无参数构造方法
        Object obj = c.newInstance();
        System.out.println(obj);
 
        // 调用有参数的构造方法
        // 第一步：先获取到这个有参数的构造方法
        Constructor con = c.getDeclaredConstructor(int.class, String.class, String.class,boolean.class);
        // 第二步：调用构造方法new对象
        Object newObj = con.newInstance(110, "jackson", "1990-10-11", true);
        System.out.println(newObj);
 
        // 获取无参数构造方法
        Constructor con2 = c.getDeclaredConstructor();
        Object newObj2 = con2.newInstance();
        System.out.println(newObj2);
    }
}

六、反射机制获取类的父类和实现的接口

public class ReflectTest13 {
    public static void main(String[] args) throws Exception{
 
        // String举例
        Class stringClass = Class.forName("java.lang.String");
 
        // 获取String的父类getSuperclass()
        Class superClass = stringClass.getSuperclass();
        System.out.println(superClass.getName());
 
        // 获取String类实现的所有接口getInterfaces()
        Class[] interfaces = stringClass.getInterfaces();
        for(Class in : interfaces){
            System.out.println(in.getName());
        }
    }
}

 

 

扩展：类加载器

1、类加载器概述

  专门负责加载类的命令/工具。ClassLoader

2、jdk自带3个类加载器

  启动类加载器  rt.jar

  扩展类加载器  ext/*.jar

  应用类加载器  classpath

3、类加载器运行原理

  1）原理

  代码在开始执行之前，会将所需要类全部加载到JVM当中。

  通过类加载器加载，看到String = "abc"; 代码类加载器会找String.class文件，找到就加载，那么是怎么进行加载的呢？

    a）首先通过“启动类加载器”加载

    注意：启动类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\rt.jar

      rt.jar中都是JDK最核心的类库

    b）如果通过“启动类加载器”加载不到的时候，会通过"扩展类加载器"加载

    注意：扩展类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\*.jar

    c）如果“扩展类加载器”没有加载到，那么会通过“应用类加载器”加载

    注意：应用类加载器专门加载：classpath中的类

  2）双亲委派机制

  java中为了保证类加载的安全，使用了双亲委派机制。

  优先从启动类加载器中加载，这个称为“父”，“父”无法加载到，再从扩展类加载器中加载，这个称为“母”。所以叫做双亲委派

  如果都加载不到，才会考虑从应用类加载器中加载。直到加载到为止。

  比如：自己写了一个java.lang.String这样一个类，然后但是里面的代码不一样，然后如果没有启动类加载器，就加载我们这个类，假如这个类中有一些后门的黑手的话，那程序就很危险