业务层、数据权限、数据事务、通用基类、分页逻辑

// 最后一个参数是 bizScope，指定的 office_user 对应角色里选择的业务范围字典编码
SqlMap sqlMap = empUser.getSqlMap(); // v5.3.0 之前版本
SqlMap sqlMap = empUser.sqlMap(); // v5.3.0+ 及之后版本
sqlMap.getDataScope().addFilter("dsfOffice",
	"Office", "e.office_code", "a.create_by", ctrlPermi, "office_user");

/**
 * 添加数据权限过滤条件
 */
public void addDataScopeFilter(T entity){
	SqlMap sqlMap = entity.getSqlMap(); // v5.3.0 之前版本
	SqlMap sqlMap = entity.sqlMap(); // v5.3.0+ 及之后版本

	// 举例1：公司数据权限过滤，实体类@Table注解extWhereKeys="dsf"
	sqlMap.getDataScope().addFilter("dsf", "Company",
			"a.company_code", DataScope.CTRL_PERMI_HAVE);

	// 举例2：部门数据权限过滤，实体类@Table注解extWhereKeys="dsf"
	sqlMap.getDataScope().addFilter("dsf", "Office",
			"a.office_code", DataScope.CTRL_PERMI_HAVE);

	// 举例3：角色数据权限过滤，实体类@Table注解extWhereKeys="dsf"
	sqlMap.getDataScope().addFilter("dsf", "Role",
			"a.role_code", DataScope.CTRL_PERMI_HAVE);

	// 举例4：用户、员工（自己创建的）数据权限根据部门过滤，实体类@Table注解extWhereKeys="dsfOffice"
	sqlMap.getDataScope().addFilter("dsfOffice", "Office", 
			"e.office_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);

	// 举例5：用户、员工（自己创建的）数据权限根据公司过滤，实体类@Table注解extWhereKeys="dsfCompany"
	sqlMap.getDataScope().addFilter("dsfCompany", "Company", 
			"e.company_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);
}

@RequiresPermissions("user")
@RequestMapping(value = "listData")
@ResponseBody
public Page<EmpUser> listData(EmpUser empUser, HttpServletRequest request, HttpServletResponse response) {
	empUser.setPage(new Page<>(request, response));
	empUserService.addDataScopeFilter(empUser); 	// 调用数据权限过滤方法（重点）
	Page<EmpUser> page = empUserService.findPage(empUser);
	return page;
}

/**
 * 添加数据权限过滤条件
 */
public void addDataScopeFilter(T entity){
	SqlMap sqlMap = entity.getSqlMap(); // v5.3.0 之前版本
	SqlMap sqlMap = entity.sqlMap(); // v5.3.0+ 及之后版本

	// 添加数据权限过滤条件
	sqlMap.getDataScope().addFilter("dsfOffice", "Office", 
			"e.office_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);

	// 添加自定义权限过滤条件（或者包含所有的部门经理）
	sqlMap.getDataScope().addFilter("dsfOffice",
		"EXISTS (SELECT 1 FROM js_sys_user_role WHERE user_code=a.user_code and role_code='dept')");
		
	// 若不需要此数据权限了，也可以进行根据 key 进行清理权限数据
	sqlMap.getDataScope().clearFilter("dsfOffice");

}

/**
 * 添加到数据范围过滤条件（如果之前sqlMapKey已经存在，则使用OR增加到该条件）
 * @param sqlMapKey sqlMap的键值，举例：如设置“dsf”数据范围过滤，则：<br>
 * 		exists方式对应：sqlMap.dsf； join方式对应：sqlMap.dsfFrom 和 sqlMap.dsfWhere
 * @param ctrlTypes 控制类型，多个用“,”隔开，多个是“or”关系，举例：<br>
 *		控制角色：Role<br>
 *		控制部门：Office<br>
 *		控制公司：Company
 * @param bizCtrlDataFields 业务表对应过滤表别名和加权字段，多个使用“,”分隔。<br>
 * 		长度必须与 ctrlTypes 保持一致，举例：<br>
 * 		业务表控制角色：a.role_code<br>
 * 		业务表控制部门：a.office_code<br>
 * 		业务表控制公司：a.company_code
 * @param bizCtrlUserField 业务表对应过滤表别名和用户字段，用于过滤只可以查看本人数据（自己创建的）。<br>
 * 		不设置的话，如果没有范围权限，则查不到任何数据，举例：<br>
 * 		业务表：a.create_by
 * @param ctrlPermi 拥有的数据权限：DataScope.CTRL_PERMI_HAVE、可管理的数据权限：DataScope.CTRL_PERMI_HAVE
 * @param bizScope 业务范围，多个用“,”隔开  v4.1.6
 * @see example
 * 		1）在Service中调用如下两种方式：<br>
 * 			// 添加数据权限过滤条件（控制角色）<br>
 * 			sqlMap.getDataScope().addFilter("dsf", "Role", <br>
 * 		 			"a.role_code", DataScope.CTRL_PERMI_HAVE);<br>
 * 			// 添加数据权限过滤条件（控制部门）<br>
 * 			sqlMap.getDataScope().addFilter("dsf", "Office", <br>
 * 					"a.office_code", DataScope.CTRL_PERMI_HAVE);<br>
 * 			// 添加数据权限过滤条件（控制公司）<br>
 * 			sqlMap.getDataScope().addFilter("dsf", "Company", <br>
 * 					"a.company_code", DataScope.CTRL_PERMI_HAVE);<br>
 * 			// 添加数据权限过滤条件（如果没有部门权限，则控制当前用户）<br>
 * 			sqlMap.getDataScope().addFilter("dsf", "Office", <br>
 * 					"a.office_code", "a.create_by", DataScope.CTRL_PERMI_HAVE);<br>
 * 		2）在 \@Table 注解中调用如下：<br>
 * 			采用 EXISTS 方式调用 ： \@Table(extWhereKeys="dsf")<br>
 * 			采用 JOIN 方式调用	 ： \@Table(extFromKeys="dsfFrom", extWhereKeys="dsfWhere")
 * 		3）MyBatis Mapper 中调用如下两种方式：<br>
 * 			采用 EXISTS 方式调用 ： 将  ${sqlMap.dsf} 放在Where语句里<br>
 * 			采用 JOIN 方式调用	 ： 将  ${sqlMap.dsfFrom} 放在From后 ，将  ${sqlMap.dsfWhere} 放在Where语句里
 */
public QueryDataScope addFilter(String sqlMapKey, String ctrlTypes, String bizCtrlDataFields, 
			String bizCtrlUserField, String ctrlPermi, String bizScope);

/**
 * 添加到数据范围过滤条件（如果之前sqlMapKey已经存在，则使用OR增加到该条件）
 * 详见：{@link QueryDataScope#addFilter(String, String, String, String, String)}
 */
public QueryDataScope addFilter(String sqlMapKey, String ctrlTypes,
			String bizCtrlDataFields, String ctrlPermi) {
	addFilter(sqlMapKey, ctrlTypes, bizCtrlDataFields, null, ctrlPermi);
	return this;
}

/**
 * 添加到数据范围过滤条件（如果之前sqlMapKey已经存在，则使用OR增加到该条件）
 * 详见：{@link QueryDataScope#addFilter(String, String, String, String, String, String)}
 */
public QueryDataScope addFilter(String sqlMapKey, String ctrlTypes,
			String bizCtrlDataFields, String bizCtrlUserField, String ctrlPermi) {
	addFilter(sqlMapKey, ctrlTypes, bizCtrlDataFields, bizCtrlUserField, ctrlPermi, null);
	return this;
}

/**
 * 添加到数据范围过滤条件（如果之前sqlMapKey已经存在，则使用OR增加到该条件）
 * @param sqlMapKey sqlMap的键值，举例：如设置“dsf”数据范围过滤，则：exists方式对应：sqlMap.dsf
 * @param sqlWhere 具体的Where子句。
 */
public QueryDataScope addFilter(String sqlMapKey, String sqlWhere);

/**
 * 清理数据范围过滤条件
 * @param sqlMapKey 要清理的数据过滤条件
 */
public QueryDataScope clearFilter(String sqlMapKey);

@Transactional(rollbackFor=CustomException.class)

try{ 
	// 出现异常
} catch (Exception e) {
	e.printStackTrace();
	// 抛出异常，使得事务回滚
	throw new RuntimeException(e);
}
// ======== 或者 ========
try{ 
	// 出现异常
} catch (Exception e) {
	e.printStackTrace();
	// 手动通知事务回滚
	TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}

// 设置回滚点：
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
// 回滚到 savePoint 指定位置：
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);

@Autowired
private PlatformTransactionManager platformTransactionManager;
@Autowired
private TransactionDefinition transactionDefinition;
// 编程式事务
public void transTest(Long orderId) {
	// 开启事务
	TransactionStatus transaction = platformTransactionManager.getTransaction(transactionDefinition);
	try {
		
		// 业务处理代码，此处省略...

		// 提交事务
		platformTransactionManager.commit(transaction);
	} catch (Exception e) {
		// 回滚事务
		platformTransactionManager.rollback(transaction);
	}
}

/**
 * 新建实体对象
 * @return
 */
protected T newEntity();

/**
 * 新建实体对象（带一个String构造参数）
 * @return
 */
protected T newEntity(String id);

/**
 * 获取单条数据
 * @param id 主键
 * @return
 */
public T get(String id);

/**
 * 获取单条数据
 * @param entity
 * @return
 */
public T get(T entity);

/**
 * 获取单条数据，如果获取不到，则实例化一个空实体
 * @param id 主键编号
 * @param isNewRecord 如果是新记录，则验证主键编号是否存在。
 * 					     如果存在抛出ValidationException异常。
 * @return
 */
public T get(String id, boolean isNewRecord);

/**
 * 获取单条数据，如果获取不到，则实例化一个空实体（多个主键情况下调用）
 * @param pkClass 主键类型数组
 * @param pkValue 主键数据值数组
 * @param isNewRecord 如果是新记录，则验证主键编号是否存在。
 * 					     如果存在抛出ValidationException异常。
 * @return
 */
public T get(Class<?>[] pkClass, Object[] pkValue, boolean isNewRecord);

/**
 * 列表查询数据
 * @param entity
 * @return
 */
public List<T> findList(T entity);

/**
 * 分页查询数据
 * @param page 分页对象
 * @param entity
 * @return
 */
public Page<T> findPage(Page<T> page, T entity);

/**
 * 查询列表总数
 * @param entity
 * @return
 */
public long findCount(T entity);

/**
 * 保存数据（插入或更新）
 * @param entity
 */
@Transactional(readOnly = false)
public void save(T entity)

/**
 * 插入数据
 * @param entity
 */
@Transactional(readOnly = false)
public void insert(T entity);

/**
 * 更新数据
 * @param entity
 */
@Transactional(readOnly = false)
public void update(T entity);

/**
 * 更新状态（级联更新子节点）
 * @param entity
 */
@Transactional(readOnly = false)
public void updateStatus(T entity);

/**
 * 删除数据
 * @param entity
 */
@Transactional(readOnly = false)
public void delete(T entity);

/**
 * 根据父节点获取子节点最后一条记录
 */
public T getLastByParentCode(T entity);

/**
 * 保存数据（插入或更新）
 * 实现自动保存字段：所有父级编号、所有排序号、是否是叶子节点、节点的层次级别等数据
 * 实现级联更新所有子节点数据：同父级自动保存字段
 */
@Transactional(readOnly = false)
public void save(T entity);

/**
 * 更新parent_codes、tree_sorts、tree_level字段值
 */
@Transactional(readOnly = false, isolation = Isolation.READ_UNCOMMITTED) // 可读取未提交数据
private void updateParentCodes(T entity);

/**
 * 更新当前节点排序号
 */
@Transactional(readOnly = false)
public void updateTreeSort(T entity);

/**
 * 更新tree_leaf字段值
 */
@Transactional(readOnly = false, isolation = Isolation.READ_UNCOMMITTED) // 可读取未提交数据
private void updateTreeLeaf(T entity);

/**
 * 修正本表树结构的所有父级编号
 * 包含：数据修复（parentCodes、treeLeaf、treeLevel）字段
 */
@Transactional(readOnly = false) // 可读取未提交数据
public void updateFixParentCodes();

/**
 * 按父级编码修正树结构的所有父级编号
 * 包含：数据修复（parentCodes、treeLeaf、treeLevel）字段
 */
@Transactional(readOnly = false) // 可读取未提交数据
public void updateFixParentCodes(String parentCode);

/**
 * 预留接口事件，更新子节点
 * @param childEntity 当前操作节点的子节点
 * @param parentEntity 当前操作节点
 */
protected void updateChildNode(T childEntity, T parentEntity);

/**
 * 更新状态（级联更新子节点）
 * @param entity
 */
@Transactional(readOnly = false)
public void updateStatus(T entity);

/**
 * 删除数据（级联删除子节点）
 * @param entity
 */
@Transactional(readOnly = false)
public void delete(T entity);

/**
 * 转换为树结构列表形式[code,childList[code,childList[...]]]<br>
 * 举例如下：<br>
 * 	List<T> sourceList = service.findList(entity);<br>
 * 	List<T> targetList = service.convertTreeList(sourceList, T.ROOT_CODE);<br>
 * @param sourceList 源数据列表
 * @param parentCode 目标数据列表的顶级节点
 * @return targetList 目标数据列表
 */
public List<T> convertTreeList(List<T> sourceList, String parentCode);

@RequestMapping(value = "listData")
public Page<Custom> listData(Custom custom, HttpServletRequest request, HttpServletResponse response){
	custom.setPage(new Page<Custom>(request, response));
	Page<Custom> page = service.findListByCodeAndName(custom);
	return page;
}

public Page<Custom> findPageByCodeAndName(Custom custom){
	Page<Custom> page = (Page<Custom>) custom.getPage();

	// 不执行Count，不查询总数。
	page.setCount(Page.COUNT_NOT_COUNT);

	// 只Count数据，不返回数据，通过 page.getCount()获取
	page.setCount(Page.COUNT_ONLY_COUNT);

	// 不分页，不执行Count，返回全部数据。
	custom.setPage(new Page(1, Page.PAGE_SIZE_NOT_PAGING, Page.COUNT_NOT_COUNT));
	// 或者
	custom.setPage(null);
	
	// 执行查询，获取当前页列表数据和Count数据
	page.setList(dao.findListByCodeAndName(custom));

	// 获取当前页数据
	System.out.println(page.getList());

	// 获取总条数
	System.out.println(page.getCount());
	return page;
}

public List<Custom> findListByCodeAndName(Custom custom);
public Long findListByCodeAndNameCount(Custom custom);

public Custom extends BaseEntity{
	private String code;
	private String name;	
}

Page<Map<String, Object>> pageMap = new Page<>(1, 20); // 该 Page 可以来自 Controller，例如上节所示。
Map<String, Object> params = MapUtils.newHashMap();
params.put("testInput", "123");
params.put("page", pageMap); // 给 Map 设置 page 参数即可自动分页
pageMap.setList(dao.findListForMap(params));
System.out.println(pageMap.getList());	// 获取当前页数据
System.out.println(pageMap.getCount()); // 获取总条数

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

@RequestMapping(value = "listData")
public Page<Custom> listData(Custom custom, HttpServletRequest request, HttpServletResponse response){
	custom.setPage(new Page<Custom>(request, response));
	Page<Custom> page = service.findListByCodeAndName(custom);
	return page;
}

public Page<Custom> findPageByCodeAndName(Custom custom){
	Page<Custom> page = (Page<Custom>) custom.getPage();

	// 执行查询，获取当前页列表数据
	page.setCount(Page.COUNT_NOT_COUNT);
	page.setList(dao.findListByCodeAndName(custom));

	// 获取总条数，并初始化分页对象
	custom.setPage(null);
	page.setCount(dao.findListByCodeAndNameCount(custom));
	page.initialize();

	// 获取当前页数据
	System.out.println(page.getList());

	// 获取总条数
	System.out.println(page.getCount());
	return page;
}

public List<Custom> findListByCodeAndName(Custom custom);
public Long findListByCodeAndNameCount(Custom custom);

public Custom extends BaseEntity{
	private String code;
	private String name;	
}

@Service
@Transactional(readOnly=true)
public class UserServiceImpl extends UserServiceSupport{
	
	public UserServiceImpl() {
		super.setEntityClass(User.class);
	}
	
	/**
	 * 更新个人信息
	 */
	@Override
	@Transactional(readOnly=false)
	public void updateUserInfo(User user){
		String avatarBase64 = user.getAvatarBase64();
		if (StringUtils.isNotBlank(avatarBase64)){
			if ("EMPTY".equals(avatarBase64)){
				user.setAvatar(StringUtils.EMPTY);
			}else{
				String imageUrl = "avatar/"+user.getCorpCode()+"/"
						+user.getUserType()+"/"+user.getUserCode()
						+"."+FileUtils.getFileExtensionByImageBase64(avatarBase64);
				String fileName = Global.getUserfilesBaseDir(imageUrl);
				FileUtils.writeToFileByImageBase64(fileName, avatarBase64);
				user.setAvatar(Global.USERFILES_BASE_URL + imageUrl);
			}
		}
		super.updateUserInfo(user);
	}
	
}

@Service
@Transactional(readOnly=true)
public class RoleServiceImpl extends RoleServiceSupport {

	public RoleServiceImpl() {
		super.setEntityClass(Role.class);
	}

	@Override
	public void addDataScopeFilter(Role entity) {
		// 以下是角色列表过滤条件，覆写该方法可重写过滤条件
		User currentUser = role.getCurrentUser(); // v5.3.0 之前版本
		User currentUser = role.currentUser(); // v5.3.0+ 及之后版本
		SqlMap sqlMap = role.getSqlMap(); // v5.3.0 之前版本
		SqlMap sqlMap = role.sqlMap(); // v5.3.0+ 及之后版本
		sqlMap.getWhere().disableAutoAddCorpCodeWhere();
		sqlMap.getDataScope().addFilter("dsf", "Role", "a.role_code", ctrlPermi);
		sqlMap.getDataScope().addFilter("dsf", "a.is_sys = '"+Global.YES
					+"' OR a.create_by = '"+currentUser.getUserCode()+"'");
		if (currentUser.isAdmin()){
			sqlMap.getDataScope().addFilter("dsf", "a.is_sys = '"+Global.NO
					+"' AND a.corp_code = '"+ CorpUtils.getCurrentCorpCode()+"'");
		}
	}

	@Override
	public List<Role> findList(Role role) {
		return super.findList(role);
	}
	
}