mybatis-plus 分页 , 以及增删改查 工具类

自定义分页PageData:

代码：

点击查看代码

import lombok.Data;

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

@Data
public class PageData<T> implements Serializable {

    private static final long serialVersionUID = 1L;

    private long total;
    private List<T> list;

    public PageData(List<T> list, long total) {
        this.list = list;
        this.total = total;
    }
}

BaseService，替换 iService ，
代码：
`
import com.baomidou.mybatisplus.core.conditions.Wrapper;

import java.io.Serializable;
import java.util.Collection;

public interface BaseService {

boolean insert(T entity);

boolean insertBatch(Collection<T> entityList);

boolean insertBatch(Collection<T> entityList, int batchSize);

boolean updateById(T entity);

boolean update(T entity, Wrapper<T> updateWrapper);

boolean updateBatchById(Collection<T> entityList);

boolean updateBatchById(Collection<T> entityList, int batchSize);

T selectById(Serializable id);

boolean deleteById(Serializable id);

boolean deleteBatchIds(Collection<? extends Serializable> idList);

}
**BaseServiceImpl ;**
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.enums.SqlMethod;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.*;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import org.apache.ibatis.binding.MapperMethod;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.SqlSessionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

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

public abstract class BaseServiceImpl<M extends BaseMapper, T> implements BaseService {

@Autowired
protected M baseDao;

protected IPage<T> getPage(Map<String, Object> params, String defaultOrderField, boolean isAsc) {
    Integer curPage = 1;
    Integer limit = 10;
    if(params.get("page") != null){
        curPage = Integer.parseInt((String)params.get("page"));
    }
    if(params.get("limit") != null){
        limit = Integer.parseInt((String)params.get("limit"));
    }
    Page<T> page = new Page<>(curPage, limit);
    params.put("page", page);
    String orderField = (String)params.get("sidx");
    String order = (String)params.get("order");
    if(StringUtils.isNotEmpty(orderField) && StringUtils.isNotEmpty(order)){
        if("asc".equalsIgnoreCase(order)) {
            return page.setAsc(orderField);
        }else {
            return page.setDesc(orderField);
        }
    }
    if(isAsc) {
        page.setAsc(defaultOrderField);
    }else {
        page.setDesc(defaultOrderField);
    }
    return page;
}

protected <T> PageData<T> getPageData(List<?> list, long total, Class<T> target){
    List<T> targetList = ConvertUtils.sourceToTarget(list, target);
    return new PageData<>(targetList, total);
}

protected <T> PageData<T> getPageData(IPage page, Class<T> target){
    return getPageData(page.getRecords(), page.getTotal(), target);
}

protected Map<String, Object> paramsToLike(Map<String, Object> params, String... likes){
    for (String like : likes){
        String val = (String)params.get(like);
        if (StringUtils.isNotEmpty(val)){
            params.put(like, "%" + val + "%");
        }else {
            params.put(like, null);
        }
    }
    return params;
}

protected static boolean retBool(Integer result) {
    return SqlHelper.retBool(result);
}

protected Class<T> currentModelClass() {
    return (Class<T>) ReflectionKit.getSuperClassGenericType(getClass(), 1);
}

protected SqlSession sqlSessionBatch() {
    return SqlHelper.sqlSessionBatch(currentModelClass());
}

protected void closeSqlSession(SqlSession sqlSession){
    SqlSessionUtils.closeSqlSession(sqlSession, GlobalConfigUtils.currentSessionFactory(currentModelClass()));
}

protected String sqlStatement(SqlMethod sqlMethod) {
    return SqlHelper.table(currentModelClass()).getSqlStatement(sqlMethod.getMethod());
}

@Override
public boolean insert(T entity) {
    return BaseServiceImpl.retBool(baseDao.insert(entity));
}

@Override
@Transactional(rollbackFor = Exception.class)
public boolean insertBatch(Collection<T> entityList) {
    return insertBatch(entityList, 100);
}

@Override
@Transactional(rollbackFor = Exception.class)
public boolean insertBatch(Collection<T> entityList, int batchSize) {
    SqlSession batchSqlSession = sqlSessionBatch();
    int i = 0;
    String sqlStatement = sqlStatement(SqlMethod.INSERT_ONE);
    try {
        for (T anEntityList : entityList) {
            batchSqlSession.insert(sqlStatement, anEntityList);
            if (i >= 1 && i % batchSize == 0) {
                batchSqlSession.flushStatements();
            }
            i++;
        }
        batchSqlSession.flushStatements();
    }finally {
        closeSqlSession(batchSqlSession);
    }
    return true;
}

@Override
public boolean updateById(T entity) {
    return BaseServiceImpl.retBool(baseDao.updateById(entity));
}

@Override
public boolean update(T entity, Wrapper<T> updateWrapper) {
    return BaseServiceImpl.retBool(baseDao.update(entity, updateWrapper));
}

@Override
@Transactional(rollbackFor = Exception.class)
public boolean updateBatchById(Collection<T> entityList) {
    return updateBatchById(entityList, 30);
}

@Override
@Transactional(rollbackFor = Exception.class)
public boolean updateBatchById(Collection<T> entityList, int batchSize) {
    if (CollectionUtils.isEmpty(entityList)) {
        throw new IllegalArgumentException("Error: entityList must not be empty");
    }
    SqlSession batchSqlSession = sqlSessionBatch();
    int i = 0;
    String sqlStatement = sqlStatement(SqlMethod.UPDATE_BY_ID);
    try {
        for (T anEntityList : entityList) {
            MapperMethod.ParamMap<T> param = new MapperMethod.ParamMap<>();
            param.put(Constants.ENTITY, anEntityList);
            batchSqlSession.update(sqlStatement, param);
            if (i >= 1 && i % batchSize == 0) {
                batchSqlSession.flushStatements();
            }
            i++;
        }
        batchSqlSession.flushStatements();
    }finally {
        closeSqlSession(batchSqlSession);
    }
    return true;
}

@Override
public T selectById(Serializable id) {
    return baseDao.selectById(id);
}

@Override
public boolean deleteById(Serializable id) {
    return SqlHelper.delBool(baseDao.deleteById(id));
}

@Override
public boolean deleteBatchIds(Collection<? extends Serializable> idList) {
    return SqlHelper.delBool(baseDao.deleteBatchIds(idList));
}

}`

用法: