Mybatis plus+QueryWrapper+Swagger2实现所有类超级查询 后台解放

第一，实体类举例：

package com.sinday.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
import lombok.Data;

@ApiModel(value="zql_company")
@Data
@TableName(value = "zql_company")
public class ZqlCompany implements Serializable {

    @TableId(value = "userid", type = IdType.AUTO)
    @ApiModelProperty(value="")
    private Integer userid;

    /**
     * 公司名称
     */
    @TableField(value = "companyname")
    @ApiModelProperty(value="公司名称")
    private String companyname;

    /**
     * 企业性质
     */
    @TableField(value = "pattern")
    @ApiModelProperty(value="企业性质")
    private String pattern;

    private static final long serialVersionUID = 1L;
}

第二，自己写的帮助类获取注解（存在字段属性与数据库不一致的情况，所以我们要使用 注解获取数据库字段）

mybatis-plus注解实体对象中有三种 

表名：@TableName(value = "zql_company")

id列名：@TableId(value = "userid")

普通列名：@TableField(value = "companyname")

我们要获取了上方三种属性，就能拼接sql了

        获取注解id：

 public static Map<String, String>getDeclaredFieldsInfoId(Object instance) {

        Map<String, String> fieldMap=new HashMap<>();
        Map<String, String> map =new HashMap();
        Class<?> clazz = instance.getClass();
        Field[] fields = clazz.getDeclaredFields();
        boolean b =false;
        for(int i =0; i < fields.length; i++){
            if(!fieldMap.containsValue(fields[i].getName())){
                //                Field field=clazz.getDeclaredField(fields[i].getName());
                boolean annotationPresent = fields[i].isAnnotationPresent(TableId.class);
                if(annotationPresent){
                    String name = fields[i].getAnnotation(TableId.class).value();
                    map.put(fields[i].getName(),name);
                }
            }
        }
        //System.out.println(JSON.toJSONString(map));
        return map;
    }

        获取注解列名：

public static Map<String, String>getDeclaredFieldsInfo2(Object instance) {

    Map<String, String> fieldMap=new HashMap<>();
    Map<String, String> map =new HashMap();
    Class<?> clazz = instance.getClass();
    Field[] fields = clazz.getDeclaredFields();
    boolean b =false;
    for(int i =0; i < fields.length; i++){
            if(!fieldMap.containsValue(fields[i].getName())){
    //                Field field=clazz.getDeclaredField(fields[i].getName());
                boolean annotationPresent = fields[i].isAnnotationPresent(TableField.class);
                if(annotationPresent){
                    String name = fields[i].getAnnotation(TableField.class).value();
                    map.put( fields[i].getName(),name);
                }
            }
        }
       // System.out.println(JSON.toJSONString(map));
    return map;
    }

        获取注解表名：

public static String getDeclaredFieldsInfoTableName(Object instance) {
        Map<String, String> fieldMap=new HashMap<>();
        
        Map<String, String> map =new HashMap();
        Class<?> clazz = instance.getClass();
        String name = clazz.getAnnotation(TableName.class).value();
        System.out.println("name:"+name);
        return name;
    }

接下来就是拼接QueryWrapper

注意：我这里是数字就是eq也就是 = 查询，汉字就是 like 查询

    public  static QueryWrapper getQuerwapperByT(Object t,QueryWrapper queryWrapper){
        //获取实际对象属性与值
        Map<String, String> entiys = new HashMap<String, String>();
        entiys = JSON.parseObject(JSON.toJSONString(t), new TypeReference<Map<String, String>>() {
        });//获取实际对象属性与值

        //获取非id字段数据库对应字段
        Map<String, String> fieldMap=getDeclaredFieldsInfo2(t);
        //结束获取非id字段数据库对应字段

        //获取id字段数据库对应字段
        Map<String, String> field_idMap=getDeclaredFieldsInfoId(t);
        //结束获取id字段数据库对应字段
        for (String sx:entiys.keySet()){
            int s=0;
            try {
                double abc=Double.parseDouble(entiys.get(sx));
            }catch (Exception e){
                s=1;
            }
            if(entiys.get(sx)!=null&&!entiys.get(sx).trim().equals("")
                    &&!entiys.get(sx).trim().equals("0")
                    &&!entiys.get(sx).trim().equals("0.0")){

                if(s==0||null!=field_idMap.get(sx)){//数字或者id
                    queryWrapper.eq(field_idMap.get(sx),entiys.get(sx));
                }else{
                    queryWrapper.like(fieldMap.get(sx),entiys.get(sx));
                }


            }
        }
        return queryWrapper;
    }

最后调用这个方法：

@PostMapping("/selectC")
    @ApiOperation(value = "企业查询")
    @ResponseBody
    @CrossOrigin
    public Object selectC(HttpSession session, HttpServletResponse response, HttpServletRequest req,
                         @RequestBody @ApiParam zqlCompany dq) throws NoSuchFieldException {



        QueryWrapper queryWrapper=new QueryWrapper();
        queryWrapper=sindayHelp.getQuerwapperByT(dq,queryWrapper);

        List<ZqlCompany> zs=new ArrayList<>();

        //这里我写的是通用查询方法，具体的我会在下面贴出来
         String json= JSON.toJSONString(zqlTongYong.selectCom(sindayHelp.getDeclaredFieldsInfoTableName(dq.getZqlCompany()),queryWrapper)) ;
        zs=JSON.parseArray(json,ZqlCompany.class);
       
        return  conMessBack.suss("suss","查询成功",new fxlei(zs));
    }

直接写的通用查询类，传QueryWrapper和表名，表名获取方式上面写了

package com.sinday.mapper;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

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

@Mapper
public interface ZqlTongYong {
    @Select("select  * from ${tableName_s} ${ew.customSqlSegment}")
    List<Map<String,String>> selectCom(@Param("tableName_s")String tableName, @Param(Constants.WRAPPER) QueryWrapper wrapper);
}

这样，你就只需要传实体对象就能完成所有查询操作，任何表或实体对象都可以用这一个方法