反射都不会，还敢说自己会Java？----->(浅谈)-低调大师

反射都不会，还敢说自己会Java？----->(浅谈)

2020-08-24 743

在谈反射之前，先思考一个问题，java中如何创建一个对象，有哪几种方式?

Java中创建对象大概有这几种方式：

1、使用new关键字：这是我们最常见的也是最简单的创建对象的方式

2、使用Clone的方法：无论何时我们调用一个对象的clone方法，JVM就会创建一个新的对象，将前面的对象的内容全部拷贝进去

3、使用反序列化：当我们序列化和反序列化一个对象，JVM会给我们创建一个单独的对象

上边是Java中常见的创建对象的三种方式，其实除了上边的三种还有另外一种方式，就是接下来我们要讨论的 “反射”

1、反射概述

1.1什么是反射

在程序运行状态中，对于任意一个类或对象，都能够获取到这个类的所有属性和方法（包括私有属性和方法），这种动态获取信息以及动态调用对象方法的功能就称为反射机制。简单来讲，通过反射，类对我们是完全透明的，想要获取任何东西都可以。

反射它把Java类中的各个部分，映射成一个个的Java对象，拿到这些对象后可以做一些事情。既然说反射是反射Java类中的各个组成部分，所以说我们得知道一个类中有哪儿些部分？

例如，一个类有：成员变量，方法，构造方法，等信息，利用反射技术咱们可以把这些组成部分映射成一个个对象。

1.2、反射能干什么

一般来说反射是用来做框架的，或者说可以做一些抽象度比较高的底层代码，反射在日常的开发中用到的不多，但是我们还必须搞懂它，因为搞懂了反射以后，可以帮助咱们理解框架的一些原理。所以说有一句很经典的话：反射是框架设计的灵魂。

1.3 反射的优点

可以在程序运行过程中，操作这些对象；
可以解耦，提高程序的可扩展性。

在学习反射以前，我们先来了解一下Java代码在计算机中所经历的三个阶段：

Source源代码阶段：.java被编译成*.class字节码文件。
Class类对象阶段：.class字节码文件被类加载器加载进内存，并将其封装成Class对象（用于在内存中描述字节码文件），Class对象将原字节码文件中的成员变量抽取出来封装成数组Field[],将原字节码文件中的构造函数抽取出来封装成数组Construction[]，将成员方法封装成数组Method[]。当然Class类内不止这三个，还封装了很多，我们常用的就这三个。
RunTime运行时阶段：使用new创建对象的过程。

1.4 获取Class对象的三种方式

【Source源代码阶段】 Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象；
多用于配置文件，将类名定义在配置文件中，通过读取配置文件加载类。
【Class类对象阶段】类名.class：通过类名的属性class获取；
多用于参数的传递
【Runtime运行时阶段】对象.getClass()：此方法是定义在Objec类中的方法，因此所有的类都会继承此方法。
多用于对象获取字节码的方式

//方法演示
public class getClass {
    public static void main(String[] args) throws Exception {
    
        //方式一：Class.forName("全类名");
        Class class1 = Class.forName("com.czxy.mybatis_plus.test.Person");   //Person自定义实体类
        System.out.println("class1 = " + class1);

        //方式二：类名.class
        Class class2 = Person.class;
        System.out.println("class2 = " + class2);

        //方式三：对象.getClass();
        Person person = new Person();
        Class class3 = person.getClass();
        System.out.println("class3 = " + class3);

        //比较三个对象
        System.out.println(class1 == class2);    //true
        System.out.println(class1 == class3);    //true
    }
}

运行结果：

通过上述比较三个对象的结果可以得出一个结论：同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，无论通过哪一种方式获取的Class对象都是同一个。

2、Class对象的功能

2.1 获取功能

这里只写出一些常用的，具体可以参看jdk的帮助文档。

获取成员变量

Field[] getFields()          //获取所有public修饰的成员变量
Field getField(String name)  //获取指定名称的public修饰的成员变量

Field[] getDeclaredFields()  //获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)  //获取指定的成员变量，不考虑修饰符

2. 获取构造方法

Constructor<?>[] getConstructors() //获取所有public修饰的构造函数
Constructor<T> getConstructor(类<?>... parameterTypes)  //获取指定的public修饰的构造函数

Constructor<?>[] getDeclaredConstructors()  //获取所有的构造函数，不考虑修饰符
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  //获取指定的构造函数，不考虑修饰符

3. 获取成员方法

Method[] getMethods()           //获取所有public修饰的成员方法
Method getMethod(String name, 类<?>... parameterTypes) //获取指定名称的public修饰的成员方法

Method[] getDeclaredMethods()  //获取所有的成员方法，不考虑修饰符
Method getDeclaredMethod(String name, 类<?>... parameterTypes) //获取指定名称的成员方法，不考虑修饰符

4. 获取全类名

String getName()

2.2 Field：成员变量

（1）设置值 set(Object obj, Object value)
（2）获取值 get(Object obj)
（3）忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射

2.3 测试的实体类

import lombok.Data;
import lombok.ToString;


@Data
@ToString
public class Person {
    public String a;        //最大范围public
    protected String b;     //受保护类型
    String c;               //默认的访问权限
    private String d;       //私有类型

}

2.4 测试getFields和getField(String name)方法

/**
 *      获取成员变量
 *    * Field[] getFields()
 *    * Field getField(String name)
 *     @throws Exception
 */
public class reflectDemo{
    public static void main(String[] args) throws Exception {
    
        //获取Person的Class对象
        Class personClass = Person.class;

        //1、Field[] getFields()获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for(Field field : fields){
            System.out.println(field);
        }

        System.out.println("=============================");

        //2.Field getField(String name) 获取指定名称的public修饰的成员变量
        Field a = personClass.getField("a");
        //获取成员变量a的值 [也只能获取公有的，获取私有的或者不存在的字符会抛出异常]
        Person p = new Person();
        Object value = a.get(p);
        System.out.println("value = " + value);//因为在Person类中a没有赋值，所以为null

        //设置成员变量a的属性值
        a.set(p,"李四");
        System.out.println(p);
    }
}

运行结果：

2.5 测试 getDeclaredFields 和 getDeclaredField(String name)方法

/**
 *     Field[] getDeclaredFields()
 *     Field getDeclaredField(String name)
 *     @throws Exception
 */
public class reflectDemo1 {
    public static void main(String[] args) throws Exception {
    
        //获取Person的Class对象
        Class personClass = Person.class;

        //Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for(Field filed : declaredFields){
            System.out.println(filed);
        }

        System.out.println("===================================");

        //Field getDeclaredField(String name) //获取指定的成员变量，不考虑修饰符
        Field d = personClass.getDeclaredField("d"); //private String d;
        Person p = new Person();

        //Object value1 = d.get(p);  //如果直接获取会抛出异常，因为对于私有变量虽然能会获取到，但不能直接set和get，必须忽略访问权限修饰符的安全检查后才可以
        //System.out.println("value1 = " + value1); 

        //忽略访问权限修饰符的安全检查，又称为暴力反射
        d.setAccessible(true);
        Object value2 = d.get(p);
        System.out.println("value2 = " + value2);
    }
}

运行结果：

注意：如果没有忽略访问修饰符直接访问会抛出如下所示的异常

3、 Constructor:构造方法

3.1修改测试的实体类

import lombok.Data;
import lombok.ToString;


@Data
@ToString
public class Person {
    private String name;
    private Integer age;
    //无参构造函数
    public Person() {
    }
    //单个参数的构造函数，且为私有构造方法
    private Person(String name){
    }
    //有参构造函数
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

}

3.2 测试获取构造函数的方法

/**
 *    获取构造方法
 *    Constructor<?>[] getConstructors()
 *    Constructor<T> getConstructor(类<?>... parameterTypes)
 */
public class reflectDemo2{
    public static void main(String[] args) throws Exception {

        //获取Person的Class对象
        Class personClass = Person.class;

        //Constructor<?>[] getConstructors() //获取所有public修饰的构造函数
        Constructor[] constructors = personClass.getConstructors();
        for(Constructor constructor : constructors){   
            System.out.println(constructor);
        }

        System.out.println("==========================================");

        //获取无参构造函数   注意：Person类中必须要有无参的构造函数，不然抛出异常
        Constructor constructor1 = personClass.getConstructor(); 
        System.out.println("constructor1 = " + constructor1);
        //使用获取到的无参构造函数创建对象
        Object person1 = constructor1.newInstance();
        System.out.println("person1 = " + person1);


        System.out.println("==========================================");

        //获取有参的构造函数  //public Person(String name, Integer age) 参数类型顺序要与构造函数内一致，且参数类型为字节码文件类型
        Constructor constructor2 = personClass.getConstructor(String.class,Integer.class);
        System.out.println("constructor2 = " + constructor2);
        //使用获取到的有参构造函数创建对象
        Object person2 = constructor2.newInstance("zhangsan", 22);   //获取的是有参的构造方法，就必须要指定参数
        System.out.println(person2);

        System.out.println("=========================================");

        //对于一般的无参构造函数，我们都不会先获取无参构造器之后在进行初始化,而是直接调用Class类内的newInstance()方法
        Object person3 = personClass.newInstance();
        System.out.println("person3 = " + person3);
    }
}

运行结果：

4、 Method：方法对象

4.1 执行方法：Object invoke(Object obj, Object… args)

import lombok.Data;
import lombok.ToString;


@Data
@ToString
public class Person {
    private String name;
    private Integer age;

    //无参构造函数
    public Person() {

    }
    //有参构造函数
    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    //无参方法
    public void test(){
        System.out.println("test...");
    }

    //重载有参方法
    public void test(String food){
        System.out.println("test..."+food);
    }

}

4.2 测试获取成员方法的方法

/**
 *     获取成员方法
 *    * Method[] getMethods()
 *    * Method getMethod(String name, 类<?>... parameterTypes)
 */
public class reflectDemo3 {
    public static void main(String[] args) throws Exception {

        //获取Person的Class对象
        Class personClass = Person.class;

        //获取指定名称的方法
        Method method1 = personClass.getMethod("test");
        //执行方法
        Person person = new Person();
        Object rtValue = method1.invoke(person);//如果方法有返回值类型可以获取到，没有就为null
        //因为eat方法没有返回值，故输出null
        System.out.println("rtValue = " + rtValue);

        System.out.println("--------------------------------------------");

        //获取有参的函数，有两个参数：第一个参数为方法名，第二个参数是获取方法的参数类型的字节码文件
        Method method2 = personClass.getMethod("test", String.class);
        //执行方法
         method2.invoke(person,"嗨");

        System.out.println("============================================");

        //获取方法列表
        Method[] methods = personClass.getMethods();
        for(Method method : methods){     //注意：获取到的方法不仅仅是Person类内自己的方法
            System.out.println(method);   //继承Object中的方法也会被获取到（当然前提是public修饰的）
        }
    }
}

运行结果：

我们可以看出Person内的public方法都被打印出来了，此外Object中的public方法也都被打印出来了。

同之前的叙述一样，带有Declared关键字的方法这两个方法，可以获取到任意修饰符的方法。同样也提供了setAccessible(true)方法进行暴力反射。

综上所述：在反射面前没有公有私有，都可以通过暴力反射解决。

5、获取全类名

5.1 getName()方法获取的类名是全类名（带有路径）

public class getNameDemo {
    public static void main(String[] args) throws Exception {

        //获取Person的Class对象
        Class personClass = Person.class;
        //获取全类名
        String className = personClass.getName();
        System.out.println(className);
    }
}

运行结果：

6、反射机制的应用案例

6.1 需求

写一个"框架"，在不改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中的任意方法。

6.2 实现

（1）配置文件
（2）反射机制

6.3 步骤

（1）将需要创建的对象的全类名和需要执行的方法定义在配置文件中
（2）在程序中加载读取配置文件
（3）使用反射技术把类文件加载进内存
（4）创建对象
（5）执行方法

6.4 代码实现需要的实体类

(1)Person类


public class Person {
    //无参方法
    public void test(){
        System.out.println("test...");
    }
}

(2)Student类

public class Student {
    //无参方法
    public void study(){
        System.out.println("I'm Student");
    }
}

6.5 编写配置文件

className = com.czxy.mybatis_plus.test.Person
methodName = test

6.6 实现框架

 /**
  * 前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
  * 即：拒绝硬编码
  */
public class ReflectTest {
    public static void main(String[] args) throws Exception {
    
        //1.加载配置文件
        //1.1创建Properties对象
        Properties pro = new Properties();
        //1.2加载配置文件
        //1.2.1获取class目录下的配置文件(使用类加载器)
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream inputStream = classLoader.getResourceAsStream("pro.properties");
        pro.load(inputStream);

        //2.获取配置文件中定义的数据
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");

        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
    }
}

运行结果:

6.7 修改配置文件，再次运行

className = com.czxy.mybatis_plus.test.Student 
methodName = study

运行结果:

总结：

对于框架来说，已经对基础的代码进行了封装并提供相应的API。
在框架的基础上进行软件开发，可以简化编码。但如果我们使用传统的new形式来实例化，那么当类更改时我们就要修改Java代码，这是很繁琐的。
修改Java代码以后我们还要进行重新编译、测试、发布等一系列的操作。
而如果我们仅仅只是修改配置文件，而不需要修改Java代码就简单的多。
此外使用反射还能达到解耦的效果，如果我们使用的是new这种形式进行对象的实例化。
此时如果在项目的某一个小模块中我们的一个实例类丢失了，那么在编译期间就会报错，会导致整个项目无法启动。
而对于反射创建对象Class.forName(“全类名”)这种形式，我们在编译期需要的仅仅只是一个字符串（全类名），在编译期不会报错，这样其他的模块就可以正常的运行，而不会因为一个模块的问题导致整个项目崩溃。

微信关注我们

原文链接：https://my.oschina.net/u/4234912/blog/4525375

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

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

基于Filebeat和ELK监控业务接口运行指标

目标描述基于springboot开发的一套接口服务部署在TOMCAT中，需要对接口的日常运行情况的数据进行收集和展示，便于及时掌握服务的实时运行状态，对异常情况及时告警。需要统计的数据如下：访问请求数统计访问流量统计访问处理响应时间统计统计接口的错误码分布情况统计访问最频繁的接口统计访问处理时间最久的接口统计并发访问频率最高的接口方案简介 Tomcat Access Log中存放了很多有用的信息，将这些信息利用起来，就可以我们的统计目标。完整流程为： Filebeat 收集Tomcat Access Log，将数据发送到 Logstash，然后 Logstash 对数据进行处理，并将处理后的数据发送到 ES，最后再用 Kibana 进行数据展示。方案实施 1 配置tomcat access Log Tomcat Access Log 的展示信息在 conf/server.xml 中进行配置，配置如下： <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"...

2020-08-24

758

之前的推文已经分享了数据库优化的方法，链接为https://mp.weixin.qq.com/s/6Atzk9UKPJRxxAs0nsKBXg。其中操作系统部分介绍了IO调度算法的优化，本文将通过压力测试的方式来对比不同的调度算法下磁盘IO的表现。 1 准备工作 1.1 安装sysbench 本次采用sysbench进行压测，先安装sysbench，步骤如下： curl -s https://packagecloud.io/install/repositories/akopytov/sysbench/script.rpm.sh | sudo bashyum -y install sysbenchsysbench --version 1.2 准备测试文件生成后续需要使用的测试文件，block大小为16k（MySQL DBA都懂的，哈哈），创建4个文件，合计20G [root@mha1 ~]# sysbench fileio --file-num=4 --file-block-size=16384 --file-total-size=20G preparesysbench 1.0.20 ...

2020-08-24

695

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

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文件系统，支持十年生命周期更新。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。