反射类的使用ReflectUtil(设置set和获取get某个类属性值)

最新推荐文章于 2023-09-06 13:56:41 发布
最新推荐文章于 2023-09-06 13:56:41 发布
阅读量3.6k 收藏
点赞数
分类专栏： java 反射

import java.lang.reflect.Field;  
import java.lang.reflect.Method;  
import java.lang.reflect.Modifier;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;


public class ReflectUtil {
 private static final Log logger = LogFactory.getLog(ReflectUtil.class);  
  
    public static void setFieldValue(Object target, String fname, Class ftype,  
            Object fvalue) { //设置字段值  如：username 字段,setUsername(String username)
        if (target == null 
                || fname == null 
                || "".equals(fname)  
                || (fvalue != null && !ftype.isAssignableFrom(fvalue.getClass()))) {//如果类型不匹配，直接退出
            return;  
        }  
        Class clazz = target.getClass();  
        try {  //先通过setXxx()方法设置类属性值
         String methodname="set"  + Character.toUpperCase(fname.charAt(0)) + fname.substring(1);
         System.out.println(methodname);
            Method method = clazz.getDeclaredMethod(methodname, ftype); //获取定义的方法
            if (!Modifier.isPublic(method.getModifiers())) {   //设置非共有方法权限
                method.setAccessible(true);  
            }  
            method.invoke(target, fvalue);  //执行方法回调
        } catch (Exception me) {//如果set方法不存在，则直接设置类属性值
            if (logger.isDebugEnabled()) {  
                logger.debug(me);  
            }  
            try {  
                Field field = clazz.getDeclaredField(fname);   //获取定义的类属性
                if (!Modifier.isPublic(field.getModifiers())) {   //设置非共有类属性权限
                    field.setAccessible(true);  
                }  
                field.set(target, fvalue); //设置类属性值
               
            } catch (Exception fe) {  
                if (logger.isDebugEnabled()) {  
                    logger.debug(fe);  
                }  
            }  
        }  
    }  
    public static Object getFieldValue(Object target, String fname, Class ftype 
           ) {//获取字段值  如：username 字段,getUsername()
     if (target == null 
                || fname == null 
                || "".equals(fname)  
                ) {  
            return null;  
        }  
     Class clazz = target.getClass();  
        try {   //先通过getXxx()方法获取类属性值
         String methodname="get"  + Character.toUpperCase(fname.charAt(0)) + fname.substring(1);
         System.out.println(methodname);
            Method method = clazz.getDeclaredMethod(methodname); //获取定义的方法
            if (!Modifier.isPublic(method.getModifiers())) {   //设置非共有方法权限
                method.setAccessible(true);  
            }  
            return method.invoke(target); //方法回调，返回值 
        } catch (Exception me) {//如果get方法不存在，则直接获取类属性值
            if (logger.isDebugEnabled()) {  
                logger.debug(me);  
            }  
            try {  
                Field field = clazz.getDeclaredField(fname);   //获取定义的类属性
                if (!Modifier.isPublic(field.getModifiers())) {    //设置非共有类属性权限
                    field.setAccessible(true);  
                }  
                return field.get(target);//返回类属性值
            } catch (Exception fe) {  
                if (logger.isDebugEnabled()) {  
                    logger.debug(fe);  
                }  
            }  
        } 
        return null;
    }
   
    public static void main(String[] args) {
     TestMethod testm=new TestMethod();
     ReflectUtil.setFieldValue(testm, "mtd", String.class, "sdf");
     System.out.println(testm.getMtd());
     ReflectUtil.getFieldValue(testm, "mtd", String.class);
 }
} 

 

 public class TestMethod {

 private String mtd;

 public String getMtd() {
  return mtd;
 }

// private void setMtd(String mtd) {
//  this.mtd = mtd;
// }
 
}

----------------------------------------------------------------------------------------------------------------------------------------

项目中：


package com.xxx.dhm.portalMS.common.util;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 *
 * 反射工具类
 *
 */
public class ReflectUtil
{
    
    private static final Log logger = LogFactory.getLog(ReflectUtil.class);
    
    @SuppressWarnings("unchecked")
    public static void setFieldValue(Object target, String fname, Class ftype,
            Object fvalue)
    {
        if (target == null
                || fname == null
                || "".equals(fname)
                || (fvalue != null && !ftype.isAssignableFrom(fvalue.getClass())))
        {
            return;
        }
        Class clazz = target.getClass();
        try
        {
            Field field = clazz.getDeclaredField(fname);
            if (!Modifier.isPublic(field.getModifiers()))
            {
                field.setAccessible(true);
            }
            field.set(target, fvalue);
            
        }
        catch (Exception me)
        {
            if (logger.isDebugEnabled())
            {
                logger.debug(me);
            }
        }
    }
    
    /**
     * 通过反射机制克隆一个对象
     * @param obj
     * @return
     * @throws Exception
     */
    public static Object copyObject(Object obj) throws Exception
    {
        Field[] fields = obj.getClass().getDeclaredFields();
        Object newObj = obj.getClass().newInstance();
        for (int i = 0, j = fields.length; i < j; i++)
        {
            String propertyName = fields[i].getName();
            Object propertyValue = getProperty(obj, propertyName);
            setProperty(newObj, propertyName, propertyValue);
        }
        return newObj;
        
    }
    
    // 反射调用setter方法，进行赋值
    @SuppressWarnings("unchecked")
    private static Object setProperty(Object bean, String propertyName,
            Object value) throws Exception
    {
        Class clazz = bean.getClass();
        try
        {
            Field field = clazz.getDeclaredField(propertyName);
            Method method = clazz.getDeclaredMethod(getSetterName(field.getName()),
                    new Class[] { field.getType() });
            return method.invoke(bean, new Object[] { value });
        }
        catch (Exception e)
        {
            throw e;
        }
    }
    
    // 反射调用getter方法，得到field的值
    @SuppressWarnings("unchecked")
    public static Object getProperty(Object bean, String propertyName) throws Exception
    {
        Class clazz = bean.getClass();
        try
        {
            Field field = clazz.getDeclaredField(propertyName);
            Method method = clazz.getDeclaredMethod(getGetterName(field.getName()),
                    new Class[] {});
            return method.invoke(bean, new Object[] {});
        }
        catch (Exception e)
        {
            throw e;
        }
    }
    
    // 根据field名，得到getter方法名
    private static String getGetterName(String propertyName)
    {
        String method = "get" + propertyName.substring(0, 1).toUpperCase()
                + propertyName.substring(1);
        return method;
    }
    
    // 根据field名，得到setter方法名
    private static String getSetterName(String propertyName)
    {
        String method = "set" + propertyName.substring(0, 1).toUpperCase()
                + propertyName.substring(1);
        return method;
    }
    
    /**
     * 普通的JavaBean对象转换成Map数据类型。
     * 将普通的JavaBean对象转换成Map数据类型，其中JavaBean声明的变量名作为Map类型的key，
     * 该变量的值，作为其Map数据类型相应key的值。
     *
     * @param obj
     *            - 普通JavaBean对象
     * @return 返回Map数据类类型
     *
     * @return Map<String,Object> 返回Map数据类型
     */
    @SuppressWarnings("unchecked")
    public static Map<String, Object> getObjectAsMap(Object obj)
    {
        Map<String, Object> map = new HashMap<String, Object>();
        if (obj == null)
        {
            return map;
        } else if ( obj instanceof Map ) {
            return (Map) obj;
        }
        
        Class clazz = obj.getClass();
        Method[] methods = clazz.getMethods();
        String methodname = "";
        for (int i = 0; i < methods.length; i++)
        {
            methodname = methods[i].getName();
            if (methodname.startsWith("get"))
            {
                try
                {
                    Object value = methods[i].invoke(obj);
                    if( value != null && (value instanceof String ) ) {
                        String str = (String) value;
                        value = str.trim();
                    }
                    map.put(getFieldName(methodname), value);
                }
                catch (IllegalArgumentException e)
                {
                    logger.debug("Convert JavaBean to Map Error!", e);
                }
                catch (IllegalAccessException e)
                {
                    logger.debug("Convert JavaBean to Map Error!", e);
                }
                catch (InvocationTargetException e)
                {
                    logger.debug("Convert JavaBean to Map Error!", e);
                }
            }
        }
        return map;
    }
    
    private static String getFieldName(String str)
    {
        String firstChar = str.substring(3, 4);
        String out = firstChar.toLowerCase() + str.substring(4);
        return out;
    }
    
}


反射:填充嵌套对象的属性值
sinat_36203404的博客
04-27 1545
原文点击此处 package com.test.reflection; import lombok.Data; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Arrays; public class EmbedObjectDemo { public static void main (String[] args) { S
ReflectUtils 反射工具类
最新发布
javaxueba的博客
08-20 510
重写object 的toString 方法，打印参数。获取无参构造，有参构造，修改成员变量属性。也会打印object自带的方法。调用了toString。
反射获取类属性名和属性值
04-14
利用反射获取实例化类的属性值和属性值!很实用，直接复制到控制台就行了！
ReflectUtil利用反射获取或设置其属性
方圆几里的博客
07-19 4257
ReflectUtil类 package com.yufei.core.util; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.Arrays; import java.util.Date; import java.ut...
hutool工具包ReflectUtil.getFieldValue使用
m0_55485287的博客
08-14 3121
在这个示例中，ReflectUtil.getFieldValue 方法允许你通过反射来获取 Person 对象的字段值，即使字段是私有的。注意，Hutool 还提供了其他用于字符串处理的方法，可以更方便地操作字符串，如切割、拼接、格式化等。现在，你可以使用 Hutool 的 ReflectUtil.getFieldValue 方法来获取 Person 对象的字段值，如下所示。需要注意的是，使用反射需要谨慎，因为它可能引入性能和安全方面的问题。现在，你可以使用 Hutool 的。假设你有一个 Java 类。
java reflections_Reflections.java反射工具类 | 学步园
weixin_29577885的博客
02-24 2371
import java.lang.reflect.Field;import java.lang.reflect.InvocationTargetException;import java.lang.reflect.Method;import java.lang.reflect.Modifier;import java.lang.reflect.ParameterizedType;import ja...
ReflectUtil.setFieldValue java循环放进实体中
Jwg199908的博客
09-06 294
反射Reflection 反射获取类 获取运行时实现的接口及父类 获取构造方法 成员变量 成员方法
巫山♔
11-09 422
反射常用的一些方法 getName() 获取名称 getSimpleName() 获取简称 getModifiers() 获取访问修饰符 getParameterTypes() 获取参数列表 反射获取Class类实例的三种方式： 对象.getClass() 类名.clsss Class.forName(“全限定名”) newInstance() 创建此 Cl...
Java中用反射的方式获取类中的所有属性和方法，以及获取属性的默认值，设置属性的默认值
上帝派来的逗比
04-10 2354
代码如下： package com.syh.jdbc.reflection_super; /** * 父类 * @author syh * */ public class Parent { public String publicField = "1"; String defaultField = "2"; protected String protect
ReflectUtils.java
05-29
这是一个封装了反射的类,比如说反射获取类属性名,属性值,设置属性值等,有需要的朋友可以下载下.............
java反射工具类 ReflectionUtils
08-02
该工具类下载后拷贝到你要用的包，只需该包名即可
反射工具类ReflectionUtils.java
01-19
进行数据库查询操作经常用到，包括getDeclaredField、getDeclaredMethod、getFieldValue、getSuperClassGenricType、getSuperGenericType、invokeMethod、makeAccessible、setFieldValue
移植Xposed的反射工具类
10-31
- 操作字段：`set()`和`get()`用于设置和获取字段值。 3. **移植策略**：由于`XposedHelper`依赖于Xposed的钩子机制，我们需要替换这部分功能。可以使用Java的常规反射API（如`Method.invoke()`）来代替Xposed的...
java反向映射_类反向映射工具类ReflectUtil（实现对象属性查询修改克隆)
weixin_31269713的博客
02-13 556
1.自定义工具类 - 通过该工具类实现对象属性的修改、属性名称获取值、深度克隆属性的内容，使用业务抽象层面的初始化改造、遍历修改或动态修改任意类属性等场景，具体代码示例如下importjava.lang.reflect.Field;@b@importjava.math.BigDecimal;@b@importjava.util.Date;@b@importcom.xwood.common....
java reflect method_通过java.lang.reflect.Method/Field方法属性反射工具类ReflectUtils实现获取属性set/getter方法调用等操作...
weixin_33473110的博客
02-13 250
一、前言关于通过java.lang.reflect.Field/java.lang.reflect.Method反射属性方法实现ReflectUtils工具类,实现了基于class创建实例createInstance方法、属性Field类对象实例获取属性值、类对象实例指定property属性字符串获取值invokeGetter、类对象实例指定方法反射调用invokeMethod、给类属性sette...
使用反射调用set和get方法
ksqqxq的专栏
03-23 2472
package com.ksqqxq.utils; import java.lang.reflect.Field; import java.lang.reflect.Method; /** * * @author ksqqxq * trigger setter or getter method by java refection * **/ publi
反射工具类. 提供调用getter/setter方法, 访问私有变量, 调用私有方法, 获取泛型类型Class, 被AOP过的真实类等工具函数
悟●禅●酒的专栏
02-20 794
使用示例： T entity = null; // 如果不存在实例则新建. entity = (entity == null ? clazz.newInstance() : entity); ReflectUtils.invokeSetter(entity, propertyName, val); ReflectUtils.java类 import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; im
java 反射给对象新增属性并赋值工具类
04-05
以下是示例代码，可以通过反射给对象新增属性并赋值： ```java import java.lang.reflect.Field; public class ReflectUtil { public static void setFieldValue(Object obj, String fieldName, Object fieldValue) throws Exception { Class<?> clazz = obj.getClass(); Field field = clazz.getDeclaredField(fieldName); field.setAccessible(true); field.set(obj, fieldValue); } } ``` 使用示例： ```java public class User { private String name; private int age; // getter and setter } public class Main { public static void main(String[] args) throws Exception { User user = new User(); ReflectUtil.setFieldValue(user, "name", "Tom"); ReflectUtil.setFieldValue(user, "age", 18); System.out.println(user.getName()); // Tom System.out.println(user.getAge()); // 18 } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值