不藏了，这些 Java 反射用法总结都告诉你们-低调大师

不藏了，这些 Java 反射用法总结都告诉你们

2021-07-08 464

摘要：Java 反射是一种非常强大的机制，它可以在同一个系统中去检测内部的类的字段、方法和构造函数。它非常多的 Java 框架中，都大量应用了反射技术，如 Hibernate 和 Spring。可以说，反射机制的特征让 Java 可以构建异常强大，具备柔性的系统。

本文分享自华为云社区《JAVA编程不可不知的反射用法总结丨【奔跑吧！JAVA】》，原文作者：jackwangcumt 。

Java 反射是一种非常强大的机制，它可以在同一个系统中去检测内部的类的字段、方法和构造函数。它非常多的 Java 框架中，都大量应用了反射技术，如 Hibernate 和 Spring。可以说，反射机制的特征让 Java 可以构建异常强大，具备柔性的系统。

虽然 Java 反射机制存在效率低、速度慢和安全性不高等弊端，但在很多场景下，这些特征并不是主要的因素，或者可以通过缓存或者 JVM 优化等来逐步提升执行效率。

根据网上的说法，反射技术能够检查或修改在 JVM 中应用程序在运行时的行为，这是一个比较高级的语言特性和一种强大的技术，反射可以使应用程序实现本来不可能的操作。

下面对 Java 反射的基础知识进行说明和总结：

首先定义一个 MyBase 类，其中有私有字段，也有公有字段。同时也有公有方法和私有方法。MyBase 类示例如下：

package com.hwdev.demo;
/**
 * 基类示例
 * @author wangming
 */
public class MyBase {
    //公有字段  
    public int version  = 1;
    //私有字段
    private String date = "2021-05-18" ;
    //公有方法   
    public void say2(String msg){
	System.out.println("Hello " + msg);
    }
    //私有方法
    private String getData(){
        return this.date;
    }
}

这里再定义一个 Hello 类，它继承自 MyBase 类，通过继承主要用于验证一下反射对于父类、子类的反射用法。

package com.hwdev.demo;
/**
 *
 * @author wangming
 */
public class Hello extends MyBase {
    
    public String author = "JackWang" ;
    public int version  = 1;
    private String company = "kzcloud" ;
    
    public void say(String msg){
	     System.out.println("Hello " + msg);
    }
    public void setAuthor(String author){
	    this.author = author;
    }
    public String getAuthor(){
        return this.author;
    }
    private int getVersion(){
        return this.version;
    }
}

关于 Java 反射，功能强大的就是可以通过字符串配置来动态从系统中调用方法或者修改其中某个对象的字段值，而 Class.forName 方法即可以通过传入类全路径字符串名称来获取对应的 Class 对象，非常的方便。另外通过 getField 方法和 GetMethod 方法可以获取指定字段和方法，并动态调用。

package com.hwdev.demo;
import java.lang.reflect.*;
import java.util.Arrays;
/**
 * 反射第一种用法 Class.forName
 * @author wangming
 */
public class ReflectDemo01 {
    
     public static void Test() {
        try
        {
            //通过字符串全路径类名查找Class
            Class helloC = Class.forName("com.hwdev.demo.Hello"); 
            //获取所有公有的字段数组，私有的无法获取   
            Field [] fields = helloC.getFields();
            //打印字段数组内容
            System.out.println(Arrays.toString(fields));
            //[public java.lang.String com.hwdev.demo.Hello.author, public int com.hwdev.demo.Hello.version]
            //实例化
            Object obj = helloC.newInstance();
            //获取特定字段，比遍历Field[]效率更高
            Field f = helloC.getField("author");
            if (f != null){
                //关闭安全检查，提高效率
                f.setAccessible(true);
                //获取字段author内容
                String author = (String)f.get(obj);
                System.out.println("author=" + author);
                //author=JackWang
            }
            //获取所有公有的方法数组，私有的无法获取 
            Method [] methods = helloC.getMethods();
            //打印方法数组内容,子类等方法也可以获取到
            System.out.println(Arrays.toString(methods));
            //本类所有方法
            Method [] methods2 = helloC.getDeclaredMethods();
            //打印方法数组内容
            System.out.println(Arrays.toString(methods2));
            //获取特定方法，第二个参数String.class为say方法的参数类型
            //say(java.lang.String)
            Method m = helloC.getDeclaredMethod("say",String.class); 
            if (m != null){
                //关闭安全检查，提高效率
                m.setAccessible(true);
                //获取字段author内容
                Object returnValue = m.invoke(obj, new Object[]{"Java"});
                //Hello Java
                if (returnValue!=null){
                    System.out.println("returnValue =" + returnValue);    
                }
            }
            
        }catch(ClassNotFoundException | SecurityException ex){
            ex.printStackTrace();
        }
        catch(Exception ex){
            ex.printStackTrace();
        }
    }    
}

这里需要注意：xxx.getMethods()方法默认情况下，会返回本类、父类、父接口的公有方法，而 xxx.getDeclaredMethods()返回本类的所有方法，包括私有的方法。同理，反射 API 中其他 getXXX 和 getDeclaredXXX 的用法类似。

package com.hwdev;
import com.hwdev.demo.ReflectDemo01;
/**
 * 
 * @author wangming
 */
public class Main {


    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        //反射第一种用法 Class.forName
        ReflectDemo01.Test();
    }    
}

执行程序，输出的结果如下：

[public java.lang.String com.hwdev.demo.Hello.author, public int com.hwdev.demo.Hello.version, public int com.hwdev.demo.MyBase.version]
author=JackWang
[public void com.hwdev.demo.Hello.say(java.lang.String), public void com.hwdev.demo.Hello.setAuthor(java.lang.String), public java.lang.String com.hwdev.demo.Hello.getAuthor(), public void com.hwdev.demo.MyBase.say2(java.lang.String), public final void java.lang.Object.wait() throws java.lang.InterruptedException, public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException, public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException, public boolean java.lang.Object.equals(java.lang.Object), public java.lang.String java.lang.Object.toString(), public native int java.lang.Object.hashCode(), public final native java.lang.Class java.lang.Object.getClass(), public final native void java.lang.Object.notify(), public final native void java.lang.Object.notifyAll()]
[public void com.hwdev.demo.Hello.say(java.lang.String), public void com.hwdev.demo.Hello.setAuthor(java.lang.String), public java.lang.String com.hwdev.demo.Hello.getAuthor(), private int com.hwdev.demo.Hello.getVersion()]
Hello Java

从输出结果上来看，Field [] fields = helloC.getFields();不但可以获取 Hello 类的公有字段，还可以获取到父类 MyBase 的公有字段：
com.hwdev.demo.MyBase.version

而 Method [] methods2 = helloC.getDeclaredMethods();则可以获取本类，即 Hello 类所有的方法，包括公有的方法和私有的方法。因此，Java 反射可以访问类的私有字段和方法，从而暴露内部的信息，这也是 Java 反射有安全问题的原因。

由于 Java 方法支持重载，因此同名的方法可以存在多个，即参数不同，因此在用反射调用方法时，需要指定方法的参数类型，这样就可以明确调到的具体是哪个方法签名，如 Method m = helloC.getDeclaredMethod("say",String.class); 调用的是 public void com.hwdev.demo.Hello.say(java.lang.String) 。

除了可以用 Class.forName 来进行反射外，还可以通过如下方式来获取反射对象：

Hello hello = new Hello();
Class helloC = hello.getClass();
Field [] fields = helloC.getFields();
//////////////////////////////////////////
Class helloC = Hello.class; 
Field [] fields = helloC.getFields();

下面介绍一下如何用 Java 反射修改私有字段和调用私有方法的示例：

package com.hwdev.demo;
import java.lang.reflect.*;
/**
 * 反射访问私有字段和方法
 * @author wangming
 */
public class ReflectDemo02 {
    
     public static void Test() {
        try
        {
            //通过已有类查找Class         
            Class helloC = Hello.class; 
            //实例化
            Object obj = helloC.newInstance();
            //获取特定私有字段
            Field f = helloC.getDeclaredField("company");
            if (f != null){
                //私有必须开启
                f.setAccessible(true);
                //设置私有字段值
                f.set(obj, "newKZ");
                //获取字段author内容
                String fv = (String)f.get(obj);
                System.out.println("company=" + fv);
                //company=newKZ
            } 
            //获取私有方法
            Method m = helloC.getDeclaredMethod("getVersion", null); 
            if (m != null){
                //私有必须开启
                m.setAccessible(true);
                Object returnValue = m.invoke(obj, null);
                if (returnValue!=null){
                    //returnValue =1
                    System.out.println("returnValue =" + returnValue);    
                }
            }
            
        }catch(SecurityException ex){
            ex.printStackTrace();
        }
        catch(Exception ex){
            ex.printStackTrace();
        }
    }    
}

另外，Java 反射可以获取注解信息，这个对于 ORM 框架来讲，用的非常多。

package com.hwdev.demo;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 注解示例
 * @author wangming
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ORMAnnotation {
    public String FieldName();
    public String FieldType();
}

其中，@Retention(RetentionPolicy.RUNTIME)表示注解可以在运行时通过反射访问。@Target(ElementType.FIELD) 表示这个注解只能用在字段上面。同理，可以把 FIELD 改为 Type 或者 Method 等。

package com.hwdev.demo;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
/**
 * 反射或者字段注解
 * @author wangming
 */
public class ReflectDemo03 {
    
     public static void Test() {
        try
        {
        
            Class helloC = Class.forName("com.hwdev.demo.HelloAnnotation");      
            Field[] fields = helloC.getDeclaredFields();
            for(Field f : fields){
                 //关闭安全检查，提高效率
                f.setAccessible(true);
                Annotation ann = f.getAnnotation(ORMAnnotation.class);
                if(ann instanceof ORMAnnotation){
                    ORMAnnotation ormAnn = (ORMAnnotation) ann;
                    System.out.println("FieldName=" + ormAnn.FieldName());
                    System.out.println("FieldType=" + ormAnn.FieldType());
                }
                
            }          
            
        }catch(ClassNotFoundException | SecurityException ex){
            ex.printStackTrace();
        }
        catch(Exception ex){
            ex.printStackTrace();
        }
    }    
}

执行此示例，则输出如下：

FieldName=f_author
FieldType=varchar(50)
FieldName=f_ver
FieldType=int

再次，介绍一下如何用反射获取方法参数个数和类型，其中包含泛型的信息获取：

package com.hwdev.demo;


import java.util.ArrayList;
import java.util.List;


/**
 * 泛型示例
 * @author wangming
 */
public class GenericCls {
   protected List<String> myList = new ArrayList(); 
   public GenericCls(int size){      
       for(int i = 0;i<size;i++){
           myList.add("item"+i);
       }
   }
   public  List<String> getList(){ 
      return this.myList;
   }
   public String getList(int idx){ 
      return this.myList.get(idx);
   }
}
package com.hwdev.demo;
import java.lang.reflect.*;
/**
 * 反射获取方法参数
 * @author wangming
 */
public class ReflectDemo05 {
    
     public static void Test() {
        try
        {
        
            Class helloC = Class.forName("com.hwdev.demo.GenericCls"); 
            //构造函数调用
            Object obj = helloC.getConstructor(int.class).newInstance(3);
            Method method = helloC.getMethod("getList", int.class);
            Class<?> returnType = method.getReturnType();
            System.out.println("ReturnType = " + returnType.getName());
            Parameter[] params = method.getParameters();
            for(Parameter p : params){    
                System.out.println("ParameterizedType = " + p.getParameterizedType());
                System.out.println("getModifiers = " + p.getModifiers());
                System.out.println("getName = " + p.getName());
                System.out.println("getType = " + p.getType());
            }
           //调用方法
           Object ret =  method.invoke(obj, new Object[]{2});
           System.out.println("ret = " + ret.toString());
            Method method2 = helloC.getMethod("getList", null);
            Type greturnType = method2.getGenericReturnType();
            System.out.println("getGenericReturnType = " + returnType.getName());
            if(greturnType instanceof ParameterizedType){
                ParameterizedType type = (ParameterizedType) greturnType;
                System.out.println("type = " + type.getTypeName());
                Type[] typeArguments = type.getActualTypeArguments();
                for(Type typeArgument : typeArguments){
                    Class typeArgClass = (Class) typeArgument;
                    System.out.println("typeArgClass = " + typeArgClass);
                }
            }
        }catch(ClassNotFoundException | SecurityException ex){
            ex.printStackTrace();
        }
        catch(Exception ex){
            ex.printStackTrace();
        }
    }    
}

执行上述示例，输出如下所示。

ReturnType = java.lang.String
ParameterizedType = int
getModifiers = 0
getName = arg0
getType = int
ret = item2
getGenericReturnType = java.lang.String
type = java.util.List<java.lang.String>
typeArgClass = class java.lang.String

关于反射还有非常多的知识点可以讲解，比如利用反射技术实现插件的动态加载等。反射的效率问题，可以通过使用高效的第三方反射库，或者加入缓冲机制来解决，这里不再赘述。

点击关注，第一时间了解华为云新鲜技术~

微信关注我们

原文链接：https://blog.51cto.com/u_15214399/3007445

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Pandas高级教程之:统计方法

2 --> 简介数据分析中经常会用到很多统计类的方法，本文将会介绍Pandas中使用到的统计方法。变动百分百 Series和DF都有一个pct_change()方法用来计算数据变动的百分比。这个方法在填充NaN值的时候特别有用。 ser = pd.Series(np.random.randn(8)) ser.pct_change() Out[45]: 0 NaN 1 -1.264716 2 4.125006 3 -1.159092 4 -0.091292 5 4.837752 6 -1.182146 7 -8.721482 dtype: float64 ser Out[46]: 0 -0.950515 1 0.251617 2 1.289537 3 -0.205155 4 -0.186426 5 -1.088310 6 0.198231 7 -1.530635 dtype: float64 pct_change还有个periods参数，可以指定计算百分比的periods，也就是隔多少个元素来计算： In [3]: df = pd.DataFrame(np.random.randn(...

2021-07-08

565

# 写在前面简单的介绍一下JVM（Java Virtual Machine）吧，它也叫Java虚拟机。虽然它叫虚拟机，但是实际上不是我们所理解的虚拟机，它更像操作系统中的一个进程。JVM屏蔽了各个操作系统底层的相关的东西，Java程序只需要生成对应的字节码文件，然后由JVM来负责解释运行。介绍几个容易混淆的概念，**JDK**（Java Development Kit) 可以算是整个Java的核心，其中有编译、调试的工具包和基础类库，它也包含了**JRE**。 **JRE**（Java Runtime Environment)，包含了JVM和基础类库。而JVM就是我们今天要聊的主角，开篇聊到，JVM负责解释运行，它会将自己的指令映射到当前不同设备的CPU指令集上，所以只需要在不同的操作系统上装不同版本的虚拟机即可。这也给了Java跨平台的能力。 # JVM的发展就跟我们用三方库一样，同样的功能有不同的实现。JVM也是一样的，第一款JVM是Sun公司的Classic VM，JDK1.2之前JVM都是采用的Classic VM，而之后，逐渐被我们都知道的HotSpot给替代，直到JD...

2021-07-08

454

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。