小蔡学Java

Java之反射小结

2023-05-05 16:18 855 0 Java基础 反射

什么是反射?

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

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

优点:能够运行时动态获取类的实例,提高灵活性;可与动态编译结合 Class.forName('com.mysql.jdbc.Driver.class'); ,加载MySQL的驱动类。

缺点:使用反射性能较低,需要解析字节码,将内存中的对象进行解析。其解决方案是:通过 setAccessible(true)关闭JDK的安全检查来提升反射速度;多次创建一个类的实例时,有缓存会快很多; ReflflectASM工具类,通过字节码生成的方式加快反射速度。

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

  1. Class.forName(“类的路径”);当你知道该类的全路径名时,你可以使用该方法获取 Class 类对象。
Class clz = Class.forName("java.lang.String");
  1. 类名.class。这种方法只适合在编译前就知道操作的 Class。
Class clz = String.class;
  1. 对象名.getClass()。
String str = new String("Hello");
Class clz = str.getClass();
  1. 如果是基本类型的包装类,可以调用包装类的Type属性来获得该包装类的Class对象。

Java反射API有几类?

  1. Class 类:反射的核心类,可以获取类的属性,方法等信息。
  2. Field 类:Java.lang.reflec 包中的类,表示类的成员变量,可以用来获取和设置类之中的属性值。
  3. Method 类:Java.lang.reflec 包中的类,表示类的方法,它可以用来获取类中的方法信息或者执行方法。
  4. Constructor 类:Java.lang.reflec 包中的类,表示类的构造方法。

反射使用的步骤?

  1. 获取想要操作的类的Class对象,这是反射的核心,通过Class对象我们可以任意调用类的方法。
  2. 调用 Class 类中的方法,既就是反射的使用阶段。
  3. 使用反射 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.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

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

  1. 获取类的 Class 对象实例
Class clz = Class.forName("com.zhenai.api.Apple");
  1. 根据 Class 对象实例获取 Constructor 对象
Constructor appleConstructor = clz.getConstructor();
  1. 使用 Constructor 对象的 newInstance 方法获取反射类对象
Object appleObj = appleConstructor.newInstance();

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

  • 获取方法的 Method 对象
Method setPriceMethod = clz.getMethod("setPrice", int.class);
  • 利用 invoke 方法调用方法
setPriceMethod.invoke(appleObj, 14);


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

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 DBURL = "jdbc:frowning://localhost:3306/test";
    
    // 连接数据库的用户名
    public static final String DBUSER = "root";
    
    // 连接数据库的密码
    public static final String DBPASS = "";

    public static void main(String[] args) throws Exception {
        Connection con = null; // 表示数据库的连接对象

        // 1、使用CLASS类加载驱动程序,反射机制的体现
        Class.forName(DBDRIVER);

        // 2、连接数据库
        con = DriverManager.getConnection(DBURL, DBUSER, DBPASS);
        System.out.println(con);
        
        // 3、关闭数据库
        con.close();
    }
}

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

Spring 通过 XML 配置模式装载 Bean 的过程:

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

Spring这样做的好处是:

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

模拟 Spring 加载 XML 配置文件:

public class BeanFactory {
    private Map<String, Object> beanMap = new HashMap<String, Object>();

    /**
     * bean工厂的初始化.
     * @param xml xml配置文件
     */
    public void init(String xml) {
        try {
            // 读取指定的配置文件
            SAXReader reader = new SAXReader();
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            // 从class目录下获取指定的xml文件
            InputStream ins = classLoader.getResourceAsStream(xml);
            Document doc = reader.read(ins);
            Element root = doc.getRootElement();
            Element foo;

            // 遍历bean
            for (Iterator i = root.elementIterator("bean"); i.hasNext();) {
                foo = (Element) i.next();
                // 获取bean的属性id和class
                Attribute id = foo.attribute("id");
                Attribute cls = foo.attribute("class");
                // 利用Java反射机制,通过class的名称获取Class对象
                Class bean = Class.forName(cls.getText());
                // 获取对应class的信息
                java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);
                // 获取其属性描述
                java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();
                // 设置值的方法
                Method mSet = null;
                // 创建一个对象
                Object obj = bean.newInstance();

                // 遍历该bean的property属性
                for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {
                    Element foo2 = (Element) ite.next();
                    // 获取该property的name属性
                    Attribute name = foo2.attribute("name");
                    String value = null;

                    // 获取该property的子元素value的值
                    for (Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {
                        Element node = (Element) ite1.next();
                        value = node.getText();
                        break;
                    }

                    for (int k = 0; k < pd.length; k++) {
                        if (pd[k].getName().equalsIgnoreCase(name.getText())) {
                            mSet = pd[k].getWriteMethod();
                            // 利用Java的反射机制调用对象的某个set方法,并将值设置进去
                            mSet.invoke(obj, value);
                        }
                    }
                }

                // 将对象放入beanMap中,其中key为id值,value为对象
                beanMap.put(id.getText(), obj);
            }
        } catch (Exception e) {
            System.out.println(e.toString());
        }
    }

    // other codes
}

反射机制的原理是什么?

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

上面就是最常见的反射使用的例子,前两行实现了类的装载、链接和初始化(newInstance方法实际上 也是使用反射调用了方法),后两行实现了从class对象中获取到method对象然后执行反射调用。 因反射原理较复杂,下面简要描述下流程,想要详细了解的小伙伴,可以看这篇文章:https://www.cnblogs.com/yougewe/p/10125073.html

  1. 反射获取类实例 Class.forName(),并没有将实现留给了java,而是交给了jvm去加载!主要是先获取 ClassLoader, 然后调用 native 方法,获取信息,加载类则是回调 java.lang.ClassLoader。最后,jvm又会回调 ClassLoader 进类加载!
  2. newInstance() 主要做了三件事:权限检测,如果不通过直接抛出异常;查找无参构造器,并将其缓存起来;调用具体方法的无参构造方法,生成实例并返回。
  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;
}
  1. 调用invoke()方法。调用invoke方法的流程如下:

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

创建机制采用了一种名为inflation的方式(JDK1.4之后):如果该方法的累计调用次数<=15,会创建出NativeMethodAccessorImpl,它的实现就是直接调用native方法实现反射;如果该方法的累计调用次数>15,会由java代码创建出字节码组装而成的MethodAccessorImpl。(是否采用inflation和15这个数字都可以在jvm参数中调整)以调用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);
        }
    }
}

参考链接:https://www.cnblogs.com/yougewe/p/10125073.html

评论( 0 )

  • 博主 Mr Cai
  • 坐标 河南 信阳
  • 标签 Java、SpringBoot、消息中间件、Web、Code爱好者

文章目录