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反射技术内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • java反射机制的一些学习心得小结

    概述 之前在了解Spring的类加载机制的时候,了解了java的反射机制.但是,我对反射理解一直不深.也一直有点疑惑:Spring为什么利用反射创建对象?直接new对象和依靠反射创建对象有什么区别?什么是动态加载类? 什么是反射? 要想知道反射到底是什么,首先需要知道java的类加载和对象创建的机制. 当我们写完一个java文件的时候,后缀是.java.在我们利用IDE执行java文件的时候,其实IDE也帮我们运行了javac,即java编译器.编译器会将.java文件编译成.class文件.j

  • java 非常好用的反射框架Reflections介绍

    Reflections通过扫描classpath,索引元数据,并且允许在运行时查询这些元数据. 使用Reflections可以很轻松的获取以下元数据信息: 1)获取某个类型的所有子类:比如,有一个父类是TestInterface,可以获取到TestInterface的所有子类. 2)获取某个注解的所有类型/字段变量,支持注解参数匹配. 3)使用正则表达式获取所有匹配的资源文件 4)获取特定签名方法. 通常的用法有: 引入依赖jar <dependency> <groupId>org

  • JAVA基础之注解与反射的使用方法和场景

    注解 注解定义 Java 注解(Annotation)又称 Java 标注,是 JDK5.0 引入的一种注释机制. Java 语言中的类.方法.变量.参数和包等都可以被标注.和注释不同,Java 标注可以通过反射获取标注内容.在编译器生成类文件时,标注可以被嵌入到字节码中.Java 虚拟机可以保留标注内容,在运行 时可以获取到标注内容 . 当然它也支持自定义 Java 标注. 注解与注释的区别:注解是给机器看的注释,而注释是给程序员看的提示,编译时自动忽略注释. 使用场景 编译格式检查 反射中解

  • Java 使用反射调用jar包中的类方式

    下面讲展示的是从image.jar包中调用image.Buddy类的方法. public class Main { public static void main(String[] args) { try { // 两种方式都可以 URL url = new File("/Users/wuchen/Documents/IntelliJIDEA/Applet/out/production/Applet/image.jar").toURI().toURL(); // URL url = n

  • java技巧:反射判断field类型的操作

    JAVA 反射机制中,Field的getModifiers()方法返回int类型值表示该字段的修饰符. 其中,该修饰符是java.lang.reflect.Modifier的静态属性. 对应表如下: //判断是不是private类型方法 public static boolean is Private(int modifiers){ retrurn ((modifiers & 0x2)!=0); } 分析一下,&是按位与操作符,0x2是十六进制,二进制是10,所以只有private类型按位

  • java 实现反射 json动态转实体类--fastjson

    我就废话不多说了,大家还是直接看代码吧~ package test.refect; public class Student { // 姓名 private String name; // 年龄 private String age; // 住址 private String address; public String getName() { return name; } public void setName(String name) { this.name = name; } public

  • 如何用Java注解和反射实现依赖注入

    概述 在Spring中,我们可以通过 @Autowired注解的方式为一个方法中注入参数,那么这种方法背后到底发生了什么呢,这篇文章将讲述如何用Java的注解和反射实现一个"低配版"的依赖注入. 下面是我们要做的一些事情: 通过 @interface的方式定义一个注解 为某个希望杯被注入的方法添加这个注解 编写测试代码,通过反射获取添加了注解的方法对应的Method对象,将该方法对象设置为可访问的,通过反射创建对象并调用这个方法,同时注入依赖数据 如上所述,我们分为三个步骤, 去加工出

  • Java基础之反射详解

    前言 反射是我们框架的灵魂,反射也是我们框架的一个底层基石,没有反射也就没有框架,如果我们学好了反射,对我们阅读框架底层是有很大班助的--阿俊.有些文章上来就讲反射,就会很懵逼,不知道是干啥的,所以我们就引出一些问题来看看为什么需要反射 一.一个需求引出反射 看下面的问题 根据配置文件reflection.properties指定信息,创建People对象并调用方法hi classullpath= com.reflection.People method=hi 思考:使用现有技术,能做吗? 我们

  • java反射方式创建代码详解

    在谈到实例的时候,很多人对这个概念还不能说出所以然.其实实例就是一个具体的对象,像我们之前学习的类.数组都可以创建实例.反射相对而言也是比较抽象的概念,所以我们是能够把它实例化的.下面简单对实例进行了解,然后分别带来无参和有参的反射实例实例化方法. 1.实例说明 new 一个对象是实例,可以把这个new出来的对象叫做实例,说白了就是这个new出来的"东西",叫它对象也可以,叫它实例也可以,对象和实例在这个角度上来讲是等价的. 2.创建空参的实例 使用Class对象的newInstanc

  • Java中的注解和反射实例详解

    一.注解 注解(Annotation): 从jdk5.0开始引进,可以对程序进行解释或被其他程序读取. 注解格式:"@注释名",并可以添加一些参数. 例:@MyAnnotation(value='value') 1.内置注解 @override: 用于修饰方法,表示该方法声明是重写或实现一个父类的方法 @Deprecated: 用于修饰方法.属性.类,表示已过时不建议使用的 @SuppressWarnings: 用于抑制编译时的警告信息 2.元注解 作用:用于注解其他注解 @Targe

随机推荐