业务逻辑层、数据权限、数据事务处理、通用基类

引言

对于业务逻辑层的开发重复代码很多，尽管有代码生成器，但从代码量总的来说还是比较多，所以就有了以下抽象类及工具，对一些常用操作进行封装。

对通用新增、删除、编辑、查询，代码操作进行封装简化。你只需要写你的业务逻辑代码就可以了。

对特有树状结构特有字段如（所有父级编码、所有排序号编码、是否是叶子节点、当前节点层次）进行更新，比如，通过所有父级编码可快速查询到所有子级的数据；通过所有排序号，可快速对整个树结构进行排序；通过是否叶子节点快速得知是否有下级；根据当前层次快速知道当前节点在树中的级别。

对通用数据权限进行简化封装，将颗粒度降到人员身上，支持人员与数据，角色与数据权限定制（角色上的数据权限与人员身上的数据权限为或者关系）。数据权限不仅仅支持公司、部门、角色，还可以通过配置支持你的业务字段数据信息过滤，如订单的区域、内容管理的栏目、故障单类型等等。

对事务处理使用Spring事务@Transactional注解，进行方法级别的事务控制，不用单独处理事务及回滚。如配置传播行为，进行事务继承，子事务，事务回滚行为等，配置隔离级别读取未提交的数据等。

数据权限

相对于旧版本，本次对数据权限这块进行了全面的升级，让数据权限颗粒度细化到人员身上。

支持人员与权限和角色与权限：主要是这两张表：js_sys_role_data_scope、js_sys_user_data_scope

权限表中的关键字段的含义，如下：

  • 控制类型：Office：部门；Company：公司、Role：角色；
  • 控制数据：被控制数据权限的数据主键编号，业务表的主键编号；
  • 控制权限：1：拥有的权限（DataScope.CTRL_PERMI_HAVE）；2：管理的权限（DataScope.CTRL_PERMI_MANAGE）。 你可以根据需要，扩展控制类型的权限，如：行业、区域、分类；也可以扩展控制权限，如：查询权限、修改权限。

用户管理的数据权限被定义为管理的权限（所以需要从二级管理员里授权设置），如果采用无限级授权（即只能创建本部门的用户，只能分配自己有用的角色，只能分配自己拥有的菜单），这时你需要将用户管理的权限改为拥有的权限，设置（user.adminCtrlPermi=1 v4.1.5+）即可。

角色数据范围：

指定数据权限范围类型，多个角色同时指定，之间为或者关系；人员权限与角色权限之间同样为或者关系，多个位置设置权限，依照最大权限为主。

  • 未设置：忽略这个角色的数据源权限设置
  • 全部数据：可以查看全部数据，无需控制权限
  • 自定义数据：打对勾，跨部门、跨机构的情况设置数据权限
  • 本部门数据：仅控制当前用户所在部门（所在机构）的数据权限
  • 本公司数据：仅控制当前用户所在公司的数据权限
  • 本部门和本公司：控制当前用户所在部门和所在公司的数据权限

控制业务范围：

在 v4.1.6 中新增的功能，当你使用 addFilter 权限过滤的时候可以指定适应的业务范围，不指定代表所有生效。

举例如：有的功能可以看本部门，有的功能可以看本公司，有的功能可以看全部数据，分功能去控制权限。

新增的业务范围可以从字典管理中找到 sys_role_biz_scope 类型进行添加。

第一步

  1. /**
  2.  * 添加数据权限过滤条件
  3.  */
  4. public void addDataScopeFilter(T entity){
  5.     // 举例1：公司数据权限过滤，实体类@Table注解extWhereKeys="dsf"
  6.     company.getSqlMap().getDataScope().addFilter("dsf", "Company",
  7.             "a.company_code", DataScope.CTRL_PERMI_HAVE);
  8.     // 举例2：部门数据权限过滤，实体类@Table注解extWhereKeys="dsf"
  9.     office.getSqlMap().getDataScope().addFilter("dsf", "Office",
  10.             "a.office_code", DataScope.CTRL_PERMI_HAVE);
  11.     // 举例3：角色数据权限过滤，实体类@Table注解extWhereKeys="dsf"
  12.     role.getSqlMap().getDataScope().addFilter("dsf", "Role",
  13.             "a.role_code", DataScope.CTRL_PERMI_HAVE);
  14.     // 举例4：用户、员工（自己创建的）数据权限根据部门过滤，实体类@Table注解extWhereKeys="dsfOffice"
  15.     empUser.getSqlMap().getDataScope().addFilter("dsfOffice", "Office", 
  16.             "e.office_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);
  17.     // 举例5：用户、员工（自己创建的）数据权限根据公司过滤，实体类@Table注解extWhereKeys="dsfCompany"
  18.     empUser.getSqlMap().getDataScope().addFilter("dsfCompany", "Company", 
  19.             "e.company_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);
  20. }

注意：在调用 findList 或 findPage 之前去手动调用 addDataScopeFilter 方法，才可生效。

第二步

1）在 \@Table 注解中调用如下：

  • 采用 EXISTS方式调用： @Table(extWhereKeys="dsf")

  • 采用JOIN方式调用： @Table(extFromKeys="dsf",extWhereKeys="dsf") 2）MyBatis Mapper 中调用如下两种方式：

  • 采用 EXISTS方式调用： 将 ${sqlMap.dsf} 放在 Where 后

  • 采用JOIN方式调用： 将 ${sqlMap.dsfFrom} 放在 From 后 ，将 ${sqlMap.dsfWhere} 放在 Where 后

调用 API 接口

  1. /**
  2.  * 数据范围过滤
  3.  * @param sqlMapKey sqlMap的键值，举例：如设置“dsf”数据范围过滤，则：<br>
  4.  *         exists方式对应：sqlMap.dsf；   join方式对应：sqlMap.dsfFrom 和 sqlMap.dsfWhere
  5.  * @param ctrlTypes 控制类型，多个用“,”隔开，举例：<br>
  6.  *        控制角色：Role<br>
  7.  *        控制部门：Office<br>
  8.  *        控制公司：Company<br>
  9.  * @param bizCtrlDataFields 业务表对应过滤表别名或需要过滤的表别名加权限字段，多个使用“,”分隔，
  10.  *         长度必须与ctrlTypes保持一致，举例：<br>
  11.  *         业务表控制角色：a.role_code<br>
  12.  *         业务表控制部门：a.office_code<br>
  13.  *         业务表控制公司：a.company_code<br>
  14.  * @param bizCtrlUserField 业务表对应表别名或用户字段。过滤只可以查看本人数据。
  15.  *         不设置的话，如果没有范围权限，则查不到任何数据，举例：<br>
  16.  *         业务表a.create_by"
  17.  * @param bizScope 业务范围  v4.1.6
  18.  * @see example
  19.  *         1）在Service中调用如下两种方式：<br>
  20.  *             // 添加数据权限过滤条件（控制角色）<br>
  21.  *             entity.getSqlMap().getDataScope().addFilter("dsf", "Role", <br>
  22.  *                  "a.role_code", DataScope.CTRL_PERMI_HAVE);<br>
  23.  *             // 添加数据权限过滤条件（控制公司或部门）<br>
  24.  *             entity.getSqlMap().getDataScope().addFilter("dsf", "Office,Company", <br>
  25.  *                 "a.office_code,a.company_code", DataScope.CTRL_PERMI_HAVE);<br>
  26.  *             // 添加数据权限过滤条件（控制公司、部门或当前用户）<br>
  27.  *             entity.getSqlMap().getDataScope().addFilter("dsf", "Office,Company", <br>
  28.  *                 "a.office_code,a.company_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);<br>
  29.  *         2）在 \@Table 注解中调用如下：<br>
  30.  *             采用 EXISTS 方式调用 ： \@Table(extWhereKeys="dsf")
  31.  *             采用 JOIN 方式调用   ： \@Table(extFromKeys="dsf",extWhereKeys="dsf")
  32.  *         3）MyBatis Mapper 中调用如下两种方式：<br>
  33.  *             采用 EXISTS 方式调用 ： 将  ${sqlMap.dsf} 放在Where语句里<br>
  34.  *             采用 JOIN 方式调用   ： 将  ${sqlMap.dsfFrom} 放在From后 ，将  ${sqlMap.dsfWhere} 放在Where语句里<br>
  35.  */
  36. public QueryDataScope addFilter(String sqlMapKey, String ctrlTypes, String bizCtrlDataFields, 
  37.             String bizCtrlUserField, String ctrlPermi, String bizScope);

数据库事务

事务管理对于企业应用来说是至关重要的，当出现异常情况，它也可以保证数据的一致性。

JeeSite主要使用Spring的@Transactional注解，也称声明式事务管理，是建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需通过基于@Transactional注解的方式，便可以将事务规则应用到业务逻辑中。

JeeSite支持分布式事务，在 yml 配置文件里将 jdbc.jta.enabled 设置为 true 即可。

注解属性

属性类型描述
传播性（propagation）枚举型可选的传播性设置（默认值：Propagation.REQUIRED）
隔离性（isolation）枚举型可选的隔离性级别（默认值：Isolation.ISOLATION_DEFAULT）
只读性（readOnly）布尔型读写型事务 vs. 只读型事务
超时（timeout）int型事务超时（以秒为单位）
回滚异常类（rollbackFor）Class 类的实例，必须是Throwable 的子类异常类，遇到时必须进行回滚。默认情况下checked exceptions不进行回滚，仅unchecked exceptions（即RuntimeException的子类）才进行事务回滚。
不回滚异常类（noRollbackFor）Class 类的实例，必须是Throwable的子类异常类，遇到时必须不回滚。

事务传播行为

所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在Propagation定义中包括了如下几个表示传播行为的常量：

  • Propagation.REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务，这是默认值。
  • Propagation.REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
  • Propagation.SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
  • Propagation.NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
  • Propagation.NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
  • Propagation.MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
  • Propagation.NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

事务隔离级别

隔离级别是指若干个并发的事务之间的隔离程度。Isolation 接口中定义了五个表示隔离级别的常量：

  • Isolation.DEFAULT：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是Isolation.READ_COMMITTED。
  • Isolation.READ_UNCOMMITTED：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读，不可重复读和幻读，因此很少使用该隔离级别。比如PostgreSQL实际上并没有此级别。
  • Isolation.READ_COMMITTED：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
  • Isolation.REPEATABLE_READ：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。该级别可以防止脏读和不可重复读。
  • Isolation.SERIALIZABLE：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

基类及接口的继承关系

TreeService -> TreeQueryService -> CrudService -> QueryService -> BaseService

TreeDao -> CrudDao -> QueryDao -> BaseDao

TreeEntity -> DataEntity -> BaseEntity

QueryService 查询抽象基类

  1. /**
  2.  * 新建实体对象
  3.  * @return
  4.  */
  5. protected T newEntity();
  7. /**
  8.  * 新建实体对象（带一个String构造参数）
  9.  * @return
  10.  */
  11. protected T newEntity(String id);
  13. /**
  14.  * 获取单条数据
  15.  * @param id 主键
  16.  * @return
  17.  */
  18. public T get(String id);
  20. /**
  21.  * 获取单条数据
  22.  * @param entity
  23.  * @return
  24.  */
  25. public T get(T entity);
  27. /**
  28.  * 获取单条数据，如果获取不到，则实例化一个空实体
  29.  * @param id 主键编号
  30.  * @param isNewRecord 如果是新记录，则验证主键编号是否存在。
  31.  *                          如果存在抛出ValidationException异常。
  32.  * @return
  33.  */
  34. public T get(String id, boolean isNewRecord);
  36. /**
  37.  * 获取单条数据，如果获取不到，则实例化一个空实体（多个主键情况下调用）
  38.  * @param pkClass 主键类型数组
  39.  * @param pkValue 主键数据值数组
  40.  * @param isNewRecord 如果是新记录，则验证主键编号是否存在。
  41.  *                          如果存在抛出ValidationException异常。
  42.  * @return
  43.  */
  44. public T get(Class<?>[] pkClass, Object[] pkValue, boolean isNewRecord);
  46. /**
  47.  * 列表查询数据
  48.  * @param entity
  49.  * @return
  50.  */
  51. public List<T> findList(T entity);
  53. /**
  54.  * 分页查询数据
  55.  * @param page 分页对象
  56.  * @param entity
  57.  * @return
  58.  */
  59. public Page<T> findPage(Page<T> page, T entity);
  61. /**
  62.  * 查询列表总数
  63.  * @param entity
  64.  * @return
  65.  */
  66. public long findCount(T entity);

CrudService 增删改抽象基类

该类继承QueryService抽象类

  1. /**
  2.  * 保存数据（插入或更新）
  3.  * @param entity
  4.  */
  5. @Transactional(readOnly = false)
  6. public void save(T entity)
  8. /**
  9.  * 插入数据
  10.  * @param entity
  11.  */
  12. @Transactional(readOnly = false)
  13. public void insert(T entity);
  15. /**
  16.  * 更新数据
  17.  * @param entity
  18.  */
  19. @Transactional(readOnly = false)
  20. public void update(T entity);
  22. /**
  23.  * 更新状态（级联更新子节点）
  24.  * @param entity
  25.  */
  26. @Transactional(readOnly = false)
  27. public void updateStatus(T entity);
  29. /**
  30.  * 删除数据
  31.  * @param entity
  32.  */
  33. @Transactional(readOnly = false)
  34. public void delete(T entity);

TreeService 树结构抽象基类

该类继承CrudService抽象类

  1. /**
  2.  * 根据父节点获取子节点最后一条记录
  3.  */
  4. public T getLastByParentCode(T entity);
  6. /**
  7.  * 保存数据（插入或更新）
  8.  * 实现自动保存字段：所有父级编号、所有排序号、是否是叶子节点、节点的层次级别等数据
  9.  * 实现级联更新所有子节点数据：同父级自动保存字段
  10.  */
  11. @Transactional(readOnly = false)
  12. public void save(T entity);
  14. /**
  15.  * 更新parent_codes、tree_sorts、tree_level字段值
  16.  */
  17. @Transactional(readOnly = false, isolation = Isolation.READ_UNCOMMITTED) // 可读取未提交数据
  18. private void updateParentCodes(T entity);
  20. /**
  21.  * 更新当前节点排序号
  22.  */
  23. @Transactional(readOnly = false)
  24. public void updateTreeSort(T entity);
  26. /**
  27.  * 更新tree_leaf字段值
  28.  */
  29. @Transactional(readOnly = false, isolation = Isolation.READ_UNCOMMITTED) // 可读取未提交数据
  30. private void updateTreeLeaf(T entity);
  32. /**
  33.  * 修正本表树结构的所有父级编号
  34.  * 包含：数据修复（parentCodes、treeLeaf、treeLevel）字段
  35.  */
  36. @Transactional(readOnly = false) // 可读取未提交数据
  37. public void updateFixParentCodes();
  39. /**
  40.  * 按父级编码修正树结构的所有父级编号
  41.  * 包含：数据修复（parentCodes、treeLeaf、treeLevel）字段
  42.  */
  43. @Transactional(readOnly = false) // 可读取未提交数据
  44. public void updateFixParentCodes(String parentCode);
  46. /**
  47.  * 预留接口事件，更新子节点
  48.  * @param childEntity 当前操作节点的子节点
  49.  * @param parentEntity 当前操作节点
  50.  */
  51. protected void updateChildNode(T childEntity, T parentEntity);
  53. /**
  54.  * 更新状态（级联更新子节点）
  55.  * @param entity
  56.  */
  57. @Transactional(readOnly = false)
  58. public void updateStatus(T entity);
  60. /**
  61.  * 删除数据（级联删除子节点）
  62.  * @param entity
  63.  */
  64. @Transactional(readOnly = false)
  65. public void delete(T entity);
  67. /**
  68.  * 将不同级别无序的树列表进行排序，前提是sourcelist每一级是有序的<br>
  69.  * 举例如下：<br>
  70.  *     List<T> targetList = Lists.newArrayList();<br>
  71.  *     List<T> sourcelist = service.findList(category);<br>
  72.  *     service.execTreeSort(targetList, sourcelist, "0");<br>
  73.  * @param sourceList 源数据列表
  74.  * @param targetList 目标数据列表
  75.  * @param parentCode 目标数据列表的顶级节点
  76.  */
  77. public void execTreeSort(List<T> sourceList, List<T> targetList, String parentCode);
  79. /**
  80.  * 将简单列表code,parentCode转换为嵌套列表形式code,childList[code,childList[...]]<br>
  81.  * 举例如下：<br>
  82.  *     List<T> targetList = Lists.newArrayList();<br>
  83.  *     List<T> sourcelist = service.findList(category);<br>
  84.  *     service.execChildListBulid(targetList, sourcelist, "0");<br>
  85.  * @param sourceList 源数据列表
  86.  * @param targetList 目标数据列表
  87.  * @param parentCode 目标数据列表的顶级节点
  88.  */
  89. public void execChildListBulid(List<T> sourceList, List<T> targetList, String parentCode);

其它使用技巧

分页逻辑说明

Entity部分：

  1. public Custom extends BaseEntity{
  2.     private String code;
  3.     private String name;    
  4. }

Dao部分：

  1. public List<Custom> findListByCodeAndName(Custom custom);

Service部分：

  1. Page<Custom> page = new Page<Custom>();
  2. Custom custom = new Custom();
  3. custom.setCode("code");
  4. custom.setName("name");
  5. custom.setPage(page); // 给实体设置 page 参数即可自动分页
  6. page.setList(dao.findListByCodeAndName(custom));
  7. System.out.println(page.getList());     // 获取当前页数据
  8. System.out.println(page.getCount()); // 获取总条数

MAP参数分页

Dao部分：

  1. public List<Map<String, Object>> findListForMap(Map<String, Object> params);

Mapper部分：

  1. <select id="findListForMap" resultType="map">
  2.     SELECT * FROM test_data a
  3.     <where>
  4.         <if test="testInput != null and testInput != ''">
  5.             AND a.test_input = #{testInput}
  6.         </if>
  7.     </where>
  8.     <if test="page != null and page.orderBy != null and page.orderBy != ''">
  9.         ORDER BY ${page.orderBy}
  10.     </if>
  11. </select>

Service部分：

  1. Page<Map<String, Object>> pageMap = new Page<>();
  2. Map<String, Object> params = MapUtils.newHashMap();
  3. params.put("testInput", "123");
  4. params.put("page", pageMap); // 给 Map 设置 page 参数即可自动分页
  5. pageMap.setList(dao.findListForMap(params));
  6. System.out.println(pageMap.getList());    // 获取当前页数据
  7. System.out.println(pageMap.getCount()); // 获取总条数

覆写内置Service

  1. @Service
  2. @Transactional(readOnly=true)
  3. public class UserServiceImpl extends UserServiceSupport{
  5.     public UserServiceImpl() {
  6.         super.setEntityClass(User.class);
  7.     }
  9.     /**
  10.      * 更新个人信息
  11.      */
  12.     @Override
  13.     @Transactional(readOnly=false)
  14.     public void updateUserInfo(User user){
  15.         String avatarBase64 = user.getAvatarBase64();
  16.         if (StringUtils.isNotBlank(avatarBase64)){
  17.             if ("EMPTY".equals(avatarBase64)){
  18.                 user.setAvatar(StringUtils.EMPTY);
  19.             }else{
  20.                 String imageUrl = "avatar/"+user.getCorpCode()+"/"
  21.                         +user.getUserType()+"/"+user.getUserCode()
  22.                         +"."+FileUtils.getFileExtensionByImageBase64(avatarBase64);
  23.                 String fileName = Global.getUserfilesBaseDir(imageUrl);
  24.                 FileUtils.writeToFileByImageBase64(fileName, avatarBase64);
  25.                 user.setAvatar(Global.USERFILES_BASE_URL + imageUrl);
  26.             }
  27.         }
  28.         super.updateUserInfo(user);
  29.     }
  31. }