通过反射机制调用对象的某个方法 -- 将一个对象的属性值赋值给另一个对象的属性
开发环境
创建对象UserOne、UserTwo
编写基于反射的工具类
测试结果
预留占位

模拟一个场景：
众所周知，EasyExcel导出Excel文档是依赖于注解完成的，在实体类需要导出的属性上面加上注解，导出的时候会自动识别该属性。
假如我们现在需要导出用户的信息，又不想污染原本的实体类，又要过滤掉password这个属性。那么我们可以另外创建一个实体类，不包含password属性。然后我们将查到的用户信息，赋值给新创建的对象即可。
赋值这一步是比较繁琐的，我们需要写循环，然后判断，然后赋值。等将来需要导出管理员信息的时候我们又要写循环，然后判断，然后赋值、、、
怎么能写一个共用的方法去帮我们做循环、判断、赋值这些事呢？源对象类型不确定，目标对象类型不确定。
于是，反射机制来了。它来了，它来了，它哼着小曲走来了、、、
通过 Java 的反射机制，程序员可以更深入地控制程序的运行过程。例如，在程序运行时由用户输入一个类名，然后动态获取该类拥有的构造、属性和方法，甚至调用任意类的任意方法。
Java 反射机制主要提供了以下功能，这些功能都位于 java.lang.reflect包下。

在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的方法。
生成动态代理。

开发环境

请参照: 基于SpringBoot构建分模块项目

创建对象UserOne、UserTwo

UserOne为与数据库表对应的实体类，UserTwo为即将要通过EasyExcel导出的对象

package com.wayne.common.entity;

/**
 * @author Wayne
 * @date 2019/6/5
 */
public class UserOne {

    private Integer id;

    private String username;

    private String password;

   // Getter and Setter 、、、
}

package com.wayne.common.dto;

/**
 * @author Wayne
 * @date 2019/6/5
 */
public class UserTwo {

    private Integer id;

    private String username;

    // Getter and Setter 、、、
}

编写基于反射的工具类

通过反射创建对象、调用方法

package com.wayne.common.utils;

import com.google.common.collect.Lists;
import com.wayne.common.exception.CopyPropertyException;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;

/**
 * @author Wayne
 * @date 2019/6/5
 */
public class BaseUtil {

    /**
     * 将一个集合中对象的值拷贝到另一个对象，属性相同即赋值
     * @param source 源数据，将此对象数据取出
     * @param tClass 目标对象，将取出的数据赋值到该对象中
     * @param <T> 源数据类型
     * @param <E> 目标数据类型
     * @return 被赋值后的目标对象集合
     * @throws CopyPropertyException 自定义异常，通过反射创建对象或调用方法时抛出的异常
     */
    public static <T, E> List<E> copyProperties(List<T> source, Class<E> tClass) throws CopyPropertyException {

        // 判断传入源数据是否为空，如果空，则抛自定义异常
        if(null == source) {
            throw new CopyPropertyException("数据源为空");
        }

        // 创建一个集合，用于存储目标对象，全部数据抓换完成后，将该集合返回
        List<E> targetList = Lists.newArrayList();

        // 循环取到单个源对象
        for(T t : source) {
            // 获取源对象的类的详情信息
            Class<?> sClass = t.getClass();
            // 获取源对象的所有属性
            Field[] sFields = sClass.getDeclaredFields();
            // 获取目标对象的所有属性
            Field[] tFields = tClass.getDeclaredFields();

            E target;
            try {
                // 通过类的详情信息，创建目标对象 这一步等同于UserTwo target = new UserTwo()；
                target = tClass.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
                throw new CopyPropertyException("目标对象创建失败");
            }

            // 循环取到源对象的单个属性
            for(Field sField : sFields) {
                // 循环取到目标对象的单个属性
                for(Field tField : tFields) {

                    // 判断源对象的属性名、属性类型是否和目标对象的属性名、属性类型一致
                    if(sField.getName().equals(tField.getName()) && sField.getGenericType().equals(tField.getGenericType())) {

                        try {
                            // 获取源对象的属性名，将属性名首字母大写，拼接如：getUsername、getId的字符串
                            String sName = sField.getName();
                            char[] sChars = sName.toCharArray();
                            sChars[0] -= 32;
                            String sMethodName = "get" + String.valueOf(sChars);
                            // 获得属性的get方法
                            Method sMethod = sClass.getMethod(sMethodName);
                            // 调用get方法
                            Object sFieldValue = sMethod.invoke(t);

                            // 获取目标对象的属性名，将属性名首字母大写，拼接如：setUsername、setId的字符串
                            String tName = tField.getName();
                            char[] tChars = tName.toCharArray();
                            tChars[0] -= 32;
                            String tMethodName = "set" + String.valueOf(tChars);
                            // 获得属性的set方法
                            Method tMethod = tClass.getMethod(tMethodName, tField.getType());
                            // 调用方法，并将源对象get方法返回值作为参数传入
                            tMethod.invoke(target, sFieldValue);

                            break;
                        } catch (Exception e) {
                            e.printStackTrace();
                            throw new CopyPropertyException("转换失败，请检查属性类型是否匹配");
                        }
                    }
                }
            }
            // 将通过反射创建的目标对象放入集合中
            targetList.add(target);
        }
        // 返回集合
        return targetList;
    }
}

测试结果

预留占位
开发怎能不留扩展字段 (￢_￢)…

@SneakyThrows
    public static Object objectClone(Object newObject,Object oldObject){
        Field[] oldFields = oldObject.getClass().getDeclaredFields();
        Field newField;
        for (Field oldField : oldFields){
            oldField.setAccessible(true);
            newField = newObject.getClass().getDeclaredField(oldField.getName());
            newField.setAccessible(true);
            newField.set(newObject,oldField.get(oldObject));
        }
        return newObject;
    }

/**
 * 将一个对象转换为另一个对象需要两个bean对象的变量相同
 *
 * @param <T1>      要转换的对象
 * @param <T2>      转换后的类
 * @param orimodel  要转换的对象
 * @param castClass 转换后的类
 * @return 转换后的对象
 */
public static <T1, T2> T2 convertBean(T1 orimodel, Class<T2> castClass) {
    T2 returnModel;
    try {
        returnModel = castClass.newInstance();
    } catch (Exception e) {
        throw new RuntimeException("创建" + castClass.getName() + "对象失败");
    }
    //要转换的字段集合
    List<Field> fieldlist = new ArrayList<Field>();
    final String objClass = "java.lang.object";
    //循环获取要转换的字段,包括父类的字段
    while (castClass != null && !objClass.equals(castClass.getName().toLowerCase())) {
        fieldlist.addAll(Arrays.asList(castClass.getDeclaredFields()));
        //得到父类,然后赋给自己
        castClass = (Class<T2>) castClass.getSuperclass();
    }
    for (Field field : fieldlist) {
        PropertyDescriptor getpd;
        PropertyDescriptor setpd;
        try {
            getpd = new PropertyDescriptor(field.getName(), orimodel.getClass());
            setpd = new PropertyDescriptor(field.getName(), returnModel.getClass());
        } catch (Exception e) {
            continue;
        }
        try {
            Method getMethod = getpd.getReadMethod();
            Object transValue = getMethod.invoke(orimodel);
            Method setMethod = setpd.getWriteMethod();
            setMethod.invoke(returnModel, transValue);
        } catch (Exception e) {
            throw new RuntimeException("cast " + orimodel.getClass().getName() + "to "
                    + castClass.getName() + " failed");
        }
    }
    return returnModel;
}

第一个方法是一个类的不同实例化对象，比如类A，实例化对象a1，a2,：（使用的方法是得到类的属性名）
/**  
 *   
 *<p>  
*@description 转换javabean ,将class2中的属性值赋值给class1，如果class1属性有值，则不覆盖  
 *</p>  
 *@param class1 基准类,被赋值对象  
 *@param class2 提供数据的对象  
 *@throws Exception  
 * @see  
 */  
private void converJavaBean(Object class1, Object class2) {  
    Class<?> clazz1 = class1.getClass();  
    Class<?> clazz2 = class2.getClass();  
    Field[] fields1 = clazz1.getDeclaredFields();  
    Field[] fields2 = clazz2.getDeclaredFields();  
    for (int i = 0; i < fields1.length; i++) {  
        try {  
            fields1[i].setAccessible(true);  
            fields2[i].setAccessible(true);  
            Object obg1 = fields1[i].get(class1);  
            Object obg2 = fields2[i].get(class2);  
  
            if (null == fields1[i].get(class1) && null != fields2[i].get(class2)) {  
                fields1[i].set(class1, fields2[i].get(class2));  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
}  
第二个方法得到get和set方法进行赋值，比第一个功能强大，只要有相同的属性名都可以
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;

import java.util.Map;
/** 
 *  
 * <p> 
 *  
 * @description 转换javabean ,将class2中的属性值赋值给class1，如果class1属性有值，则不覆盖 
 *              ，前提条件是有相同的属性名 
 *              </p> 
 * @param class1 
 *            基准类,被赋值对象 
 * @param class2 
 *            提供数据的对象 
 * @throws Exception 
 * @author ex_dingyongbiao 
 * @see 
 */  

public class CopyBeans {
	 /**
	 * @param src  获取属性值
	 * @param dest 给属性赋值
	 */
	public static void copy(Object class1, Object class2) {

		 
		try {  
	           Class<?> clazz1 = class1.getClass();  
	           Class<?> clazz2 = class2.getClass();  
	           // 得到method方法  
	           Method[] method1 = clazz1.getMethods();  
	           Method[] method2 = clazz2.getMethods();  
	  
	           int length1 = method1.length;  
	           int length2 = method2.length;  
	           if (length1 != 0 && length2 != 0) {  
	               // 创建一个get方法数组，专门存放class2的get方法。  
	               Method[] get = new Method[length2];  
	               for (int i = 0, j = 0; i < length2; i++) {  
	                   if (method2[i].getName().indexOf("get") == 0) {  
	                       get[j] = method2[i];  
	                       ++j;  
	                   }  
	               }  
	  
	               for (int i = 0; i < get.length; i++) {  
	                   if (get[i] == null)// 数组初始化的长度多于get方法，所以数组后面的部分是null  
	                       continue;  
	                   // 得到get方法的值，判断时候为null，如果为null则进行下一个循环  
	                   Object value = get[i].invoke(class2, new Object[] {});  
	                   if (null == value)  
	                       continue;  
	                   // 得到get方法的名称 例如：getXxxx  
	                   String getName = get[i].getName();  
	                   // 得到set方法的时候传入的参数类型，就是get方法的返回类型  
	                   Class<?> paramType = get[i].getReturnType();  
	                   Method getMethod = null;  
	                   try {  
	                       // 判断在class1中时候有class2中的get方法，如果没有则抛异常继续循环  
	                       getMethod = clazz1.getMethod(getName, new Class[] {});  
	                   } catch (NoSuchMethodException e) {  
	                       continue;  
	                   }  
	                   // class1的get方法不为空并且class1中get方法得到的值为空，进行赋值，如果class1属性原来有值，则跳过  
	                   if (null == getMethod || null != getMethod.invoke(class1, new Object[] {}))  
	                       continue;  
	                   // 通过getName 例如getXxxx 截取后得到Xxxx，然后在前面加上set，就组装成set的方法名  
	                   String setName = "set" + getName.substring(3);  
	                   // 得到class1的set方法，并调用  
	                   Method setMethod = clazz1.getMethod(setName, paramType);  
	                   setMethod.invoke(class1, value);  
	               }  
	           }  
	       } catch(Exception e) {  
	        System.out.println(e);  
	       }  
	}
}
推荐使用第二种方法。