Base包

BaseMapper是一个公共的增删改的方法

直接插入自己的项目包然后实例化即可使用

package com.crm.Base;

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.session.RowBounds;

import java.io.Serializable;
import java.util.List;
import java.util.Map;


/**
 * Mapper接口
 * 拥有基本增删改查数据库的一些方法
 */
public interface BaseMapper {
    /**
     * 插入一条记录
     * @param entity
     * 实体对象
     * @return int
     */
    Integer insert(T entity);

    /**
     * 根据 ID 删除
     * @param id
     * 主键ID
     * @return int
     */
    Integer deleteById(Serializable id);

    /**
     * 根据 columnMap 条件，删除记录
     * @param columnMap
     * 表字段 map 对象
     * @return int
     */
    Integer deleteByMap(@Param("cm") Map<String, Object> columnMap);

    /**
     * 根据 entity 条件，删除记录
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return int
     */
    Integer delete(@Param("ew") Wrapper<T> wrapper);

    /**
     * 删除（根据ID 批量删除）
     * @param idList
     * 主键ID列表
     * @return int
     */
    Integer deleteBatchIds(List<? extends Serializable> idList);

    /**
     * 根据 ID 修改
     * @param entity
     * 实体对象
     * @return int
     */
    Integer updateById(T entity);

    /**
     * 根据 whereEntity 条件，更新记录
     * @param entity
     * 实体对象
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return
     */
    Integer update(@Param("et") T entity, @Param("ew") Wrapper<T> wrapper);

    /**
     * 根据 ID 查询
     * @param id
     * 主键ID
     * @return T
     */
    T selectById(Serializable id);

    /**
     * 查询（根据ID 批量查询）
     * @param idList
     * 主键ID列表
     * @return List<T>
     */
    List<T> selectBatchIds(List<? extends Serializable> idList);

    /**
     * 查询（根据 columnMap 条件）
     * @param columnMap
     * 表字段 map 对象
     * @return List<T>
     */
    List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);

    /**
     * 根据 entity 条件，查询一条记录
     * @param entity
     * 实体对象
     * @return T
     */
    T selectOne(@Param("ew") T entity);

    /**
     * 根据 Wrapper 条件，查询总记录数
     * @param wrapper
     * 实体对象
     * @return int
     */
    Integer selectCount(@Param("ew") Wrapper<T> wrapper);

    /**
     * 根据 entity 条件，查询全部记录
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return List<T>
     */
    List<T> selectList(@Param("ew") Wrapper<T> wrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return List<T>
     */
    List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> wrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return List<Object>
     */
    List<Object> selectObjs(@Param("ew") Wrapper<T> wrapper);

    /**
     * 用法：(new RowBounds(offset, limit), ew);
     * 根据 entity 条件，查询全部记录（并翻页）
     * @param rowBounds
     * 分页查询条件（可以为 RowBounds.DEFAULT）
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return List<T>
     */
    List<T> selectPage(RowBounds rowBounds, @Param("ew") Wrapper<T> wrapper);

    /** -- 不常用,
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     * @param rowBounds
     * 分页查询条件（可以为 RowBounds.DEFAULT）
     * @param wrapper
     * 实体对象封装操作类
     * @return List<Map<String, Object>>
     */
    List<Map<String, Object>> selectMapsPage(RowBounds rowBounds, @Param("ew") Wrapper<T> wrapper);
}

 

BaseController类：总结了一些调用网页中信息的方法

package com.crm.crm.controller;

import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.PageHelper;
import org.mybatis.logging.Logger;
import org.mybatis.logging.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

/**
 * @description: 基础的类
 * @author: Lidong
 * @time: 2020/7/29 21:14
 **/
public class BaseController {

    private static final Logger logger = LoggerFactory.getLogger(BaseController.class);

    @Autowired
    protected HttpServletRequest request;

    /**
     * @return java.util.Map<java.lang.String, java.lang.String>
     * @Author LiDong
     * @Description //TODO 处理HttpServletRequest拿到参数的Map
     * @Date 20:17 2020/11/30
     * @Param [request]
     **/
    public Map<String, String> getParamMap(HttpServletRequest request) {
        try {
            if (Objects.isNull(this.request)) {
                this.request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
            }
            Map<String, String[]> parameterMap = this.request.getParameterMap();
            Map<String, String> map = new HashMap<>(16);
            // 以form的方式传递参数
            if (parameterMap != null && parameterMap.size() > 0) {
                for (String key : parameterMap.keySet()) {
                    String[] strings = parameterMap.get(key);
                    String value = Arrays.asList(strings).get(0);
                    map.put(key, String.valueOf(value));
                }
                return map;
            }else{
                // 从流中读取参数
                ServletInputStream inputStream = request.getInputStream();
                StringBuffer stringBuffer = new StringBuffer();
                int data;
                while ((data=inputStream.read())!=-1){
                    stringBuffer.append((char)data);
                }
                if(Objects.nonNull(stringBuffer)){
                    String res= String.valueOf(stringBuffer);
                    try {
                        Map<String, String> mp = JSONObject.parseObject(res, Map.class);
                        if(Objects.nonNull(mp)){
                            return mp;
                        }
                    }catch (Exception e){
                       e.printStackTrace();
                    }
                }
                return new HashMap<>(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return new HashMap<>(1);
        }
    }

    /**
     * @return com.li.core.domain.common.CurrentUser
     * @Author LiDong
     * @Description //TODO 得到当前Session中的信息
     * @Date 20:07 2020/11/30
     * @Param []
     **/
//    public CurrentUser getCurrentUser() {
//        try {
//            if (Objects.isNull(request)) {
//                request = ((ServletRequestAttributes) (RequestContextHolder.currentRequestAttributes())).getRequest();
//            }
//            Object user = request.getSession().getAttribute("user");
//            if (user == null) {
//                return null;
//            }
//            CurrentUser currentUser = (CurrentUser) user;
//            return currentUser;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return null;
//        }
//
//    }

    /**
     * 封装Post查询Es中的结果
     */
    public String getEsResultBysql(String sql) {
        PrintWriter out = null;
        BufferedReader in = null;
        String result = "";
        try {
            // 请求的Url
            String urlLocation = "http://127.0.0.1:9200/_sql";
            // 请求体
            String content = "{\"query\":\"" + sql + "\"}";
            URL realUrl = new URL(urlLocation);
            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            ((HttpURLConnection) conn).setRequestMethod("POST");
            // 获取URLConnection对象对应的输出流
            out = new PrintWriter(conn.getOutputStream());
            // 发送请求参数
            out.print(content);
            // flush输出流的缓冲
            out.flush();
            // 定义BufferedReader输入流来读取URL的响应
            in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            System.out.println("发送 POST 请求出现异常！" + e);
            e.printStackTrace();
        }
        //使用finally块来关闭输出流、输入流
        finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        return result;
    }

    /**
     * @return void
     * @Author LiDong
     * @Description //TODO 分页查询
     * @Date 20:17 2020/11/30
     * @Param [request]
     **/
    public void getPageInit(HttpServletRequest request) {
        try {
            Map<String, String> paramMap = getParamMap(request);
            int pagenumber = Integer.parseInt(paramMap.getOrDefault("pageNumber", "1"));
            int pagesize = Integer.parseInt(paramMap.getOrDefault("pageSize", "10"));
            PageHelper.startPage(pagenumber, pagesize);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}