Java中反射在项目中的应用

已于 2022-10-26 10:09:31 修改
阅读量358 收藏
点赞数
文章标签： java spring junit
于 2022-10-08 11:40:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/helldoger/article/details/127205895
版权

比如从前端获得了一个对象person，想让其属性输入map中：

package com.zg.reflactiontest;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;

/**
 * @Auther: zhaoss
 * @Date: 2022/10/8 - 10 - 08 - 11:26
 * @Description: com.zg.reflactiontest
 * @version: 1.0
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Slf4j
public class Person {
    private String name;
    private String gender;
    private Integer age;
}


package com.zg.reflactiontest;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

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

@SpringBootTest
class ReflactiontestApplicationTests {

    @Test
    void contextLoads() throws IllegalAccessException {
        Person person = new Person("张三","男",18);
        Map<String,Object> map = new TreeMap<>();
        Field[] fields = person.getClass().getDeclaredFields();

        for (Field f:fields
             ) {
            f.setAccessible(true);
            map.put(f.getName(), f.get(person));
            System.out.println(map.get(f.getName()));
        }
    }

}

结果：

张三
男
18

    @Test
    public void Test9() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException {
        //获取类对应的字节码的对象（三种）
        /*
        1, 由对象获取全类名：
         */
        Emp emp = new Emp();
        Class clazz1 = emp.getClass();
        System.out.println(clazz1);
        System.out.println("========");
        /*
        结果：class com.zg.myssm.entities.Emp
         */

        /*
        2, 通过全类名获取字节码对象，实例化
         */
        Class clazz2 = Class.forName("com.zg.myssm.entities.Emp");
        System.out.println(clazz2.toString());

        Object o = clazz1.newInstance();
        System.out.println(o.toString());

        System.out.println("==========");
        /*
        结果：
        class com.zg.myssm.entities.Emp
        Emp(empId=null, empName=null, age=null, gender=null, dept=null)
         */

        /*
        3，调用类的class属性 获取字节码对象 必须要导入包，局限性
         */
        Class clazz3 = Emp.class;
        System.out.println(clazz3);
        System.out.println("==========");

        /*
        结果：class com.zg.myssm.entities.Emp
         */

        /*
        4，获取包名常用方法：
        */
        System.out.println(clazz1.getPackage());
        System.out.println("============");
        /*
        结果：
        package com.zg.myssm.entities
         */

        System.out.println(clazz1.getPackage().getName());
        System.out.println("============");
        /*
        结果：
        com.zg.myssm.entities
         */

        /*
        5，获取类名
         */
        String simpleName = clazz1.getSimpleName();
        System.out.println(simpleName);
        System.out.println("============");
        /*
        结果：
        Emp
         */

        /*
        6，获取完整类名
         */
        String name = clazz1.getName();
        System.out.println(name);
        System.out.println("============");
        /*
        结果：com.zg.myssm.entities.Emp
         */

        /*
        7，获取全部字段，公开字段：
         */
        Field[] declaredFields = clazz1.getDeclaredFields();
        Field[] fields = clazz1.getFields();

        //全是私有字段，不显示
        Arrays.asList(fields).forEach(System.out::println);
        System.out.println("============");

        //解除检查setAccessible
        for (Field f: declaredFields
             ) {
            f.setAccessible(true);
            System.out.println(f);
        }
        /*
        结果：
        private java.lang.Integer com.zg.myssm.entities.Emp.empId
        private java.lang.String com.zg.myssm.entities.Emp.empName
        private java.lang.Integer com.zg.myssm.entities.Emp.age
        private java.lang.String com.zg.myssm.entities.Emp.gender
        private com.zg.myssm.entities.Dept com.zg.myssm.entities.Emp.dept
         */


        //获取单一字段：
        System.out.println("============");
        Field empName = clazz2.getDeclaredField("empName");
        empName.setAccessible(true);
        System.out.println(empName);
        System.out.println("============");
        /*
        结果：
        private java.lang.String com.zg.myssm.entities.Emp.empName
         */

        /*
        8，获取构造方法
         */
        //获取单个构造方法
        Constructor constructor = clazz1.getConstructor(null); //参数类型

        System.out.println(constructor);
        System.out.println("+++++++++++++++++++");
        /*
        结果：
        public com.zg.myssm.entities.Emp()
         */

        //获取全部公开构造方法
        Constructor[] constructors = clazz1.getConstructors();
        for (Constructor ctor: constructors
             ) {
            System.out.println(ctor);
        }
        System.out.println("+++++++++++++++++++");
        //结果：
        /*
        public com.zg.myssm.entities.Emp()
        public com.zg.myssm.entities.Emp(java.lang.Integer,java.lang.String,java.lang.Integer,java.lang.String,com.zg.myssm.entities.Dept)
         */

        /*
        获取所有：
        getDeclaredConstructors()//获取所有的构造方法,包括私有
        getDeclaredConstructor(int.class,String.class)
         */
        Constructor ctor2 = clazz1.getDeclaredConstructor(Integer.class, String.class, Integer.class, String.class,Dept.class);

        System.out.println(ctor2);
        System.out.println("-------------------------");
        /*
        结果：
        public com.zg.myssm.entities.Emp(java.lang.Integer,java.lang.String,java.lang.Integer,java.lang.String,com.zg.myssm.entities.Dept)
         */

        /*
        9，获取方法
         */
        Class clazz5 = Class.forName("com.zg.myssm.entities.Demon");

        //获取所有方法
        Method[] methods = clazz5.getDeclaredMethods();

        for (Method m: methods
             ) {
            m.setAccessible(true);
            System.out.println(m);
        }
        System.out.println("-==============-");

        //结果:
        /*
        public void com.zg.myssm.entities.Demon.runFunc(com.zg.myssm.entities.TestFuncPoint)
         */


        /*
        Demon：

        public class Demon {
            public void runFunc(TestFuncPoint funcPoint){
                System.out.println(funcPoint.run("通过funcPoint.run()传入的参数"));
            }
        }
         */


        //获取指定方法: 方法名，参数类型
        Method runFunc = clazz5.getDeclaredMethod("runFunc", TestFuncPoint.class);

        //TestFuncPoint 函数式接口，保证入参和返回值类型，
        // s在Demon中通过funcPoint.run(String str)传入过了。

        //定义有参数，有返回值函数指针
        TestFuncPoint fp = (String s)->{
            return s+"myStr";
        };

        //运行函数: 对象，参数数据
        runFunc.invoke(clazz5.newInstance(), fp);
        //结果：通过funcPoint.run()传入的参数myStr

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

        //定义无参数，无返回值函数指针
        TestFuncPointVoid fpVoid = ()->{
            System.out.println("SBSBSBSB");
        };

        Class clazz6 = Class.forName("com.zg.myssm.entities.TestFuncPointImpl");

        /*
        public class TestFuncPointImpl {
            public void runFunc(TestFuncPointVoid funcPoint){
                funcPoint.run();
            }
        }
         */
        //获取指定方法: 方法名，参数类型
        Method mypointVoid = clazz6.getDeclaredMethod("runFunc", TestFuncPointVoid.class);
        System.out.println(mypointVoid);
        /*
        结果：
        public void com.zg.myssm.entities.
        TestFuncPointImpl.runFunc(com.zg.myssm.entities.TestFuncPointVoid)
         */

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

        TestFuncPointVoid p = ()->{
            System.out.println("Test 函数指针&函数式编程");
        };

        p.run();
        /*
        结果：
        Test 函数指针&函数式编程
         */

        System.out.println("========+-+-+==============");
        //运行函数: 对象，参数数据, Impl中自带了run方法
        mypointVoid.invoke(clazz6.newInstance(),p);
        /*
        结果：Test 函数指针&函数式编程
         */
    }

用到的类：

package com.zg.myssm.entities;

/**
 * @Auther: Zg
 * @Date: 2022/10/24 - 10 - 24 - 20:14
 * @Description: com.zg.myssm.entities
 * @version: 1.0
 */
// Java中 接口只有一个函数，可以用接口指定函数类型，实现函数指针，委托
public interface TestFuncPoint {
    String run(String str);
}


package com.zg.myssm.entities;

/**
 * @Auther: Zg
 * @Date: 2022/10/24 - 10 - 24 - 20:16
 * @Description: com.zg.myssm.entities
 * @version: 1.0
 */
public class Demon {
    public void runFunc(TestFuncPoint funcPoint){
        System.out.println(funcPoint.run("通过funcPoint.run()传入的参数"));
    }
}


package com.zg.myssm.entities;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Auther: Zg
 * @Date: 2022/10/16 - 10 - 16 - 20:39
 * @Description: com.zg.myssm.entities
 * @version: 1.0
 */

@Builder
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Emp {

    @TableId(type = IdType.AUTO)
    private Integer empId;

    private String empName;

    private Integer age;

    private String gender;

    @TableField(exist = false)
    private Dept dept;

}


package com.zg.myssm.entities;

import com.fasterxml.jackson.databind.util.ClassUtil;

import javax.lang.model.element.VariableElement;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * @Auther: Zg
 * @Date: 2022/10/24 - 10 - 24 - 21:07
 * @Description: com.zg.myssm.entities
 * @version: 1.0
 */
public class DemonReflaction {

    Map funcMap = new HashMap<String,String >();

    public DemonReflaction() {
        myinit();
    }

    private void myinit() {
        funcMap.put("猩猩","callLebrown");
        funcMap.put("Goat", "callGinnis");
        funcMap.put("Hunter","callCurry");
    }

    public void call(String funcName) throws ClassNotFoundException {
        Object methodName = funcMap.get(funcName);
        if (methodName != null){
            try {
                Method method = DemonReflaction.class.getMethod((String) methodName);
                Class<?> clazz = Class.forName("com.zg.myssm.entities.DemonReflaction");
                //method.invoke(this,null); //对象名，参数数据
                method.invoke(clazz.newInstance(),null);
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException | InstantiationException e) {
                e.printStackTrace();
            }
        }
    }


    public void callLebrown() {
        System.out.println("I am Lebrown！");
    }

    public void callGinnis() {
        System.out.println("I am Giannis！");
    }

    public void callCurry() {
        System.out.println("I am Hunter！");
    }

}


package com.zg.myssm.entities;

import java.util.HashMap;
import java.util.Map;

/**
 * @Auther: Zg
 * @Date: 2022/10/24 - 10 - 24 - 23:33
 * @Description: com.zg.myssm.entities
 * @version: 1.0
 */
public class DemonVoid {
    Map<String, TestFuncPointVoid> funcMap = new HashMap<>();

    public DemonVoid(){
        myInit();
    }

    private void myInit() {
        funcMap.put("猩猩", this::callCurry);
        funcMap.put("Goat", this::callGinnis);
        funcMap.put("Hunter",this::callLebrown);
    }

    public void callLebrown(){
        System.out.println("我是Lebrown!!!");
    }

    public void callGinnis(){
        System.out.println("我是Lebrown!!!");
    }

    public void callCurry(){
        System.out.println("我是Lebrown!!!");
    }

    public void call(String funcName){
        TestFuncPointVoid method = funcMap.get(funcName);
        if (method != null){
            method.run();
        }
    }
}

函数式编程：

    @Test
    public void Test10() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        Class clazz = Class.forName("com.zg.myssm.entities.Demon");

        //获取方法 方法名，参数类型
        Method runFunc = clazz.getMethod("runFunc", TestFuncPoint.class);//方法名，参数类型
        runFunc.setAccessible(true);

        TestFuncPoint p = (String str) -> {
            return str;
        };
        //对象，参数数据
        runFunc.invoke(clazz.newInstance(), p);
        System.out.println(runFunc);
    }

    @Test
    public void Test11(){
//        printNum_(new IntPredicate() {
//            @Override
//            public boolean test(int value) {
//                return value%2==0;
//            }
//        });
        // 结果：2,4,6,8

        printNum_((int value)->{
            return value%2==0;
        });
    }

    public void printNum(IntPredicate predicate){
        int[] arr = {1,2,3,4,5,6,7,8,9};
        Arrays.asList(arr).forEach(a->{
            System.out.println(a);
        });
    }

    public void printNum_(IntPredicate predicate){
        Integer[] arr = {1,2,3,4,5,6,7,8,9};
        //List<Integer> ints = Arrays.asList(arr);
        //调用了test方法，返回bool
        Arrays.asList(arr).forEach(a->{
            if (predicate.test(a))
            System.out.println(a);
        });
    }
潘诺西亚的火山
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
面试官：什么是Java反射？它的应用场景有哪些？
xmt1139057136的专栏
03-12 5081
反射就是指程序在运行的时候可以知道一个类的自身信息。对于任何一个类：可以知道这个类的属性和方法。对于任何一个对象：可以调用这个对象的任何一个方法和属性。反射就是把java类中的各种成分映射成一个个的Java对象例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行 解剖，把个个 组成部分映射成一个个对象。（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
java反射的基本使用方法
最新发布
qq_23921815的博客
02-24 2748
Java反射
JAVA反射以及它的应用
qq_34654085的博客
08-31 236
反射 java 编程
java反射机制的应用场景有哪些？
weixin_43110289的博客
05-27 1508
反射是框架设计的灵魂。 在我们平时的项目开发过程中，基本上很少会直接使用到反射机制，但这不能说明反射机制没有用，实际上有很多设计、开发都与反射机制有关，例如模块化的开发，通过反射去调用对应的字节码；动态代理设计模式也采用了反射机制，还有我们日常使用的 Spring／Hibernate 等框架也大量使用到了反射机制。 举例： ①我们在使用JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序； ②Spring框架也用到很多反射机制，最经典的就是xml的配置模式。Spring 通过
初识Java反射概念和使用
CRMEB小程序商城的博客
11-10 1593
前言   大家好，瑞雪后的第一天，每个周一的大家都期待这周五的来临。相信很多小伙伴上周末就两件事，赏雪和看EDG。哈哈 开始正题吧，今天聊一聊反射吧，在java中经常使用。 反射   相信刚接触Java的，第一句肯定会问什么是反射呢？反射有什么作用呢？为什么使用反射呢？首先反射是Java的特征之一，项目中Java程序在运行的过程中，自动去识别并创建对应的类，能够动态的调用类的属性、构造方法、类中的方法。一句话描述：在程序中能动态调用不同的类和属性，去执行特定的操作。 正因为反射能够在运行时动态加载需要的对象
Java反射在实际工作中的应用笔记
08-28
Java反射在实际工作中的应用笔记 Java反射是Java语言中一个非常重要的特性，它可以在实际工作中发挥着非常重要的作用。通过Java反射，我们可以在运行时动态地调用类的成员变量和方法，从而实现了更加灵活和灵活的...
java反射在项目中的应用
05-26
NULL 博文链接：https://songlixiao.iteye.com/blog/486880
详解Java项目中读取properties文件
08-31
在Java项目中，读取properties文件是常见的任务，主要用于配置应用程序的参数或环境设置。本文将详细介绍几种在Java中读取properties文件的方法，并探讨在不同场景下的适用性。 首先，最常用的读取properties文件的...
java中反射知识总结
12-15
2. **类对象** - 在Java中，每个类都有一个对应的Class对象，它是Java反射的入口。我们可以通过Class对象来实例化对象、获取类的构造器、方法和字段信息。例如，`Class<?> clazz = Class.forName("全限定类名");` 这...
Java 通过反射给实体类赋值操作
08-24
Java 反射在实体类赋值操作中的应用 在实体类赋值操作中，Java 反射机制可以用来将请求中的参数赋值给实体类对象。具体来说，就是使用反射机制来获取实体类的字段，然后通过 setter 方法将请求中的参数赋值给对应...
Java反射详解：入门+使用+原理+应用场景
Java搜索工程技术栈
06-09 635
反射非常强大和有用，现在市面上绝大部分框架(spring、mybatis、rocketmq等等)中都有反射的影子，反射机制在框架设计中占有举足轻重的作用。所以，在你Java进阶的道路上，你需要掌握好反射。怎么才能学好反射，我们需要弄懂以下几个问题：下面我就针对以上的疑问，一一来讲解。反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行操作。反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法,对于任意一个对象，都能够调用它的任意方法和属性,这
Java基础之—反射
如果我爱自己我就会日出而坐，日落而息
09-02 324
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） 一、反射的概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的字节码文件...
Java反射在类中的应用：通过反射执行方法（获取方法）
jijiangpeng的博客
07-08 7761
要动态获取一个对象方法的信息，首先需要通过下列方法之一创建一个 Method 类型的对象或者数组。 getMethods() getMethods(String name,Class<?> …parameterTypes) getDeclaredMethods() getDeclaredMethods(String name,Class<?>...parameter...
java反射机制具体到项目中有什么用
weixin_38431146的博客
04-28 1143
http://how2j.cn/k/reflection/reflection-usage/1111.html#nowhere
Java中的反射机制（附实例程序）
一只攻城的柿子
08-22 1885
声明：本文转载自 http://zlb1986.iteye.com/blog/937781，若需要转载，请保留原作者的文章原始链接。 　　对于刚入门Java的新手来说，这是一篇不错的文章，特向大家推荐一下。先说说我在看完这篇文章之后的感受吧，作为一个对Java反射机制一点都不懂的人来说，可以说是一个入门的学习资料，建议大家详细看一下。原作者提供的代码很有价值，各位可以将他的代码作为模版，自己进行
Java 反射在实际开发中的应用
leedh_码农
07-14 1898
　　运行时类型识别(RTTI, Run-Time Type Information)是Java中非常有用的机制，在java中，有两种RTTI的方式，一种是传统的，即假设在编译时已经知道了所有的类型；还有一种，是利用反射机制，在运行时再尝试确定类型信息。 　　本篇博文会结合Thinking in Java 的demo 和实际开发中碰到的例子，对Java反射和获取类型信息做总体上整理。...
Java反射使用
鹏鹏2077
05-02 747
目录反射如何使用 反射 Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。 以上这些是百度百科的描述。 首先我们要知道一个类到对象正常的方式是这样的： 引入需要的”包类“名称——>通过new关键字实例化——>取得实例化对象 但是反射的方式是这样的： 实例化对象—
java的反射机制及使用
好好玩的博客
03-27 592
文章目录1.反射的简介（Reflection）（1）反射的理解（2）反射的优点（3）Class类2.反射的获取（1）Class类的一些常用方法（2）获取Class类的实例的方法（3）获取运行时类的完整结构1、获取类的名字2、获取类的属性3、获取类的方法4、获取类的构造器4、测试3.反射的使用（1）创建对象（2）调用对象的方法（3）操作对象的属性（4）测试4.反射操作注解 1.反射的简介（Reflection） （1）反射的理解 反射机制允许程序在执行期借助Reflection API取得类内部的任何信息，
Java中的反射以及简单运用（原理+例子）
zzvar的博客
04-10 1997
Java多线程总结内容1. 为什么要使用反射2. 反射的概念3. Java反射加载过程4. 字节码对象理解5. 获取字节码对象（.class）的三种方式6. 反射常用API总结 总结内容 1. 为什么要使用反射 Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。 2. 反射的概念 Java反射机制的核心是在程序运行时

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潘诺西亚的火山

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值