通过反射来获取类的属性并调用Setter,getter方法

获得class的三种方式

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.Class.forName("全类名")
        Class cls0 = Class.forName("domain.Person");
        System.out.println(cls0);

        //2.类名.class
        Class cls1 = Person.class;
        System.out.println(cls1);

        //3.对象.getClass()
        Person p = new Person();
        Class cls2 = p.getClass();
        System.out.println(cls2);
    }
}

class.getDeclaredFields() 用法说明

getFields()：获得某个类的所有的公共（public）的字段，包括父类中的字段。
getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。

Field field =class.getDeclaredFields(“字段名”)：获得类的该字段

···········································································································
getDeclaredMethod：获取当前类的所有声明的方法，从父类中继承的不算，实现接口的方法由于有声明所以包括在内。
getMethod：获取当前类和所有父类的所有public的方法。
···········································································································

filed.getType

• getType()：返回一个 Class 对象，它标识了此 Field 对象所表示字段的声明类型。
• getGenericType()：返回一个 Type 对象，它表示此 Field 对象所表示字段的声明类型，如果是泛型，则返回泛型

setter和getter方法

/*
	 *@param obj 操作的对象
	 *@param att 操作的属性
	 *@param value 设置的值
	 *@param type 参数的类型
	 */
	public static void setter(Object obj, String att, Object value, Class<?>type){
		try {
			Method met = obj.getClass().
							getMethod("set" + initStr(att), type);
			met.invoke(obj, value);
		}catch (Exception e){
			e.printStackTrace();
		}
	}
	public static void getter(Object obj, String att){
		try {
			Method met = obj.getClass().getMethod("get" + initStr(att));
			System.out.println(met.invoke(obj));
		}catch (Exception e){
			e.printStackTrace();
		}
	}
	public static String initStr(String old){	// 将单词的首字母大写
		String str = old.substring(0,1).toUpperCase() + old.substring(1) ;
		return str ;
	}

一个把hbase数据库内容映射为实体类的demo

 
public <T extends BaseEntity> List<T> scan(String tableNameStr, Class<T> clazz) throws Exception {
        Table table = connection.getTable(TableName.valueOf(tableNameStr));
        Scan scan = new Scan();
        scan.setLimit(5);
        ResultScanner results = table.getScanner(scan);
        List<T> list = new ArrayList<>();
        for (Result result : results) {
            // 拿到了每一行
            CellScanner cellScanner = result.cellScanner();
            T entity = clazz.newInstance();
            entity.setRowKey(Bytes.toString(result.getRow()));
            // advance :判断有没有下一个
            while (cellScanner.advance()) {
                Cell cell = cellScanner.current();
               // String family = Bytes.toString(CellUtil.cloneFamily(cell));//列族
                String qualifier = Bytes.toString(CellUtil.cloneQualifier(cell));//列限定符
                try {
                    Field field = clazz.getDeclaredField(qualifier);
                    // 给字段设置值 不合法，所以调用用set,get方法
                    field.setAccessible(true);
                    //判断
                    Util Util=new Util();
                    String type = Util.TypeJudge(Student.class, qualifier);
                    // 获取字段的类型，根据不同的类型调用不同的api设置值
                    if (type.equals("int")){
                        
        Util.setter(entity,qualifier,Bytes.toInt(CellUtil.cloneValue(cell)),int.class);
                       // field.set(entity, Bytes.toInt(CellUtil.cloneValue(cell)));
                    }else {
                        field.set(entity, Bytes.toString(CellUtil.cloneValue(cell)));
                    }

                } catch (NoSuchFieldException  e) {
                    throw new RuntimeException(e);
                }
            }

            list.add(entity);
        }

        return list;
    }



///Util类



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

public class Util {
   public    <T extends BaseEntity> String TypeJudge(Class<T> clazz,String qualifier) throws Exception {

       Field field = clazz.getDeclaredField(qualifier);
       Type genericType = field.getGenericType();
       System.out.println(field.getType());
       return  genericType.toString();
   }

    /*
     *@param obj 操作的对象
     *@param att 操作的属性
     *@param value 设置的值
     *@param type 参数的类型
     */


    public  void setter(Object obj, String att, Object value, Class<?>type){

        try {
            Method met = obj.getClass().
                    getMethod("set" + initStr(att), type);
            met.invoke(obj, value);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public  void getter(Object obj, String att){
        try {
            Method met = obj.getClass().getMethod("get" + initStr(att));
            System.out.println(met.invoke(obj));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public  String initStr(String old){	// 将单词的首字母大写
        String str = old.substring(0,1).toUpperCase() + old.substring(1) ;
        return str ;
    }
}