Spring：ReflectionUtils工具类使用一：Field

已于 2022-05-24 19:21:43 修改
阅读量1.1w 收藏 14
点赞数 4
分类专栏： Spring 文章标签： spring java 后端
于 2022-02-17 11:36:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a232884c/article/details/122930028
版权

Spring：ReflectionUtils工具类使用一：Field

1 前言

spring-core依赖中，带有反射工具类ReflectionUtils，导包如下：

import org.springframework.util.ReflectionUtils;

在这里插入图片描述
2 Field相关使用

（1）ReflectionUtils.makeAccessible、ReflectionUtils.findField使用：

实际上，ReflectionUtils.makeAccessible本质就是调用field.setAccessible(true)，让非public修饰的字段，可以操作如protected、private修饰的字段。如下，ReflectionUtils.findField不使用ReflectionUtils.makeAccessible也是可以的，但是ReflectionUtils.getField是需要使用的。
在这里插入图片描述
新建注解类MyFruit：

package com.xiaoxu.annotation;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MyFruit {
    String fruitName();
    int number();
}

新建一个DTO类：FruitDTO：
在这里插入图片描述

package com.xiaoxu.dto;

import com.xiaoxu.annotation.MyFruit;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * @author xiaoxu
 * @date 2022-02-14
 * Ymybatis:com.xiaoxu.dto.FruitDto
 */
public class FruitDto {
    @MyFruit(fruitName = "荔枝",number = 1)
    private String one;

    @MyFruit(fruitName = "菠萝",number = 2)
    private String two;

    public static void main(String[] args) {
        Class<FruitDto> clazz = FruitDto.class;
        Field[] f = clazz.getDeclaredFields();
        System.out.println(Arrays.toString(f));
        Map<Integer,Field> m = new HashMap<>();
        for (Field field : f) {
            System.out.println("*********开始*********");
            System.out.printf("我是field:%s%n",field);
            String fieldName = field.getName();
            System.out.printf("我是字段名：%s%n",fieldName);
            Field field1 = ReflectionUtils.findField(clazz, fieldName);
            if(field1 !=null){
                ReflectionUtils.makeAccessible(field1);
            }
            System.out.printf("ReflectionUtils的findField方法获取字段：%s%n",field1);
            // 如果字段具有MyFruit注解
            if(field.isAnnotationPresent(MyFruit.class)){
                MyFruit myFruit = field.getAnnotation(MyFruit.class);
                System.out.printf("字段field调用getAnnotation获取注解：%s%n",myFruit);
                System.out.printf("map.put返回值为null,说明key不重复：%s%n",m.put(myFruit.number(),field));
                System.out.printf("map.put返回值为value(这里是Filed的name),说明key重复了：%s%n",m.put(myFruit.number(),field).getName());
                System.out.printf("获取注解的fruitName:%s%n",myFruit.fruitName());
                System.out.printf("获取注解的number:%s%n",myFruit.number());
            }
            System.out.println("*********结束*********");
        }
        System.out.printf("字典如下：%s%n",m);
        for(Map.Entry<Integer,Field> e:m.entrySet()){
            System.out.printf("字典的key:%s,value:%s%n",e.getKey(),e.getValue());
            System.out.println(e.getValue().getAnnotation(MyFruit.class).fruitName());
            System.out.println(e.getValue().getAnnotation(MyFruit.class).number());
        }
    }
}

执行结果如下：

[private java.lang.String com.xiaoxu.dto.FruitDto.one, private java.lang.String com.xiaoxu.dto.FruitDto.two]
*********开始*********
我是field:private java.lang.String com.xiaoxu.dto.FruitDto.one
我是字段名：one
ReflectionUtils的findField方法获取字段：private java.lang.String com.xiaoxu.dto.FruitDto.one
字段field调用getAnnotation获取注解：@com.xiaoxu.annotation.MyFruit(fruitName=荔枝, number=1)
map.put返回值为null,说明key不重复：null
map.put返回值为value(这里是Filed的name),说明key重复了：one
获取注解的fruitName:荔枝
获取注解的number:1
*********结束*********
*********开始*********
我是field:private java.lang.String com.xiaoxu.dto.FruitDto.two
我是字段名：two
ReflectionUtils的findField方法获取字段：private java.lang.String com.xiaoxu.dto.FruitDto.two
字段field调用getAnnotation获取注解：@com.xiaoxu.annotation.MyFruit(fruitName=菠萝, number=2)
map.put返回值为null,说明key不重复：null
map.put返回值为value(这里是Filed的name),说明key重复了：two
获取注解的fruitName:菠萝
获取注解的number:2
*********结束*********
字典如下：{1=private java.lang.String com.xiaoxu.dto.FruitDto.one, 2=private java.lang.String com.xiaoxu.dto.FruitDto.two}
字典的key:1,value:private java.lang.String com.xiaoxu.dto.FruitDto.one
荔枝
1
字典的key:2,value:private java.lang.String com.xiaoxu.dto.FruitDto.two
菠萝
2

（2）ReflectionUtils.doWithFields使用：
在这里插入图片描述
注解MFruit：

package com.xiaoxu.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface MFruit {
    String name();
    long num();
}

在这里插入图片描述
dto下新建PreciousFruit类：

package com.xiaoxu.dto;

import com.xiaoxu.annotations.MFruit;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

/**
 * @author xiaoxu
 * @date 2022-02-14 22:26
 * mybatis_learn:com.xiaoxu.dto.PreciousFruit
 */
public class PreciousFruit {
    @MFruit(name = "芒果",num = 1)
    private String fruitOne;

    @MFruit(name = "猕猴桃",num = 2)
    private String fruitTwo;

    @MFruit(name = "香蕉",num = 3)
    public String fruitThree;

    @MFruit(name = "砂糖橘",num = 4)
    protected String fruitFour;

    public static Map<Long,Field> injectMethod(){
        Map<Long,Field> m = new HashMap<>();
        ReflectionUtils.doWithFields(PreciousFruit.class,
                // FieldCallback是一个函数式接口，所以可以使用lambda表达式,
                // 也可以使用方法引用，或者直接new 重写接口的doWith方法
                new ReflectionUtils.FieldCallback() {
                    @Override
                    public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
                        System.out.println("我是回调，哈哈哈哈");
                        if(field.isAnnotationPresent(MFruit.class)){
                            System.out.printf("字段:%s;具有注解MFruit%n",field);
                            long number = field.getAnnotation(MFruit.class).num();
                            if(m.put(number,field)!=null){
                                System.out.println("该水果number重复，跳过");
                            }
                        }
                        System.out.println("********");
                    }
                });
        return m;
    }

    public static void main(String[] args) {
        Map<Long, Field> longFieldMap = PreciousFruit.injectMethod();
        longFieldMap.forEach((k,v)->System.out.printf("map的key:%s,value:%s%n",k,v));
    }
}

执行结果：

我是回调，哈哈哈哈
字段:private java.lang.String com.xiaoxu.dto.PreciousFruit.fruitOne;具有注解MFruit
********
我是回调，哈哈哈哈
字段:private java.lang.String com.xiaoxu.dto.PreciousFruit.fruitTwo;具有注解MFruit
********
我是回调，哈哈哈哈
字段:public java.lang.String com.xiaoxu.dto.PreciousFruit.fruitThree;具有注解MFruit
********
我是回调，哈哈哈哈
字段:protected java.lang.String com.xiaoxu.dto.PreciousFruit.fruitFour;具有注解MFruit
********
map的key:1,value:private java.lang.String com.xiaoxu.dto.PreciousFruit.fruitOne
map的key:2,value:private java.lang.String com.xiaoxu.dto.PreciousFruit.fruitTwo
map的key:3,value:public java.lang.String com.xiaoxu.dto.PreciousFruit.fruitThree
map的key:4,value:protected java.lang.String com.xiaoxu.dto.PreciousFruit.fruitFour

Process finished with exit code 0

（3）ReflectionUtils.getField使用：

ReflectionUtils.getField本质是调用的field.get(target)，getField获取对象该字段的值时，引用类型若未使用setter赋值，那么默认值就是null。另外，ReflectionUtils.getField使用时，若是protected或者private修饰的字段，需先使用ReflectionUtils.makeAccessible(field)。

package com.xiaoxu.dto;

import com.xiaoxu.annotation.MyFruit;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * @author xiaoxu
 * @date 2022-02-15 21:31
 * mybatis_learn:com.xiaoxu.dto.FruitDto
 */
public class FruitDto {
    @MyFruit(fruitName = "荔枝",number = 1)
    public String one;
    @MyFruit(fruitName = "菠萝",number = 2)
    private String two;
    @MyFruit(fruitName = "车厘子",number = 3)
    protected String three;

    public void setOne(String one) {
        this.one = one;
    }

    public void setTwo(String two) {
        this.two = two;
    }

    public void setThree(String three) {
        this.three = three;
    }

    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        Class<FruitDto> clazz = FruitDto.class;
        FruitDto cls = clazz.newInstance();
        Field[] fields = clazz.getDeclaredFields();
        cls.setThree("nihao");
        for (Field field : fields) {
            System.out.printf("我是字段%s%n",field);
            System.out.printf("我是字段的修饰符：%s%n",field.getModifiers());
            switch(field.getModifiers()){
                case 1:
                    System.out.println("我是public");
                    Object filed1 = ReflectionUtils.getField(field,cls);
                    System.out.printf("我是field:%s%n",filed1);
                    break;
                case 2:
                    System.out.println("我是private");
                    ReflectionUtils.makeAccessible(field);
                    Object filed2 = ReflectionUtils.getField(field,cls);
                    System.out.printf("我是field:%s%n",filed2);
                    break;
                case 4:
                    System.out.println("我是protected");
                    ReflectionUtils.makeAccessible(field);
                    Object filed3 = ReflectionUtils.getField(field,cls);
                    System.out.printf("我是field:%s%n",filed3);
                    break;
                default:
                    System.out.println("暂时只支持public、protected、private.");
            }
            if(Modifier.isProtected(field.getModifiers())){
                System.out.println("我是保护的");
                ReflectionUtils.makeAccessible(field);
                Object field1 = ReflectionUtils.getField(field, cls);
                System.out.println(field1);
            }
            System.out.println("****************");
        }
    }
}

执行结果：

我是字段public java.lang.String com.xiaoxu.dto.FruitDto.one
我是字段的修饰符：1
我是public
我是field:null
****************
我是字段private java.lang.String com.xiaoxu.dto.FruitDto.two
我是字段的修饰符：2
我是private
我是field:null
****************
我是字段protected java.lang.String com.xiaoxu.dto.FruitDto.three
我是字段的修饰符：4
我是protected
我是field:nihao
我是保护的
nihao
****************

（4）ReflectionUtils.setField使用：

实体类中重写toString便于观察，无需加入setter方法。且使用ReflectionUtils.setField前，也需要为private、protected修饰的字段执行setAccessible(ture)操作。

package com.xiaoxu.dto;

import com.xiaoxu.annotations.MyFruit;
import org.springframework.util.ReflectionUtils;

import java.lang.reflect.Modifier;
import java.util.Arrays;

/**
 * @author xiaoxu
 * @date 2022-02-16 22:31
 * mybatis_learn:com.xiaoxu.dto.FruitDto2
 */
public class FruitDto2 {
    @MyFruit(fruitName = "牛油果",number = 1)
    public String one;

    @MyFruit(fruitName = "葡萄",number = 2)
    private String two;

    @MyFruit(fruitName = "桃子",number = 3)
    protected String three;

    @Override
    public String toString() {
        return "水果2{" +
                "one='" + one + '\'' +
                ", two='" + two + '\'' +
                ", three='" + three + '\'' +
                '}';
    }

    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        Class<? extends FruitDto2> clazz = FruitDto2.class;
        FruitDto2 f = clazz.newInstance();
        Arrays.stream(clazz.getDeclaredFields()).forEach(field->{
            System.out.println(field);
            if(Modifier.isPrivate(field.getModifiers())||Modifier.isProtected(field.getModifiers())){
                ReflectionUtils.makeAccessible(field);
            }
            ReflectionUtils.setField(field,f,"one");
        });
        System.out.println(f);
    }
}

结果如下：

public java.lang.String com.xiaoxu.dto.FruitDto2.one
private java.lang.String com.xiaoxu.dto.FruitDto2.two
protected java.lang.String com.xiaoxu.dto.FruitDto2.three
水果2{one='one', two='one', three='one'}
小徐也要努力鸭
关注
  • 4
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何使用Spring工具类动态匹配url
08-25
使用 Spring 工具类动态匹配 URL 是一种非常实用的技术，它可以帮助开发者快速实现业务逻辑，并提高开发效率和工作效率。本文通过示例代码详细介绍了如何使用 Spring 工具类动态匹配 URL，希望能够对读者的学习和...
Spring源码问答
涛
04-27 262
问题1：Spring怎么这么聪明，知道哪些bean需要被实例化？　　　  什么控制反转、依赖注入，说到底就是程序在需要使用一个bean的时候，Spring框架确保该bean已经被实例化了，可以直接拿来使用。那么这时候，我想要知道，Spring是如何知道哪些bean需要实例化？其实程序总归是程序，程序是很笨的，它并不知道要实例化哪些东西，除非你告诉它。首先需要配置DispatcherServlet，...
Spring中的各种Utils（五）：ReflectionUtils详解
热门推荐
wolfcode_cn的博客
06-12 4万+
原创文章，转载请注明出处。本节中，我们来看看Spring针对反射提供的工具类：ReflectionUtils。反射在容器中使用是非常频繁的了，ReflectionUtils中也提供了想当多的有用的方法，一起来看看。在ReflectionUtils中提供了一些专门用于处理在反射中异常相关的方法，这些方法一般在Spring框架内部使用，当然，出于规范考虑，我们在开发中涉及到反射的异常，也可以使用这些方...
Spring ReflectionUtils深度解析：揭开Java反射的神秘面纱
最新发布
m0_51176516的博客
05-01 50
Spring框架中的ReflectionUtils是一个工具类，提供了许多便利的方法来简化Java反射（Reflection）的操作。Java反射允许程序在运行时获取类的内部信息，包括类的成员变量、方法、构造器等信息，并且可以动态地创建对象、调用方法。然而，反射操作通常比较繁琐，涉及大量的异常处理。Spring的ReflectionUtils就是为了简化这些操作而设计的。
Spring 中一个常用的反射类库ReflectionUtils
夜-feng的专栏
06-02 1万+
在项目中部分方法采用反射，通过类访问类的属性，通过类反问方法，通过属性访问方法。以及常用异常的处理在等可以使用反射出处理。   public abstract class ReflectionUtils {    //根据类和属性名称查找属性字段 //Attempt to find a {@link Field field} on the supplied {@link Class} w
Springboot内置的工具类之ReflectionUtils
凡夫编程
12-16 3644
ReflectionUtils应该是Springboot内置工具类梳理的最后一篇了，可以很多人都没有听说过这个工具类。这个类封装的是一些与java反射相关的静态工具方法，可能很多人知道反射，却不怎么经常使用反射。其实反射是一个很用的技术点，我认为是可以和AOP比肩的，甚至有过之而不及。大家都知道AOP是面向切面编程，可以在定义的切面前、后执行一些操作，但是反射更厉害，它可以在程序运行时，对已装载的任意类的属性和方法进行操作，这就是java的反射机制。
Spring反射内置工具类ReflectionUtils
evanYang的博客
02-13 2894
Spring反射内置工具类ReflectionUtils
反射工具类ReflectionUtils
aizhupo1314的博客
07-02 4348
AVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 通俗点讲，反射就是把java类中的各种成分映射成一个个的Java对象。 例如：类的class声明（class对象），变量（field），方法（method）等等信息，利用反射技术可以对一个类进行解剖，动态获取信息进行处理。1、获取Class对象的三种方式 1.1 Object ——> getClass(
简单了解Spring中常用工具类
08-29
Spring 中常用工具类详解 Spring 框架提供了许多有用的工具类，用于简化应用程序的开发和维护。在这篇文章中，我们将详细介绍 Spring 中常用工具类，包括资源操作、文件操作等。 资源操作 在 Spring 中，资源操作...
JdbcUtils:（仿Spring JdbcTemplate）JDBC工具类
04-03
JdbcUtils使用指南JdbcUtils是JDBC的工具类，封装了JDBC连接获取，语句结构，资源释放等繁琐步骤，对外提供简洁的数据库查询和更新操作接口。使用前准备添加maven仓库地址< repositories> < repository> < id>byx-...
Spring的优秀工具类盘点，第1部分:文件资源操作和Web相关工具类
03-03
Spring不但提供了一个功能全面的应用开发框架，本身还拥有众多可以在程序编写时直接使用的工具类，您不但可以在Spring应用中使用这些工具类，也可以在其它的应用中使用，这些工具类中的大部分是可以在脱离Spring框架...
lazyers-spring:懒人工具
03-21
懒惰的春天 懒人工具
Spring：ReflectionUtils工具类使用二：Method
a232884c的博客
02-23 3035
Spring：ReflectionUtils工具类使用二：Method 1 使用 package com.xiaoxu.base; import org.springframework.util.ReflectionUtils; import java.lang.reflect.Method; import java.util.Arrays; /** * @author xiaoxu * @date 2022-02-21 * Ymybatis:com.xiaoxu.base.FruitMetho
ReflectionUtils反射工具：精要介绍与实战应用指南
码到三十五
04-01 1577
ReflectionUtils是 Spring 框架提供的一个反射工具类，它封装了 Java 反射 API 的一些常用操作，使得我们能够更加方便、简洁地使用反射功能。
field.setAccessible(true)安全漏洞
Tu南的博客
09-24 3608
代码扫描提示：AccessibleObject类是Field、Method和Constructor对象的基类，能够允许反射对象修改访问权限修饰符，绕过由Java访问修饰符提供的访问控制检查。它让程序员能够更改私有字段或调用私有方法，这在通常情况下是不允许的。 解决方案：ReflectionUtils.makeAccessible(field)（该方法是spring针对反射提供的工具类）。 ...
Spring框架中的反射工具类ReflectionUtils
hello，word！
01-09 1511
获取类的信息：ReflectionUtils可以通过类的全限定名获取对应的Class对象，进而获取类的各种信息，如类名、包名、父类、接口等。创建对象：ReflectionUtils可以通过Class对象创建实例，即通过反射实现动态创建对象的功能。调用方法：ReflectionUtils可以通过Method对象调用类的方法，包括无参方法和有参方法，可以通过方法名和参数类型来定位方法。访问字段：ReflectionUtils可以通过Field对象访问类的字段，包括获取字段值和设置字段值。
Spring源码深度解析（三）：自动注入原理源码详解
欢迎来到Jimmy的博客
09-09 1214
前言 IOC容器的一个强大功能就是可以实现自动注入，本节就来看一下自动注入的原理，并且看一下循环依赖是如何解决的。
Spring工具类 -- ReflectionUtils
lingguangyong
02-17 1417
Field相关操作 根据字段名称与字段类型查找Field findField(Class<?> clazz, String name, Class<?> type) 根据字段名称查找Field Field findField(Class<?> clazz, String name) 给指定字段设置值 setField(Field field, Object target, Object value) 获取指定字段的值 getField(Field field, Objec
spring中的反射工具类ReflectionUtils
qq_42772400的博客
05-18 1万+
spring提供的ReflectionUtils可以简化项目中反射代码的复杂性 在项目中如果使用最原始的方法来开发反射的功能的话肯能会比较复杂，需要处理一大堆异常以及访问权限等问题。spring中提供了ReflectionUtils这个反射的工具类 获取方法 根据bean的名称、需要调用的方法名、和要传递的参数来调用该bean的特定方法。 ReflectionUtils.findMethod()方法： public static Method findMethod(Class<?> clazz,
spring:datasource:schenma 如何使用
07-08
在 Spring 中，你可以使用 `spring.datasource.schema` 属性来指定要在应用程序启动时执行的数据库模式（schema）脚本。 首先，你需要在 Spring Boot 的配置文件（例如 application.properties 或 application.yml）中添加以下属性： application.properties: ``` spring.datasource.schema=classpath:schema.sql ``` application.yml: ```yaml spring: datasource: schema: classpath:schema.sql ``` 上述示例中，`schema.sql` 是你要执行的数据库模式脚本的文件路径。使用 `classpath:` 前缀表示该脚本位于类路径下。 当应用程序启动时，Spring 会自动检测并执行指定的数据库模式脚本。 注意：`spring.datasource.schema` 属性只适用于数据库模式脚本，如果你还需要执行数据初始化脚本，可以使用 `spring.datasource.data` 属性来指定。例如： application.properties: ``` spring.datasource.schema=classpath:schema.sql spring.datasource.data=classpath:data.sql ``` application.yml: ```yaml spring: datasource: schema: classpath:schema.sql data: classpath:data.sql ``` 这样，在应用程序启动时，Spring 会先执行数据库模式脚本，然后执行数据初始化脚本。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值