JAVA反射的基本应用

 

 

package com.shby.core.utils;

import javax.persistence.Column;
import javax.persistence.Table;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.*;

/**
 * @author: 李小龙
 * @description:JAVA开发
 * @created:2019/8/31
 * @modified by 李小龙 on 2019/8/31
 */
public class ReflectUtils {

    public static final String AND = " AND ";
    public static final String OC_EQUALS  =  " = ";

    /**
     * 获取范型类（CLASS）
     * @param index
     * @return
     * @throws Exception
     */
    public static Class getActualType(int index, Object obj) throws Exception {//获取范型类
//                        if(Modifier.isStatic(field[j].getModifiers())) {//static 修饰的不做查询
//                            continue;
//                        }
        Class[] cl = obj.getClass().getInterfaces();//代理类获取方式
        Class repository = null;
        if (null != cl && cl.length > 0) {
            repository = cl[0];
            Type[] genType = repository.getGenericInterfaces();
            Type[] params = ((ParameterizedType) genType[0]).getActualTypeArguments();

            if (index >= params.length || index < 0) {
                return Object.class;
            }
            if (!(params[index] instanceof Class)) {
                return Object.class;
            }
            return (Class) params[index];
        }
        return null;
    }

    /**
     * 获得JPA的查询条件
     * @param param
     * @param root
     * @param criteriaBuilder
     * @return
     */
    public static Predicate assemblyWhere(Object param, Root root, CriteriaBuilder criteriaBuilder) {
        Field[] field = param.getClass().getDeclaredFields(); // 获取实体类的所有属性，返回Field数组
        List<Predicate> predicatesList = new ArrayList<>();
        try {
            for (int j = 0; j < field.length; j++) { // 遍历所有属性
                String oriname = field[j].getName(); // 获取属性的名字
                String name = oriname.substring(0, 1).toUpperCase() + oriname.substring(1); // 将属性的首字符大写，方便构造get，set方法
                String type = field[j].getGenericType().toString(); // 获取属性的类型
                if(type.equals("class java.util.Date") && (name.endsWith("Start") || name.endsWith("End"))) {
                    oriname = oriname.substring(0,oriname.length()-5);
                }
                Path path = null;
                try {
                    path = root.get(oriname);
                } catch (IllegalArgumentException e) {
                    continue;
                }

                Predicate p1 = null;
                if (type.equals("class java.lang.String")) { // 如果type是类类型，则前面包含"class "，后面跟类名
                    Method m = param.getClass().getMethod("get" + name);
                    String value = (String) m.invoke(param); // 调用getter方法获取属性值
                    if(null == value || value.isEmpty()) {
                        continue;
                    }
                    p1 = criteriaBuilder.greaterThan(
                            criteriaBuilder.function("locate",Integer.class, criteriaBuilder.literal(value), path),
                            criteriaBuilder.literal(0)
                    );
                } else if(type.equals("class java.util.Date")) {
                    Method m = param.getClass().getMethod("get" + name);
                    Date value = (Date) m.invoke(param); // 调用getter方法获取属性值
                    if(null == value) {
                        continue;
                    }
                    if(name.endsWith("Start")) {
                        p1 = criteriaBuilder.and(criteriaBuilder.greaterThanOrEqualTo(path, value));
                    } else if(name.endsWith("End")) {
                        p1 = criteriaBuilder.and(criteriaBuilder.lessThanOrEqualTo(path, value));
                    } else {
                        p1 = criteriaBuilder.and(criteriaBuilder.equal(path, value));
                    }
                } else {
                    Method m = param.getClass().getMethod("get" + name);
                    Object value = m.invoke(param); // 调用getter方法获取属性值
                    if(null == value) {
                        continue;
                    }
                    p1 = criteriaBuilder.and(criteriaBuilder.equal(path, value));
                }
                predicatesList.add(p1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return criteriaBuilder.and(predicatesList.toArray(new Predicate[predicatesList.size()]));
    }

    /**
     * 根据对象，计算WHERE
     * @param param
     * @return
     * @throws Exception
     */
    public static String assemblyWhere(Object param) throws Exception  {

        Field[] fields = param.getClass().getDeclaredFields(); // 获取实体类的所有属性，返回Field数组
        String where = " WHERE 1=1 ";
        for(Field field : fields) {
            String oriname = field.getName(); // 获取属性的名字
            String name = oriname.substring(0, 1).toUpperCase() + oriname.substring(1); // 将属性的首字符大写，方便构造get，set方法
            Method method = param.getClass().getMethod("get" + name);
            Object value = method.invoke(param); // 调用getter方法获取属性值
            if(null == value) {
                continue;
            }
            String coloumn = getColumnName(field);
            if(null == coloumn) {
                continue;
            }
            where += AND + coloumn+ OC_EQUALS + value;
        }
        return where;
    }

    /**
     * 获得JAVAbean和数据库 字段的对应关系
     * @param obj
     * @return
     */
    public static Map getColumnAndFieldRelation(Object obj) {
        Map<String, String> map = new LinkedHashMap();
        Field[] fields = obj.getClass().getDeclaredFields();
        for(Field field : fields) {
            map.put(field.getName(), getColumnName(field));
        }
        return map;
    }

    /**
     * 获取数据库字段名
     * @param field
     * @return
     */
    public static Column getColumn(Field field) {
        Annotation[] annotations = field.getAnnotations();
        for(Annotation annotation : annotations) {
            if(annotation instanceof javax.persistence.Column) {
                javax.persistence.Column column = (javax.persistence.Column)annotation;
                return column;
            }
        }
        return null;
    }

    /**
     * 获取数据库字段名
     * @param field
     * @return
     */
    public static String getColumnName(Field field) {
        Annotation[] annotations = field.getAnnotations();
        for(Annotation annotation : annotations) {
            if(annotation instanceof javax.persistence.Column) {
                javax.persistence.Column column = (javax.persistence.Column)annotation;
                return column.name();
            }
        }
        return null;
    }

    /**
     * 获取数据库字段名
     * @param field
     * @return
     */
    public static String getTableName(Object field) {
        Annotation[] annotations = field.getClass().getAnnotations();
        for(Annotation annotation : annotations) {
            if(annotation instanceof Table) {
                Table column = (Table)annotation;
                return column.name();
            }
        }
        return null;
    }
}