如何使用ssm实现班级事务管理系统+vue

    package com.controller;
    
    import java.io.File;
    import java.math.BigDecimal;
    import java.net.URL;
    import java.text.SimpleDateFormat;
    import com.alibaba.fastjson.JSONObject;
    import java.util.*;
    import org.springframework.beans.BeanUtils;
    import javax.servlet.http.HttpServletRequest;
    import org.springframework.web.context.ContextLoader;
    import javax.servlet.ServletContext;
    import com.service.TokenService;
    import com.utils.*;
    import java.lang.reflect.InvocationTargetException;
    
    import com.service.DictionaryService;
    import org.apache.commons.lang3.StringUtils;
    import com.annotation.IgnoreAuth;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.*;
    import com.baomidou.mybatisplus.mapper.EntityWrapper;
    import com.baomidou.mybatisplus.mapper.Wrapper;
    import com.entity.*;
    import com.entity.view.*;
    import com.service.*;
    import com.utils.PageUtils;
    import com.utils.R;
    import com.alibaba.fastjson.*;
    
    /** * 成绩
     * 后端接口
     * @author
     * @email
    */
    @RestController
    @Controller
    @RequestMapping("/chengji")
    public class ChengjiController {
    private static final Logger logger = LoggerFactory.getLogger(ChengjiController.class);
    
    @Autowired
    private ChengjiService chengjiService;
    
    
    @Autowired
    private TokenService tokenService;
    @Autowired
    private DictionaryService dictionaryService;
    
    //级联表service
    @Autowired
    private XueshengService xueshengService;
    
    @Autowired
    private LaoshiService laoshiService;
    
    
    /** * 后端列表
    */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永不会进入");
        else if("学生".equals(role))
            params.put("xueshengId",request.getSession().getAttribute("userId"));
        else if("老师".equals(role))
            params.put("laoshiId",request.getSession().getAttribute("userId"));
        if(params.get("orderBy")==null || params.get("orderBy")==""){
            params.put("orderBy","id");
        }
        PageUtils page = chengjiService.queryPage(params);
    
        //字典表数据转换
        List<ChengjiView> list =(List<ChengjiView>)page.getList();
        for(ChengjiView c:list){
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(c, request);
        }
        return R.ok().put("data", page);
    }
    
    /** * 后端详情
    */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        ChengjiEntity chengji = chengjiService.selectById(id);
        if(chengji !=null){
            //entity转view
            ChengjiView view = new ChengjiView();
            BeanUtils.copyProperties( chengji , view );//把实体数据重构到view中
    
                //级联表
                XueshengEntity xuesheng = xueshengService.selectById(chengji.getXueshengId());
                if(xuesheng != null){
                    BeanUtils.copyProperties( xuesheng , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setXueshengId(xuesheng.getId());
                }
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }
    
    }
    
    /** * 后端保存
    */
    @RequestMapping("/save")
    public R save(@RequestBody ChengjiEntity chengji, HttpServletRequest request){
        logger.debug("save方法:,,Controller:{},,chengji:{}",this.getClass().getName(),chengji.toString());
    
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永远不会进入");
        else if("学生".equals(role))
            chengji.setXueshengId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
    
        Wrapper<ChengjiEntity> queryWrapper = new EntityWrapper<ChengjiEntity>()
            .eq("xuesheng_id", chengji.getXueshengId())
            .eq("chengji_name", chengji.getChengjiName())
            .eq("chengji_types", chengji.getChengjiTypes())
            ;
    
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ChengjiEntity chengjiEntity = chengjiService.selectOne(queryWrapper);
        if(chengjiEntity==null){
            chengji.setInsertTime(new Date());
            chengji.setCreateTime(new Date());
            chengjiService.insert(chengji);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }
    
    /** * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody ChengjiEntity chengji, HttpServletRequest request){
        logger.debug("update方法:,,Controller:{},,chengji:{}",this.getClass().getName(),chengji.toString());
    
        String role = String.valueOf(request.getSession().getAttribute("role"));
    //        if(false)
    //            return R.error(511,"永远不会进入");
    //        else if("学生".equals(role))
    //            chengji.setXueshengId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
        //根据字段查询是否有相同数据
        Wrapper<ChengjiEntity> queryWrapper = new EntityWrapper<ChengjiEntity>()
            .notIn("id",chengji.getId())
            .andNew()
            .eq("xuesheng_id", chengji.getXueshengId())
            .eq("chengji_name", chengji.getChengjiName())
            .eq("chengji_types", chengji.getChengjiTypes())
            ;
    
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ChengjiEntity chengjiEntity = chengjiService.selectOne(queryWrapper);
        if(chengjiEntity==null){
            chengjiService.updateById(chengji);//根据id更新
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }
    
    /** * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        chengjiService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
    
    
    /** * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save( String fileName){
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
        try {
            List<ChengjiEntity> chengjiList = new ArrayList<>();//上传的东西
            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
            Date date = new Date();
            int lastIndexOf = fileName.lastIndexOf(".");
            if(lastIndexOf == -1){
                return R.error(511,"该文件没有后缀");
            }else{
                String suffix = fileName.substring(lastIndexOf);
                if(!".xls".equals(suffix)){
                    return R.error(511,"只支持后缀为xls的excel文件");
                }else{
                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
                    File file = new File(resource.getFile());
                    if(!file.exists()){
                        return R.error(511,"找不到上传文件，请联系管理员");
                    }else{
                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
                        dataList.remove(0);//删除第一行，因为第一行是提示
                        for(List<String> data:dataList){
                            //循环
                            ChengjiEntity chengjiEntity = new ChengjiEntity();
    //                            chengjiEntity.setXueshengId(Integer.valueOf(data.get(0)));   //学生 要改的
    //                            chengjiEntity.setChengjiName(data.get(0));                    //成绩名称 要改的
    //                            chengjiEntity.setChengjiTypes(Integer.valueOf(data.get(0)));   //成绩类型 要改的
    //                            chengjiEntity.setChengjiContent("");//照片
    //                            chengjiEntity.setChengjifenshu(data.get(0));                    //成绩 要改的
    //                            chengjiEntity.setInsertTime(date);//时间
    //                            chengjiEntity.setCreateTime(date);//时间
                            chengjiList.add(chengjiEntity);
    
    
                            //把要查询是否重复的字段放入map中
                        }
    
                        //查询是否重复
                        chengjiService.insertBatch(chengjiList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            return R.error(511,"批量插入数据异常，请联系管理员");
        }
    }
    
    
    
    
    
    
    }
    
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    AI写代码

    package com.controller;
    
    import java.io.File;
    import java.math.BigDecimal;
    import java.net.URL;
    import java.text.SimpleDateFormat;
    import com.alibaba.fastjson.JSONObject;
    import java.util.*;
    import org.springframework.beans.BeanUtils;
    import javax.servlet.http.HttpServletRequest;
    import org.springframework.web.context.ContextLoader;
    import javax.servlet.ServletContext;
    import com.service.TokenService;
    import com.utils.*;
    import java.lang.reflect.InvocationTargetException;
    
    import com.service.DictionaryService;
    import org.apache.commons.lang3.StringUtils;
    import com.annotation.IgnoreAuth;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.*;
    import com.baomidou.mybatisplus.mapper.EntityWrapper;
    import com.baomidou.mybatisplus.mapper.Wrapper;
    import com.entity.*;
    import com.entity.view.*;
    import com.service.*;
    import com.utils.PageUtils;
    import com.utils.R;
    import com.alibaba.fastjson.*;
    
    /** * 字典
     * 后端接口
     * @author
     * @email
    */
    @RestController
    @Controller
    @RequestMapping("/dictionary")
    public class DictionaryController {
    private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class);
    
    @Autowired
    private DictionaryService dictionaryService;
    
    
    @Autowired
    private TokenService tokenService;
    
    //级联表service
    
    @Autowired
    private XueshengService xueshengService;
    @Autowired
    private LaoshiService laoshiService;
    
    
    /** * 后端列表
    */
    @RequestMapping("/page")
    @IgnoreAuth
    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        if(params.get("orderBy")==null || params.get("orderBy")==""){
            params.put("orderBy","id");
        }
        PageUtils page = dictionaryService.queryPage(params);
    
        //字典表数据转换
        List<DictionaryView> list =(List<DictionaryView>)page.getList();
        for(DictionaryView c:list){
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(c, request);
        }
        return R.ok().put("data", page);
    }
    
    /** * 后端详情
    */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        DictionaryEntity dictionary = dictionaryService.selectById(id);
        if(dictionary !=null){
            //entity转view
            DictionaryView view = new DictionaryView();
            BeanUtils.copyProperties( dictionary , view );//把实体数据重构到view中
    
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }
    
    }
    
    /** * 后端保存
    */
    @RequestMapping("/save")
    public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){
        logger.debug("save方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString());
    
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永远不会进入");
    
        Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
            .eq("dic_code", dictionary.getDicCode())
            .eq("index_name", dictionary.getIndexName())
            ;
        if(dictionary.getDicCode().contains("_erji_types")){
            queryWrapper.eq("super_id",dictionary.getSuperId());
        }
    
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
        if(dictionaryEntity==null){
            dictionary.setCreateTime(new Date());
            dictionaryService.insert(dictionary);
            //字典表新增数据,把数据再重新查出,放入监听器中
            List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
            ServletContext servletContext = request.getServletContext();
            Map<String, Map<Integer,String>> map = new HashMap<>();
            for(DictionaryEntity d :dictionaryEntities){
                Map<Integer, String> m = map.get(d.getDicCode());
                if(m ==null || m.isEmpty()){
                    m = new HashMap<>();
                }
                m.put(d.getCodeIndex(),d.getIndexName());
                map.put(d.getDicCode(),m);
            }
            servletContext.setAttribute("dictionaryMap",map);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }
    
    /** * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){
        logger.debug("update方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString());
    
        String role = String.valueOf(request.getSession().getAttribute("role"));
    //        if(false)
    //            return R.error(511,"永远不会进入");
        //根据字段查询是否有相同数据
        Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
            .notIn("id",dictionary.getId())
            .eq("dic_code", dictionary.getDicCode())
            .eq("index_name", dictionary.getIndexName())
            ;
    
        if(dictionary.getDicCode().contains("_erji_types")){
            queryWrapper.eq("super_id",dictionary.getSuperId());
        }
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
        if(dictionaryEntity==null){
            dictionaryService.updateById(dictionary);//根据id更新
            //如果字典表修改数据的话,把数据再重新查出,放入监听器中
            List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
            ServletContext servletContext = request.getServletContext();
            Map<String, Map<Integer,String>> map = new HashMap<>();
            for(DictionaryEntity d :dictionaryEntities){
                Map<Integer, String> m = map.get(d.getDicCode());
                if(m ==null || m.isEmpty()){
                    m = new HashMap<>();
                }
                m.put(d.getCodeIndex(),d.getIndexName());
                map.put(d.getDicCode(),m);
            }
            servletContext.setAttribute("dictionaryMap",map);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }
    
    /** * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        dictionaryService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }
    
    /** * 最大值
     */
    @RequestMapping("/maxCodeIndex")
    public R maxCodeIndex(@RequestBody DictionaryEntity dictionary){
        logger.debug("maxCodeIndex:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString());
        List<String> descs = new ArrayList<>();
        descs.add("code_index");
        Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
                .eq("dic_code", dictionary.getDicCode())
                .orderDesc(descs);
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        List<DictionaryEntity> dictionaryEntityList = dictionaryService.selectList(queryWrapper);
        if(dictionaryEntityList != null ){
            return R.ok().put("maxCodeIndex",dictionaryEntityList.get(0).getCodeIndex()+1);
        }else{
            return R.ok().put("maxCodeIndex",1);
        }
    }
    
    /** * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save( String fileName){
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
        try {
            List<DictionaryEntity> dictionaryList = new ArrayList<>();//上传的东西
            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
            Date date = new Date();
            int lastIndexOf = fileName.lastIndexOf(".");
            if(lastIndexOf == -1){
                return R.error(511,"该文件没有后缀");
            }else{
                String suffix = fileName.substring(lastIndexOf);
                if(!".xls".equals(suffix)){
                    return R.error(511,"只支持后缀为xls的excel文件");
                }else{
                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
                    File file = new File(resource.getFile());
                    if(!file.exists()){
                        return R.error(511,"找不到上传文件，请联系管理员");
                    }else{
                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
                        dataList.remove(0);//删除第一行，因为第一行是提示
                        for(List<String> data:dataList){
                            //循环
                            DictionaryEntity dictionaryEntity = new DictionaryEntity();
    //                            dictionaryEntity.setDicCode(data.get(0));                    //字段 要改的
    //                            dictionaryEntity.setDicName(data.get(0));                    //字段名 要改的
    //                            dictionaryEntity.setCodeIndex(Integer.valueOf(data.get(0)));   //编码 要改的
    //                            dictionaryEntity.setIndexName(data.get(0));                    //编码名字 要改的
    //                            dictionaryEntity.setSuperId(Integer.valueOf(data.get(0)));   //父字段id 要改的
    //                            dictionaryEntity.setBeizhu(data.get(0));                    //备注 要改的
    //                            dictionaryEntity.setCreateTime(date);//时间
                            dictionaryList.add(dictionaryEntity);
    
    
                            //把要查询是否重复的字段放入map中
                        }
    
                        //查询是否重复
                        dictionaryService.insertBatch(dictionaryList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            return R.error(511,"批量插入数据异常，请联系管理员");
        }
    }
    
    
    
    
    
    
    }
    
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    AI写代码

    package com.utils;
    
    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    
    import org.apache.commons.lang3.StringUtils;
    
    import cn.hutool.core.bean.BeanUtil;
    
    import com.baomidou.mybatisplus.mapper.Wrapper;
    
    /** * Mybatis-Plus工具类
     */
    public class MPUtil {
    	public static final char UNDERLINE = '_';
    
    	
    	//mybatis plus allEQ 表达式转换
    		public static Map allEQMapPre(Object bean,String pre) {
    		   Map<String, Object> map =BeanUtil.beanToMap(bean);
    		  return camelToUnderlineMap(map,pre);
    	   }
    
    		//mybatis plus allEQ 表达式转换
    		public static Map allEQMap(Object bean) {
    		   Map<String, Object> map =BeanUtil.beanToMap(bean);
    		   return camelToUnderlineMap(map,"");
    	   }
    
    		public static Wrapper allLikePre(Wrapper wrapper,Object bean,String pre) {
    			   Map<String, Object> map =BeanUtil.beanToMap(bean);
    			   Map result = camelToUnderlineMap(map,pre);
    			 
    			return genLike(wrapper,result);
    		}
    	
    		public static Wrapper allLike(Wrapper wrapper,Object bean) {
    			  Map result = BeanUtil.beanToMap(bean, true, true);			 
    			return genLike(wrapper,result);
    		}
    	
    	
    		public static Wrapper genLike( Wrapper wrapper,Map param) {
    			Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
    			int i=0;
    			while (it.hasNext()) {
    				if(i>0) wrapper.and();
    				Map.Entry<String, Object> entry = it.next();
    				String key = entry.getKey();
    				String value = (String) entry.getValue();
    				wrapper.like(key, value);
    				i++;
    			}
    			return wrapper;
    		}
    		
    		public static Wrapper likeOrEq(Wrapper wrapper,Object bean) {
    			  Map result = BeanUtil.beanToMap(bean, true, true);			 
    			return genLikeOrEq(wrapper,result);
    		}
    		
    		public static Wrapper genLikeOrEq( Wrapper wrapper,Map param) {
    			Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
    			int i=0;
    			while (it.hasNext()) {
    				if(i>0) wrapper.and();
    				Map.Entry<String, Object> entry = it.next();
    				String key = entry.getKey();
    				if(entry.getValue().toString().contains("%")) {
    					wrapper.like(key, entry.getValue().toString().replace("%", ""));
    				} else {
    					wrapper.eq(key, entry.getValue());
    				}
    				i++;
    			}
    			return wrapper;
    		}
    		
    		public static Wrapper allEq(Wrapper wrapper,Object bean) {
    			  Map result = BeanUtil.beanToMap(bean, true, true);			 
    			return genEq(wrapper,result);
    		}
    	
    	
    		public static Wrapper genEq( Wrapper wrapper,Map param) {
    			Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
    			int i=0;
    			while (it.hasNext()) {
    				if(i>0) wrapper.and();
    				Map.Entry<String, Object> entry = it.next();
    				String key = entry.getKey();
    				wrapper.eq(key, entry.getValue());
    				i++;
    			}
    			return wrapper;
    		}
    	
    	
    		public static Wrapper between(Wrapper wrapper,Map<String, Object> params) {
    			for(String key : params.keySet()) {
    				String columnName = "";
    				if(key.endsWith("_start")) {
    					columnName = key.substring(0, key.indexOf("_start"));
    					if(StringUtils.isNotBlank(params.get(key).toString())) {
    						wrapper.ge(columnName, params.get(key));
    					}
    				}
    				if(key.endsWith("_end")) {
    					columnName = key.substring(0, key.indexOf("_end"));
    					if(StringUtils.isNotBlank(params.get(key).toString())) {
    						wrapper.le(columnName, params.get(key));
    					}
    				}
    			}
    			return wrapper;
    		}
    	
    		public static Wrapper sort(Wrapper wrapper,Map<String, Object> params) {
    			String order = "";
    			if(params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) {
    				order = params.get("order").toString();
    			}
    			if(params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) {
    				if(order.equalsIgnoreCase("desc")) {
    					wrapper.orderDesc(Arrays.asList(params.get("sort")));
    				} else {
    					wrapper.orderAsc(Arrays.asList(params.get("sort")));
    				}
    			}
    			return wrapper;
    		}
    	
    	
    	/** * 驼峰格式字符串转换为下划线格式字符串
    	 * * @param param
    	 * @return
    	 */
    	public static String camelToUnderline(String param) {
    		if (param == null || "".equals(param.trim())) {
    			return "";
    		}
    		int len = param.length();
    		StringBuilder sb = new StringBuilder(len);
    		for (int i = 0; i < len; i++) {
    			char c = param.charAt(i);
    			if (Character.isUpperCase(c)) {
    				sb.append(UNDERLINE);
    				sb.append(Character.toLowerCase(c));
    			} else {
    				sb.append(c);
    			}
    		}
    		return sb.toString();
    	}
    
    	public static void main(String[] ages) {
    		System.out.println(camelToUnderline("ABCddfANM"));
    	}
    	
    	public static Map camelToUnderlineMap(Map param, String pre) {
    
    		Map<String, Object> newMap = new HashMap<String, Object>();
    		Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
    		while (it.hasNext()) {
    			Map.Entry<String, Object> entry = it.next();
    			String key = entry.getKey();
    			String newKey = camelToUnderline(key);
    			if (pre.endsWith(".")) {
    				newMap.put(pre + newKey, entry.getValue());
    			} else if (StringUtils.isEmpty(pre)) {
    				newMap.put(newKey, entry.getValue());
    			} else {
    
    				newMap.put(pre + "." + newKey, entry.getValue());
    			}
    		}
    		return newMap;
    	}
    }
    
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    AI写代码

    # replace default config
    # 基于svgo对svg文件进行压缩：https://panjiachen.github.io/vue-element-admin-site/zh/feature/script/svgo.html
    # multipass: true
    # full: true
    
    plugins:
    
      # - name
      #
      # or:
      # - name: false
      # - name: true
      #
      # or:
      # - name:
      #     param1: 1
      #     param2: 2
    
    - removeAttrs:
    attrs:
      - 'fill'
      - 'fill-rule'
    
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    AI写代码