【commons-beanutils专题】001- MethodUtils 专题

待我称王封你为后i 2023-09-28 14:48 16阅读 0赞

# 【commons-beanutils专题】001- MethodUtils 专题 #

### 文章目录 ###

*  【commons-beanutils专题】001- MethodUtils 专题
 *  一、准备
 *   *  0、MethodUtils 主要作用
     *  1、引入 commons-beanutils 依赖
     *  2、pom.xml 文件
     *  3、实体类父类
     *  4、实体类子类
 *  二、缓存
 *   *  0、前置代码
     *  1、设置是否应该缓存方法以获得更高的性能，默认为true
     *  2、清空方法缓存
 *  三、执行方法
 *   *  1、执行方法：单个参数 + 自动获取类型
     *  2、执行方法：多个参数 + 自动获取类型
     *  3、执行方法：单个参数 + 手动设置类型
 *  四、精确执行方法
 *   *  1、精确执行方法，此处我们精确调用有 1 个参数的方法 + 自动获取类型
     *  2、精确执行方法：此处我们精确调用有 2 个参数的方法 + 自动获取类型
     *  3、精确执行方法：此处我们精确调用有 2 个参数的方法 + 手动设置类型
 *  五、精确指定静态方法
 *   *  1、精确执行静态方法：单个参数 + 自动获取类型
     *  2、精确执行静态方法：多个参数 + 自动获取类型
     *  3、精确执行静态方法：多个参数 + 手动设置类型
     *  4、精确执行静态方法：无参数
 *  六、获取可访问方法
 *   *  1、获取一个可访问的方法：类名，方法名，参数类型
     *  2、获取一个可访问的方法：类名，方法名，参数类型列表
 *  七、获取指定方法的可访问方法
 *   *  1、获取指定方法的可访问方法：找不到这个方法返回空（测试1）
     *  2、获取指定方法的可访问方法：找不到这个方法返回空（测试2）
     *  3、获取指定方法的可访问方法：找不到这个方法返回空（测试3）
     *  4、获取指定方法的可访问方法：类 + 方法
     *  5、获取与指定方法名称相同且与参数类型列表匹配的可访问方法
 *  八、确定一个类型是否可以用作方法调用中的参数
 *  九、基本类型 & 包装类型
 *   *  1、获取一个基本类型的包装类型
     *  2、获得包装类的基本数据类型
     *  3、如果是简单数据类型则返回对应的包装类，否则返回本身
 *  十、完整代码

# 一、准备 #

## 0、MethodUtils 主要作用 ##

**主要用于通过反射技术操作对象的方法：执行方法、精确执行方法、精确执行静态方法、获取可访问方法等；**  
**普通和精确的区别：普通的会找到兼容类型的方法，精确的只会匹配到确切的参数类型的方法。**

## 1、引入 commons-beanutils 依赖 ##

<dependency>
        <groupId>commons-beanutils</groupId>
        <artifactId>commons-beanutils</artifactId>
        <version>1.9.4</version>
    </dependency>

## 2、pom.xml 文件 ##

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.7.1</version>
            <relativePath/> 
        </parent>
        <groupId>com.zibo</groupId>
        <artifactId>zibo2022</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>zibo2022</name>
        <description>zibo2022</description>
        <properties>
            <java.version>17</java.version>
        </properties>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
    
            
            <dependency>
                <groupId>commons-beanutils</groupId>
                <artifactId>commons-beanutils</artifactId>
                <version>1.9.4</version>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <version>2.7.1</version>
                    <configuration>
                        <excludes>
                            <exclude>
                                <groupId>org.projectlombok</groupId>
                                <artifactId>lombok</artifactId>
                            </exclude>
                        </excludes>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>

## 3、实体类父类 ##

package com.zibo.zibo2022.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @author zibo
     * @date 2022/7/12 0012 21:17
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class God {
        
    
        /**
         * 数字
         */
        private Integer num;
    }

## 4、实体类子类 ##

package com.zibo.zibo2022.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.EqualsAndHashCode;
    import lombok.NoArgsConstructor;
    
    /**
     * @author zibo
     * @date 2022/7/12 0012 20:09
     */
    @Data
    @EqualsAndHashCode(callSuper = true)
    @NoArgsConstructor
    @AllArgsConstructor
    public class People extends God {
        
    
        /**
         * 名字
         */
        private String name;
    
        /**
         * 年龄
         */
        private Integer age;
    
        /**
         * 地址
         */
        private String address;
    
        /**
         * 两个参数的 setName 方法
         * @param name1 名字1
         * @param name2 名字2
         */
        public void setName(String name1, String name2) {
        
            this.name = name1 + name2;
        }
    
        /**
         * 单参数静态方法：say
         * @param word
         */
        public static void say(String word) {
        
            System.out.println(word);
            System.out.println("单参数静态方法：say");
        }
    
        /**
         * 多参数静态方法：say
         * @param word1
         * @param word2
         */
        public static void say(String word1, String word2) {
        
            System.out.println(word1 + word2);
            System.out.println("多参数静态方法：say");
        }
    
        /**
         * 无参数静态方法：say
         */
        public static void say() {
        
            System.out.println("无参数静态方法：say");
        }
    
    }

# 二、缓存 #

## 0、前置代码 ##

People people = new People("zibo", 18, "beijing");

## 1、设置是否应该缓存方法以获得更高的性能，默认为true ##

// 1、设置是否应该缓存方法以获得更高的性能，默认为true。
    MethodUtils.setCacheMethods(true);

## 2、清空方法缓存 ##

// 2、清空方法缓存
    MethodUtils.clearCache();

# 三、执行方法 #

## 1、执行方法：单个参数 + 自动获取类型 ##

// 3、执行方法：单个参数 + 自动获取类型
    try {
        
        // 参数：对象，方法名，参数
        MethodUtils.invokeMethod(people, "setName", "大哥");
    } catch (Exception e) {
        
        e.printStackTrace();
    }
    System.out.println("name: " + people.getName()); // name: 大哥

## 2、执行方法：多个参数 + 自动获取类型 ##

// 4、执行方法：多个参数 + 自动获取类型
    Object[] args1 = new Object[] {
        26};
    try {
        
        // 参数：对象，方法名，参数列表，参数类型列表
        MethodUtils.invokeMethod(people, "setAge", args1);
    } catch (Exception e) {
        
        e.printStackTrace();
    }
    System.out.println("age: " + people.getAge()); // age: 26

## 3、执行方法：单个参数 + 手动设置类型 ##

// 5、执行方法：单个参数 + 手动设置类型
    Object[] args2 = new Object[] {
        "河南省"};
    Class<?>[] types = new Class[] {
        String.class};
    try {
        
        // 参数：对象，方法名，参数，参数类型
        MethodUtils.invokeMethod(people, "setAddress", args2, types);
    } catch (Exception e) {
        
        e.printStackTrace();
    }
    System.out.println("address: " + people.getAddress()); // address: 河南省

# 四、精确执行方法 #

> 执行无参方法，参数传 null 即可，参考精【确执行静态方法】！

## 1、精确执行方法，此处我们精确调用有 1 个参数的方法 + 自动获取类型 ##

// 6、精确执行方法，此处我们精确调用有 1 个参数的方法 + 自动获取类型
    try {
        
        // 参数：对象，方法名，参数
        MethodUtils.invokeExactMethod(people, "setName", "大哥刘备");
    } catch (Exception e) {
        
        e.printStackTrace();
    }
    System.out.println("name: " + people.getName()); // name: 大哥刘备

## 2、精确执行方法：此处我们精确调用有 2 个参数的方法 + 自动获取类型 ##

// 6、精确执行方法：此处我们精确调用有 2 个参数的方法 + 自动获取类型
    Object[] args3 = new Object[] {
        "大哥的名字叫做", "刘备"};
    try {
        
        // 参数：对象，方法名，参数列表，参数类型列表
        MethodUtils.invokeExactMethod(people, "setName", args3);
    } catch (Exception e) {
        
        e.printStackTrace();
    }
    System.out.println("name: " + people.getName()); // name: 大哥的名字叫做刘备

## 3、精确执行方法：此处我们精确调用有 2 个参数的方法 + 手动设置类型 ##

// 7、精确执行方法：此处我们精确调用有 2 个参数的方法 + 手动设置类型
    Class<?>[] types1 = new Class[] {
        String.class, String.class};
    try {
        
        // 参数：对象，方法名，参数列表，参数类型列表
        MethodUtils.invokeExactMethod(people, "setName", args3, types1);
    } catch (Exception e) {
        
        e.printStackTrace();
    }
    System.out.println("name: " + people.getName()); // name: 大哥的名字叫做刘备

# 五、精确指定静态方法 #

## 1、精确执行静态方法：单个参数 + 自动获取类型 ##

// 8、精确执行静态方法：单个参数 + 自动获取类型
    try {
        
        // 参数：类名，方法名，参数
        MethodUtils.invokeStaticMethod(People.class, "say", "大哥，快来啦！");
        // 大哥，快来啦！
        // 单参数静态方法：say
    } catch (Exception e) {
        
        e.printStackTrace();
    }

## 2、精确执行静态方法：多个参数 + 自动获取类型 ##

// 9、精确执行静态方法：多个参数 + 自动获取类型
    Object[] args4 = new Object[] {
        "大哥，快来啦！", "大哥，快来啦！"};
    try {
        
        // 参数：类名，方法名，参数列表，参数类型列表
        MethodUtils.invokeStaticMethod(People.class, "say", args4);
        // 大哥，快来啦！大哥，快来啦！
        // 多参数静态方法：say
    } catch (Exception e) {
        
        e.printStackTrace();
    }

## 3、精确执行静态方法：多个参数 + 手动设置类型 ##

// 10、精确执行静态方法：多个参数 + 手动设置类型
    Object[] args5 = new Object[] {
        "大哥，快来啦！", "大哥，快来啦！"};
    Class<?>[] types2 = new Class[] {
        String.class, String.class};
    try {
        
        // 参数：类名，方法名，参数列表，参数类型列表
        MethodUtils.invokeStaticMethod(People.class, "say", args5, types2);
        // 大哥，快来啦！大哥，快来啦！
        // 多参数静态方法：say
    } catch (Exception e) {
        
        e.printStackTrace();
    }

## 4、精确执行静态方法：无参数 ##

try {
        
        // 参数：类名，方法名，参数
        // 参数设置为 null 可调用无参方法
        MethodUtils.invokeStaticMethod(People.class, "say", null);
        // 无参数静态方法：say
    } catch (Exception e) {
        
        e.printStackTrace();
    }

# 六、获取可访问方法 #

## 1、获取一个可访问的方法：类名，方法名，参数类型 ##

// 12、获取一个可访问的方法：类名，方法名，参数类型
    Method method = MethodUtils.getAccessibleMethod(People.class, "setName", String.class);
    try {
        
        method.invoke(people, "二哥关羽");
    } catch (IllegalAccessException | InvocationTargetException e) {
        
        e.printStackTrace();
    }
    System.out.println("name: " + people.getName()); // name: 二哥关羽

## 2、获取一个可访问的方法：类名，方法名，参数类型列表 ##

// 13、获取一个可访问的方法：类名，方法名，参数类型列表
    Class<?>[] types3 = new Class[] {
        String.class, String.class};
    Method method1 = MethodUtils.getAccessibleMethod(People.class, "setName", types3);
    try {
        
        method1.invoke(people, "二哥关羽", "三哥张飞");
    } catch (IllegalAccessException | InvocationTargetException e) {
        
        e.printStackTrace();
    }
    System.out.println("name: " + people.getName()); // name: 二哥关羽三哥张飞

# 七、获取指定方法的可访问方法 #

## 1、获取指定方法的可访问方法：找不到这个方法返回空（测试1） ##

// 14、获取指定方法的可访问方法：找不到这个方法返回空（测试1）
    try {
        
        Method setName = People.class.getDeclaredMethod("setName", String.class);
        Method accessibleMethod = MethodUtils.getAccessibleMethod(setName);
        accessibleMethod.invoke(people, "四哥赵云");
    } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
        
        e.printStackTrace();
    }
    System.out.println("name: " + people.getName()); // name: 四哥赵云

## 2、获取指定方法的可访问方法：找不到这个方法返回空（测试2） ##

// 15、获取指定方法的可访问方法：找不到这个方法返回空（测试2）
    // 备注：如果不用工具，此时没有这个方法，会被捕捉到 NoSuchMethodException 异常，搞不懂为何还需要 getAccessibleMethod 这个方法！
    try {
        
        Method setName = People.class.getDeclaredMethod("setNumber", Integer.class);
        // java.lang.NoSuchMethodException: com.zibo.zibo2022.entity.People.setNumber(java.lang.Integer)
        Method accessibleMethod = MethodUtils.getAccessibleMethod(setName);
        System.out.println(accessibleMethod);
    } catch (NoSuchMethodException e) {
        
        e.printStackTrace();
    }

## 3、获取指定方法的可访问方法：找不到这个方法返回空（测试3） ##

// 16、获取指定方法的可访问方法：找不到这个方法返回空（测试3）
    // 使用工具获取方法：我知道了，因为使用工具获取方法，如果没有也不会报错，因此使用这个方法来判断是否有此方法！
    Method method2 = MethodUtils.getAccessibleMethod(People.class, "setNumber", types3);
    Method method3 = MethodUtils.getAccessibleMethod(method2);
    System.out.println(method3); // null

## 4、获取指定方法的可访问方法：类 + 方法 ##

// 17、获取指定方法的可访问方法：类 + 方法
    Method method4 = MethodUtils.getAccessibleMethod(People.class, method2);
    System.out.println(method4); // null

## 5、获取与指定方法名称相同且与参数类型列表匹配的可访问方法 ##

// 18、获取与指定方法名称相同且与参数类型列表匹配的可访问方法
    Method method5 = MethodUtils.getMatchingAccessibleMethod(People.class, "setName", types3);
    try {
        
        method5.invoke(people, "二哥关羽", "三哥张飞");
    } catch (IllegalAccessException | InvocationTargetException e) {
        
        e.printStackTrace();
    }
    System.out.println("name: " + people.getName()); // name: 二哥关羽三哥张飞

# 八、确定一个类型是否可以用作方法调用中的参数 #

> 我想实际使用中没这么简单！

// 19、确定一个类型是否可以用作方法调用中的参数。
    boolean isAssignableFrom = MethodUtils.isAssignmentCompatible(String.class, Integer.class);
    System.out.println(isAssignableFrom); // false
    isAssignableFrom = MethodUtils.isAssignmentCompatible(String.class, String.class);
    System.out.println(isAssignableFrom); // true
    isAssignableFrom = MethodUtils.isAssignmentCompatible(String.class, Object.class);
    System.out.println(isAssignableFrom); // false
    isAssignableFrom = MethodUtils.isAssignmentCompatible(Integer.class, Object.class);
    System.out.println(isAssignableFrom); // false
    isAssignableFrom = MethodUtils.isAssignmentCompatible(Integer.class, Long.class);
    System.out.println(isAssignableFrom); // false

# 九、基本类型 & 包装类型 #

## 1、获取一个基本类型的包装类型 ##

// 20、获取一个基本类型的包装类型
    Class<?> primitiveType = MethodUtils.getPrimitiveWrapper(int.class);
    System.out.println(primitiveType); // class java.lang.Integer

## 2、获得包装类的基本数据类型 ##

// 21、获得包装类的基本数据类型
    Class<?> primitiveType2 = MethodUtils.getPrimitiveType(Integer.class);
    System.out.println(primitiveType2); // int

## 3、如果是简单数据类型则返回对应的包装类，否则返回本身 ##

// 22、如果是简单数据类型则返回对应的包装类，否则返回本身
    Class<?> primitiveType3 = MethodUtils.toNonPrimitiveClass(int.class);
    System.out.println(primitiveType3); // class java.lang.Integer
    Class<?> primitiveType4 = MethodUtils.toNonPrimitiveClass(Integer.class);
    System.out.println(primitiveType4); // class java.lang.Integer

# 十、完整代码 #

package com.zibo.zibo2022.main;
    
    import com.zibo.zibo2022.entity.People;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import org.apache.commons.beanutils.MethodUtils;
    
    /**
     * @author zibo
     * @date 2022/7/12 0012 20:11
     */
    public class Main {
        
    
        public static void main(String[] args) {
        
            People people = new People("zibo", 18, "beijing");
            // 1、设置是否应该缓存方法以获得更高的性能，默认为true。
            MethodUtils.setCacheMethods(true);
            // 2、清空方法缓存
            MethodUtils.clearCache();
    
            // 3、执行方法：单个参数 + 自动获取类型
            try {
        
                // 参数：对象，方法名，参数
                MethodUtils.invokeMethod(people, "setName", "大哥");
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            System.out.println("name: " + people.getName()); // name: 大哥
    
            // 4、执行方法：多个参数 + 自动获取类型
            Object[] args1 = new Object[] {
        26};
            try {
        
                // 参数：对象，方法名，参数列表，参数类型列表
                MethodUtils.invokeMethod(people, "setAge", args1);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            System.out.println("age: " + people.getAge()); // age: 26
    
            // 5、执行方法：单个参数 + 手动设置类型
            Object[] args2 = new Object[] {
        "河南省"};
            Class<?>[] types = new Class[] {
        String.class};
            try {
        
                // 参数：对象，方法名，参数，参数类型
                MethodUtils.invokeMethod(people, "setAddress", args2, types);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            System.out.println("address: " + people.getAddress()); // address: 河南省
    
            // 6、精确执行方法，此处我们精确调用有 1 个参数的方法 + 自动获取类型
            try {
        
                // 参数：对象，方法名，参数
                MethodUtils.invokeExactMethod(people, "setName", "大哥刘备");
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            System.out.println("name: " + people.getName()); // name: 大哥刘备
    
            // 6、精确执行方法：此处我们精确调用有 2 个参数的方法 + 自动获取类型
            Object[] args3 = new Object[] {
        "大哥的名字叫做", "刘备"};
            try {
        
                // 参数：对象，方法名，参数列表，参数类型列表
                MethodUtils.invokeExactMethod(people, "setName", args3);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            System.out.println("name: " + people.getName()); // name: 大哥的名字叫做刘备
    
            // 7、精确执行方法：此处我们精确调用有 2 个参数的方法 + 手动设置类型
            Class<?>[] types1 = new Class[] {
        String.class, String.class};
            try {
        
                // 参数：对象，方法名，参数列表，参数类型列表
                MethodUtils.invokeExactMethod(people, "setName", args3, types1);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
            System.out.println("name: " + people.getName()); // name: 大哥的名字叫做刘备
    
            // 8、精确执行静态方法：单个参数 + 自动获取类型
            try {
        
                // 参数：类名，方法名，参数
                MethodUtils.invokeStaticMethod(People.class, "say", "大哥，快来啦！");
                // 大哥，快来啦！
                // 单参数静态方法：say
            } catch (Exception e) {
        
                e.printStackTrace();
            }
    
            // 9、精确执行静态方法：多个参数 + 自动获取类型
            Object[] args4 = new Object[] {
        "大哥，快来啦！", "大哥，快来啦！"};
            try {
        
                // 参数：类名，方法名，参数列表，参数类型列表
                MethodUtils.invokeStaticMethod(People.class, "say", args4);
                // 大哥，快来啦！大哥，快来啦！
                // 多参数静态方法：say
            } catch (Exception e) {
        
                e.printStackTrace();
            }
    
            // 10、精确执行静态方法：多个参数 + 手动设置类型
            Object[] args5 = new Object[] {
        "大哥，快来啦！", "大哥，快来啦！"};
            Class<?>[] types2 = new Class[] {
        String.class, String.class};
            try {
        
                // 参数：类名，方法名，参数列表，参数类型列表
                MethodUtils.invokeStaticMethod(People.class, "say", args5, types2);
                // 大哥，快来啦！大哥，快来啦！
                // 多参数静态方法：say
            } catch (Exception e) {
        
                e.printStackTrace();
            }
    
            // 11、精确执行静态方法：无参数
            try {
        
                // 参数：类名，方法名，参数
                // 参数设置为 null 可调用无参方法
                MethodUtils.invokeStaticMethod(People.class, "say", null);
                // 无参数静态方法：say
            } catch (Exception e) {
        
                e.printStackTrace();
            }
    
    
            // 12、获取一个可访问的方法：类名，方法名，参数类型
            Method method = MethodUtils.getAccessibleMethod(People.class, "setName", String.class);
            try {
        
                method.invoke(people, "二哥关羽");
            } catch (IllegalAccessException | InvocationTargetException e) {
        
                e.printStackTrace();
            }
            System.out.println("name: " + people.getName()); // name: 二哥关羽
    
            // 13、获取一个可访问的方法：类名，方法名，参数类型列表
            Class<?>[] types3 = new Class[] {
        String.class, String.class};
            Method method1 = MethodUtils.getAccessibleMethod(People.class, "setName", types3);
            try {
        
                method1.invoke(people, "二哥关羽", "三哥张飞");
            } catch (IllegalAccessException | InvocationTargetException e) {
        
                e.printStackTrace();
            }
            System.out.println("name: " + people.getName()); // name: 二哥关羽三哥张飞
    
            // 14、获取指定方法的可访问方法：找不到这个方法返回空（测试1）
            try {
        
                Method setName = People.class.getDeclaredMethod("setName", String.class);
                Method accessibleMethod = MethodUtils.getAccessibleMethod(setName);
                accessibleMethod.invoke(people, "四哥赵云");
            } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
        
                e.printStackTrace();
            }
            System.out.println("name: " + people.getName()); // name: 四哥赵云
    
            // 15、获取指定方法的可访问方法：找不到这个方法返回空（测试2）
            // 备注：如果不用工具，此时没有这个方法，会被捕捉到 NoSuchMethodException 异常，搞不懂为何还需要 getAccessibleMethod 这个方法！
            try {
        
                Method setName = People.class.getDeclaredMethod("setNumber", Integer.class);
                // java.lang.NoSuchMethodException: com.zibo.zibo2022.entity.People.setNumber(java.lang.Integer)
                Method accessibleMethod = MethodUtils.getAccessibleMethod(setName);
                System.out.println(accessibleMethod);
            } catch (NoSuchMethodException e) {
        
                e.printStackTrace();
            }
    
            // 16、获取指定方法的可访问方法：找不到这个方法返回空（测试3）
            // 使用工具获取方法：我知道了，因为使用工具获取方法，如果没有也不会报错，因此使用这个方法来判断是否有此方法！
            Method method2 = MethodUtils.getAccessibleMethod(People.class, "setNumber", types3);
            Method method3 = MethodUtils.getAccessibleMethod(method2);
            System.out.println(method3); // null
    
            // 17、获取指定方法的可访问方法：类 + 方法
            Method method4 = MethodUtils.getAccessibleMethod(People.class, method2);
            System.out.println(method4); // null
    
            // 18、获取与指定方法名称相同且与参数类型列表匹配的可访问方法
            Method method5 = MethodUtils.getMatchingAccessibleMethod(People.class, "setName", types3);
            try {
        
                method5.invoke(people, "二哥关羽", "三哥张飞");
            } catch (IllegalAccessException | InvocationTargetException e) {
        
                e.printStackTrace();
            }
            System.out.println("name: " + people.getName()); // name: 二哥关羽三哥张飞
    
            // 19、确定一个类型是否可以用作方法调用中的参数。
            boolean isAssignableFrom = MethodUtils.isAssignmentCompatible(String.class, Integer.class);
            System.out.println(isAssignableFrom); // false
            isAssignableFrom = MethodUtils.isAssignmentCompatible(String.class, String.class);
            System.out.println(isAssignableFrom); // true
            isAssignableFrom = MethodUtils.isAssignmentCompatible(String.class, Object.class);
            System.out.println(isAssignableFrom); // false
            isAssignableFrom = MethodUtils.isAssignmentCompatible(Integer.class, Object.class);
            System.out.println(isAssignableFrom); // false
            isAssignableFrom = MethodUtils.isAssignmentCompatible(Integer.class, Long.class);
            System.out.println(isAssignableFrom); // false
    
            // 20、获取一个基本类型的包装类型
            Class<?> primitiveType = MethodUtils.getPrimitiveWrapper(int.class);
            System.out.println(primitiveType); // class java.lang.Integer
    
            // 21、获得包装类的基本数据类型
            Class<?> primitiveType2 = MethodUtils.getPrimitiveType(Integer.class);
            System.out.println(primitiveType2); // int
    
            // 22、如果是简单数据类型则返回对应的包装类，否则返回本身
            Class<?> primitiveType3 = MethodUtils.toNonPrimitiveClass(int.class);
            System.out.println(primitiveType3); // class java.lang.Integer
            Class<?> primitiveType4 = MethodUtils.toNonPrimitiveClass(Integer.class);
            System.out.println(primitiveType4); // class java.lang.Integer
    
        }
    
    }