拆分CRUD

hsweb-web-bean/src/main/java/org/hsweb/web/bean/po/GenericPo.java

@@ -61,7 +61,6 @@ public class GenericPo<PK> implements Serializable, Cloneable {
     /**
      * 创建一个主键
      *
-     * @return
      */
     public static String createUID() {
         return MD5.encode(UUID.randomUUID().toString());
@@ -75,15 +74,6 @@ public class GenericPo<PK> implements Serializable, Cloneable {
         this.properties = properties;
     }
 
-    @Override
-    public Object clone() throws CloneNotSupportedException {
-        Field[] fields = this.getClass().getDeclaredFields();
-        for (int i = 0; i < fields.length; i++) {
-
-        }
-        return super.clone();
-    }
-
     public interface Property {
         /**
          * 主键

hsweb-web-dao/hsweb-web-dao-api/src/main/java/org/hsweb/web/dao/CRUMapper.java

@@ -0,0 +1,7 @@
+package org.hsweb.web.dao;
+
+/**
+ * @author zhouhao
+ */
+public interface CRUMapper<Po, Pk> extends InsertMapper<Po>, QueryMapper<Po, Pk>, UpdateMapper<Po> {
+}

hsweb-web-dao/hsweb-web-dao-api/src/main/java/org/hsweb/web/dao/DeleteMapper.java

@@ -0,0 +1,10 @@
+package org.hsweb.web.dao;
+
+import org.hsweb.web.bean.common.DeleteParam;
+
+/**
+ * @author zhouhao
+ */
+public interface DeleteMapper {
+    int delete(DeleteParam param);
+}

hsweb-web-dao/hsweb-web-dao-api/src/main/java/org/hsweb/web/dao/GenericMapper.java

@@ -1,74 +1,8 @@
 package org.hsweb.web.dao;
 
-import org.hsweb.web.bean.common.DeleteParam;
-import org.hsweb.web.bean.common.InsertParam;
-import org.hsweb.web.bean.common.QueryParam;
-import org.hsweb.web.bean.common.UpdateParam;
-
-import java.util.List;
-
 /**
  * 通用dao，定义常用的增删改查操作。其他daoMapper接口继承此接口，则无需再定义这些方法
- * <p>
- * Created by zh.sqy@qq.com on 2015-07-20 0020.
  */
-public interface GenericMapper<Po, Pk> {
-    /**
-     * 根据参数添加一条数据
-     *
-     * @param param 参数对象
-     * @return 添加后生成的主键
-     */
-    int insert(InsertParam<Po> param);
-
-    /**
-     * 根据条件删除数据
-     *
-     * @param param 主键
-     * @return 影响记录数
-     */
-    int delete(DeleteParam param);
-
-    /**
-     * 修改记录信息
-     *
-     * @param data 要修改的对象
-     * @return 影响记录数
-     */
-    int update(UpdateParam<Po> data);
-
-    /**
-     * 根据条件集合查询记录，支持分页，排序。
-     * <br/>查询条件支持 类似$LIKE,$IN 表达式查询，如传入 name$LIKE 则进行name字段模糊查询
-     * <br/>$LIKE -->模糊查询 (只支持字符)
-     * <br/>$START -->以?开始 (只支持字符 和数字)
-     * <br/>$END -->以?结尾 (只支持字符 和数字)
-     * <br/>$IN -->in查询，参数必须为List实现，传入类似 1,2,3 是非法的
-     * <br/>$GT -->大于 (只支持 数字和日期)
-     * <br/>$LT -->小于 (只支持 数字和日期)
-     * <br/>$NOT -->不等于
-     * <br/>$NOTNULL -->值不为空
-     * <br/>$ISNULL -->值为空
-     * <br/>所有操作支持取反
-     *
-     * @param param 查询参数
-     * @return 查询结果
-     */
-    List<Po> select(QueryParam param);
-
-    /**
-     * 查询记录总数，用于分页等操作。查询条件同 {@link GenericMapper#select}
-     *
-     * @param param 查询参数
-     * @return 查询结果，实现mapper中的sql应指定默认值，否则可能抛出异常
-     */
-    int total(QueryParam param);
+public interface GenericMapper<Po, Pk> extends QueryMapper<Po, Pk>, UpdateMapper<Po>, InsertMapper<Po>, DeleteMapper {
 
-    /**
-     * 根据主键查询记录
-     *
-     * @param pk 主键
-     * @return 查询结果
-     */
-    Po selectByPk(Pk pk);
 }

hsweb-web-dao/hsweb-web-dao-api/src/main/java/org/hsweb/web/dao/InsertMapper.java

@@ -0,0 +1,10 @@
+package org.hsweb.web.dao;
+
+import org.hsweb.web.bean.common.InsertParam;
+
+/**
+ * @author zhouhao
+ */
+public interface InsertMapper<Po> {
+    int insert(InsertParam<Po> param);
+}

hsweb-web-dao/hsweb-web-dao-api/src/main/java/org/hsweb/web/dao/QueryMapper.java

@@ -0,0 +1,45 @@
+package org.hsweb.web.dao;
+
+import org.hsweb.web.bean.common.QueryParam;
+
+import java.util.List;
+
+/**
+ * @author zhouhao
+ */
+public interface QueryMapper<Po, Pk>  {
+    /**
+     * 根据条件集合查询记录，支持分页，排序。
+     * <br/>查询条件支持 类似$LIKE,$IN 表达式查询，如传入 name$LIKE 则进行name字段模糊查询
+     * <br/>$LIKE -->模糊查询 (只支持字符)
+     * <br/>$START -->以?开始 (只支持字符 和数字)
+     * <br/>$END -->以?结尾 (只支持字符 和数字)
+     * <br/>$IN -->in查询，参数必须为List实现，传入类似 1,2,3 是非法的
+     * <br/>$GT -->大于 (只支持 数字和日期)
+     * <br/>$LT -->小于 (只支持 数字和日期)
+     * <br/>$NOT -->不等于
+     * <br/>$NOTNULL -->值不为空
+     * <br/>$ISNULL -->值为空
+     * <br/>所有操作支持取反
+     *
+     * @param param 查询参数
+     * @return 查询结果
+     */
+    List<Po> select(QueryParam param);
+
+    /**
+     * 查询记录总数，用于分页等操作。查询条件同 {@link GenericMapper#select}
+     *
+     * @param param 查询参数
+     * @return 查询结果，实现mapper中的sql应指定默认值，否则可能抛出异常
+     */
+    int total(QueryParam param);
+
+    /**
+     * 根据主键查询记录
+     *
+     * @param pk 主键
+     * @return 查询结果
+     */
+    Po selectByPk(Pk pk);
+}

hsweb-web-dao/hsweb-web-dao-api/src/main/java/org/hsweb/web/dao/UpdateMapper.java

@@ -0,0 +1,16 @@
+package org.hsweb.web.dao;
+
+import org.hsweb.web.bean.common.UpdateParam;
+
+/**
+ * @author zhouhao
+ */
+public interface UpdateMapper<Po> {
+    /**
+     * 修改记录信息
+     *
+     * @param data 要修改的对象
+     * @return 影响记录数
+     */
+    int update(UpdateParam<Po> data);
+}

hsweb-web-dao/hsweb-web-dao-mybatis/src/test/java/org/hsweb/web/mybatis/SpringApplication.java

@@ -37,7 +37,7 @@ import java.sql.SQLException;
 @Configuration
 @EnableAutoConfiguration
 @ComponentScan("org.hsweb.web")
-@MapperScan("org.hsweb.web.dao")
+@MapperScan({"org.hsweb.web.dao", "org.hsweb.web.mybatis.mappers"})
 public class SpringApplication {
 
     @Bean

hsweb-web-dao/hsweb-web-dao-mybatis/src/test/java/org/hsweb/web/mybatis/user/UserMapperTest.java

@@ -17,7 +17,6 @@
 package org.hsweb.web.mybatis.user;
 
 import org.hsweb.ezorm.core.dsl.Query;
-import org.hsweb.ezorm.rdb.render.dialect.Dialect;
 import org.hsweb.web.bean.common.DeleteParam;
 import org.hsweb.web.bean.common.InsertParam;
 import org.hsweb.web.bean.common.QueryParam;
@@ -31,12 +30,9 @@ import org.junit.Assert;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.Date;
 
-import static org.hsweb.ezorm.rdb.render.dialect.Dialect.TermTypeMapper.sql;
-
 /**
  * @author zhouhao
  */

hsweb-web-service/hsweb-web-service-api/src/main/java/org/hsweb/web/service/DeleteService.java

@@ -0,0 +1,56 @@
+package org.hsweb.web.service;
+
+import org.hsweb.ezorm.core.dsl.Delete;
+import org.hsweb.web.bean.common.DeleteParam;
+import org.hsweb.web.dao.DeleteMapper;
+import org.hsweb.web.dao.GenericMapper;
+
+/**
+ * @author zhouhao
+ */
+public interface DeleteService<Pk> {
+    /**
+     * 根据主键删除记录
+     *
+     * @param pk 主键
+     * @return 影响记录数
+     */
+    int delete(Pk pk);
+
+    Delete createDelete();
+
+    /**
+     * 指定一个dao映射接口,接口需继承{@link GenericMapper}创建dsl数据删除操作对象<br>
+     * 可通过返回的Update对象进行dsl方式操作如:<br>
+     * <code>
+     * createDelete(userMapper).where("id",1).exec();
+     * </code>
+     *
+     * @param mapper dao映射结构
+     * @return {@link Delete}
+     * @see Delete
+     * @see org.hsweb.ezorm.core.Conditional
+     * @since 2.2
+     */
+    static Delete createDelete(DeleteMapper mapper) {
+        Delete update = new Delete();
+        update.setParam(new DeleteParam());
+        update.setExecutor(param -> mapper.delete(((DeleteParam) param)));
+        return update;
+    }
+
+    /**
+     * 自定义一个删除执行器。创建dsl数据删除操作对象
+     *
+     * @param executor 执行器
+     * @return {@link Delete}
+     * @since 2.2
+     */
+    static Delete createDelete(Delete.Executor<DeleteParam> executor) {
+        Delete update = new Delete();
+        update.setParam(new DeleteParam());
+        update.setExecutor(param -> executor.doExecute(((DeleteParam) param)));
+        return update;
+    }
+
+}

hsweb-web-service/hsweb-web-service-api/src/main/java/org/hsweb/web/service/GenericService.java

@@ -1,228 +1,11 @@
 package org.hsweb.web.service;
 
-import org.hsweb.ezorm.core.dsl.Delete;
-import org.hsweb.ezorm.core.dsl.Query;
-import org.hsweb.ezorm.core.dsl.Update;
-import org.hsweb.ezorm.core.param.Param;
-import org.hsweb.web.bean.common.*;
-import org.hsweb.web.dao.GenericMapper;
-
-import java.util.HashMap;
-import java.util.List;
-
-
 /**
  * 通用Service,实现增删改查
  *
  * @author zhouhao
  * @since 1.0
  */
-public interface GenericService<Po, Pk> {
-
-    /**
-     * 分页进行查询数据，查询条件同 {@link GenericService#select}
-     *
-     * @param param 查询参数
-     * @return 分页结果
-     * @ 查询异常
-     */
-    PagerResult<Po> selectPager(QueryParam param);
-
-    /**
-     * 添加一条数据
-     *
-     * @param data 要添加的数据
-     * @return 添加后生成的主键
-     */
-    Pk insert(Po data);
-
-    /**
-     * 此方法即将删除
-     */
-    @Deprecated
-    default List<Pk> batchInsert(List<Po> data) {
-        return batchInsert(data, false);
-    }
-
-    /**
-     * 此方法即将删除
-     */
-    @Deprecated
-    List<Pk> batchInsert(List<Po> data, boolean skipFail);
-
-    /**
-     * 根据主键删除记录
-     *
-     * @param pk 主键
-     * @return 影响记录数
-     */
-    int delete(Pk pk);
-
-    /**
-     * 修改记录信息
-     *
-     * @param data 要修改的对象
-     * @return 影响记录数
-     */
-    int update(Po data);
-
-    /**
-     * 批量修改记录
-     *
-     * @param data 要修改的记录集合
-     * @return 影响记录数
-     */
-    int update(List<Po> data);
-
-    /**
-     * 保存或修改
-     *
-     * @param po 要修改的数据
-     * @return
-     */
-    int saveOrUpdate(Po po);
-
-    /**
-     * 根据查询参数进行查询，参数可使用 {@link Query}进行构建
-     * 推荐使用 {@link this#createQuery()}进行查询
-     *
-     * @param param 查询参数
-     * @return 查询结果
-     * @see Query
-     */
-    List<Po> select(QueryParam param);
-
-    /**
-     * 查询记录总数，用于分页等操作。查询条件同 {@link GenericService#select}
-     *
-     * @param param 查询参数
-     * @return 查询结果，实现mapper中的sql应指定默认值，否则可能抛出异常
-     */
-    int total(QueryParam param);
-
-    /**
-     * 根据主键查询记录
-     *
-     * @param pk 主键
-     * @return 查询结果
-     */
-    Po selectByPk(Pk pk);
-
-    /**
-     * 查询只返回单个结果
-     *
-     * @param param 查询条件
-     * @return 单个结果
-     * @see this#select(QueryParam)
-     */
-    default Po selectSingle(QueryParam param) {
-        param.doPaging(0, 1);
-        List<Po> list = this.select(param);
-        if (list.size() == 0) return null;
-        else return list.get(0);
-    }
-
-    /**
-     * 指定一个dao映射接口,接口需继承{@link GenericMapper}创建dsl数据更新操作对象<br>
-     * 可通过返回的Update对象进行dsl方式操作如:<br>
-     * <code>
-     * createUpdate(userMapper).where("id",1).exec();
-     * </code>
-     *
-     * @param mapper dao映射接口
-     * @param <PO>   PO泛型
-     * @param <PK>   主键泛型
-     * @return {@link Update}
-     * @see Update
-     * @see org.hsweb.ezorm.core.Conditional
-     * @see UpdateParam
-     * @since 2.2
-     */
-    static <PO, PK> Update<PO, UpdateParam<PO>> createUpdate(GenericMapper<PO, PK> mapper) {
-        return Update.build(mapper::update, new UpdateParam(new HashMap<>()));
-    }
-
-    /**
-     * 指定一个dao映射接口,接口需继承{@link GenericMapper}创建dsl数据删除操作对象<br>
-     * 可通过返回的Update对象进行dsl方式操作如:<br>
-     * <code>
-     * createDelete(userMapper).where("id",1).exec();
-     * </code>
-     *
-     * @param mapper dao映射结构
-     * @param <PO>   PO泛型
-     * @param <PK>   主键泛型
-     * @return {@link Delete}
-     * @see Delete
-     * @see org.hsweb.ezorm.core.Conditional
-     * @since 2.2
-     */
-    static <PO, PK> Delete createDelete(GenericMapper<PO, PK> mapper) {
-        Delete update = new Delete();
-        update.setParam(new DeleteParam());
-        update.setExecutor(param -> mapper.delete(((DeleteParam) param)));
-        return update;
-    }
-
-    /**
-     * 自定义一个删除执行器。创建dsl数据删除操作对象
-     *
-     * @param executor 执行器
-     * @return {@link Delete}
-     * @since 2.2
-     */
-    static Delete createDelete(Delete.Executor<DeleteParam> executor) {
-        Delete update = new Delete();
-        update.setParam(new DeleteParam());
-        update.setExecutor(param -> executor.doExecute(((DeleteParam) param)));
-        return update;
-    }
-
-    /**
-     * 创建本服务的dsl查询操作对象
-     * 可通过返回的Query对象进行dsl方式操作如:<br>
-     * <code>
-     * createQuery().where("id",1).single();
-     * </code>
-     *
-     * @return {@link Query}
-     * @see Query
-     * @see org.hsweb.ezorm.core.Conditional
-     * @since 2.2
-     */
-    default Query<Po, QueryParam> createQuery() {
-        Query<Po, QueryParam> query = Query.empty(new QueryParam());
-        query.setListExecutor(this::select);
-        query.setTotalExecutor(this::total);
-        query.setSingleExecutor(this::selectSingle);
-        return query;
-    }
+public interface GenericService<Po, Pk> extends QueryService<Po, Pk>, UpdateService<Po>, InsertService<Po, Pk>, DeleteService<Pk> {
 
-    /**
-     * 指定一个dao映射接口,接口需继承{@link GenericMapper}创建dsl数据查询对象<br>
-     * 可通过返回的Query对象进行dsl方式操作如:<br>
-     * <code>
-     * createQuery(userMapper).where("id",1).single();
-     * </code>
-     *
-     * @param mapper dao映射结构
-     * @param <PO>   PO泛型
-     * @param <PK>   主键泛型
-     * @return {@link Query}
-     * @see Query
-     * @see org.hsweb.ezorm.core.Conditional
-     * @since 2.2
-     */
-    static <PO, PK> Query<PO, QueryParam> createQuery(GenericMapper<PO, PK> mapper) {
-        Query<PO, QueryParam> query = new Query<>(new QueryParam());
-        query.setListExecutor(mapper::select);
-        query.setTotalExecutor(mapper::total);
-        query.setSingleExecutor((param) -> {
-            param.doPaging(0, 1);
-            List<PO> list = mapper.select(param);
-            if (null == list || list.size() == 0) return null;
-            else return list.get(0);
-        });
-        return query;
-    }
 }

hsweb-web-service/hsweb-web-service-api/src/main/java/org/hsweb/web/service/InsertService.java

@@ -0,0 +1,15 @@
+package org.hsweb.web.service;
+
+/**
+ * @author zhouhao
+ */
+public interface InsertService<Po,Pk> {
+
+    /**
+     * 添加一条数据
+     *
+     * @param data 要添加的数据
+     * @return 添加后生成的主键
+     */
+    Pk insert(Po data);
+}

hsweb-web-service/hsweb-web-service-api/src/main/java/org/hsweb/web/service/QueryService.java

@@ -0,0 +1,109 @@
+package org.hsweb.web.service;
+
+import org.hsweb.ezorm.core.dsl.Query;
+import org.hsweb.web.bean.common.PagerResult;
+import org.hsweb.web.bean.common.QueryParam;
+import org.hsweb.web.dao.GenericMapper;
+
+import java.util.List;
+
+public interface QueryService<Po, Pk> {
+    /**
+     * 分页进行查询数据，查询条件同 {@link GenericService#select}
+     *
+     * @param param 查询参数
+     * @return 分页结果
+     * @ 查询异常
+     */
+    PagerResult<Po> selectPager(QueryParam param);
+
+    /**
+     * 根据查询参数进行查询，参数可使用 {@link Query}进行构建
+     * 推荐使用 {@link this#createQuery()}进行查询
+     *
+     * @param param 查询参数
+     * @return 查询结果
+     * @see Query
+     */
+    List<Po> select(QueryParam param);
+
+    List<Po> select();
+
+    /**
+     * 查询记录总数，用于分页等操作。查询条件同 {@link GenericService#select}
+     *
+     * @param param 查询参数
+     * @return 查询结果，实现mapper中的sql应指定默认值，否则可能抛出异常
+     */
+    int total(QueryParam param);
+
+    /**
+     * 根据主键查询记录
+     *
+     * @param pk 主键
+     * @return 查询结果
+     */
+    Po selectByPk(Pk pk);
+
+    /**
+     * 查询只返回单个结果
+     *
+     * @param param 查询条件
+     * @return 单个结果
+     * @see this#select(QueryParam)
+     */
+    default Po selectSingle(QueryParam param) {
+        param.doPaging(0, 1);
+        List<Po> list = this.select(param);
+        if (list.size() == 0) return null;
+        else return list.get(0);
+    }
+
+    /**
+     * 创建本服务的dsl查询操作对象
+     * 可通过返回的Query对象进行dsl方式操作如:<br>
+     * <code>
+     * createQuery().where("id",1).single();
+     * </code>
+     *
+     * @return {@link Query}
+     * @see Query
+     * @see org.hsweb.ezorm.core.Conditional
+     * @since 2.2
+     */
+    default Query<Po, QueryParam> createQuery() {
+        Query<Po, QueryParam> query = Query.empty(new QueryParam());
+        query.setListExecutor(this::select);
+        query.setTotalExecutor(this::total);
+        query.setSingleExecutor(this::selectSingle);
+        return query;
+    }
+
+    /**
+     * 指定一个dao映射接口,接口需继承{@link GenericMapper}创建dsl数据查询对象<br>
+     * 可通过返回的Query对象进行dsl方式操作如:<br>
+     * <code>
+     * createQuery(userMapper).where("id",1).single();
+     * </code>
+     *
+     * @param mapper dao映射结构
+     * @param <PO>   PO泛型
+     * @param <PK>   主键泛型
+     * @return {@link Query}
+     * @see Query
+     * @see org.hsweb.ezorm.core.Conditional
+     * @since 2.2
+     */
+    static <PO, PK> Query<PO, QueryParam> createQuery(GenericMapper<PO, PK> mapper) {
+        Query<PO, QueryParam> query = new Query<>(new QueryParam());
+        query.setListExecutor(mapper::select);
+        query.setTotalExecutor(mapper::total);
+        query.setSingleExecutor((param) -> {
+            param.doPaging(0, 1);
+            List<PO> list = mapper.select(param);
+            if (null == list || list.size() == 0) return null;
+            else return list.get(0);
+        });
+        return query;
+    }
+}

hsweb-web-service/hsweb-web-service-api/src/main/java/org/hsweb/web/service/UpdateService.java

@@ -0,0 +1,56 @@
+package org.hsweb.web.service;
+
+import org.hsweb.ezorm.core.dsl.Update;
+import org.hsweb.web.bean.common.UpdateParam;
+import org.hsweb.web.bean.po.GenericPo;
+import org.hsweb.web.dao.GenericMapper;
+import org.hsweb.web.dao.UpdateMapper;
+
+import java.util.HashMap;
+import java.util.List;
+
+public interface UpdateService<Po> {
+    /**
+     * 修改记录信息
+     *
+     * @param data 要修改的对象
+     * @return 影响记录数
+     */
+    int update(Po data);
+
+    /**
+     * 批量修改记录
+     *
+     * @param data 要修改的记录集合
+     * @return 影响记录数
+     */
+    int update(List<Po> data);
+
+    /**
+     * 保存或修改
+     *
+     * @param po 要修改的数据
+     * @return
+     */
+    int saveOrUpdate(Po po);
+
+    /**
+     * 指定一个dao映射接口,接口需继承{@link GenericMapper}创建dsl数据更新操作对象<br>
+     * 可通过返回的Update对象进行dsl方式操作如:<br>
+     * <code>
+     * createUpdate(userMapper).where("id",1).exec();
+     * </code>
+     *
+     * @param mapper dao映射接口
+     * @param <PO>   PO泛型
+     * @return {@link Update}
+     * @see Update
+     * @see org.hsweb.ezorm.core.Conditional
+     * @see UpdateParam
+     * @since 2.2
+     */
+    static <PO> Update<PO, UpdateParam<PO>> createUpdate(UpdateMapper<PO> mapper) {
+        return Update.build(mapper::update, new UpdateParam(new HashMap<>()));
+    }
+
+}

hsweb-web-service/hsweb-web-service-simple/src/main/java/org/hsweb/web/service/commons/CRUService.java

@@ -0,0 +1,28 @@
+package org.hsweb.web.service.commons;
+
+import org.hsweb.web.dao.CRUMapper;
+import org.hsweb.web.dao.InsertMapper;
+import org.hsweb.web.dao.QueryMapper;
+import org.hsweb.web.dao.UpdateMapper;
+
+/**
+ * @author zhouhao
+ */
+public interface CRUService<Po, Pk> extends SimpleInsertService<Po, Pk>, SimpleQueryService<Po, Pk>, SimpleUpdateService<Po> {
+    CRUMapper<Po, Pk> getCRUMapper();
+
+    @Override
+    default InsertMapper<Po> getInsertMapper() {
+        return getCRUMapper();
+    }
+
+    @Override
+    default QueryMapper<Po, Pk> getQueryMapper() {
+        return getCRUMapper();
+    }
+
+    @Override
+    default UpdateMapper<Po> getUpdateMapper() {
+        return getCRUMapper();
+    }
+}

hsweb-web-service/hsweb-web-service-simple/src/main/java/org/hsweb/web/service/commons/GenericPoInsertService.java

@@ -0,0 +1,9 @@
+package org.hsweb.web.service.commons;
+
+import org.hsweb.web.bean.po.GenericPo;
+
+/**
+ * @author zhouhao
+ */
+public interface GenericPoInsertService extends SimpleInsertService<GenericPo<String>, String> {
+}

hsweb-web-service/hsweb-web-service-simple/src/main/java/org/hsweb/web/service/commons/GenericPoUpdateService.java

@@ -0,0 +1,9 @@
+package org.hsweb.web.service.commons;
+
+import org.hsweb.web.bean.po.GenericPo;
+
+/**
+ * @author zhouhao
+ */
+public interface GenericPoUpdateService extends SimpleUpdateService<GenericPo<String>> {
+}

hsweb-web-service/hsweb-web-service-simple/src/main/java/org/hsweb/web/service/commons/SimpleDeleteService.java

@@ -0,0 +1,31 @@
+package org.hsweb.web.service.commons;
+
+import org.hsweb.ezorm.core.dsl.Delete;
+import org.hsweb.web.bean.common.DeleteParam;
+import org.hsweb.web.bean.po.GenericPo;
+import org.hsweb.web.dao.DeleteMapper;
+import org.hsweb.web.service.DeleteService;
+import org.hsweb.web.service.GenericService;
+
+/**
+ * @author zhouhao
+ */
+public interface SimpleDeleteService<Pk> extends DeleteService<Pk> {
+    DeleteMapper getDeleteMapper();
+
+    default int delete(Pk pk) {
+        return getDeleteMapper().delete(DeleteParam.build().where(GenericPo.Property.id, pk));
+    }
+
+    /**
+     * 创建dsl删除操作对象
+     *
+     * @return {@link Delete}
+     * @see Delete
+     * @see GenericService#createDelete(DeleteMapper)
+     */
+    default Delete createDelete() {
+        return DeleteService.createDelete(getDeleteMapper());
+    }
+
+}

hsweb-web-service/hsweb-web-service-simple/src/main/java/org/hsweb/web/service/commons/SimpleInsertService.java

@@ -0,0 +1,29 @@
+package org.hsweb.web.service.commons;
+
+import org.hsweb.web.bean.common.InsertParam;
+import org.hsweb.web.bean.po.GenericPo;
+import org.hsweb.web.dao.InsertMapper;
+import org.hsweb.web.service.InsertService;
+
+/**
+ * @author zhouhao
+ */
+public interface SimpleInsertService<Po, Pk> extends InsertService<Po, Pk> {
+
+    InsertMapper<Po> getInsertMapper();
+
+    void tryValidPo(Po data);
+
+    @Override
+    default Pk insert(Po data) {
+        Pk primaryKey = null;
+        if (data instanceof GenericPo) {
+            if (((GenericPo) data).getId() == null)
+                ((GenericPo) data).setId(GenericPo.createUID());
+            primaryKey = (Pk) ((GenericPo) data).getId();
+        }
+        tryValidPo(data);
+        getInsertMapper().insert(InsertParam.build(data));
+        return primaryKey;
+    }
+}

hsweb-web-service/hsweb-web-service-simple/src/main/java/org/hsweb/web/service/commons/SimpleQueryService.java

@@ -0,0 +1,59 @@
+package org.hsweb.web.service.commons;
+
+import org.hsweb.web.bean.common.PagerResult;
+import org.hsweb.web.bean.common.QueryParam;
+import org.hsweb.web.dao.QueryMapper;
+import org.hsweb.web.service.QueryService;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author zhouhao
+ */
+public interface SimpleQueryService<Po, Pk> extends QueryService<Po, Pk> {
+    QueryMapper<Po, Pk> getQueryMapper();
+
+    @Override
+    default PagerResult<Po> selectPager(QueryParam param) {
+        PagerResult<Po> pagerResult = new PagerResult<>();
+        param.setPaging(false);
+        int total = getQueryMapper().total(param);
+        pagerResult.setTotal(total);
+        if (total == 0) {
+            pagerResult.setData(new ArrayList<>());
+        } else {
+            //根据实际记录数量重新指定分页参数
+            param.rePaging(total);
+            pagerResult.setData(getQueryMapper().select(param));
+        }
+        return pagerResult;
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    default List<Po> select(QueryParam param) {
+        return getQueryMapper().select(param);
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    default int total(QueryParam param) {
+        return getQueryMapper().total(param);
+    }
+
+
+    @Override
+    @Transactional(readOnly = true)
+    default Po selectByPk(Pk pk) {
+        return getQueryMapper().selectByPk(pk);
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    default List<Po> select() {
+        return this.createQuery().listNoPaging();
+    }
+
+}

hsweb-web-service/hsweb-web-service-simple/src/main/java/org/hsweb/web/service/commons/SimpleUpdateService.java

@@ -0,0 +1,75 @@
+package org.hsweb.web.service.commons;
+
+import org.hsweb.ezorm.core.dsl.Update;
+import org.hsweb.web.bean.common.UpdateParam;
+import org.hsweb.web.bean.po.GenericPo;
+import org.hsweb.web.dao.UpdateMapper;
+import org.hsweb.web.service.InsertService;
+import org.hsweb.web.service.QueryService;
+import org.hsweb.web.service.UpdateService;
+
+import java.util.List;
+
+/**
+ * @author zhouhao
+ */
+public interface SimpleUpdateService<Po> extends UpdateService<Po> {
+
+    UpdateMapper<Po> getUpdateMapper();
+
+    void tryValidPo(Po po);
+
+    @Override
+    default int update(Po data) {
+        tryValidPo(data);
+        return createUpdate().fromBean(data).where(GenericPo.Property.id).exec();
+    }
+
+    @Override
+    default int update(List<Po> data) {
+        int i = 0;
+        for (Po po : data) {
+            i += update(po);
+        }
+        return i;
+    }
+
+    @Override
+    default int saveOrUpdate(Po po) {
+        if (po instanceof GenericPo && this instanceof QueryService) {
+            Po old = (Po) ((QueryService) this).selectByPk(((GenericPo) po).getId());
+            if (old != null)
+                return update(po);
+            else {
+                if (this instanceof InsertService)
+                    ((InsertService) this).insert(po);
+            }
+        } else {
+            throw new UnsupportedOperationException("不支持此操作");
+        }
+        return 1;
+    }
+
+    /**
+     * 创建dsl更新操作对象，默认使用map进行数据填充,调用此方法,需要通过{@link Update#set(String, Object)}进行属性赋值
+     *
+     * @return {@link Update}
+     * @see Update
+     * @see UpdateService#createUpdate(UpdateMapper)
+     */
+    default Update<Po, UpdateParam<Po>> createUpdate() {
+        return UpdateService.createUpdate(getUpdateMapper());
+    }
+
+    /**
+     * 创建dsl更新操作对象，并指定要操作的数据
+     *
+     * @return {@link Update}
+     * @see Update
+     * @see UpdateService#createUpdate(UpdateMapper)
+     */
+    default Update<Po, UpdateParam<Po>> createUpdate(Po data) {
+        return Update.build(getUpdateMapper()::update, new UpdateParam<>(data));
+    }
+
+}

hsweb-web-service/hsweb-web-service-simple/src/main/java/org/hsweb/web/service/impl/AbstractServiceImpl.java

@@ -1,15 +1,14 @@
 package org.hsweb.web.service.impl;
 
-import org.hsweb.ezorm.core.dsl.Delete;
-import org.hsweb.ezorm.core.dsl.Query;
-import org.hsweb.ezorm.core.dsl.Update;
-import org.hsweb.web.bean.common.*;
-import org.hsweb.web.bean.po.GenericPo;
 import org.hsweb.web.bean.validator.ValidateResults;
 import org.hsweb.web.core.exception.NotFoundException;
 import org.hsweb.web.core.exception.ValidationException;
-import org.hsweb.web.dao.GenericMapper;
+import org.hsweb.web.dao.*;
 import org.hsweb.web.service.GenericService;
+import org.hsweb.web.service.commons.SimpleDeleteService;
+import org.hsweb.web.service.commons.SimpleInsertService;
+import org.hsweb.web.service.commons.SimpleQueryService;
+import org.hsweb.web.service.commons.SimpleUpdateService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -17,8 +16,6 @@ import org.springframework.transaction.annotation.Transactional;
 
 import javax.validation.ConstraintViolation;
 import javax.validation.Validator;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Set;
 
 /**
@@ -31,7 +28,11 @@ import java.util.Set;
  * @since 1.0
  */
 @Transactional(rollbackFor = Throwable.class)
-public abstract class AbstractServiceImpl<Po, PK> implements GenericService<Po, PK> {
+public abstract class AbstractServiceImpl<Po, PK> implements GenericService<Po, PK>
+        , SimpleQueryService<Po, PK>
+        , SimpleUpdateService<Po>
+        , SimpleDeleteService<PK>
+        , SimpleInsertService<Po, PK> {
     protected Logger logger = LoggerFactory.getLogger(this.getClass());
 
     @Autowired
@@ -40,130 +41,26 @@ public abstract class AbstractServiceImpl<Po, PK> implements GenericService<Po,
     protected abstract GenericMapper<Po, PK> getMapper();
 
     @Override
-    @Transactional(readOnly = true)
-    public PagerResult<Po> selectPager(QueryParam param) {
-        PagerResult<Po> pagerResult = new PagerResult<>();
-        param.setPaging(false);
-        int total = getMapper().total(param);
-        pagerResult.setTotal(total);
-        if (total == 0) {
-            pagerResult.setData(new ArrayList<>());
-        } else {
-            //根据实际记录数量重新指定分页参数
-            param.rePaging(total);
-            pagerResult.setData(getMapper().select(param));
-        }
-        return pagerResult;
-    }
-
-    @Override
-    public PK insert(Po data) {
-        PK primaryKey = null;
-        if (data instanceof GenericPo) {
-            if (((GenericPo) data).getId() == null)
-                ((GenericPo) data).setId(GenericPo.createUID());
-            primaryKey = (PK) ((GenericPo) data).getId();
-        }
-        tryValidPo(data);
-        getMapper().insert(InsertParam.build(data));
-        return primaryKey;
-    }
-
-    @Deprecated
-    public List<PK> batchInsert(List<Po> data, boolean skipFail) {
-        List<PK> pkList = new ArrayList<>();
-        List<Po> insertData = new ArrayList<>();
-        //build
-        for (Po po : data) {
-            if (data instanceof GenericPo) {
-                if (((GenericPo) data).getId() == null)
-                    ((GenericPo) data).setId(GenericPo.createUID());
-                PK primaryKey = (PK) ((GenericPo) data).getId();
-                try {
-                    tryValidPo(po);
-                    insertData.add(po);
-                    pkList.add(primaryKey);
-                } catch (ValidationException e) {
-                    if (!skipFail) {
-                        throw e;
-                    } else if (logger.isWarnEnabled()) {
-                        logger.warn("data validate fail:{}", e);
-                    }
-                }
-
-            }
-        }
-        getMapper().insert((InsertParam) InsertParam.build(insertData));
-        return pkList;
-    }
-
-    @Override
-    public int delete(PK pk) {
-        return createDelete().where(GenericPo.Property.id, pk).exec();
-    }
-
-    @Override
-    public int update(Po data) {
-        return createUpdate().fromBean(data).where(GenericPo.Property.id).exec();
-    }
-
-    @Override
-    public int update(List<Po> data) {
-        int i = 0;
-        for (Po po : data) {
-            i += update(po);
-        }
-        return i;
-    }
-
-    @Override
-    @Transactional(readOnly = true)
-    public List<Po> select(QueryParam param) {
-        return this.getMapper().select(param);
-    }
-
-    @Transactional(readOnly = true)
-    public List<Po> select() {
-        return createQuery().listNoPaging();
+    public QueryMapper<Po, PK> getQueryMapper() {
+        return getMapper();
     }
 
     @Override
-    @Transactional(readOnly = true)
-    public int total(QueryParam param) {
-        return this.getMapper().total(param);
+    public UpdateMapper<Po> getUpdateMapper() {
+        return getMapper();
     }
 
     @Override
-    @Transactional(readOnly = true)
-    public Po selectByPk(PK pk) {
-        return this.getMapper().selectByPk(pk);
+    public DeleteMapper getDeleteMapper() {
+        return getMapper();
     }
 
     @Override
-    public int saveOrUpdate(Po po) {
-        if (po instanceof GenericPo) {
-            Po old = selectByPk((PK) ((GenericPo) po).getId());
-            if (old != null)
-                return update(po);
-            else
-                insert(po);
-        } else {
-            throw new UnsupportedOperationException("不支持此操作");
-        }
-        return 1;
-    }
-
-    protected void assertNotNull(Object po, String message) {
-        if (po == null) {
-            throw new NotFoundException(message);
-        }
-    }
-
-    protected void assertNotNull(Object po) {
-        assertNotNull(po, "数据不存在");
+    public InsertMapper<Po> getInsertMapper() {
+        return getMapper();
     }
 
-    protected void tryValidPo(Po data) {
+    public void tryValidPo(Po data) {
         Set<ConstraintViolation<Object>> set = validator.validate(data);
         ValidateResults results = new ValidateResults();
         if (set.isEmpty()) {
@@ -175,37 +72,14 @@ public abstract class AbstractServiceImpl<Po, PK> implements GenericService<Po,
             throw new ValidationException(results);
     }
 
-    /**
-     * 创建dsl更新操作对象，默认使用map进行数据填充,调用此方法,需要通过{@link Update#set(String, Object)}进行属性赋值
-     *
-     * @return {@link Update}
-     * @see Update
-     * @see GenericService#createUpdate(GenericMapper)
-     */
-    public Update<Po, UpdateParam<Po>> createUpdate() {
-        return GenericService.createUpdate(getMapper());
-    }
-
-    /**
-     * 创建dsl更新操作对象，并指定要操作的数据
-     *
-     * @return {@link Update}
-     * @see Update
-     * @see GenericService#createUpdate(GenericMapper)
-     */
-    public Update<Po, UpdateParam<Po>> createUpdate(Po data) {
-        return Update.build(getMapper()::update, new UpdateParam<>(data));
+    protected void assertNotNull(Object po, String message) {
+        if (po == null) {
+            throw new NotFoundException(message);
+        }
     }
 
-    /**
-     * 创建dsl删除操作对象
-     *
-     * @return {@link Delete}
-     * @see Delete
-     * @see GenericService#createDelete(Delete.Executor)
-     */
-    public Delete createDelete() {
-        return GenericService.createDelete(getMapper());
+    protected void assertNotNull(Object po) {
+        assertNotNull(po, "数据不存在");
     }
 
 }

hsweb-web-service/hsweb-web-service-simple/src/main/java/org/hsweb/web/service/impl/datasource/DataSourceServiceImpl.java

@@ -16,9 +16,6 @@
 
 package org.hsweb.web.service.impl.datasource;
 
-import org.hsweb.web.bean.common.QueryParam;
-import org.hsweb.web.bean.common.UpdateMapParam;
-import org.hsweb.web.bean.common.UpdateParam;
 import org.hsweb.web.bean.po.datasource.DataSource;
 import org.hsweb.web.core.datasource.DynamicDataSource;
 import org.hsweb.web.core.exception.BusinessException;
@@ -40,7 +37,6 @@ import java.util.Date;
 import java.util.List;
 
 import static org.hsweb.web.bean.po.GenericPo.Property.id;
-import static org.hsweb.web.bean.po.datasource.DataSource.*;
 import static org.hsweb.web.bean.po.datasource.DataSource.Property.*;
 
 /**

hsweb-web-service/hsweb-web-service-simple/src/main/java/org/hsweb/web/service/impl/quartz/QuartzJobServiceImpl.java

@@ -30,6 +30,7 @@ import org.hsweb.web.bean.po.quartz.QuartzJobHistory;
 import org.hsweb.web.core.exception.BusinessException;
 import org.hsweb.web.dao.quartz.QuartzJobHistoryMapper;
 import org.hsweb.web.dao.quartz.QuartzJobMapper;
+import org.hsweb.web.service.DeleteService;
 import org.hsweb.web.service.GenericService;
 import org.hsweb.web.service.impl.AbstractServiceImpl;
 import org.hsweb.web.service.quartz.QuartzJobHistoryService;
@@ -134,7 +135,7 @@ public class QuartzJobServiceImpl extends AbstractServiceImpl<QuartzJob, String>
     @CacheEvict(value = CACHE_KEY, key = "'id:'+#id")
     public int delete(String id) {
         deleteJob(id);
-        GenericService.createDelete(quartzJobHistoryMapper).where(QuartzJobHistory.Property.jobId, id).exec();
+        DeleteService.createDelete(quartzJobHistoryMapper).where(QuartzJobHistory.Property.jobId, id).exec();
         return super.delete(id);
     }
 

hsweb-web-service/hsweb-web-service-simple/src/main/java/org/hsweb/web/service/impl/user/UserServiceImpl.java

@@ -12,6 +12,7 @@ import org.hsweb.web.core.utils.RandomUtil;
 import org.hsweb.web.dao.role.UserRoleMapper;
 import org.hsweb.web.dao.user.UserMapper;
 import org.hsweb.web.service.GenericService;
+import org.hsweb.web.service.QueryService;
 import org.hsweb.web.service.impl.AbstractServiceImpl;
 import org.hsweb.web.service.module.ModuleService;
 import org.hsweb.web.service.user.UserService;
@@ -69,11 +70,6 @@ public class UserServiceImpl extends AbstractServiceImpl<User, String> implement
         return id;
     }
 
-    @Override
-    public List<String> batchInsert(List<User> data, boolean skipFail) {
-        throw new UnsupportedOperationException("不支持此操作");
-    }
-
     @Override
     public int update(User data) {
         tryValidPo(data);
@@ -111,7 +107,7 @@ public class UserServiceImpl extends AbstractServiceImpl<User, String> implement
 
     @Override
     public void initGuestUser(User user) {
-        List<UserRole> userRoles = GenericService.createQuery(userRoleMapper).where(UserRole.Property.roleId, "guest").list();
+        List<UserRole> userRoles = QueryService.createQuery(userRoleMapper).where(UserRole.Property.roleId, "guest").list();
         user.setUserRoles(userRoles);
         user.initRoleInfo();
     }