【Java基础】Java基础之反射

Money、坤

已于 2022-08-22 23:43:48 修改

阅读量444

点赞数 1

分类专栏： java基础文章标签： java jvm 开发语言

于 2022-08-09 19:06:42 首次发布

本文链接：https://blog.csdn.net/qq_57549633/article/details/126253585

版权

java基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1.什么是反射?

反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 Java 语言的反射机制。

2.反射机制的优缺点有哪些?

优点：能够运行时动态获取类的实例，提高灵活性；可与动态编译结合Class.forName(‘com.mysql.jdbc.Driver.class’)加载MySQL的驱动类。
缺点：使用反射性能较低，需要解析字节码，将内存中的对象进行解析。
其解决方案是：
（1）通过setAccessible(true)关闭JDK的安全检查来提升反射速度；
（2）多次创建一个类的实例时，有缓存会快很多；
（3）ReflflectASM工具类，通过字节码生成的方式加快反射速度。

3.如何获取反射中的Class对象?

Class.forName(“类的路径”)：当你知道该类的全路径名时，你可以使用该方法获取 Class 类对象

Class clz = Class.forName("java.lang.String");

2.类名.class。这种方法只适合在编译前就知道操作的 Class

Class clz = String.class;

3.对象名.getClass()

String str = new String("Hello");
Class clz = str.getClass();

如果是基本类型的包装类，可以调用包装类的Type属性来获得该包装类的Class对象。

代码演示：

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Apple {

        private int price;


    	public int getPrice() {
            return price;
        }

        public void setPrice(int price) {
            this.price = price;
        }

        public static void main(String[] args) throws Exception{
            //正常的调用
            Apple apple = new Apple();
            apple.setPrice(5);
            System.out.println("Apple Price:" + apple.getPrice());

           //反射对象的获取
//         1. Class.forName(“类的路径”)；当你知道该类的全路径名时，你可以使用该方法获取 Class 类对象
            Class clz = Class.forName("JavaSE.反射.Apple");

//          2. 类名.class。这种方法只适合在编译前就知道操作的 Class。
            Class clz =Apple.class;
//          3. 对象名.getClass()。
            Apple apple1 =new Apple();
            Class  clz = apple1.getClass();
//          4.如果是基本类型的包装类，可以调用包装类的Type属性来获得该包装类的Class对象。
            Integer integer =new Integer(5);
             Class aClass = integer.getClass();
//	        获取方法
            Method setPriceMethod = clz.getMethod("setPrice", int.class);
//            获取构造器
            Constructor appleConstructor = clz.getConstructor();
            Object appleObj = appleConstructor.newInstance();
//           调用方法
            setPriceMethod.invoke(appleObj, 14);

            Method getPriceMethod = clz.getMethod("getPrice");
            System.out.println("Apple Price:" + getPriceMethod.invoke(appleObj));
        }
    }

4.反射使用的步骤?

获取想要操作的类的Class对象，这是反射的核心，通过Class对象我们可以任意调用类的方法。
调用 Class 类中的方法，既就是反射的使用阶段。
使用反射 API 来操作这些信息。
具体可以看下面的例子：

public class Apple {

    private int price;

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public static void main(String[] args) throws Exception{
        //正常的调用
        Apple apple = new Apple();
        apple.setPrice(5);
        System.out.println("Apple Price:" + apple.getPrice());
        //使用反射调用
        Class clz = Class.forName("com.chenshuyi.api.Apple");
        Method setPriceMethod = clz.getMethod("setPrice", int.class);
        Constructor appleConstructor = clz.getConstructor();
        Object appleObj = appleConstructor.newInstance();
        setPriceMethod.invoke(appleObj, 14);
        Method getPriceMethod = clz.getMethod("getPrice");
        System.out.println("Apple Price:" + getPriceMethod.invoke(appleObj));
    }
}

从代码中可以看到我们使用反射调用了 setPrice 方法，并传递了 14 的值。之后使用反射调用了 getPrice 方法，输出其价格。上面的代码整个的输出结果是：

Apple Price:5
Apple Price:14

从这个简单的例子可以看出，一般情况下我们使用反射获取一个对象的步骤：

获取类的 Class 对象实例

Class clz = Class.forName("com.zhenai.api.Apple");

根据 Class 对象实例获取 Constructor 对象

Constructor appleConstructor = clz.getConstructor();

使用 Constructor 对象的 newInstance 方法获取反射类对象

Object appleObj = appleConstructor.newInstance();

而如果要调用某一个方法，则需要经过下面的步骤：

获取方法的 Method 对象

Method setPriceMethod = clz.getMethod("setPrice", int.class);

利用 invoke 方法调用方法

setPriceMethod.invoke(appleObj, 14);

5.为什么引入反射概念？反射机制的应用有哪些?

从 Oracle 官方文档中可以看出，反射主要应用在以下几方面：

反射让开发人员可以通过外部类的全路径名创建对象，并使用这些类，实现一些扩展的功能。
反射让开发人员可以枚举出类的全部成员，包括构造函数、属性、方法。以帮助开发者写出正确的代码。
测试时可以利用反射 API 访问类的私有成员，以保证测试代码覆盖率。

也就是说，Oracle 希望开发者将反射作为一个工具，用来帮助程序员实现本不可能实现的功能。

举两个最常见使用反射的例子，来说明反射机制的强大之处：

第一种：JDBC 的数据库的连接
在JDBC 的操作中，如果要想进行数据库的连接，则必须按照以上的几步完成：

1.通过Class.forName()加载数据库的驱动程序（通过反射加载，前提是引入相关了Jar包）；
2.通过 DriverManager 类进行数据库的连接，连接的时候要输入数据库的连接地址、用户名、密码；
3.通过Connection 接口接收连接。

public class ConnectionJDBC {  
  
    /** 
     * @param args 
     */  
    //驱动程序就是之前在classpath中配置的JDBC的驱动程序的JAR 包中  
    public static final String DBDRIVER = "com.mysql.jdbc.Driver";  
    //连接地址是由各个数据库生产商单独提供的，所以需要单独记住  
    public static final String URL = "jdbc:mysql://localhost:3306/test";  
    //连接数据库的用户名  
    public static final String USER = "root";  
    //连接数据库的密码  
    public static final String PASSWORD = "1234";  
      
      
    public static void main(String[] args) throws Exception {  
        Connection con = null; 		//表示数据库的连接对象  
        Class.forName(DBDRIVER);	//1、使用CLASS 类加载驱动程序 ,反射机制的体现 
        con = DriverManager.getConnection(URL,USER,PASSWORD); 	//2、连接数据库  
        System.out.println(con);  
        con.close();			   // 3、关闭数据库  
    }

第二种：Spring 框架的使用，最经典的就是xml的配置模式。

Spring 通过 XML 配置模式装载 Bean 的过程：
1.将程序内所有 XML 或 Properties 配置文件加载入内存中；
2.Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息；
3.使用反射机制，根据这个字符串获得某个类的Class实例；
4.动态配置实例的属性。

Spring这样做的好处是：
1.不用每一次都要在代码里面去new或者做其他的事情；
2.以后要改的话直接改配置文件，代码维护起来就很方便了；
3.有时为了适应某些需求，Java类里面不一定能直接调用另外的方法，可以通过反射机制来实现。

6.反射机制的原理是什么?

Class actionClass=Class.forName(“MyClass”);
Object action=actionClass.newInstance();
Method method = actionClass.getMethod(“myMethod”,null);
method.invoke(action,null);

上面就是最常见的反射使用的例子，前两行实现了类的装载、链接和初始化（newInstance方法实际上也是使用反射调用了方法），后两行实现了从class对象中获取到method对象然后执行反射调用。
反射的原理较为复杂，下面简述一下流程：

1.反射获取类实例 Class.forName()，并没有将实现留给了java,而是交给了jvm去加载！主要是先获取 ClassLoader,然后调用 native 方法，获取信息，加载类则是回调 java.lang.ClassLoader。最后，jvm又会回调ClassLoader 进类加载！
2.newInstance() 主要做了三件事：

1.权限检测，如果不通过直接抛出异常；
2.查找无参构造器，并将其缓存起来；
3.调用具体方法的无参构造方法，生成实例并返回。

3.获取Method对象

上面的Class对象是在加载类时由JVM构造的，JVM为每个类管理一个独一无二的Class对象，这份Class对象里维护着该类的所有Method，Field，Constructor的cache，这份cache也可以被称作根对象。

每次getMethod获取到的Method对象都持有对根对象的引用，因为一些重量级的Method的成员变量（主要是MethodAccessor），我们不希望每次创建Method对象都要重新初始化，于是所有代表同一个方法的Method对象都共享着根对象的MethodAccessor，每一次创建都会调用根对象的copy方法复制一份：

Method copy() { 

       	Method res = new Method(clazz, name, parameterTypes, returnType,

                                exceptionTypes, modifiers, slot, signature,

                                annotations, parameterAnnotations, annotationDefault);

        res.root = this;

        res.methodAccessor = methodAccessor;

        return res;

    }

4.调用invoke()方法。调用invoke方法的流程如下：

调用Method.invoke之后，会直接去调MethodAccessor.invoke。MethodAccessor就是上面提到的所有同名method共享的一个实例，由ReflectionFactory创建。

创建机制采用了一种名为inflation的方式（JDK1.4之后）：如果该方法的累计调用次数<=15，会创建出NativeMethodAccessorImpl，它的实现就是直接调用native方法实现反射；如果该方法的累计调用次数>15，会由java代码创建出字节码组装而成的MethodAccessorImpl。以调用MyClass.myMethod(String s)为例，生成出的MethodAccessorImpl字节码翻译成Java代码大致如下：

public class GeneratedMethodAccessor1 extends MethodAccessorImpl {    
    public Object invoke(Object obj, Object[] args)  throws Exception {
        try {
            MyClass target = (MyClass) obj;
            String arg0 = (String) args[0];
            target.myMethod(arg0);
        } catch (Throwable t) {
            throw new InvocationTargetException(t);
        }
    }
}