亲宝软件园·资讯

展开

JavaSE反射机制

@每天都要敲代码 人气:0

一:反射机制概述

1、反射机制有什么用?

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

优点类似于黑客。(可以读和修改字节码文件。)

通过反射机制可以操作代码片段。(class文件。)   

2、反射机制的相关类在哪个包下?

java.lang.reflect.*;   

3、反射机制相关的重要的类有哪些?

java.lang.Class:代表整个字节码,代表一个类型,代表整个类。

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

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

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

   // java.lang.Class:(整个是一个class)
            public class User{
                // Field (成员变量)
                int no;
 
                // Constructor(构造方法)
                public User(){
                
                }
                public User(int no){
                    this.no = no;
                }
 
 
                // Method(方法)
                public void setNo(int no){
                    this.no = no;
                }
                public int getNo(){
                    return no;
                }
            }

二:反射Class

1. 获取Class的三种方式 

要操作一个类的字节码,需要首先获取到这个类的字节码,怎么获取java.lang.Class实例?

三种方式:

第一种:Class c = Class.forName("完整类名带包名");

1、静态方法

2、方法的参数是一个字符串。

3、字符串需要的是一个完整类名。

4、完整类名必须带有包名。java.lang包也不能省略。

第二种:Class c = 对象(引用).getClass();

第三种:Class c = 任何类型.class;

package com.bjpowernode.java.reflect;
 
import java.util.Date;
 
public class ReflectTest01 {
    public static void main(String[] args) {
 
        // 第一种方式:Class.forName()
        Class c1 = null;
        Class c2 = null;
        try {
            // c1代表String.class文件,或者说c1代表String类型。
            c1 = Class.forName("java.lang.String"); 
            // c2代表Date类型
            c2 = Class.forName("java.util.Date"); 
            // c3代表Integer类型
            Class c3 = Class.forName("java.lang.Integer"); 
            // c4代表System类型
            Class c4 = Class.forName("java.lang.System");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
 
        // 第二种方式:对象.getClass()
        // java中任何一个对象都有一个方法:getClass()
        String s = "abc";
        // x代表String.class字节码文件;x代表String类型
        Class x = s.getClass(); 
        // true(==判断的是对象的内存地址)
        System.out.println(x == c1); 
 
        Date time = new Date();
        Class y = time.getClass();
        // true (c2和y两个变量中保存的内存地址都是一样的,都指向方法区中的字节码文件)
        System.out.println(c2 == y); 
 
        // 第三种方式,java语言中任何一种类型,包括基本数据类型,它都有.class属性。
        // z代表String类型
        Class z = String.class;
        // k代表Date类型 
        Class k = Date.class; 
        // f代表int类型
        Class f = int.class; 
        // e代表double类型
        Class e = double.class; 
        System.out.println(c1 == x && x == z); // true
 
    }
 
}

2. 通过反射实例化(创建)对象

(1)获取到Class,通过Class的newInstance()方法来实例化(创建)对象。

(2)newInstance()方法内部实际上调用了无参数构造方法,必须保证无参构造存在才可以;所以一旦我们写上了有参构造方法,无参构造方法也要写上! 如果有有参构造方法,而没有写无参构造方法会出现异java.lang.InstantiationException 实例化异常

package com.bjpowernode.java.reflect;
 
import com.bjpowernode.java.bean.User;
 
public class ReflectTest02 {
    public static void main(String[] args) {
 
        // 第一种方法创建对象:不使用反射机制
        User user = new User();
        System.out.println(user);
 
        // 第二种方法创建对象:以反射机制的方式创建对象。(这种方式比较灵活)
        try {
            // 通过反射机制,获取Class,通过Class来实例化(创建)对象
            Class c = Class.forName("com.bjpowernode.java.bean.User");
            Object obj = c.newInstance();
           
            System.out.println(obj);
            /*
            执行结果:
                无参数构造方法
                com.bjpowernode.java.bean.User@4554617c
            */
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}
package com.bjpowernode.java.bean;
 
public class User {
    // 无参构造(不写也行,默认会有)
    public User() {
        System.out.println("无参数构造方法");
    }
 
    // 有参构造写了,无参构造必须写;不然调用newInstance()会出现异常
    public User(String s) {
        System.out.println("无参数构造方法");
    }
 
}

3. 通过读配置属性文件实例化对象

(1)通过读配置属性文件实例化对象,java代码写一遍,再不改变java源代码的基础之上,只改变配置文件,可以做到不同对象的实例化;非常之灵活。(符合OCP开闭原则:对扩展开放,对修改关闭)

(2)配置文件写好,命名为xxx.properties,然后使用IO流+Properties

(3)后期我们要学习的是高级框架,而工作过程中,也都是使用高级框架,

包括: ssh ssm

这些高级框架底层实现原理:都采用了反射机制。所以反射机制很重要的;学会了反射机制有利于我们理解剖析框架底层的源代码。

package com.bjpowernode.java.reflect;
 
import java.io.FileReader;
import java.util.Properties;
 
public class ReflectTest03 {
    public static void main(String[] args) throws Exception {
        // IO流+Properties集合
        // 通过IO流读classinfo.properties配置文件
        // 配置文件内容是:className=com.bjpowernode.java.bean.User
        FileReader reader = new FileReader("day08\\classinfo.properties");
        // 创建属性类对象Map,properties的key和value都是String
        Properties pro = new Properties();
        // 加载
        pro.load(reader);
        // reader关闭流
        reader.close();
        // 通过key获取value
        String s = pro.getProperty("className");
        //System.out.println(s); // com.bjpowernode.java.bean.User
 
        // 最后在通过反射机制实例化对象
        Class c = Class.forName(s);
        Object obj = c.newInstance();
        System.out.println(obj);
        /*
        执行结果:
            无参数构造方法
            com.bjpowernode.java.bean.User@4554617c
        */
 
        // 怎么体现灵活性?
        // 这里的代码我们都不改变,只改变classinfo.properties配置文件
        // 例如改成:className=java.util.Date
        // 此时执行的结果就变了:Wed Aug 03 15:40:02 CST 2022
 
    }
}

4. 只让静态代码块执行

Class.forName()执行发生了什么

(1)Class.forName("完整类名");这个方法的执行会导致类加载,类加载时,静态代码块执行。如果你只是希望一个类的静态代码块执行,其它代码一律不执行,使用Class.forName()

package com.bjpowernode.java.reflect;
 
public class ReflectTest04 {
    public static void main(String[] args) {
        try {
            // Class.forName()这个方法的执行会导致:类加载。
            // 类加载,静态代码块就会执行
            Class.forName("com.bjpowernode.java.reflect.MyClass");
            // 执行结果:MyClass类的静态代码块执行了!
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}
 
class MyClass{
    // 静态代码块在类加载时执行,并且只执行一次
    static{
        System.out.println("MyClass类的静态代码块执行了!");
    }
}

5. 获取类路径下文件的绝对路径

(1)怎么获取一个文件的绝对路径。以下讲解的这种方式是通用的。但前提是:文件需要在类路径(src)下才能用这种方式。

(2) 例如:

 String path = Thread.currentThread().getContextClassLoader()
               .getResource("User.properties").getPath();
package com.bjpowernode.java.reflect;
 
import java.io.FileReader;
 
// 研究一下文件路径的问题
public class AboutPath {
    public static void main(String[] args) throws Exception {
        // 我们写成下面这种路径形式,只能在IDEA工具中才能找到,不够通用!
        FileReader reader = new FileReader("day08\\classinfo.properties");
 
        // 通用的一种方式:
        // 注意:使用以下通用方式的前提是:这个文件必须在类路径下。
        // 什么类路径下?方式在src下的都是类路径下。【src是类的根路径】
 
        //Thread.currentThread() 当前线程对象
        //getContextClassLoader() 是线程对象的方法,可以获取到当前线程的类加载器对象。
        //getResource() 【获取资源】这是类加载器对象的方法,当前线程的类加载器默认从类的根路径下加载资源。
        // 写成下面这种形式,放到Linux环境下也是没问题的
        // 假设classinfo.properties刚好在src下
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo.properties").getPath();
        // 拿到绝对路径
        System.out.println(path); // C:/Users/86177/IdeaProjects/JavaSe1/out/production/day08/classinfo.properties
 
        // 假设有一个example文件没有直接在src下面,而是bean下面(com/bjpowernode/java/bean/example)
        String path2 = Thread.currentThread().getContextClassLoader()
                .getResource("com/bjpowernode/java/bean/example").getPath();
        // 获取绝对路径
        System.out.println(path2); // C:/Users/86177/IdeaProjects/JavaSe1/out/production/day08/com/bjpowernode/java/bean/example
    }
}

这样我们就可以修改原来的代码,得到更加通用的方式!

第一种:先通过相对路径(这里的相对路径前提:一定是在src下的才可以;在模块下的就不行)获取绝对路径,然后创建流:

// 1.得到相对路径
String path =Thread.currentThread().getContextClassLoader().getResource("相对路径").getPath(); 
// 2.创建流
 FileReader reader = new FileReader(path);

第二种方式:直接返回一个流(InputStream)

InputStream reader = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/bjpowernode/java/bean/example");

注意:这两种方式还是还是使用IO流+properties集合的方式,使用绝对路径而不是相对路径更加的通用:

第一种方式先得到绝对路径,返回String,然后在创建IO流

第二种方式直接返回的就是一个流InputStream

package com.bjpowernode.java.reflect;
 
import java.io.FileReader;
import java.io.InputStream;
import java.util.Properties;
 
public class ReflectTest05 {
    public static void main(String[] args) throws Exception {
         // 第一种方式:先拿到绝对路径,然后创建流
          //还是以example为例(className=java.util.Date),先拿到绝对路径
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("com/bjpowernode/java/bean/example").getPath();
        FileReader reader = new FileReader(path);
      
        // 第二种方式:直接返回一个流(InputStream)
        InputStream reader = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/bjpowernode/java/bean/example");
 
        // 创建Map集合对象
        Properties pro = new Properties();
        pro.load(reader);
        reader.close();
        // 通过key获取value
        String className = pro.getProperty("className");
 
        // 创建对象
        Class c = Class.forName(className);
        Object obj= c.newInstance();
        System.out.println(obj); // Wed Aug 03 17:00:36 CST 2022
 
    }
}

第三种方式:利用资源绑定器(常用)

(1)前两种方式都需要创建一个流,而是用资源绑定器就不需要了!

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

(3)使用这种方式的时候,属性配置文件xxx.properties必须放到类路径下。

资源绑定器,只能绑定xxx.properties文件。并且这个文件必须在类路径下。文件扩展名也必须是properties

(4)并且在写路径的时候,路径后面的扩展名.properties不能写。

ResourceBundle boudle = ResourceBundle.getBundle("classinfo");
String className = boudle.getString("className");
package com.bjpowernode.java.reflect;
 
import java.util.ResourceBundle;
 
public class ResourceBundleTest {
    public static void main(String[] args) throws Exception {
        // 例如:classinfo.properties(className=java.util.Date)
        ResourceBundle boudle = ResourceBundle.getBundle("classinfo");
        // 通过key获取value
        String className = boudle.getString("className");
        //System.out.println(className); // java.util.Date
        // 实例化对象
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        System.out.println(obj); // Wed Aug 03 19:31:20 CST 2022
 
    }
}

6. 扩展:类加载器概述

关于JDK中自带的类加载器:(不需要掌握)

(1)什么是类加载器?

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

(2)JDK中自带了3个类加载器

(3)假设有这样一段代码:String s = "abc"; 

代码在开始执行之前,会将所需要类全部加载到JVM当中。通过类加载器加载,看到以上代码类加载器会找String.class文件,找到就加载,那么是怎么进行加载的呢?

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

注意:启动类加载器专门加载:C:\Program Files\Java\jdk1.8.0_101\jre\lib\rt.jarrt.jar中都是JDK最核心的类库。

如果通过“启动类加载器”加载不到的时候,然后会通过"扩展类加载器"加载

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

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

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

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

优先从启动类加载器中加载,这个称为“父”,“父”无法加载到,再从扩展类加载器中加载,这个称为“母”。

双亲委派。如果都加载不到,才会考虑从应用类加载器中加载。直到加载到为止。

小总结

1、回顾反射机制

(1)什么是反射机制?反射机制有什么用?

反射机制:可以操作字节码文件

作用:可以让程序更加灵活

(2)反射机制相关的类在哪个包下?

java.lang.reflect.*;

(3)反射机制相关的主要的类?

java.lang.Class
java.lang.reflect.Method;
java.lang.reflect.Constructor;
java.lang.reflect.Field;

(4)在java中获取Class的三种方式?

第一种:     

Class c = Class.forName("完整类名");

第二种:

Class c = 对象.getClass();

第三种:

Class c = int.class;

(5)获取了Class之后,可以调用无参数构造方法来实例化对象      

//c代表的就是日期Date类型
Class c = Class.forName("java.util.Date");
//实例化一个Date日期类型的对象
Object obj = c.newInstance();

一定要注意:

newInstance()底层调用的是该类型的无参数构造方法。

如果没有这个无参数构造方法会出现"实例化"异常。

(6)如果你只想让一个类的“静态代码块”执行的话,你可以怎么做?

Class.forName("该类的类名");这样类就加载,类加载的时候,静态代码块执行!

(7)关于路径问题?    

String path = Thread.currentThread().getContextClassLoader()
    .getResource("写相对路径,但是这个相对路径从src出发开始找").getPath();    
 
String path = Thread.currentThread().getContextClassLoader()
    .getResource("abc").getPath();    //必须保证src下有abc文件。
 
String path = Thread.currentThread().getContextClassLoader()
    .getResource("a/db").getPath();    //必须保证src下有a目录,a目录下有db文件。

这种方式是为了获取一个文件的绝对路径。(通用方式,不会受到环境移植的影响)

但是该文件要求放在类路径下,换句话说:也就是放到src下面。src下是类的根路径。      

// 直接以流的形式返回:
InputStream in = Thread.currentThread().getContextClassLoader()
     .getResourceAsStream("com/bjpowernode/test.properties");

(8)IO流 + Properties集合,怎么快速绑定属性资源文件?

// 第一:第一这个文件必须在类路径(src)下
// 第二:这个文件必须是以.properties结尾,但是写的时候不能带上.properties。
ResourceBundle bundle = ResourceBundle.getBundle("com/bjpowernode/test");
String value = bundle.getString(key);

加载全部内容

相关教程
猜你喜欢
用户评论