新增userdao

common-docus/docus-sys/src/main/java/com/docus/server/sys/infrastructure/cache/DeptCacheLayer.java

@@ -0,0 +1,4 @@
+package com.docus.server.sys.infrastructure.cache;
+
+public class DeptCacheLayer {
+}

common-docus/docus-sys/src/main/java/com/docus/server/sys/infrastructure/dao/IPowerUserDao.java

@@ -0,0 +1,17 @@
+package com.docus.server.sys.infrastructure.dao;
+
+import com.docus.server.common.IDao;
+import com.docus.server.sys.common.pojo.dto.UserModifyParam;
+import com.docus.server.sys.common.pojo.entity.PowerUser;
+
+public interface IPowerUserDao extends IDao<PowerUser> {
+
+    PowerUser getUserByUserName(String userName);
+
+    void addUser(UserModifyParam userModifyParam);
+
+    void updateUser(UserModifyParam userModifyParam);
+
+    void delUserByUserName(String userName);
+
+}

common-docus/docus-sys/src/main/java/com/docus/server/sys/infrastructure/dao/impl/PowerUserDaoImpl.java

@@ -0,0 +1,32 @@
+package com.docus.server.sys.infrastructure.dao.impl;
+
+import com.docus.server.common.BaseDaoImpl;
+import com.docus.server.sys.common.pojo.dto.UserModifyParam;
+import com.docus.server.sys.common.pojo.entity.PowerUser;
+import com.docus.server.sys.infrastructure.dao.IPowerUserDao;
+import com.docus.server.sys.infrastructure.mapper.PowerUserMapper;
+import org.springframework.stereotype.Repository;
+
+@Repository
+public class PowerUserDaoImpl extends BaseDaoImpl<PowerUserMapper, PowerUser> implements IPowerUserDao {
+
+    @Override
+    public PowerUser getUserByUserName(String userName) {
+        return baseMapper.getUserByUserName(userName);
+    }
+
+    @Override
+    public void addUser(UserModifyParam userModifyParam) {
+        baseMapper.addUser(userModifyParam);
+    }
+
+    @Override
+    public void updateUser(UserModifyParam userModifyParam) {
+        baseMapper.updateUser(userModifyParam);
+    }
+
+    @Override
+    public void delUserByUserName(String userName) {
+        baseMapper.delUserByUserName(userName);
+    }
+}

common-docus/docus-sys/src/main/java/com/docus/server/sys/infrastructure/mapper/PowerDeptMapper.java

@@ -1,4 +1,4 @@
-package com.docus.server.sys.mapper;
+package com.docus.server.sys.infrastructure.mapper;
 
 import com.baomidou.dynamic.datasource.annotation.DS;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;

common-docus/docus-sys/src/main/java/com/docus/server/sys/infrastructure/mapper/PowerThirdLoginMapper.java

@@ -1,4 +1,4 @@
-package com.docus.server.sys.mapper;
+package com.docus.server.sys.infrastructure.mapper;
 
 import com.baomidou.dynamic.datasource.annotation.DS;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;

common-docus/docus-sys/src/main/java/com/docus/server/sys/infrastructure/mapper/PowerUserMapper.java

@@ -1,4 +1,4 @@
-package com.docus.server.sys.mapper;
+package com.docus.server.sys.infrastructure.mapper;
 
 import com.baomidou.dynamic.datasource.annotation.DS;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;

common-docus/docus-sys/src/main/java/com/docus/server/sys/service/IPowerUserService.java

@@ -1,15 +1,15 @@
 package com.docus.server.sys.service;
 
-import com.docus.infrastructure.core.db.service.IBaseService;
 import com.docus.server.sys.common.pojo.dto.UserDTO;
 import com.docus.server.sys.common.pojo.entity.PowerUser;
 
+import java.util.Collection;
 import java.util.List;
 
 /**
  * 用户服务
  */
-public interface IPowerUserService extends IBaseService<PowerUser> {
+public interface IPowerUserService {
     /**
      * 用户注册
      *
@@ -32,4 +32,9 @@ public interface IPowerUserService extends IBaseService<PowerUser> {
      * @param users
      */
     void batchInsertOrUpdatePowerUser(List<UserDTO> users);
+
+
+    PowerUser findOneBy(String userName, String userValue);
+
+    List<PowerUser> findByList(String userName, Collection<Object> userNames);
 }

common-docus/docus-sys/src/main/java/com/docus/server/sys/service/impl/PowerDeptServiceImpl.java

@@ -6,7 +6,7 @@ import com.docus.infrastructure.redis.service.IdService;
 import com.docus.server.sys.common.pojo.dto.DeptDTO;
 import com.docus.server.sys.common.pojo.dto.DeptModifyParam;
 import com.docus.server.sys.common.pojo.entity.PowerDept;
-import com.docus.server.sys.mapper.PowerDeptMapper;
+import com.docus.server.sys.infrastructure.mapper.PowerDeptMapper;
 import com.docus.server.sys.service.IPowerDeptService;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

common-docus/docus-sys/src/main/java/com/docus/server/sys/service/impl/PowerThirdLoginServiceImpl.java

@@ -2,7 +2,7 @@ package com.docus.server.sys.service.impl;
 
 import com.docus.infrastructure.core.db.service.impl.BaseServiceImpl;
 import com.docus.server.sys.common.pojo.entity.PowerThirdLogin;
-import com.docus.server.sys.mapper.PowerThirdLoginMapper;
+import com.docus.server.sys.infrastructure.mapper.PowerThirdLoginMapper;
 import com.docus.server.sys.service.IPowerThirdLoginService;
 import org.springframework.stereotype.Service;
 

common-docus/docus-sys/src/main/java/com/docus/server/sys/service/impl/PowerUserServiceImpl.java

@@ -1,18 +1,18 @@
 package com.docus.server.sys.service.impl;
 
 import com.docus.core.util.Func;
-import com.docus.infrastructure.core.db.service.impl.BaseServiceImpl;
 import com.docus.infrastructure.redis.service.IdService;
 import com.docus.server.common.config.UserProperties;
 import com.docus.server.sys.common.pojo.dto.UserDTO;
 import com.docus.server.sys.common.pojo.dto.UserModifyParam;
 import com.docus.server.sys.common.pojo.entity.PowerUser;
-import com.docus.server.sys.mapper.PowerUserMapper;
+import com.docus.server.sys.infrastructure.dao.IPowerUserDao;
 import com.docus.server.sys.service.IPowerUserService;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -21,11 +21,13 @@ import java.util.List;
  * @author wyb
  */
 @Service
-public class PowerUserServiceImpl extends BaseServiceImpl<PowerUserMapper, PowerUser> implements IPowerUserService {
+public class PowerUserServiceImpl implements IPowerUserService {
     @Resource
     private IdService idService;
     @Resource
     private UserProperties userProperties;
+    @Resource
+    private IPowerUserDao userDao;
 
     @Transactional
     @Override
@@ -33,31 +35,41 @@ public class PowerUserServiceImpl extends BaseServiceImpl<PowerUserMapper, Power
         userDTOList.forEach(this::insertOrUpdatePowerUser);
     }
 
+    @Override
+    public PowerUser findOneBy(String userName, String userValue) {
+        return userDao.findOneBy(userName, userValue);
+    }
+
+    @Override
+    public List<PowerUser> findByList(String userName, Collection<Object> values) {
+        return userDao.findByList(userName, values);
+    }
+
     @Transactional
     @Override
     public boolean insertOrUpdatePowerUser(UserDTO userDTO) {
-        PowerUser powerUser = baseMapper.getUserByUserName(userDTO.getUserName());
+        PowerUser powerUser = userDao.getUserByUserName(userDTO.getUserName());
         UserModifyParam userModifyParam = userDTO.transUserAddParam();
         if (Func.isEmpty(powerUser)) {
             long userId = idService.getDateSeq();
             userModifyParam.setUserId(userId);
             userModifyParam.setUserPwd(userProperties.getPassword());
-            baseMapper.addUser(userModifyParam);
+            userDao.addUser(userModifyParam);
             return true;
         }
         userModifyParam.setUserId(powerUser.getUserId());
-        baseMapper.updateUser(userModifyParam);
+        userDao.updateUser(userModifyParam);
         return true;
     }
 
     @Transactional
     @Override
     public boolean delUserByUserName(String userName) {
-        PowerUser powerUser = baseMapper.getUserByUserName(userName);
+        PowerUser powerUser = userDao.getUserByUserName(userName);
         if (Func.isEmpty(powerUser)) {
             return true;
         }
-        baseMapper.delUserByUserName(userName);
+        userDao.delUserByUserName(userName);
         return true;
     }
 

common-docus/docus-sys/src/main/resources/mapper/PowerDeptMapper.xml

@@ -2,7 +2,7 @@
 <!DOCTYPE mapper
         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.docus.server.sys.mapper.PowerDeptMapper">
+<mapper namespace="com.docus.server.sys.infrastructure.mapper.PowerDeptMapper">
     <insert id="addDept">
         INSERT INTO `docus_system`.`power_dept`(`dept_id`,
                                                 `dept_code`,

common-docus/docus-sys/src/main/resources/mapper/PowerUserMapper.xml

@@ -2,7 +2,7 @@
 <!DOCTYPE mapper
         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
-<mapper namespace="com.docus.server.sys.mapper.PowerUserMapper">
+<mapper namespace="com.docus.server.sys.infrastructure.mapper.PowerUserMapper">
     <insert id="addUser">
         INSERT INTO `docus_system`.`power_user`(`user_id`,
                                                 `user_name`,

docus-api-common/pom.xml

@@ -15,6 +15,31 @@
             <artifactId>docus-client-interface</artifactId>
             <version>1.0-SNAPSHOT</version>
         </dependency>
+
+        <!-- 分页插件pagehelper -->
+        <dependency>
+            <groupId>com.github.pagehelper</groupId>
+            <artifactId>pagehelper</artifactId>
+            <version>5.2.0</version>
+        </dependency>
+
+<!--        <dependency>-->
+        <!--            <groupId>com.github.pagehelper</groupId>-->
+        <!--            <artifactId>pagehelper-spring-boot-autoconfigure</artifactId>-->
+        <!--            <version>1.3.0</version>-->
+        <!--        </dependency>-->
+
+        <!--        <dependency>-->
+        <!--            <groupId>com.github.pagehelper</groupId>-->
+        <!--            <artifactId>pagehelper-spring-boot-starter</artifactId>-->
+        <!--            <version>1.3.0</version>-->
+        <!--            <exclusions>-->
+        <!--                <exclusion>-->
+        <!--                    <groupId>org.mybatis</groupId>-->
+        <!--                    <artifactId>mybatis</artifactId>-->
+        <!--                </exclusion>-->
+        <!--            </exclusions>-->
+        <!--        </dependency>-->
     </dependencies>
     <build>
         <resources>

docus-api-common/src/main/java/com/docus/server/common/AbstractBaseService.java

@@ -0,0 +1,112 @@
+package com.docus.server.common;
+
+import com.docus.infrastructure.core.db.Sort;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.List;
+
+public abstract class AbstractBaseService<T> implements IService<T> {
+
+    protected abstract IDao<T> getDao();
+
+    @Override
+    public T findById(Serializable id) {
+        return getDao().findById(id);
+    }
+
+    @Override
+    public List<T> findByIds(Collection<Serializable> ids) {
+        return getDao().findByIds(ids);
+    }
+
+    @Override
+    public List<T> findBy(String propertyName, Object propertyValue) {
+        return getDao().findBy(propertyName, propertyValue);
+    }
+
+    @Override
+    public List<T> findByList(String propertyName, Collection<?> propertyValue) {
+        return getDao().findByList(propertyName, propertyValue);
+    }
+
+    @Override
+    public List<T> findActiveBy(String propertyName, Object propertyValue) {
+        return getDao().findActiveBy(propertyName, propertyValue);
+    }
+
+    @Override
+    public List<T> findBy(String propertyName, Object propertyValue, Sort sort) {
+        return getDao().findBy(propertyName, propertyValue, sort);
+    }
+
+    @Override
+    public List<T> findActiveBy(String propertyName, Object propertyValue, Sort sort) {
+        return getDao().findActiveBy(propertyName, propertyValue, sort);
+    }
+
+    @Override
+    public T findOneBy(String propertyName, Object propertyValue) {
+        return getDao().findOneBy(propertyName, propertyValue);
+    }
+
+    @Override
+    public T findOneByList(String propertyName, Collection<?> propertyValue) {
+        return getDao().findOneByList(propertyName, propertyValue);
+    }
+
+    @Override
+    public T findActiveOneBy(String propertyName, Object propertyValue) {
+        return getDao().findActiveOneBy(propertyName, propertyValue);
+    }
+
+    @Override
+    public List<T> findAll() {
+        return getDao().findAll();
+    }
+
+    @Override
+    public List<T> findAllActive() {
+        return getDao().findAllActive();
+    }
+
+    @Override
+    public List<T> findAll(Sort sort) {
+        return getDao().findAll(sort);
+    }
+
+    @Override
+    public List<T> findAllActive(Sort sort) {
+        return getDao().findAllActive(sort);
+    }
+
+    @Override
+    public int deleteByIdList(List<Serializable> idList) {
+        return getDao().deleteByIdList(idList);
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public boolean saveBatch(Collection<T> entityList, int batchSize) {
+        return getDao().saveBatch(entityList, batchSize);
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public boolean saveOrUpdate(T entity) {
+        return getDao().saveOrUpdate(entity);
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public boolean updateBatchById(Collection<T> entityList, int batchSize) {
+        return getDao().updateBatchById(entityList, batchSize);
+    }
+
+    @Transactional(rollbackFor = Exception.class)
+    @Override
+    public boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize) {
+        return getDao().saveOrUpdateBatch(entityList, batchSize);
+    }
+}

docus-api-common/src/main/java/com/docus/server/common/BaseDaoImpl.java

@@ -0,0 +1,445 @@
+package com.docus.server.common;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.enums.SqlMethod;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.TableInfo;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.baomidou.mybatisplus.core.toolkit.Assert;
+import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
+import com.baomidou.mybatisplus.core.toolkit.Constants;
+import com.baomidou.mybatisplus.core.toolkit.GlobalConfigUtils;
+import com.baomidou.mybatisplus.core.toolkit.ReflectionKit;
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
+import com.docus.infrastructure.core.db.Sort;
+import com.github.pagehelper.PageHelper;
+import org.apache.ibatis.binding.MapperMethod;
+import org.apache.ibatis.logging.Log;
+import org.apache.ibatis.logging.LogFactory;
+import org.apache.ibatis.session.SqlSession;
+import org.mybatis.spring.SqlSessionUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.io.Serializable;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class BaseDaoImpl<M extends BaseMapper<T>, T> implements IDao<T> {
+    protected Log log = LogFactory.getLog(getClass());
+
+    @Autowired
+    protected M baseMapper;
+
+    public M getBaseMapper() {
+        return baseMapper;
+    }
+
+    protected Class<T> entityClass = currentModelClass();
+
+    public Class<T> getEntityClass() {
+        return entityClass;
+    }
+
+    protected Class<T> mapperClass = currentMapperClass();
+
+    @Override
+    public T findById(Serializable id) {
+        if (id == null) {
+            throw new RuntimeException("param id is required");
+        }
+        return baseMapper.selectById(id);
+    }
+
+    @Override
+    public List<T> findByIds(Collection<Serializable> ids) {
+        if (ids == null || ids.size() == 0) {
+            return new ArrayList<>();
+        }
+        return baseMapper.selectBatchIds(ids);
+    }
+
+    /**
+     * 按字段查询，返回所有匹配的记录, eq
+     */
+    @Override
+    public List<T> findBy(String propertyName, Object propertyValue) {
+        String columnName = getColumnName(propertyName);
+        return baseMapper.selectList(new QueryWrapper<T>().eq(columnName, propertyValue));
+    }
+
+    /**
+     * 按字段查询，返回所有匹配的记录, in
+     */
+    @Override
+    public List<T> findByList(String propertyName, Collection<?> propertyValue) {
+        String columnName = getColumnName(propertyName);
+        return baseMapper.selectList(new QueryWrapper<T>().in(!Objects.isNull(propertyValue), columnName, propertyValue));
+    }
+
+    @Override
+    public List<T> findActiveBy(String propertyName, Object propertyValue) {
+        String columnName = getColumnName(propertyName);
+        QueryWrapper<T> queryWrapper = new QueryWrapper<T>().eq(columnName, propertyValue);
+        queryWrapper.ne("state", 1);
+        return baseMapper.selectList(queryWrapper);
+    }
+
+    //返回所有匹配的记录并排序
+    @Override
+    public List<T> findBy(String propertyName, Object propertyValue, Sort sort) {
+        String columnName = getColumnName(propertyName);
+        QueryWrapper<T> query = new QueryWrapper<T>().eq(columnName, propertyValue);
+        buildSort(sort, query);
+        return baseMapper.selectList(query);
+    }
+
+    /**
+     * 返回所有匹配的Active记录并排序
+     */
+    @Override
+    public List<T> findActiveBy(String propertyName, Object propertyValue, Sort sort) {
+        String columnName = getColumnName(propertyName);
+        QueryWrapper<T> query = new QueryWrapper<T>().eq(columnName, propertyValue);
+        query.ne("state", 1);
+        buildSort(sort, query);
+        return baseMapper.selectList(query);
+    }
+
+    @Override
+    public T findOneBy(String propertyName, Object propertyValue) {
+        String columnName = getColumnName(propertyName);
+        PageHelper.startPage(1, 1);
+        List<T> list = baseMapper.selectList(new QueryWrapper<T>().eq(columnName, propertyValue));
+        return (list == null || list.size() == 0) ? null : list.get(0);
+    }
+
+    @Override
+    public T findOneByList(String propertyName, Collection<?> propertyValue) {
+        String columnName = getColumnName(propertyName);
+        List<T> list = baseMapper.selectList(new QueryWrapper<T>().eq(!Objects.isNull(propertyValue), columnName, propertyValue));
+        return (list == null || list.size() == 0) ? null : list.get(0);
+    }
+
+    //按字段查询，返回第一条Active 记录
+    @Override
+    public T findActiveOneBy(String propertyName, Object propertyValue) {
+        String columnName = getColumnName(propertyName);
+        PageHelper.startPage(1, 1);
+        QueryWrapper<T> queryWrapper = new QueryWrapper<T>().eq(columnName, propertyValue);
+        queryWrapper.ne("state", 1);
+        List<T> list = baseMapper.selectList(queryWrapper);
+        return (list == null || list.size() == 0) ? null : list.get(0);
+    }
+
+    /*Lambda方式自由组合查询条件*/
+    public List<T> find(LambdaQueryWrapper<T> queryWrapper) {
+        return baseMapper.selectList(queryWrapper);
+    }
+
+    /*Lambda方式自由组合查询条件，返回第一条记录*/
+    public T findOne(LambdaQueryWrapper<T> queryWrapper) {
+        PageHelper.startPage(1, 1);
+        List<T> list = baseMapper.selectList(queryWrapper);
+        return (list == null || list.size() == 0) ? null : list.get(0);
+    }
+
+    //返回表所有记录
+    @Override
+    public List<T> findAll() {
+        return baseMapper.selectList(null);
+    }
+
+    //返回表所有Active的记录
+    @Override
+    public List<T> findAllActive() {
+        return baseMapper.selectList(Wrappers.<T>query().ne("state", 1));
+    }
+
+    //返回表所有记录并排序
+    @Override
+    public List<T> findAll(Sort sort) {
+        QueryWrapper<T> query = new QueryWrapper<T>();
+        buildSort(sort, query);
+        return baseMapper.selectList(query);
+    }
+
+    //返回表所有Active记录并排序
+    @Override
+    public List<T> findAllActive(Sort sort) {
+        QueryWrapper<T> query = new QueryWrapper<T>();
+        query.ne("state", 1);
+        buildSort(sort, query);
+        return baseMapper.selectList(query);
+    }
+
+    //组装排序语句
+    private void buildSort(Sort sort, QueryWrapper<T> query) {
+        if (sort != null) {
+            List<Sort.SortItem> sortList = sort.getSortList();
+
+            for (Sort.SortItem sortItem : sortList) {
+                if (sortItem.getDirection() == Sort.Direction.ASC) {
+                    query.orderByAsc(getColumnName(sortItem.getProperty()));
+                } else {
+                    query.orderByDesc(getColumnName(sortItem.getProperty()));
+                }
+            }
+        }
+    }
+
+    @Override
+    public int deleteByIdList(List<Serializable> idList) {
+        if (idList == null || idList.size() == 0) {
+            return 0;
+        }
+        return baseMapper.deleteBatchIds(idList);
+    }
+
+    /**
+     * 判断数据库操作是否成功
+     *
+     * @param result 数据库操作返回影响条数
+     * @return boolean
+     * @deprecated 3.3.1
+     */
+    @Deprecated
+    protected boolean retBool(Integer result) {
+        return SqlHelper.retBool(result);
+    }
+
+    @SuppressWarnings("unchecked")
+    protected Class<T> currentMapperClass() {
+        return (Class<T>) ReflectionKit.getSuperClassGenericType(getClass(), 0);
+    }
+
+    @SuppressWarnings("unchecked")
+    protected Class<T> currentModelClass() {
+        return (Class<T>) ReflectionKit.getSuperClassGenericType(getClass(), 1);
+    }
+
+    /**
+     * 批量操作 SqlSession
+     *
+     * @deprecated 3.3.0
+     */
+    @Deprecated
+    protected SqlSession sqlSessionBatch() {
+        return SqlHelper.sqlSessionBatch(entityClass);
+    }
+
+    /**
+     * 释放sqlSession
+     *
+     * @param sqlSession session
+     * @deprecated 3.3.0
+     */
+    @Deprecated
+    protected void closeSqlSession(SqlSession sqlSession) {
+        SqlSessionUtils.closeSqlSession(sqlSession, GlobalConfigUtils.currentSessionFactory(entityClass));
+    }
+
+    /**
+     * 获取 SqlStatement
+     *
+     * @param sqlMethod ignore
+     * @return ignore
+     * @see #getSqlStatement(SqlMethod)
+     * @deprecated 3.4.0
+     */
+    @Deprecated
+    protected String sqlStatement(SqlMethod sqlMethod) {
+        return SqlHelper.table(entityClass).getSqlStatement(sqlMethod.getMethod());
+    }
+
+    /**
+     * 批量插入
+     *
+     * @param entityList ignore
+     * @param batchSize  ignore
+     * @return ignore
+     */
+    @Override
+    public boolean saveBatch(Collection<T> entityList, int batchSize) {
+        String sqlStatement = getSqlStatement(SqlMethod.INSERT_ONE);
+        return executeBatch(entityList, batchSize, (sqlSession, entity) -> sqlSession.insert(sqlStatement, entity));
+    }
+
+    /**
+     * 获取mapperStatementId
+     *
+     * @param sqlMethod 方法名
+     * @return 命名id
+     * @since 3.4.0
+     */
+    protected String getSqlStatement(SqlMethod sqlMethod) {
+        return SqlHelper.getSqlStatement(mapperClass, sqlMethod);
+    }
+
+    /**
+     * TableId 注解存在更新记录，否插入一条记录
+     *
+     * @param entity 实体对象
+     * @return boolean
+     */
+    @Override
+    public boolean saveOrUpdate(T entity) {
+        if (null != entity) {
+            TableInfo tableInfo = TableInfoHelper.getTableInfo(this.entityClass);
+            Assert.notNull(tableInfo, "error: can not execute. because can not find cache of TableInfo for entity!");
+            String keyProperty = tableInfo.getKeyProperty();
+            Assert.notEmpty(keyProperty, "error: can not execute. because can not find column for id from entity!");
+            Object idVal = ReflectionKit.getFieldValue(entity, tableInfo.getKeyProperty());
+            return StringUtils.checkValNull(idVal) || Objects.isNull(getById((Serializable) idVal)) ? save(entity) : updateById(entity);
+        }
+        return false;
+    }
+
+    /**
+     * 根据 ID 查询
+     *
+     * @param id 主键ID
+     */
+    public T getById(Serializable id) {
+        return getBaseMapper().selectById(id);
+    }
+
+    /**
+     * 根据 ID 选择修改
+     *
+     * @param entity 实体对象
+     */
+    public boolean updateById(T entity) {
+        return SqlHelper.retBool(getBaseMapper().updateById(entity));
+    }
+
+    /**
+     * 插入一条记录（选择字段，策略插入）
+     *
+     * @param entity 实体对象
+     */
+    public boolean save(T entity) {
+        return SqlHelper.retBool(getBaseMapper().insert(entity));
+    }
+
+    @Override
+    public boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize) {
+        TableInfo tableInfo = TableInfoHelper.getTableInfo(entityClass);
+        Assert.notNull(tableInfo, "error: can not execute. because can not find cache of TableInfo for entity!");
+        String keyProperty = tableInfo.getKeyProperty();
+        Assert.notEmpty(keyProperty, "error: can not execute. because can not find column for id from entity!");
+        return SqlHelper.saveOrUpdateBatch(this.entityClass, this.mapperClass, this.log, entityList, batchSize, (sqlSession, entity) -> {
+            Object idVal = ReflectionKit.getFieldValue(entity, keyProperty);
+            return StringUtils.checkValNull(idVal)
+                || CollectionUtils.isEmpty(sqlSession.selectList(getSqlStatement(SqlMethod.SELECT_BY_ID), entity));
+        }, (sqlSession, entity) -> {
+            MapperMethod.ParamMap<T> param = new MapperMethod.ParamMap<>();
+            param.put(Constants.ENTITY, entity);
+            sqlSession.update(getSqlStatement(SqlMethod.UPDATE_BY_ID), param);
+        });
+    }
+
+    @Override
+    public boolean updateBatchById(Collection<T> entityList, int batchSize) {
+        String sqlStatement = getSqlStatement(SqlMethod.UPDATE_BY_ID);
+        return executeBatch(entityList, batchSize, (sqlSession, entity) -> {
+            MapperMethod.ParamMap<T> param = new MapperMethod.ParamMap<>();
+            param.put(Constants.ENTITY, entity);
+            sqlSession.update(sqlStatement, param);
+        });
+    }
+
+    public T getOne(Wrapper<T> queryWrapper, boolean throwEx) {
+        if (throwEx) {
+            return baseMapper.selectOne(queryWrapper);
+        }
+        return SqlHelper.getObject(log, baseMapper.selectList(queryWrapper));
+    }
+
+    public Map<String, Object> getMap(Wrapper<T> queryWrapper) {
+        return SqlHelper.getObject(log, baseMapper.selectMaps(queryWrapper));
+    }
+
+    public <V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper) {
+        return SqlHelper.getObject(log, listObjs(queryWrapper, mapper));
+    }
+
+    private <V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper) {
+        return getBaseMapper().selectObjs(queryWrapper).stream().filter(Objects::nonNull).map(mapper).collect(Collectors.toList());
+    }
+
+    /**
+     * 执行批量操作
+     *
+     * @param consumer consumer
+     * @since 3.3.0
+     * @deprecated 3.3.1 后面我打算移除掉 {@link #executeBatch(Collection, int, BiConsumer)} }.
+     */
+    @Deprecated
+    protected boolean executeBatch(Consumer<SqlSession> consumer) {
+        return SqlHelper.executeBatch(this.entityClass, this.log, consumer);
+    }
+
+    /**
+     * 执行批量操作
+     *
+     * @param list      数据集合
+     * @param batchSize 批量大小
+     * @param consumer  执行方法
+     * @param <E>       泛型
+     * @return 操作结果
+     * @since 3.3.1
+     */
+    protected <E> boolean executeBatch(Collection<E> list, int batchSize, BiConsumer<SqlSession, E> consumer) {
+        return SqlHelper.executeBatch(this.entityClass, this.log, list, batchSize, consumer);
+    }
+
+    /**
+     * 执行批量操作（默认批次提交数量{@link IService#DEFAULT_BATCH_SIZE}）
+     *
+     * @param list     数据集合
+     * @param consumer 执行方法
+     * @param <E>      泛型
+     * @return 操作结果
+     * @since 3.3.1
+     */
+    protected <E> boolean executeBatch(Collection<E> list, BiConsumer<SqlSession, E> consumer) {
+        return executeBatch(list, DEFAULT_BATCH_SIZE, consumer);
+    }
+
+
+    //通过实体属性获取对应的数据库字段名
+    public String getColumnName(String propertyName) {
+        Map<String, Field> fieldMap = ReflectionKit.getFieldMap(getEntityClass());
+        if (fieldMap != null) {
+            Field field = fieldMap.get(propertyName);
+
+            if (field != null) {
+                TableField annotation = field.getAnnotation(TableField.class);
+                if (annotation != null) {
+                    return annotation.value();
+                }
+                TableId idAnnotation = field.getAnnotation(TableId.class);
+                if (idAnnotation != null) {
+                    return idAnnotation.value();
+                }
+            }
+        }
+        throw new RuntimeException("获取不到属性" + propertyName + "的列名");
+    }
+
+}

docus-api-common/src/main/java/com/docus/server/common/BaseServiceImpl.java

@@ -0,0 +1,19 @@
+package com.docus.server.common;
+
+public class BaseServiceImpl<T> extends AbstractBaseService<T> {
+
+    protected IDao<T> baseDao;
+
+    @Override
+    protected IDao<T> getDao() {
+        return this.getBaseDao();
+    }
+
+    public IDao<T> getBaseDao() {
+        return baseDao;
+    }
+
+    public void setBaseDao(IDao<T> baseDao) {
+        this.baseDao = baseDao;
+    }
+}

docus-api-common/src/main/java/com/docus/server/common/IDao.java

@@ -0,0 +1,51 @@
+package com.docus.server.common;
+
+import com.docus.infrastructure.core.db.Sort;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.List;
+
+public interface IDao<T> {
+
+    /*默认批次提交数量*/
+    int DEFAULT_BATCH_SIZE = 1000;
+
+    T findById(Serializable id);
+
+    List<T> findByIds(Collection<Serializable> ids);
+
+    List<T> findBy(String propertyName, Object propertyValue);
+
+    List<T> findByList(String propertyName, Collection<?> propertyValue);
+
+    List<T> findActiveBy(String propertyName, Object propertyValue);
+
+    List<T> findBy(String propertyName, Object propertyValue, Sort sort);
+
+    List<T> findActiveBy(String propertyName, Object propertyValue, Sort sort);
+
+    T findOneBy(String propertyName, Object propertyValue);
+
+    T findOneByList(String propertyName, Collection<?> propertyValue);
+
+    T findActiveOneBy(String propertyName, Object propertyValue);
+
+    List<T> findAll();
+
+    List<T> findAllActive();
+
+    List<T> findAll(Sort sort);
+
+    List<T> findAllActive(Sort sort);
+
+    int deleteByIdList(List<Serializable> idList);
+
+    boolean saveBatch(Collection<T> entityList, int batchSize);
+
+    boolean saveOrUpdate(T entity);
+
+    boolean updateBatchById(Collection<T> entityList, int batchSize);
+
+    boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
+}

docus-api-common/src/main/java/com/docus/server/common/IService.java

@@ -0,0 +1,48 @@
+package com.docus.server.common;
+
+import com.docus.infrastructure.core.db.Sort;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.List;
+
+public interface IService<T> {
+
+    T findById(Serializable id);
+
+    List<T> findByIds(Collection<Serializable> ids);
+
+    List<T> findBy(String propertyName, Object propertyValue);
+
+    List<T> findByList(String propertyName, Collection<?> propertyValue);
+
+    List<T> findActiveBy(String propertyName, Object propertyValue);
+
+    List<T> findBy(String propertyName, Object propertyValue, Sort sort);
+
+    List<T> findActiveBy(String propertyName, Object propertyValue, Sort sort);
+
+    T findOneBy(String propertyName, Object propertyValue);
+
+    T findOneByList(String propertyName, Collection<?> propertyValue);
+
+    T findActiveOneBy(String propertyName, Object propertyValue);
+
+    List<T> findAll();
+
+    List<T> findAllActive();
+
+    List<T> findAll(Sort sort);
+
+    List<T> findAllActive(Sort sort);
+
+    int deleteByIdList(List<Serializable> idList);
+
+    boolean saveBatch(Collection<T> entityList, int batchSize);
+
+    boolean saveOrUpdate(T entity);
+
+    boolean updateBatchById(Collection<T> entityList, int batchSize);
+
+    boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
+}