如何在Java中应用反射技术

如何在Java中应用反射技术？相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。

一、反射概念

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

二、反射应用场景

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

程序解耦合使用

代码更加的优雅

三、反射更多细节

jdk中的位置: java.lang.reflect包下

获取字节码方式

// 通过类的全限定类名获取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;

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

package com.open_source.demo.domain;public class Hero {        private String type;        private String name;        private Double CE;        public void attrbute(Hero hero) {        System.out.println(hero.getType() + ": " + hero.getName() + "输出伤害： " + hero.getCE());    }        public void fighting() {        System.out.println("稳住 我们能赢");    }        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() {    }}

获取类的成员

获取类的构造函数

import java.util.StringJoiner;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.typeprivate java.lang.String com.open_source.demo.domain.Hero.nameprivate 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;public class ReflectSupport {    private ReflectSupport(){};        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);    }        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;    }        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;    }        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;    }        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的特点有哪些1.Java语言作为静态面向对象编程语言的代表，实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。2.Java具有简单性、面向对象、分布式、安全性、平台独立与可移植性、动态性等特点。3.使用Java可以编写桌面应用程序、WEB应用程序、分布式系统和嵌入式系统应用程序等。

看完上述内容，你们掌握如何在Java中应用反射技术的方法了吗？如果还想学到更多技能或想了解更多相关内容，欢迎关注编程网精选频道，感谢各位的阅读！