Java 反射

Java 反射

标签 : Java基础


动态语言

动态语言,是指程序在运行时可以改变其结构:新的函数可以被引进,已有的函数可以被删除等在结构上的变化。比如众所周知的ECMAScript(JavaScript)便是一个动态语言。除此之外如Ruby、Python等也都属于动态语言,而C、C++等语言则不属于动态语言。(引自: 百度百科)

var execString = "alert(Math.floor(Math.random()*10));";
eval(execString);

Class反射机制

  • 指的是可以于运行时加载,探知和使用编译期间完全未知的类.
  • 程序在运行状态中, 可以动态加载一个只有名称的类, 对于任意一个已经加载的类,都能够知道这个类的所有属性和方法; 对于任意一个对象,都能调用他的任意一个方法和属性;
  • 加载完类之后, 在堆内存中会产生一个Class类型的对象(一个类只有一个Class对象), 这个对象包含了完整的类的结构信息,而且这个Class对象就像一面镜子,透过这个镜子看到类的结构,所以被称之为:反射.

Instances of the class Class represent classes and interfaces in a running Java application. An enum is a kind of class and an annotation is a kind of interface. Every array also belongs to a class that is reflected as a Class object that is shared by all arrays with the same element type and number of dimensions(维度). The primitive Java types (boolean, byte, char, short, int, long, float, and double), and the keyword void are also represented as Class objects.

  • 每个类被加载进入内存之后,系统就会为该类生成一个对应的java.lang.Class对象,通过该Class对象就可以访问到JVM中的这个类.


Class对象的获取

  • 对象的getClass()方法;
  • 类的.class(最安全/性能最好)属性;
  • 运用Class.forName(String className)动态加载类,className需要是类的全限定名(最常用).


从Class中获取信息

Class类提供了大量的实例方法来获取该Class对象所对应的详细信息,Class类大致包含如下方法,其中每个方法都包含多个重载版本,因此我们只是做简单的介绍,详细请参考JDK文档

  • 获取类内信息
获取内容方法签名
构造器Constructor<T> getConstructor(Class<?>... parameterTypes)
包含的方法Method getMethod(String name, Class<?>... parameterTypes)
包含的属性Field getField(String name)
包含的Annotation<A extends Annotation> A getAnnotation(Class<A> annotationClass)
内部类Class<?>[] getDeclaredClasses()
外部类Class<?> getDeclaringClass()
所实现的接口Class<?>[] getInterfaces()
修饰符int getModifiers()
所在包Package getPackage()
类名String getName()
简称String getSimpleName()
  • 一些判断类本身信息的方法
判断内容方法签名
注解类型?boolean isAnnotation()
使用了该Annotation修饰?boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)
匿名类?boolean isAnonymousClass()
数组?boolean isArray()
枚举?boolean isEnum()
原始类型?boolean isPrimitive()
接口?boolean isInterface()
obj是否是该Class的实例boolean isInstance(Object obj)
  • 使用反射生成并操作对象:

    Method Constructor Field这些类都实现了java.lang.reflect.Member接口,程序可以通过Method对象来执行相应的方法,通过Constructor对象来调用对应的构造器创建实例,通过Filed对象直接访问和修改对象的成员变量值.


创建对象

通过反射来生成对象的方式有两种:
  • 使用Class对象的newInstance()方法来创建该Class对象对应类的实例(这种方式要求该Class对象的对应类有默认构造器).
  • 先使用Class对象获取指定的Constructor对象, 再调用Constructor对象的newInstance()方法来创建该Class对象对应类的实例(通过这种方式可以选择指定的构造器来创建实例).

通过第一种方式来创建对象比较常见, 像Spring这种框架都需要根据配置文件(如applicationContext.xml)信息来创建Java对象,从配置文件中读取的只是某个类的全限定名字符串,程序需要根据该字符串来创建对应的实例,就必须使用默认的构造器来反射对象.
下面我们就模拟Spring实现一个简单的对象池, 该对象池会根据文件读取key-value对, 然后创建这些对象, 并放入Map中.

  • 配置文件
{
  "objects": [
    {
      "id": "id1",
      "class": "com.fq.domain.User"
    },
    {
      "id": "id2",
      "class": "com.fq.domain.Bean"
    }
  ]
}
  • ObjectPool
/**
 * Created by jifang on 15/12/31.
 */
public class ObjectPool {

    private Map<String, Object> pool;

    private ObjectPool(Map<String, Object> pool) {
        this.pool = pool;
    }

    private static Object getInstance(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        return Class.forName(className).newInstance();
    }

    private static JSONArray getObjects(String config) throws IOException {
        Reader reader = new InputStreamReader(ClassLoader.getSystemResourceAsStream(config));
        return JSONObject.parseObject(CharStreams.toString(reader)).getJSONArray("objects");
    }

    // 根据指定的JSON配置文件来初始化对象池
    public static ObjectPool init(String config) {
        try {
            JSONArray objects = getObjects(config);
            ObjectPool pool = new ObjectPool(new HashMap<String, Object>());
            if (objects != null && objects.size() != 0) {
                for (int i = 0; i < objects.size(); ++i) {
                    JSONObject object = objects.getJSONObject(i);
                    if (object == null || object.size() == 0) {
                        continue;
                    }
                    String id = object.getString("id");
                    String className = object.getString("class");

                    pool.putObject(id, getInstance(className));
                }
            }
            return pool;
        } catch (IOException | ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    public Object getObject(String id) {
        return pool.get(id);
    }

    public void putObject(String id, Object object) {
        pool.put(id, object);
    }

    public void clear() {
        pool.clear();
    }
}
  • Client
public class Client {

    @Test
    public void client() {
        ObjectPool pool = ObjectPool.init("config.json");
        User user = (User) pool.getObject("id1");
        System.out.println(user);

        Bean bean = (Bean) pool.getObject("id2");
        System.out.println(bean);
    }
}
  • User
public class User {

    private int id;
    private String name;
    private String password;

    public int getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
  • Bean
public class Bean {
    private Boolean usefull;
    private BigDecimal rate;
    private String name;

    public Boolean getUsefull() {
        return usefull;
    }

    public void setUsefull(Boolean usefull) {
        this.usefull = usefull;
    }

    public BigDecimal getRate() {
        return rate;
    }

    public void setRate(BigDecimal rate) {
        this.rate = rate;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Bean{" +
                "usefull=" + usefull +
                ", rate=" + rate +
                ", name='" + name + '\'' +
                '}';
    }
}

注意: 需要在pom.xml中添加如下依赖:

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.7</version>
</dependency>

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>18.0</version>
</dependency>

调用方法

当获取到某个类对应的Class对象之后, 就可以通过该Class对象的getMethod来获取一个Method数组或Method对象.每个Method对象对应一个方法,在获得Method对象之后,就可以通过调用invoke方法来调用该Method对象对应的方法.

@CallerSensitive
public Object invoke(Object obj, Object... args)
    throws IllegalAccessException, IllegalArgumentException,
       InvocationTargetException
{
    ...
}

下面我们对上面的对象池加强:可以看到Client获取到的对象的成员变量全都是默认值,既然我们已经使用了JSON这么优秀的工具,我们又学习了动态调用对象的方法,那么我们就通过配置文件来给对象设置值(在对象创建时), 新的配置文件形式如下:

{
  "objects": [
    {
      "id": "id1",
      "class": "com.fq.domain.User",
      "fields": [
        {
          "name": "id",
          "value": 101
        },
        {
          "name": "name",
          "value": "feiqing"
        },
        {
          "name": "password",
          "value": "ICy5YqxZB1uWSwcVLSNLcA=="
        }
      ]
    },
    {
      "id": "id2",
      "class": "com.fq.domain.Bean",
      "fields": [
        {
          "name": "usefull",
          "value": true
        },
        {
          "name": "rate",
          "value": 3.14
        },
        {
          "name": "name",
          "value": "bean-name"
        }
      ]
    },
    {
      "id": "id3",
      "class": "com.fq.domain.ComplexBean",
      "fields": [
        {
          "name": "name",
          "value": "complex-bean-name"
        },
        {
          "name": "refBean",
          "ref": "id2"
        }
      ]
    }
  ]
}

其中fields代表该Bean所包含的属性, name为属性名称, value为属性值(属性类型为JSON支持的类型), ref代表引用一个对象(也就是属性类型为Object,但是一定要引用一个已经存在了的对象)

/**
 * @author jifang
 * @since 15/12/31下午4:00
 */
public class ObjectPool {

    private Map<String, Object> pool;

    private ObjectPool(Map<String, Object> pool) {
        this.pool = pool;
    }

    private static JSONArray getObjects(String config) throws IOException {
        Reader reader = new InputStreamReader(ClassLoader.getSystemResourceAsStream(config));
        return JSONObject.parseObject(CharStreams.toString(reader)).getJSONArray("objects");
    }

    private static Object getInstance(String className, JSONArray fields)
            throws ClassNotFoundException, NoSuchMethodException,
            IllegalAccessException, InstantiationException, InvocationTargetException {

        // 配置的Class
        Class<?> clazz = Class.forName(className);
        // 目标Class的实例对象
        Object targetObject = clazz.newInstance();
        if (fields != null && fields.size() != 0) {
            for (int i = 0; i < fields.size(); ++i) {
                JSONObject field = fields.getJSONObject(i);
                // 需要设置的成员变量名
                String fieldName = field.getString("name");

                // 需要设置的成员变量的值
                Object fieldValue;
                if (field.containsKey("value")) {
                    fieldValue = field.get("value");
                } else if (field.containsKey("ref")) {
                    String refBeanId = field.getString("ref");
                    fieldValue = OBJECTPOOL.getObject(refBeanId);
                } else {
                    throw new RuntimeException("neither value nor ref");
                }

                String setterName = "set" +
                        fieldName.substring(0, 1).toUpperCase() +
                        fieldName.substring(1);
                // 需要设置的成员变量的setter方法
                Method setterMethod = clazz.getMethod(setterName, fieldValue.getClass());
                // 调用setter方法将值设置进去
                setterMethod.invoke(targetObject, fieldValue);
            }
        }

        return targetObject;
    }

    private static ObjectPool OBJECTPOOL;

    // 创建一个对象池的实例(保证是多线程安全的)
    private static void initSingletonPool() {
        if (OBJECTPOOL == null) {
            synchronized (ObjectPool.class) {
                if (OBJECTPOOL == null) {
                    OBJECTPOOL = new ObjectPool(new ConcurrentHashMap<String, Object>());
                }
            }
        }
    }

    // 根据指定的JSON配置文件来初始化对象池
    public static ObjectPool init(String config) {
        // 初始化pool
        initSingletonPool();

        try {
            JSONArray objects = getObjects(config);
            for (int i = 0; objects != null && i < objects.size(); ++i) {
                JSONObject object = objects.getJSONObject(i);
                if (object == null || object.size() == 0) {
                    continue;
                }
                String id = object.getString("id");
                String className = object.getString("class");

                // 初始化bean并放入池中
                OBJECTPOOL.putObject(id, getInstance(className, object.getJSONArray("fields")));
            }
            return OBJECTPOOL;
        } catch (IOException | ClassNotFoundException |
                InstantiationException | IllegalAccessException |
                NoSuchMethodException | InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }

    public Object getObject(String id) {
        return pool.get(id);
    }

    public void putObject(String id, Object object) {
        pool.put(id, object);
    }

    public void clear() {
        pool.clear();
    }
}
  • Client
public class Client {

    @Test
    public void client() {
        ObjectPool pool = ObjectPool.init("config.json");
        User user = (User) pool.getObject("id1");
        System.out.println(user);

        Bean bean = (Bean) pool.getObject("id2");
        System.out.println(bean);

        ComplexBean complexBean = (ComplexBean) pool.getObject("id3");
        System.out.println(complexBean);
    }
}
  • ComplexBean
public class ComplexBean {

    private String name;

    private Bean refBean;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Bean getRefBean() {
        return refBean;
    }

    public void setRefBean(Bean refBean) {
        this.refBean = refBean;
    }

    @Override
    public String toString() {
        return "ComplexBean{" +
                "name='" + name + '\'' +
                ", refBean=" + refBean +
                '}';
    }
}

Spring框架就是通过这种方式将成员变量值以及依赖对象等都放在配置文件中进行管理的,从而实现了较好地解耦(不过Spring是通过XML作为配置文件).


访问成员变量

通过Class对象的的getField()方法可以获取该类所包含的全部或指定的成员变量Field,Filed提供了如下两组方法来读取和设置成员变量值.

  • getXxx(Object obj): 获取obj对象的该成员变量的值, 此处的Xxx对应8中基本类型,如果该成员变量的类型是引用类型, 则取消get后面的Xxx;
  • setXxx(Object obj, Xxx val): 将obj对象的该成员变量值设置成val值.此处的Xxx对应8种基本类型, 如果该成员类型是引用类型, 则取消set后面的Xxx;

注: getDeclaredXxx方法可以获取所有的成员变量,无论private/public;

/**
 * @author jifang
 * @since 16/1/2下午1:00.
 */
public class Client {

    @Test
    public void client() throws NoSuchFieldException, IllegalAccessException {
        User user = new User();
        Field idFiled = User.class.getDeclaredField("id");
        setAccessible(idFiled);
        idFiled.setInt(user, 46);

        Field nameFiled = User.class.getDeclaredField("name");
        setAccessible(nameFiled);
        nameFiled.set(user, "feiqing");

        Field passwordField = User.class.getDeclaredField("password");
        setAccessible(passwordField);
        passwordField.set(user, "ICy5YqxZB1uWSwcVLSNLcA==");

        System.out.println(user);
    }

    private void setAccessible(AccessibleObject object) {
        object.setAccessible(true);
    }
}

使用反射获取泛型信息

为了通过反射操作泛型以迎合实际开发的需要, Java新增了java.lang.reflect.ParameterizedType java.lang.reflect.GenericArrayType java.lang.reflect.TypeVariable java.lang.reflect.WildcardType几种类型来代表不能归一到Class类型但是又和原始类型同样重要的类型.

类型含义
ParameterizedType一种参数化类型, 比如Collection<String>
GenericArrayType一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable各种类型变量的公共接口
WildcardType一种通配符类型表达式, 如? ? extends Number ? super Integer

其中, 我们可以使用ParameterizedType来获取泛型信息.

public class Client {

    private Map<String, Object> objectMap;

    public void test(Map<String, User> map, String string) {
    }

    public Map<User, Bean> test() {
        return null;
    }

    /**
     * 测试属性类型
     *
     * @throws NoSuchFieldException
     */
    @Test
    public void testFieldType() throws NoSuchFieldException {
        Field field = Client.class.getDeclaredField("objectMap");
        Type gType = field.getGenericType();
        // 打印type与generic type的区别
        System.out.println(field.getType());
        System.out.println(gType);
        System.out.println("**************");
        if (gType instanceof ParameterizedType) {
            ParameterizedType pType = (ParameterizedType) gType;
            Type[] types = pType.getActualTypeArguments();
            for (Type type : types) {
                System.out.println(type.toString());
            }
        }
    }

    /**
     * 测试参数类型
     *
     * @throws NoSuchMethodException
     */
    @Test
    public void testParamType() throws NoSuchMethodException {
        Method testMethod = Client.class.getMethod("test", Map.class, String.class);
        Type[] parameterTypes = testMethod.getGenericParameterTypes();
        for (Type type : parameterTypes) {
            System.out.println("type -> " + type);
            if (type instanceof ParameterizedType) {
                Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments();
                for (Type actualType : actualTypes) {
                    System.out.println("\tactual type -> " + actualType);
                }
            }
        }
    }

    /**
     * 测试返回值类型
     *
     * @throws NoSuchMethodException
     */
    @Test
    public void testReturnType() throws NoSuchMethodException {
        Method testMethod = Client.class.getMethod("test");
        Type returnType = testMethod.getGenericReturnType();
        System.out.println("return type -> " + returnType);

        if (returnType instanceof ParameterizedType) {
            Type[] actualTypes = ((ParameterizedType) returnType).getActualTypeArguments();
            for (Type actualType : actualTypes) {
                System.out.println("\tactual type -> " + actualType);
            }
        }
    }
}

使用反射获取注解

使用反射获取注解信息的相关介绍, 请参看我的博客Java注解实践


反射性能测试

Method/Constructor/Field/Element都继承了AccessibleObject,AccessibleObject类中有一个setAccessible方法:

public void setAccessible(boolean flag) throws SecurityException {
    ...
}

该方法有两个作用:
1. 启用/禁用访问安全检查开关:值为true,则指示反射的对象在使用时取消Java语言访问检查;值为false,则指示应该实施Java语言的访问检查;
2. 可以禁止安全检查, 提高反射的运行效率.

/**
 * @author jifang
 * @since 15/12/31下午4:53.
 */
public class TestReflect {

    @Before
    public void testNoneReflect() {
        User user = new User();

        long start = System.currentTimeMillis();
        for (long i = 0; i < Integer.MAX_VALUE; ++i) {
            user.getName();
        }
        long count = System.currentTimeMillis() - start;
        System.out.println("没有反射, 共消耗 <" + count + "> 毫秒");
    }

    @Test
    public void testNotAccess() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        User user = new User();
        Method method = Class.forName("com.fq.domain.User").getMethod("getName");

        long start = System.currentTimeMillis();
        for (long i = 0; i < Integer.MAX_VALUE; ++i) {
            method.invoke(user, null);
        }
        long count = System.currentTimeMillis() - start;
        System.out.println("没有访问权限, 共消耗 <" + count + "> 毫秒");
    }

    @After
    public void testUseAccess() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        User user = new User();
        Method method = Class.forName("com.fq.domain.User").getMethod("getName");
        method.setAccessible(true);

        long start = System.currentTimeMillis();
        for (long i = 0; i < Integer.MAX_VALUE; ++i) {
            method.invoke(user, null);
        }
        long count = System.currentTimeMillis() - start;
        System.out.println("有访问权限, 共消耗 <" + count + "> 毫秒");
    }
}

执行上面程序,在我的机器上可以看到使用反射会比直接调用慢3000毫秒,但是前提是该方法会执行20E+次(而且服务器的性能也肯定比我的机器要高),因此在我们的实际开发中,其实是不用担心反射机制带来的性能消耗的,而且禁用访问权限检查,也会有性能的提升.

附-机器配置信息


扩展阅读:
为什么动态类型编程语言会如此流行?
动态语言和静态语言的比较
反射是否真的会让你的程序性能降低?
<think>好的,用户想了解Java反射,我得好好整理一下相关知识。首先,反射Java的高级特性,允许程序在运行时检查或修改行为。得从基本概念讲起,比如Class对象,这是反射的核心。然后要解释如何获取Class实例,三种方式:.class、getClass()、Class.forName()。 接下来是具体应用场景,比如动态加载类、获取方法、构造实例、访问字段等。需要举例说明,比如Class.forName("java.util.ArrayList"),还有getMethod()和invoke()的使用。可能用户对实际应用比较感兴趣,所以得举一些实际的例子,比如框架中使用反射的例子,比如Spring的依赖注入。 还要提到反射的优缺点,性能问题,安全性限制,以及如何绕过访问检查,比如setAccessible(true)。这里需要注意说明使用反射可能带来的问题,比如破坏封装性,安全风险等,让用户有全面的认识。 结构方面,按照用户的要求,分步骤解释,先定义,再核心类,然后使用步骤,接着应用场景,最后优缺点。确保每个部分都有清晰的标题,使用中文,行内公式用$符号,比如加载类时的Class.forName("ClassName")可能需要用代码块表示,但用户要求的是数学表达式,可能这里不需要。不过要注意LaTeX的正确使用,如果有数学相关的内容,比如泛型中的类型参数,可能需要用$T$来表示,但Java反射中可能不涉及太多数学公式,所以可能主要用代码示例。 需要检查是否符合系统级指令,特别是格式要求。行内数学表达式用$...$,独立公式用$$...$$,但Java反射内容可能较少涉及数学表达式,所以可能主要用代码块或者文字描述。不过如果有涉及的地方,比如方法参数类型,可能需要用代码格式而不是LaTeX,这点需要注意。用户可能希望看到具体的Java代码示例,但根据系统指令,可能需要避免使用代码块,而是用文字描述,或者用引号括起来? 不过用户给的例子中有类似$(a+b)^2$这样的公式,所以如果回答中有类似需要表达数学内容的地方,要用LaTeX。但Java反射主要涉及类、方法、字段等,可能不需要太多数学公式。所以可能主要用文字描述,结构清晰,分点列出。 可能用户是Java初学者,或者想深入了解反射机制,应用在框架或动态代理中。所以需要由浅入深,先讲是什么,再讲怎么用,最后讲注意事项。确保步骤清晰,帮助用户逐步理解。同时要提醒反射的适用场景和潜在问题,避免滥用。 总结一下,回答的结构应该是: 1. 反射的定义和作用 2. 核心类:Class, Field, Method, Constructor 3. 使用步骤:获取Class对象、创建实例、访问字段、调用方法 4. 应用场景:动态代理、框架、IDE等 5. 优缺点:灵活性 vs 性能和安全 需要确保每个部分都有例子,比如获取Class对象的三种方式,调用私有方法的过程,以及如何修改私有字段。同时要提到反射在常见框架中的应用,比如Spring和Hibernate,让用户明白其实际价值。 最后检查是否符合所有系统指令,特别是LaTeX的使用,但可能在这题中用得不多。如果有代码示例,可能需要用代码块,但根据用户的系统指令,可能要求使用$...$,但代码部分可能更适合用文字描述。或者用户允许代码块?需要看系统指令,用户可见层第一条要求结构清晰,帮助解决问题,所以可能需要适当使用代码示例,但根据系统级指令,可能要用行内代码用$...$,但不太确定。可能用户希望用更自然的中文描述,而代码部分用引号或斜体,但最好确认。 根据用户给的例子,比如用户提到$( \int_{-\pi}^{\pi} \cos(nx)\sin(mx)dx = 0 $,这说明数学公式需要用LaTeX,但代码示例可能不需要,所以可能分开处理。Java反射中的类名和方法名可以用引号括起来,如`Class.forName("java.lang.String")`,但根据系统指令,是否要处理成LaTeX?可能不需要,直接使用反引号或普通文字。不过用户没有明确说明代码的格式,所以可能按照常规方式处理,用文字描述,避免使用代码块,而用行内说明。 总之,整理好结构,分点说明,确保涵盖核心概念、使用方法和注意事项,让用户能够全面理解Java反射的机制和应用。</think>以下是对Java反射的逐步解释: # Java反射机制详解 ## 一、基本定义 Java反射(Reflection)是$JVM$在运行时动态**检查/修改**类信息和对象行为的机制。通过`java.lang.reflect`包中的类实现,允许程序: 1. 获取任意类的$Class$对象 2. 分析类的字段/方法/构造器 3. 动态创建对象实例 4. 调用方法或修改字段值 ## 二、核心组件 | 类名 | 功能描述 | |--------------------|---------------------------------| | `Class` | 表示正在运行的Java类或接口 | | `Field` | 提供类/接口的字段信息及访问权限 | | `Method` | 提供类/接口的方法信息及调用能力 | | `Constructor` | 提供类的构造器信息及实例化能力 | | `Array` | 动态创建和访问数组的静态方法 | ## 三、使用步骤 ### 步骤1:获取Class对象 ```java // 方式1:通过类字面常量 Class<?> strClass = String.class; // 方式2:通过对象实例 String s = "test"; Class<?> cls1 = s.getClass(); // 方式3:动态加载类 Class<?> arrayListClass = Class.forName("java.util.ArrayList"); ``` ### 步骤2:实例化对象 ```java Constructor<?> constructor = strClass.getConstructor(String.class); Object strInstance = constructor.newInstance("Hello Reflection"); ``` ### 步骤3:访问字段 ```java Field[] fields = cls.getDeclaredFields(); Field nameField = cls.getDeclaredField("name"); nameField.setAccessible(true); // 突破私有访问限制 nameField.set(obj, "newValue"); ``` ### 步骤4:调用方法 ```java Method method = cls.getMethod("methodName", String.class, int.class); Object result = method.invoke(obj, "param1", 123); ``` ## 四、典型应用场景 1. **动态代理**:`Proxy.newProxyInstance()`创建接口代理 $$动态代理类 = 原始类功能 + 增强逻辑$$ 2. **框架开发**: - Spring的依赖注入(通过反射创建Bean) - Hibernate的实体映射(解析注解配置) 3. **IDE功能**: - 代码自动补全 - 调试器的变量查看 4. **序列化工具**:Jackson/GSON通过反射获取字段信息 ## 五、优缺点分析 ✓ **优势**: - 实现高度灵活的代码(如插件系统) - 支持运行时类型检查 - 突破封装访问私有成员 ✗ **缺陷**: - 性能开销(比直接调用慢$10^{1}$~$10^{2}$倍) - 破坏封装性导致安全隐患 - 绕过泛型类型检查(可能引发`ClassCastException`) ## 六、性能优化建议 1. 缓存重复使用的$Class/Method$对象 2. 优先使用`setAccessible(true)`代替重复访问检查 3. 对高频调用使用`MethodHandle`(Java 7+) > **重要限制**:在模块化系统(Java 9+)中,需要明确授予反射访问权限(`opens`指令) 此机制为Java带来动态特性,但需严格遵循**最小使用原则**,仅在必要时选择反射方案。
评论 8
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值