您好，登录后才能下订单哦！
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
如何在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的特点有哪些 1.Java语言作为静态面向对象编程语言的代表，实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。 2.Java具有简单性、面向对象、分布式、安全性、平台独立与可移植性、动态性等特点。 3.使用Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。
看完上述内容，你们掌握如何在Java中应用反射技术的方法了吗？如果还想学到更多技能或想了解更多相关内容，欢迎关注亿速云行业资讯频道，感谢各位的阅读！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。