脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java反射技术

Java基础之反射技术相关知识总结

 更新时间：2021年05月25日 14:54:09   作者：无名终将胜有名  
今天带大家复习Java基础知识,文中对Java反射技术介绍的非常详细,对正在学习Java的小伙伴们很有帮助,,需要的朋友可以参考下

一、反射概念

Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。

二、反射应用场景

1.几乎所有的框架都会用到反射

2.程序解耦合使用

3.代码更加的优雅

三、反射更多细节

1.Jdk中的位置: java.lang.reflect包下

在这里插入图片描述

2.获取字节码方式

// 通过类的全限定类名获取
Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
// 通过类直接获取
Class<Hero> clazzB = Hero.class;
// 通过实例化对象获取
Class<? extends Hero> clazzC = (new Hero()).getClass();
// 基本类型的包装类的type获取
Class<Byte> byteClazz = Byte.TYPE;
Class<Short> typeClazz = Short.TYPE;
Class<Integer> integerClazz = Integer.TYPE;
Class<Long> longClazz = Long.TYPE;
Class<Float> floatClazz = Float.TYPE;
Class<Double> doubleClazz = Double.TYPE;
Class<Character> characterClazz = Character.TYPE;
Class<Boolean> booleanClazz = Boolean.TYPE;

3.测试类Hero省略Setter和Getter以及toString方法其中包含无参构造和满参构造

package com.open_source.demo.domain;

/**
 * 英雄实体类
 *
 * @author: tyvek
 */
public class Hero {
    /**
     * 类型
     */
    private String type;
    /**
     * 姓名
     */
    private String name;
    /**
     * 战力
     */
    private Double CE;

    /**
     * 打印英雄属性
     *
     * @param hero 英雄对象
     */
    public void attrbute(Hero hero) {
        System.out.println(hero.getType() + ": " + hero.getName() + "输出伤害： " + hero.getCE());
    }

    /**
     * 为队友加油
     */
    public void fighting() {
        System.out.println("稳住 我们能赢");
    }

    /**
     * 向英雄发起进攻
     *
     * @param name 英雄名字
     */
    public void attack(String name) {
        System.out.println("准备向" + name + "发起进攻");
    }

    public Hero(String type, String name, Double CE) {        
        this.type = type;
        this.name = name;
        this.CE = CE;
    }

    public Hero() {
    }
}

4.获取类的成员

获取类的构造函数

import java.util.StringJoiner;

/**
 * 反射测试类
 * @author: tyvek
 */
public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException {
        // 通过类的全限定类名获取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 获取所有构造函数字节码
        Constructor<?>[] declaredConstructors = clazzA.getDeclaredConstructors();
        // 打印构造函数修饰符以及参数类型
        for (int i = 0; i < declaredConstructors.length; i++) {
            // 美化输出
            StringJoiner sj = new StringJoiner(", ","[","]");
            System.out.print("构造函数修饰符：" + Modifier.toString(declaredConstructors[i].getModifiers()) + "  参数类型：");
            Class<?>[] parameterTypes = declaredConstructors[i].getParameterTypes();
            for (int j = 0; j < parameterTypes.length; j++) {
                sj.add(parameterTypes[j].getName());
            }
            System.out.println(sj.toString());
        }
    }
}
// 打印内容  
构造函数修饰符：public  参数类型：[java.lang.String, java.lang.String, java.lang.Double] 
构造函数修饰符：public  参数类型：[]

获取指定构造函数

// 通过类的全限定类名获取
Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
// 获取满参构造
Constructor<?> allArgsConstructor = clazzA.getDeclaredConstructor(String.class, String.class, Double.class);
// 获取无参构造
Constructor<?> noneArgConstructor = clazzA.getDeclaredConstructor();

调用构造函数

public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 通过类的全限定类名获取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 获取满参构造
        Constructor<?> allArgsConstructor = clazzA.getDeclaredConstructor(String.class, String.class, Double.class);
        // 获取无参构造
        Constructor<?> noneArgConstructor = clazzA.getDeclaredConstructor();
        // 如果修饰符为private需要使用暴力反射
        // noneArgConstructor.setAccessible(true);
        Hero hero = (Hero) noneArgConstructor.newInstance();
        hero.setType("射手");
        hero.setName("后裔");
        hero.setCE(1000.0);
        System.out.println(hero);
        Hero heroAll = (Hero) allArgsConstructor.newInstance("法师", "诸葛亮", 1000.1);
        heroAll.attrbute(heroAll);
    }
}
// 控制台输出
Hero{type='射手', name='后裔', CE=1000.0}
法师: 诸葛亮 输出伤害： 1000.1

获取成员方法

public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 通过类的全限定类名获取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 获取无参构造
        Constructor<?> noneArgConstructor = clazzA.getDeclaredConstructor();
        Hero hero = (Hero) noneArgConstructor.newInstance();
        // 获取所有成员方法
        Method[] declaredMethods = clazzA.getDeclaredMethods();
        for (int i = 0; i < declaredMethods.length; i++) {
            StringJoiner sj = new StringJoiner(",", "[", "]");
            System.out.print("方法名称：" + declaredMethods[i].getName() + " 方法参数: ");
            Class<?>[] parameterTypes = declaredMethods[i].getParameterTypes();
            for (int j = 0; j < parameterTypes.length; j++) {
                sj.add(parameterTypes[j].getName());
            }
            System.out.println(sj.toString());
        }
    }
}
// 控制台输出
方法名称：attrbute 方法参数: [com.open_source.demo.domain.Hero]
方法名称：attack 方法参数: [java.lang.String]
set和get省略

方法调用

// 获取attack字节码对象
Method attackMethod = clazzA.getDeclaredMethod("attack", String.class);
// 如果修饰符为private同样需要使用暴力反射
attackMethod.invoke(hero,"周瑜");
// 控制台输出
准备向周瑜发起进攻

获取所有的成员属性

public class ReflectClient {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 通过类的全限定类名获取
        Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero");
        // 获取所有成员属性
        Field[] declaredFields = clazzA.getDeclaredFields();
        Stream.of(declaredFields).forEach(System.out::println);
    }
}
// 控制台输出
private java.lang.String com.open_source.demo.domain.Hero.type
private java.lang.String com.open_source.demo.domain.Hero.name
private java.lang.Double com.open_source.demo.domain.Hero.CE

获取父类的字节码

// 通过类的全限定类名获取
Class<?> clazzA = Class.forName("com.open_source.demo.domain.Hero").getSuperclass();

反射工具类

package com.open_source.demo.support;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

/**
 * @author: tyvek
 * 反射工具类
 */
public class ReflectSupport {
    private ReflectSupport(){};

    /**
     * 获取字段对应值，并转为String类型，空值返回空字符串
     * @param fieldName
     * @param obj
     * @return
     */
    public static synchronized String getStringValue(String fieldName,Object obj) throws  ReflectiveOperationException{
        Object objectValue = getValueByGetter(fieldName,obj);
        if (objectValue == null){
            return "";
        }
        String result = objectValue.toString();
        //如果类型为BigDecimal,去掉末尾的0
        if (objectValue instanceof BigDecimal){
            BigDecimal value = (BigDecimal) objectValue;
            value = value.stripTrailingZeros();
            result = value.toPlainString();
        }else if (objectValue instanceof Date){
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            result = sdf.format((Date)objectValue).replace(" 00:00:00", "");
        }

        return result.trim();
    }

    public static Object getValueByGetter (String fieldName,Object obj) throws ReflectiveOperationException {
        Method getter = getGetter(fieldName, obj.getClass());
        if (getter != null){
            return getter.invoke(obj);
        }

        return null;
    }


    public static Object setValueBySetter (String fieldName,Object obj) throws ReflectiveOperationException {
        Method setter = getSetter(fieldName, obj.getClass());
        if (setter == null){
            throw new ReflectiveOperationException("没有set方法");
        }

        return setter.invoke(obj);
    }

    /**
     * 获取get方法
     * @param fieldName
     * @param cls
     * @return
     */
    public static Method getGetter(String fieldName,Class<?> cls){
        for (Method method : cls.getMethods()) {
            if (method.getName().equalsIgnoreCase("get".concat(fieldName)) && method.getParameterTypes().length == 0){
                return  method;
            }
        }
        return null;
    }

    /**
     * 获取set方法
     * @param fieldName
     * @param cls
     * @return
     */
    public static Method getSetter(String fieldName,Class<?> cls){
        for (Method method : cls.getMethods()) {
            if (method.getName().equalsIgnoreCase("set".concat(fieldName)) && method.getParameterTypes().length == 0){
                return  method;
            }
        }
        return null;
    }

    /**
     * 通过属性名获取Field对象
     * @param fieldName
     * @param cls
     * @return
     */
    public static synchronized Field getFieldByName(String fieldName,Class<?> cls){
        Field[] fields =cls.getDeclaredFields();
        for (Field field : fields){
            if (field.getName().equals(fieldName)){
                return field;
            }
        }

        if (cls.getSuperclass() != null){
            return getFieldByName(fieldName,cls.getSuperclass());
        }

        return null;
    }

    /**
     * 通过对象.class获取所有Fields，包括父类
     * @param cls
     * @return
     */
    public static List<Field> listFields(Class<?> cls){
        Field[] fs = cls.getDeclaredFields();
        List<Field> fields = new ArrayList<>(Arrays.asList(fs));
        if (cls.getSuperclass() !=null){
            fields.addAll(listFields(cls.getSuperclass()));
        }
        return fields;
    }

    public static  boolean fieldExist(String fieldName,Class<?> cls){
        return getFieldByName(fieldName, cls) !=null;
    }
}

到此这篇关于Java基础之反射技术相关知识总结的文章就介绍到这了,更多相关Java反射技术内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • 详细介绍Java中的各种锁

    详细介绍Java中的各种锁

    不少同学开始慢慢接触多线时候,对线程之间为了保障数据安全性，一致性有所了解,本文详细解介绍java中的21种锁 ,需要的朋友可以参考下
    2021-06-06
  • SpringBoot统一接口返回及全局异常处理高级用法

    SpringBoot统一接口返回及全局异常处理高级用法

    这篇文章主要为大家介绍了SpringBoot统一接口返回及全局异常处理高级用法示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-06-06
  • springMvc全局异常的实现

    springMvc全局异常的实现

    大家好，本篇文章主要讲的是springMvc全局异常的实现，感兴趣的同学赶紧来看一看吧，对你有帮助的话记得收藏一下
    2022-02-02
  • struts2与cookie 实现自动登录和验证码验证实现代码

    struts2与cookie 实现自动登录和验证码验证实现代码

    这篇文章主要介绍了struts2与cookie 实现自动登录和验证码验证实现代码的相关资料,需要的朋友可以参考下
    2016-10-10
  • SpringBoot 回滚操作的几种实现方式

    SpringBoot 回滚操作的几种实现方式

    回滚操作是一种常见的操作,用于撤销之前执行的操作,本文主要介绍了SpringBoot回滚操作的几种实现方式,包含基于异常类型的回滚、基于自定义逻辑的回滚和基于数据库状态的回滚,感兴趣的可以了解一下
    2024-03-03
  • JDK8环境中使用struts2的步骤详解

    JDK8环境中使用struts2的步骤详解

    这篇文章主要给大家介绍了关于在JDK8环境中使用struts2的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2018-11-11
  • Java 获取原始请求域名实现示例

    Java 获取原始请求域名实现示例

    这篇文章主要为大家介绍了Java 获取原始请求域名实现示例,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-12-12
  • mybatis深入讲解resultMap的定义及用法

    mybatis深入讲解resultMap的定义及用法

    MyBatis的每一个查询映射的返回类型都是ResultMap，当我们提供返回类型属性是resultType时，MyBatis会自动给我们把对应值赋给resultType所指定对象的属性，当我们提供返回类型是resultMap时，将数据库中列数据复制到对象的相应属性上，可以用于复制查询，两者不能同时用
    2022-04-04
  • 深入理解java内置锁(synchronized)和显式锁(ReentrantLock)

    深入理解java内置锁(synchronized)和显式锁(ReentrantLock)

    这篇文章主要介绍了Java多线程之内置锁(synchronized)和显式锁(ReentrantLock)的深入理解新的和用法，具有一定参考价值，需要的朋友可以了解下。
    2017-11-11
  • SpringBoot中处理的转发与重定向方式

    SpringBoot中处理的转发与重定向方式

    这篇文章主要介绍了SpringBoot中处理的转发与重定向方式,分别就转发和重定向做了概念解说，结合示例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2022-11-11

最新评论