开一贴分享自己用jeecg3.7所遇所感

String

记录下以后碰到的问题以及解决方案吧，有问题的可以问，能解决就帮着解决。

String

很久之前封装的一套全新查询，实现直接按照条件查询，无需过多代码。
用法：

1. @RequestMapping(params = "datagrid")
   
2. public void datagrid(XxxEntity xxxEntity, HttpServletRequest request, HttpServletResponse response,
   
3. DataGrid dataGrid) {
   
4. HqlQuery hqlQuery=new HqlQuery(XxxEntity.class, request.getParameterMap(), dataGrid);
   
5. HqlQuery hQuery=DeclareHql.declareHql(hqlQuery);
   
6. Query query=systemService.getSession().createQuery(hqlQuery.getHql());
   
7. DeclareHql.setQuery(hQuery, query).getValue(query, dataGrid);
   
8. TagUtil.datagrid(response, dataGrid);
   
9. }
   

复制代码

封装类：

1. /**
   
2. * Copyright 2018 String
   
3. * <p>
   
4. * Licensed under the Apache License, Version 2.0 (the "License");
   
5. * you may not use this file except in compliance with the License.
   
6. * You may obtain a copy of the License at
   
7. * <p>
   
8. * http://www.apache.org/licenses/LICENSE-2.0
   
9. * <p>
   
10. * Unless required by applicable law or agreed to in writing, software
    
11. * distributed under the License is distributed on an "AS IS" BASIS,
    
12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    
13. * See the License for the specific language governing permissions and
    
14. * limitations under the License.
    
15. */

复制代码

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.hibernate.Query;
import org.jeecgframework.core.common.hibernate.hql.HqlQuery;
import org.jeecgframework.core.common.model.json.DataGrid;

import javax.persistence.Column;
import javax.persistence.JoinColumn;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.Collator;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
* hql基本封装
*
* @author String
*/
public class DeclareHql {

    private static final Logger logger = Logger.getLogger(DeclareHql.class);
    private static final String SELECT = "select ";
    private static final String AND = " AND ";
    private static final String FROM = " from ";
    private static final String BLANK = " ";
    private static final String DOT = ".";
    private static final String LEFT_JOIN = " left join ";
    private static final String ORDER_BY = " order by ";
    private static final String EQ = " = ";
    private static final String LIKE = " like ";

    /**
     * 时间查询符号
     */
    private static final String END = "_end2";
    private static final String BEGIN = "_begin1";

    private static final SimpleDateFormat time = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

    /**
     * 封装进数据 判断自定义字段排序问题
     *
     * @return
     */
    public void getValue(Query query, DataGrid dataGrid) {
        List<?> li = query.list();
        int total = li.size();
        Class<?> cla = dataGrid.getCla();
        boolean flag = true;
        if (StringUtils.isNotEmpty(dataGrid.getSort())) {
            Method method = getGetMethod(cla, dataGrid.getSort());//获取get方法
            if (method != null) {
                Column column = method.getAnnotation(Column.class);//获取get方法上注解
                if (column == null) {
                    JoinColumn join = method.getAnnotation(JoinColumn.class);
                    if (join == null) {
                        flag = false;
                    }

                }
            }
        }

        List<?> testList = new ArrayList<>();
        if (!flag) {
            testList = li;
        } else
            testList = query.setFirstResult((dataGrid.getPage() - 1) * dataGrid.getRows())
                    .setMaxResults(dataGrid.getRows()).list();
        dataGrid.setResults(testList);
        dataGrid.setTotal(total);
    }

    /**
     * setquery进值
     *
     * @param query
     * @return
     */
    public static DeclareHql setQuery(HqlQuery hqlQuery, Query query) {
        if (hqlQuery.getData().size() > 0) {
            int num = hqlQuery.getNum();
            for (Map<String, Object> obj1 : hqlQuery.getData()) {
                Object datatype = obj1.get("model");
                Object value = obj1.get("value");
                switch (datatype.toString()) {
                    case "Integer":
                        query.setInteger(num, Integer.valueOf((String) value));
                        num++;
                        break;
                    case "String":
                        query.setString(num, value.toString());
                        num++;
                        break;
                    case "Date":
                        Date date = (Date) value;
                        query.setDate(num, date);
                        num++;
                        break;
                    default:
                        break;
                }
            }
        }
        return new DeclareHql();
    }

    /*
     * 拼装h q l脚本  h q l
     */
    public static HqlQuery declareHql(HqlQuery hqlQuery) {
        Class<?> clazz = hqlQuery.getEntityClass();
        Map<String, String[]> paramsMap = hqlQuery.getParamsMap();
        DataGrid datagrid = hqlQuery.getDataGrid();
        hqlQuery.getDataGrid().setCla(clazz);
        Field[] declaredFields = clazz.getDeclaredFields();
        String obj = clazz.getSimpleName();// 对象名
        String otherName = obj.substring(0, 3).toLowerCase();//前缀小写用作hql别名
        StringBuffer sb = new StringBuffer();
        boolean isPropertyFlag = false;//检验排序字段是否属于实体中的属性  存在更改为 true
        
        sb.append(SELECT + otherName + FROM + obj + BLANK + otherName);
        for (Field field : declaredFields) {//存在外键关联的 left join拼接上hql
            String type = field.getType().getName();// 类型
            String property = field.getName();// 属性名
            if (StringUtils.isNotEmpty(datagrid.getSort())) {
                if (datagrid.getSort().equals(property))
                    isPropertyFlag = true;
            }
            try {
                Class<?> cla = Class.forName(type);
                if (!isJavaClass(cla)) {// 自定义属性 left join
                    sb.append(LEFT_JOIN + otherName + DOT + property + BLANK + property);
                }
            } catch (ClassNotFoundException e) {
//                                logger.error(e);
//                                throw new BusinessException("查询出现问题,请联系开发");
                continue;
            }
        }
        sb.append(" where 1=1 ");

        
        /**--------添加自定义h q l(注意别名)------------------*/
        /**先拼接开发写的hql语句以及query值*/
        if (StringUtils.isNotBlank(hqlQuery.getAddHql())) {
            int num = 0;
            for (char c : hqlQuery.getAddHql().toCharArray()) {
                if (c == '?')
                    num++;
            }
            hqlQuery.setNum(num);
            sb.append(AND);
            sb.append(hqlQuery.getAddHql());
        }


        List<Object> valuelist = new ArrayList<>();
        Map<String, Date> dataMap = new HashMap<>();
        List<Map<String, Object>> data = new ArrayList<>();
        Map<String, Object> map1 = null;
      
        if (hqlQuery.isFlag()) {
            sb.append(" and " + otherName + DOT + "sysCompanyCode=? ");
            map1 = new HashMap<>();
            map1.put("model", "String");
            map1.put("value", ResourceUtil.getCompany());
            data.add(map1);
        }


        for (Field field : declaredFields) {
            map1 = new HashMap<>();
            String type = field.getType().getName();// 类型
            String property = field.getName();// 属性名
            String beginValue = null, endValue = null; // 判断区间
            try {
                Class<?> cla = Class.forName(type);
                if (type.contains("java.lang") || type.contains("java.math")) {//普通类型
                    if (paramsMap.containsKey(property)) {
                        if (!StringUtil.isEmpty(paramsMap.get(property)[0])) {
                            if (type.equals("java.lang.Integer")) {
                                sb.append(AND + otherName + DOT + property + EQ + " ?");
                                map1.put("model", "Integer");
                                map1.put("value", paramsMap.get(property)[0].trim());
                                data.add(map1);
                            } else {
                                sb.append(AND + otherName + DOT + property + LIKE + " ? ");
                                map1.put("model", "String");
                                map1.put("value", "%" + paramsMap.get(property)[0].trim() + "%");
                                data.add(map1);
                            }
                        }
                    }
                } else if (type.contains("java.util.Date")) {//时间类型
                    Map<String, Object> map2;
                    if (paramsMap.containsKey(property + BEGIN)) {
                        beginValue = paramsMap.get(property + BEGIN)[0].trim();
                    }
                    if (paramsMap.containsKey(property + END)) {
                        endValue = paramsMap.get(property + END)[0].trim();
                    }
                    if (paramsMap.containsKey(property)) {
                        beginValue = endValue = paramsMap.get(property)[0].trim();
                    }
                    try {
                        /*if(paramsMap.containsKey(property)){
                         *//*beginValue = endValue = paramsMap.get(property)[0].trim();*//*
                                                        String d = paramsMap.get(property)[0].trim();
                                                        if(d!=null&&!"".equals(d)){
                                                                sb.append(AND +otherName+DOT+ property + " between ? and ?");
                                                                map2 = new HashMap<>();
                                                                map2.put("model", "Date");
                                                                map2.put("value", time.parse(d + " 00:00:00"));
                                                                data.add(map2);
                                                                map2 = new HashMap<>();
                                                                map2.put("model", "Date");
                                                                map2.put("value", time.parse(d + " 23:59:59"));
                                                                data.add(map2);
                                                        }

                                                }*/
                        if (org.apache.commons.lang.StringUtils.isNotBlank(beginValue)) {
                            sb.append(AND + otherName + DOT + property + ">= ? ");
                            map2 = new HashMap<>();
                            map2.put("model", "Date");
                            map2.put("value", time.parse(beginValue + " 00:00:00"));
                            data.add(map2);
                        }

                     

                        if (org.apache.commons.lang.StringUtils.isNotBlank(endValue)) {
                            sb.append(AND + otherName + DOT + property + "< ? ");
                            map2 = new HashMap<>();
                            map2.put("model", "Date");
                            map2.put("value", time.parse(GetDateUtil.getDay(endValue, 1, "yyyy-MM-dd") + " 00:00:00"));
                            data.add(map2);
                        }
                    } catch (ParseException e) {
                        e.printStackTrace();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                } else if (!isJavaClass(cla)) {
                    Map<String, String> objMap = obj(paramsMap, property);
                    if (objMap != null) {
                        for (Map.Entry<String, String> entry : objMap.entrySet()) {
                            sb.append(AND + entry.getKey() + LIKE + " ? ");
                            map1.put("model", "String");
                            map1.put("value", "%" + entry.getValue() + "%");
                            data.add(map1);
                        }
                    }
                }

            } catch (ClassNotFoundException e) {
                continue;
//                                logger.error(e);
//                                throw new BusinessException("代码开了小差,请联系开发");
            }
        }
        hqlQuery.setData(data);
        //加进拦截器
        String interceptorHql = JeecgDataAutorUtils.loadDataSearchConditonSQLString();
        if (StringUtils.isNotEmpty(interceptorHql)) {
            if (interceptorHql.substring(0, 4).indexOf("and") == -1)
                sb.append(AND);
            sb.append(BLANK + interceptorHql);
        }
        //自定义拦截器hql
        //排序
        if (datagrid != null)
            if (StringUtils.isNotEmpty(datagrid.getSort())) {
              
                if (isPropertyFlag)
                    sb.append(BLANK + ORDER_BY + otherName + DOT + datagrid.getSort() + BLANK + datagrid.getOrder());
               
            }
        hqlQuery.setValueList(valuelist);//query条件
        hqlQuery.setDataMap(dataMap);//query时间
        hqlQuery.setHql(sb.toString());
        return hqlQuery;
    }


    /**
     * 解决前端有自定义的字段 排序问题
     *
     * @param clazz 实体
     * @param dataGrid 已经查询过的datagrid
     * @param isEntity 是否是实体
     * @return
     */
    static String property = null;

    @SuppressWarnings("unchecked")
    public static List<?> sortList(Class<?> clazz, DataGrid dataGrid, boolean isEntity) {
        String sortColumn = dataGrid.getSort();
        if (StringUtils.isEmpty(sortColumn)) {
            return null;
        }
        if (sortColumn.indexOf(".") != -1) {
            return null;
        }
        Method method = getGetMethod(clazz, sortColumn);//获取get方法
        if (method != null) {
            Column column = method.getAnnotation(Column.class);//获取get方法上注解
            if (column != null) {
                return null;
            } else {
                JoinColumn join = method.getAnnotation(JoinColumn.class);
                if (join != null) {
                    return null;
                }
            }
        }
        property = sortColumn;
        List<Map<String, Object>> m = new ArrayList<>();
        if (isEntity) {
            List<?> list = dataGrid.getResults();
            Map<String, Object> map = null;
            for (Object c : list) {
                map = new HashMap<>();
                map = MapBean.BeanToMap(c);
                m.add(map);
            }
        } else {
            m = dataGrid.getResults();
        }
        Collections.sort(m, new Comparator<Map<String, Object>>() {
            @Override
            public int compare(Map<String, Object> o1, Map<String, Object> o2) {
                String s1 = (String) o1.get(property);
                String s2 = (String) o2.get(property);
                Collator collator = Collator.getInstance();
                return collator.getCollationKey(s1).compareTo(
                        collator.getCollationKey(s2));
            }
        });
        if ("desc".equals(dataGrid.getOrder())) {
            Collections.reverse(m);
        }
        //dataGrid.setResults(m);
        return m;
    }

    /**
     * java反射bean的get方法
     *
     * @param objectClass
     * @param fieldName
     * @return
     */
    @SuppressWarnings("unchecked")
    public static Method getGetMethod(Class<?> objectClass, String fieldName) {
        StringBuffer sb = new StringBuffer();
        sb.append("get");
        sb.append(fieldName.substring(0, 1).toUpperCase());
        sb.append(fieldName.substring(1));
        try {
            return objectClass.getMethod(sb.toString());
        } catch (Exception e) {
        }
        return null;
    }


    private static Map<String, String> obj(Map<String, String[]> map, String property) {
        for (Map.Entry<String, String[]> entry : map.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue()[0];
            if (key.contains(".") && key.substring(0, key.indexOf(".")).equals(property)) {
                if (!StringUtil.isEmpty(value)) {
                    Map<String, String> result = new HashMap<>();
                    result.put(key, value);
                    return result;
                }
            }
        }
        return null;
    }

    /**
     * 系统类型
     *
     * @param clz
     * @return
     */
    public static boolean isJavaClass(Class<?> clz) {
        return clz != null && clz.getClassLoader() == null;
    }

}

1. /**
   
2. * Copyright 2018 String
   
3. * <p>
   
4. * Licensed under the Apache License, Version 2.0 (the "License");
   
5. * you may not use this file except in compliance with the License.
   
6. * You may obtain a copy of the License at
   
7. * <p>
   
8. * http://www.apache.org/licenses/LICENSE-2.0
   
9. * <p>
   
10. * Unless required by applicable law or agreed to in writing, software
    
11. * distributed under the License is distributed on an "AS IS" BASIS,
    
12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    
13. * See the License for the specific language governing permissions and
    
14. * limitations under the License.
    
15. */

复制代码

import org.hibernate.Query;
import org.jeecgframework.core.common.model.json.DataGrid;

import java.util.Date;
import java.util.List;
import java.util.Map;

/**
* 对hql封装
* @author String
*
*/
public class HqlQuery {
        private int curPage = 1;// 当前页
        private int pageSize = 10;// 默认一页条数
        private Class<?> entityClass;//POJO
        private  Map<String, String[]> paramsMap; //查询的条件
        private int total;//总页数
        private DataGrid dataGrid;
        private List<?> valueList;//条件集合
        private Map<String,Date> dataMap;
        private String hql;
        private Query query;
        private Integer num=0;//记录query数据？标示位数
        List<Map<String,Object>> data;
        private String addHql;
        private boolean flag=false;//公司标示
        
        
        public boolean isFlag() {
                return flag;
        }
        public void setFlag(boolean flag) {
                this.flag = flag;
        }
        public Integer getNum() {
                return num;
        }
        public void setNum(Integer num) {
                this.num = num;
        }
        public String getAddHql() {
                return addHql;
        }
        public void setAddHql(String addHql) {
                this.addHql = addHql;
        }
        public int getCurPage() {
                return curPage;
        }
        public void setCurPage(int curPage) {
                this.curPage = curPage;
        }
        public int getPageSize() {
                return pageSize;
        }
        public void setPageSize(int pageSize) {
                this.pageSize = pageSize;
        }
        public Map<String, String[]> getParamsMap() {
                return paramsMap;
        }
        public void setParamsMap(Map<String, String[]> paramsMap) {
                this.paramsMap = paramsMap;
        }
        public Class<?> getEntityClass() {
                return entityClass;
        }
        public void setEntityClass(Class<?> entityClass) {
                this.entityClass = entityClass;
        }
        public int getTotal() {
                return total;
        }
        public void setTotal(int total) {
                this.total = total;
        }
        public DataGrid getDataGrid() {
                return dataGrid;
        }
        public void setDataGrid(DataGrid dataGrid) {
                this.dataGrid = dataGrid;
        }
        public List<?> getValueList() {
                return valueList;
        }
        public void setValueList(List<?> valueList) {
                this.valueList = valueList;
        }
        public String getHql() {
                return hql;
        }
        public void setHql(String hql) {
                this.hql = hql;
        }
        public HqlQuery(Class<?> entityClass, Map<String, String[]> paramsMap, DataGrid dataGrid) {
                super();
                this.entityClass = entityClass;
                this.paramsMap = paramsMap;
                this.dataGrid = dataGrid;
        }
        public HqlQuery(Class<?> entityClass, Map<String, String[]> paramsMap, DataGrid dataGrid,Boolean flag) {
                super();
                this.entityClass = entityClass;
                this.paramsMap = paramsMap;
                this.dataGrid = dataGrid;
                this.flag=flag;
        }
        public Map<String, Date> getDataMap() {
                return dataMap;
        }
        public void setDataMap(Map<String, Date> dataMap) {
                this.dataMap = dataMap;
        }
        public HqlQuery() {
                super();
        }
        public Query getQuery() {
                return query;
        }
        public void setQuery(Query query) {
                this.query = query;
        }
        public List<Map<String, Object>> getData() {
                return data;
        }
        public void setData(List<Map<String, Object>> data) {
                this.data = data;
        }
        

}

1. import java.text.DateFormat;
   
2. import java.text.ParseException;
   
3. import java.text.SimpleDateFormat;
   
4. import java.util.Calendar;
   
5. import java.util.Date;
   
6. 
   
7. public class GetDateUtil {
   
8.         
   
9.         /**
   
10.          * 获取周期开始时间
    
11.          * @param startTime 上次开始时间
    
12.          * @param now 当前时间
    
13.          * @param n 周期长度
    
14.          * @param unit 周期单位
    
15.          * @return 包含当前时间的周期开始时间
    
16.          * @throws Exception
    
17.          */
    
18.         public Date getStartTime(Date startTime,Date now,int n,String unit) throws Exception{
    
19.                 Calendar cal = Calendar.getInstance();
    
20.                 Date endTime = new Date();
    
21.                 if("0".equals(unit)){
    
22.                         endTime = getHour(startTime, n);
    
23.                 }else if("1".equals(unit)){
    
24.                         endTime = getDay(startTime, n);
    
25.                 }else if("2".equals(unit)){
    
26.                         endTime = getTheWeekMonday(startTime, n);
    
27.                 }else if("3".equals(unit)){
    
28.                         endTime = getTheMonthDay(startTime, n);
    
29.                 }else{
    
30.                         endTime = getDay(startTime, n);
    
31.                 }
    
32.                 if(startTime.before(now)&&endTime.after(now)){
    
33.                         cal.setTime(startTime);
    
34.                 }else{
    
35.                         startTime.setTime(endTime.getTime());
    
36.                         startTime = getStartTime(startTime, now, n, unit);
    
37.                         cal.setTime(startTime);
    
38.                 }
    
39.                
    
40.                
    
41.                 return cal.getTime();
    
42.         }
    
43.         
    
44.         /**
    
45.          * 返回某个时间的N小时后时间
    
46.          * @param date
    
47.          * @param n
    
48.          * @return 某小时
    
49.          * @throws Exception
    
50.          */
    
51.         public static Date getHour(Date date,int n) throws Exception{
    
52.                 Calendar cal = Calendar.getInstance();
    
53.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHH");
    
54.                 date = sdf.parse(sdf.format(date));
    
55.                 cal.setTime(date);
    
56.                 cal.add(Calendar.HOUR_OF_DAY, n);
    
57.                
    
58.                 return cal.getTime();
    
59.         }
    
60.         /**
    
61.          * 返回某天后N的天日期
    
62.          * @param date
    
63.          * @param n
    
64.          * @return 日期
    
65.          * @throws Exception
    
66.          */
    
67.         public static Date getDay(Date date,int n) throws Exception{
    
68.                 Calendar cal = Calendar.getInstance();
    
69.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
    
70.                 date = sdf.parse(sdf.format(date));
    
71.                 cal.setTime(date);
    
72.                 cal.add(Calendar.DAY_OF_MONTH, n);
    
73.                
    
74.                 return cal.getTime();
    
75.         }
    
76.         
    
77.         
    
78.         /**
    
79.          * 查询n周后周一
    
80.          * @param date 当前时间
    
81.          * @param n
    
82.          * @return 返回n周后周一
    
83.          */
    
84.         public static Date        getTheWeekMonday(Date date,int n) throws Exception{
    
85.                 Calendar cal = Calendar.getInstance();
    
86.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
    
87.                 date = sdf.parse(sdf.format(date));
    
88.                 cal.setTime(date);
    
89.                 int i = cal.get(Calendar.DAY_OF_WEEK);
    
90.                 if(i==Calendar.SUNDAY){
    
91.                         cal.add(Calendar.WEEK_OF_YEAR, n-1);// 当前日期的下周一
    
92.                 }else{
    
93.                         cal.add(Calendar.WEEK_OF_YEAR, n);// 当前日期的下周一
    
94.                 }
    
95.                 cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
    
96.                
    
97.                 return cal.getTime();
    
98.         }
    
99.         
    
100.         /**
     
101.          * 返回当前日期的下N月1号
     
102.          * @param date 当前日期
     
103.          * @return 当前日期的n月后1号
     
104.          * @throws Exception

复制代码

String

删除机构出现错误，
意思不用解释，有外键关联数据，删不掉，跟踪代码，发现ts_base_user表中deparid存在外键数据，看下机构删除代码注释
/**
         * 删除部门：
         * <ul>
     *     组织机构下存在子机构时
     *     <li>不允许删除 组织机构</li>
         * </ul>
         * <ul>
     *     组织机构下存在用户时
     *     <li>不允许删除 组织机构</li>
         * </ul>
         * <ul>
     *     组织机构下 不存在子机构 且 不存在用户时
     *     <li>删除 组织机构-角色 信息</li>
     *     <li>删除 组织机构 信息</li>
         * </ul>
         * @return 删除的结果信息
         */
没有关于这张表中的说明，继续看下用户实体
@Excel(name = "组织机构编码(多个组织机构编码用逗号分隔，非必填)")
        private String departid;

非必填，看下用户 新增未体现，体现在excel导出方法：exportXls() 中
解决方案
更新 update t_s_base_user set departid=null    处理解决。
本身框架对这个deparid用处不多，只用在t_s_user_org中间表做关联，建议还是更新sql。

String

发现个不严谨的校验问题，如果账户被逻辑删除后，因为没有吧角色和机构同时删除，所以机构下面依旧会出现这个账户，如果删除到最后一个，那么这个账户不会被删除掉，按照一般逻辑来说(也可以看实际情况)，既然逻辑删除了此账户，那么在机构下面也可以删除干净此账户和机构的关联，在这里价格校验即可
dsdepartController 方法 delUserOrg()里
添加校验在：if(userOrgList.size() == 1){
Short flag=userOrgList.get(0).getTsUser().getDeleteFlag();
                                        if(flag==1){
                                                String sql = "delete from t_s_user_org where user_id = '"+userid+"' and org_id = '"+departid+"'";
                                                this.systemService.executeSql(sql);
                                                ajaxJson.setMsg("成功删除用户对应的组织机构关系");
                                        }else{
                                                ajaxJson.setSuccess(false);
                                                ajaxJson.setMsg("当前用户只包含有当前组织机构关系，不可删除，请切换用户的组织机构关系");                                               
                                        }
}

String

ztree换个风格，原来的太丑了，换后效果

直接baseTag修改这里把原有zTreeStyle.css换成metroStyle.css

然后替换下/src/main/webapp/plug-in/ztree
ztree.zip (88.44 KB, 下载次数: 34)

2017-8-23 15:15 上传

点击文件名下载附件

即可

itking

不错

eddieccq

非常感谢分享。

String

列表增加动态颜色需求，有时候我们要根据字段值动态显示不同的颜色，比如状态之类的，未审核、审核中、审核通过等等，以不同颜色来区分达到更好的用户体验，我们先看看最终的效果

好的 我们开始实现
1、以3.7为例子，其他都一样的，打开dataGridTag(对easyui datagrid的封装自定义标签类)，打开码云源码看看原代码：

这段代码是对 datagrid 列属性styler 的封装，我们看看api对其的解释，

好的我们看这是个function类型，是个函数，注意红色标示，最终返回的是个样式，那么我们知道这一点就可以进行修改了。

2、自定义其规则值，我们定义下规则

<t:dgCol title="状态" field="status" style="1&color:red;2&color:#ead148;3&color:#05eb50;4&color:black;" dictionary="bugSta" queryMode="single"></t:dgCol>
dictionary 不用多说 数字字典，其中 1&color:red;2&color:#ead148;3&color:#05eb50;4&color:black; 就是我们的规则，
意思是 值为1 显示red 2 显示#ead148 值和颜色中间用"&"符号分割，值与值之间用";"分割，很简单。
3、代码实现，我们修改这里
在代码
if((value.length == 0||StringUtils.isEmpty(value[0]))&&text.length==1){
        if(text[0].indexOf("(")>-1){
                testString = " return \'" + text[0].replace("(", "(value,rec,index") + "\'";
        }else{
            //testString = " return \'" + text[0] + "\'";  先屏蔽掉这一行
               //下面都是添加的
               StringBuffer s = new StringBuffer();
                if (text[0].indexOf("&") != -1) {
                        String t[] = text[0].split(";");
                        for (String ss : t) {
                                String[] n = ss.split("&");
                                if (n.length == 2) {
                                        s.append("if(value=='" + n[0] + "'){return \'" + n[1] + "\'}");
                                }
                        }
                testString = s.toString();

                } else
                testString = " return \'" + text[0] + "\'";
          }
}
4、结束，其实很简单的，思路很重要，当然也有其他的实现方式，这里就不一一举例了
ps：时机成熟的话，我会分享下把qbc换成hql查询的集成代码，用qbc实在是恶心。

zhangwenxiang

给楼主点个赞

String

H+plus模式下更加扁平化修改，目前我们注意到jeecg demo 和之前页面多少有些不同(2017年10月份)，但是开源源码中却没有及时更新，比如前端按钮和主页面list的优化，例如下图：

那么我们一步步改呗，其实方法很简单，浏览器F12 推荐用谷歌，我们慢慢调试其中的样式，然后修改对应css代码，具体就不做演示了，直接拿出修改好的样式，如下图所示：

如图中提示，我们最好加一条线，因为官方的是没有的，原因是因为当toolbar多的时候显得查询范围和按钮范围统一了，感觉上屏占比太大了，我们加一条线显得有些分层，感官上比较好点，还有修改的是原来的toolbar input 高度从30px调节到了25px，缩小屏占比，如果你感觉太小可以F12修改下上面input的高度，官方的是30px，好了 上附件：
metrole.zip (182.01 KB, 下载次数: 12)

2017-10-17 14:59 上传

点击文件名下载附件

直接解压，复制粘贴到项目的 src\main\webapp\plug-in\easyui\themes\下面，把metrole 文件夹覆盖掉(记得备份,万一有误还可还原)。
结束。

gaoweimaster

mark