1. Repository持久层
Spring Data 建议定义接口完成SQL语句的操作，该接口可以直接作为Repository组件使用。当使用repository模式时，既能体现业务逻辑组件封装repository组件的门面模式，也可以分离业务逻辑组件和repository组件的功能：业务逻辑组件负责业务逻辑的变化，而repository组件负责持久化的技术变化，这正是桥接模式的应用。
引入repository模式后，每个repository组件包含了数据库的访问逻辑，每个repository组件可对一个数据库表完成基本的CRUD操作。
在spring data 当中，基本的增删改查已经在父类JpaRepository 中完成，自定义接口中只需通过@Query 注解完成个性化查询即可。
1.1 DeptRepository
public interface DeptRepository extends JpaRepository<Dept, Long> {
@Query("select new Map(p.id, p.name) from Dept t")
public List<HashMap<String, Object>> findDepts();
}1.2 JobRepository
public interface JobRepository extends JpaRepository<Job, Long> {
@Query("select new Map(j.id , j.code, j.name) from Job j")
public List<Map<String, Object>> findJobs();
}1.3 ModuleRepository
public interface ModuleRepository extends JpaRepository<Module, Long>, JpaSpecificationExecutor<Module> {
@Modifying
@Query("delete Module m where m.code like ?1")
public void setCode(String code) ;
@Query("select m from Module m where m.code like :parentCode and length(m.code) = :sonCodeLen")
public List<Module> findModules(@Param("parentCode")String parentCode, @Param("sonCodeLen")int sonCodeLen);
@Query("select Max(m.code) from Module m where m.code like :parentCode and length(m.code) = :sonCodeLen ")
public String findUniqueEntity(@Param("parentCode")String parentCode, @Param("sonCodeLen")int sonCodeLen);
}1.4 PopedomRepository
public interface PopedomRepository extends JpaRepository<Popedom, Long> {
@Query("select p.opera.code from Popedom p where p.role.id = :id and p.module.code = :parentCode")
public List<String> findByIdAndParentCode(@Param("id")long id, @Param("parentCode")String parentCode);
@Modifying
@Query("delete Popedom p where p.role.id = :id and p.module.code = :parentCode")
public void setByIdAndParentCode(@Param("id")long id, @Param("parentCode")String parentCode);
@Query("select distinct p.module.code from Popedom p where "
+ "p.role.id in(select r.id from Role r "
+ "inner join r.users u where u.id = ?1 ) "
+ "order by p.module.code asc")
public List<String> getUserPopedomModuleCodes(long id);
@Query("select distinct p.opera.code from Popedom p "
+ "where p.role.id in(select r.id from Role r "
+ "inner join r.users u where u.id = ?1 ) order by p.opera.code asc")
public List<String> getUserPopedomOperasCodes(long id);
}1.5 RoleRepository
public interface RoleRepository extends JpaRepository<Role, Long>, JpaSpecificationExecutor<Role> {
}1.6 UserRepository
public interface UserRepository extends JpaRepository<User, Long>, JpaSpecificationExecutor<User> {
@Query("select u.id from User u where u.id not in(select u.id from User u inner join u.roles r where r.id = ?1)")
List<String> getRolesUsers(long id);
@Query("select u.id from User u inner join u.roles r where r.id = ?1")
List<String> findRoleUsers(long id);
}2JSP页面分页功能
2.1 分页实体
package org.oa.common.util.page;
public class PageModel {
/** 分页中默认一个5条数据 */
public static final int PAGE_DEFAULT_SIZE = 5;
/** 分页总数据条数 */
private long recordCount;
/** 当前页面 */
private int pageIndex;
/** 每页分多少条数据 */
private int pageSize = PAGE_DEFAULT_SIZE;
/** 总页数 */
private int totalSize;
public long getRecordCount() {
this.recordCount = this.recordCount <= 0 ? 0 : this.recordCount;
return recordCount;
}
public void setRecordCount(long recordCount) {
this.recordCount = recordCount;
}
public int getPageIndex() {
this.pageIndex = this.pageIndex <= 0 ? 1 : this.pageIndex;
/** 判断当前页面是否超过了总页数:如果超过了默认给最后一页作为当前页 */
return pageIndex;
}
public void setPageIndex(int pageIndex) {
this.pageIndex = pageIndex;
}
public int getPageSize() {
this.pageSize = this.pageSize <= PAGE_DEFAULT_SIZE ? PAGE_DEFAULT_SIZE : this.pageSize;
return pageSize;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public int getTotalSize() {
if (this.getRecordCount() <= 0) {
totalSize = 0;
} else {
totalSize = (int) ((this.getRecordCount() - 1) / this.getPageSize() + 1);
}
return totalSize;
}
public int getFirstLimitParam() {
return (this.getPageIndex() - 1) * this.getPageSize();
}
}2.2 自定义标签库
package org.oa.common.util.page;
import java.io.IOException;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;
public class PagerTag extends SimpleTagSupport {
/** 定义请求URL中的占位符常量 */
private static final String TAG = "{0}";
/** 当前页码 */
private int pageIndex;
/** 每页显示的数量 */
private int pageSize;
/** 总记录条数 */
private int recordCount;
/** 请求URL page.action?pageIndex={0} */
private String submitUrl;
/** 定义总页数 */
private int totalPage = 0;
/** 在页面上引用自定义标签就会触发一个标签处理类 */
@Override
public void doTag() throws JspException, IOException {
/** 定义它拼接是终的结果 */
StringBuilder res = new StringBuilder();
res.append("<center>\n" + "\t\t<p style=\"text-align: center;\">\n" + "\t\t\t<!-- 设计导航-->\n"
+ "\t\t\t<nav class=\"nav form-inline\">\n" + "\t\t\t\t <ul class=\"pagination alin\">");
/** 定义它拼接中间的页码 */
StringBuilder str = new StringBuilder();
/** 判断总记录条数 */
if (recordCount > 0) { // 1499 / 15 = 100
/** 需要显示分页标签，计算出总页数 需要分多少页 */
totalPage = (this.recordCount - 1) / this.pageSize + 1;
/** 判断上一页或下一页需不需要加a标签 */
if (this.pageIndex == 1) { // 首页
str.append("<li class=\"disabled\" ><a href=\"#\">上一页</a></li>");
/** 计算中间的页码 */
this.calcPage(str);
/** 下一页需不需要a标签 */
if (this.pageIndex == totalPage) {
/** 只有一页 */
str.append("<li class=\"disabled\" ><a href=\"#\">下一页</a></li>");
} else {
String tempUrl = this.submitUrl.replace(TAG, String.valueOf(pageIndex + 1));
str.append("<li><a href='" + tempUrl + "'>下一页</a></li>");
}
} else if (this.pageIndex == totalPage) { // 尾页
String tempUrl = this.submitUrl.replace(TAG, String.valueOf(pageIndex - 1));
str.append("<li><a href='" + tempUrl + "'>上一页</a></li>");
/** 计算中间的页码 */
this.calcPage(str);
str.append("<li class=\"disabled\" ><a href=\"#\">下一页</a></li>");
} else { // 中间
String tempUrl = this.submitUrl.replace(TAG, String.valueOf(pageIndex - 1));
str.append("<li><a href='" + tempUrl + "'>上一页</a></li>");
/** 计算中间的页码 */
this.calcPage(str);
tempUrl = this.submitUrl.replace(TAG, String.valueOf(pageIndex + 1));
str.append("<li><a href='" + tempUrl + "'>下一页</a></li>");
}
res.append(str);
/** 开始条数 */
int startNum = (this.pageIndex - 1) * this.pageSize + 1;
/** 结束条数 */
int endNum = (this.pageIndex == this.totalPage) ? this.recordCount : this.pageIndex * this.pageSize;
res.append("<li><a style=\"background-color:#D4D4D4;\" href=\"#\">共<font color='red'>" + this.recordCount
+ "</font>条记录,当前显示" + startNum + "-" + endNum + "条记录</a> </li>");
res.append("<div class=\"input-group\">\n"
+ "\t\t\t\t\t\t\t\t\t <input id='pager_jump_page_size' value='" + this.pageIndex
+ "' type=\"text\" style=\"width: 60px;text-align: center;\" class=\"form-control\" placeholder=\""
+ this.pageIndex + "\"\">\n" + "\t\t\t\t\t\t\t\t\t <span class=\"input-group-btn\">\n"
+ "\t\t\t\t\t\t\t\t\t <button class=\"btn btn-info\" id='pager_jump_btn' type=\"button\">GO</button>\n"
+ "\t\t\t\t\t\t\t\t\t </span>\n" + "\t\t\t\t\t \t\t\t\t </div>");
res.append("<script type='text/javascript'>");
res.append(" document.getElementById('pager_jump_btn').onclick = function(){");
res.append(" var page_size = document.getElementById('pager_jump_page_size').value;");
res.append(" if (!/^[1-9]\d*$/.test(page_size) || page_size < 1 || page_size > " + this.totalPage
+ "){");
res.append(" alert('请输入[1-" + this.totalPage + "]之间的页码！');");
res.append(" }else{");
res.append(" var submit_url = '" + this.submitUrl + "';");
res.append(" window.location = submit_url.replace('" + TAG + "', page_size);");
res.append(" }");
res.append("}");
res.append("</script>");
} else {
res.append(
"<li><a style=\"background-color:#D4D4D4;\" href=\"#\">总共<font color='red'>0</font>条记录,当前显示0-0条记录。</a> </li>");
}
res.append("</ul></nav></p></center>");
this.getJspContext().getOut().print(res.toString());
}
/** 计算中间页码的方法 */
private void calcPage(StringBuilder str) {
/** 判断总页数 */
if (this.totalPage <= 11) {
/** 一次性显示全部的页码 */
for (int i = 1; i <= this.totalPage; i++) {
if (this.pageIndex == i) {
/** 当前页码 */
str.append("<li class=\"active\" ><a href=\"#\">" + i + "</a></li>");
} else {
String tempUrl = this.submitUrl.replace(TAG, String.valueOf(i));
str.append("<li><a href='" + tempUrl + "'>" + i + "</a></li>");
}
}
} else {
/** 靠首页近些 */
if (this.pageIndex <= 8) {
for (int i = 1; i <= 10; i++) {
if (this.pageIndex == i) {
/** 当前页码 */
str.append("<li class=\"active\" ><a href=\"#\">" + i + "</a></li>");
} else {
String tempUrl = this.submitUrl.replace(TAG, String.valueOf(i));
str.append("<li><a href='" + tempUrl + "'>" + i + "</a></li>");
}
}
str.append("<li><a href=\"#\">...</a></li>");
String tempUrl = this.submitUrl.replace(TAG, String.valueOf(this.totalPage));
str.append("<li><a href='" + tempUrl + "'>" + this.totalPage + "</a></li>");
}
/** 靠尾页近些 */
else if (this.pageIndex + 8 >= this.totalPage) {
String tempUrl = this.submitUrl.replace(TAG, String.valueOf(1));
str.append("<li><a href='" + tempUrl + "'>1</a></li>");
str.append("<li><a href=\"#\">...</a></li>");
for (int i = this.totalPage - 10; i <= this.totalPage; i++) {
if (this.pageIndex == i) {
/** 当前页码 */
str.append("<li class=\"active\" ><a href=\"#\">" + i + "</a></li>");
} else {
tempUrl = this.submitUrl.replace(TAG, String.valueOf(i));
str.append("<li><a href='" + tempUrl + "'>" + i + "</a></li>");
}
}
}
/** 在中间 */
else {
String tempUrl = this.submitUrl.replace(TAG, String.valueOf(1));
str.append("<li><a href='" + tempUrl + "'>1</a></li>");
str.append("<li><a href=\"#\">...</a></li>");
for (int i = this.pageIndex - 4; i <= this.pageIndex + 4; i++) {
if (this.pageIndex == i) {
/** 当前页码 */
str.append("<li class=\"active\" ><a href=\"#\">" + i + "</a></li>");
} else {
tempUrl = this.submitUrl.replace(TAG, String.valueOf(i));
str.append("<li><a href='" + tempUrl + "'>" + i + "</a></li>");
}
}
str.append("<li><a href=\"#\">...</a></li>");
tempUrl = this.submitUrl.replace(TAG, String.valueOf(this.totalPage));
str.append("<li><a href='" + tempUrl + "'>" + this.totalPage + "</a></li>");
}
}
}
/** setter method */
public void setPageIndex(int pageIndex) {
this.pageIndex = pageIndex;
}
public void setPageSize(int pageSize) {
this.pageSize = pageSize;
}
public void setRecordCount(int recordCount) {
this.recordCount = recordCount;
}
public void setSubmitUrl(String submitUrl) {
this.submitUrl = submitUrl;
}
}2.3 tld标签文件
<?xml version="1.0" encoding="utf-8"?>
<taglib xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
version="2.1">
<!-- 描述 自定义标签版本的一种描述 -->
<description>Page 1.0 core library</description>
<!-- 显示的名称 导包进行的一个展示 -->
<display-name>Page core</display-name>
<!-- 版本号 -->
<tlib-version>1.0</tlib-version>
<!-- 短名 -->
<short-name>page</short-name>
<!-- uri ：导包 -->
<uri>/page-tags</uri>
<!-- 定义一个标签 -->
<tag>
<!-- 标签名 -->
<name>page</name>
<!-- 标签处理类 -->
<tag-class>org.oa.common.util.page.PagerTag</tag-class>
<!-- 设置标签为空 -->
<body-content>empty</body-content>
<!-- 定义标签的属性 -->
<attribute>
<!-- 属性名 表示分页的第几页 -->
<name>pageIndex</name>
<!-- 必须的 -->
<required>true</required>
<!-- run time expression value 为true支持EL表达式 -->
<rtexprvalue>true</rtexprvalue>
</attribute>
<!-- 定义标签的属性 -->
<attribute>
<!-- 属性名 表示分页标签 ，每页显示多少条数据 -->
<name>pageSize</name>
<!-- 必须的 -->
<required>true</required>
<!-- run time expression value 为true支持EL表达式 -->
<rtexprvalue>true</rtexprvalue>
</attribute>
<!-- 定义标签的属性 -->
<attribute>
<!-- 属性名 记录分页的总数 -->
<name>recordCount</name>
<!-- 必须的 -->
<required>true</required>
<!-- run time expression value 为true支持EL表达式 -->
<rtexprvalue>true</rtexprvalue>
</attribute>
<!-- 定义标签的属性 -->
<attribute>
<!-- 属性名 -->
<name>submitUrl</name>
<!-- 必须的 -->
<required>true</required>
<!-- run time expression value 为true支持EL表达式 -->
<rtexprvalue>true</rtexprvalue>
</attribute>
<!-- 定义标签的属性 -->
<attribute>
<!-- 属性名 -->
<name>style</name>
<!-- 必须的 -->
<required>false</required>
<!-- run time expression value 为true支持EL表达式 -->
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
</taglib>3. 业务层接口及其实现类
SysService:
package org.oa.sys.service;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpSession;
import org.common.util.page.PageModel;
import org.oa.sys.domain.Dept;
import org.oa.sys.domain.Module;
import org.oa.sys.domain.Role;
import org.oa.sys.domain.User;
import org.oa.sys.dto.UserModule;
import org.oa.sys.vo.TreeData;
public interface SysService {
/**
* @return 查询所有的部门
*/
List<Dept> getAllDepts();
/**
* 异步登录的业务层接口方法
* @param params
* @return
*/
Map<String, Object> login(Map<String, Object> params);
/**
* 根据用户的主键查询用户信息,包含了延迟加载的部门和职位信息
* @param userId
* @return
*/
User getUserById(Long id);
/**
* 修改自己
* @param user
*/
void updateSelf(User user, HttpSession session);
/**
* @return 异步加载部门与职位的json字符串信息写回到页面
*/
Map<String, Object> getAllDeptsAndJobsAjax();
/**
* 分页查询用户信息
*
* @param user
* @param pageModel
* @return
*/
List<User> getUsersByPage(User user, PageModel pageModel);
/**
* 批量删除用户
* @param ids
*/
void deleteUserByUserIds(String ids);
/**
* 校验用户是否已经被注册
* @param userId
* @return
*/
String isUserValidAjax(Long id);
/**
*
* @param user
*/
void addUser(User user);
/**
* 根据userId修改用户信息
* @param user
*/
void updateUser(User user);
/**
* 激活用户
* @param user
*/
void activeUser(User user);
/**
* 加载所有的模块树
* @return
*/
List<TreeData> loadAllModuleTrees();
/**
* 根据父节点查询所有的子模块
* @param parentCode
* @return
*/
List<Module> getModulesByParent(String parentCode, PageModel pageModel);
/**
* 根据父节点查询所有的子模块
* 不分页
* @param parentCode
* @return
*/
List<Module> getModulesByParent(String parentCode);
/**
* 批量删除菜单
* @param ids
*/
void deleteModules(String ids);
/**
* 为当前父节点菜单添加子节点模块
* @param parentCode
* @param module
*/
void addModule(String parentCode, Module module);
/**
* 根据编号查询模块信息
* @param code
* @return
*/
Module getModuleByCode(String code);
/**
* 修改模块
* @param module
*/
void updateModule(Module module);
/**
* 分页查询角色信息
* @param pageModel
* @return
*/
List<Role> getRoleByPage(PageModel pageModel);
/**
* 添加角色
* @param role
*/
void addRole(Role role);
/**
* 批量删除角色
* @param ids
*/
void deleteRole(String ids);
/**
* 根据id查询角色
* @param id
* @return
*/
Role getRoleById(Long id);
/**
* 修改角色
* @param role
*/
void updateRole(Role role);
/**
* 分页查询属于这个角色下的用户信息
* @param role
* @param pageModel
* @return
*/
List<User> selectRoleUser(Role role, PageModel pageModel);
/**
* 查询不属于某个角色下的用户
* @param role
* @param pageModel
* @return
*/
List<User> selectNotRoleUser(Role role, PageModel pageModel);
/**
* 给用户绑定角色
* @param role
* @param ids
*/
void bindUser(Role role, String ids);
/**
* 给用户解绑角色
* @param role
* @param ids
*/
void unBindUser(Role role, String ids);
/**
* 查询当前角色在当前模块下拥有的操作权限编号。
* @param role
* @param parentCode
* @return
*/
List<String> getRoleModuleOperasCodes(Role role, String parentCode);
/**
* 给角色绑定某个模块下的操作权限
* @param codes
* @param role
* @param parentCode
*/
void bindPopedom(String codes, Role role, String parentCode);
/**
* 查询当前用户的权限模块
* @return
*/
List<UserModule> getUserPopedomModules();
}实现类：
package org.oa.sys.service.impl;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.JoinType;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.servlet.http.HttpSession;
import org.common.service.BaseService;
import org.common.util.CommonContants;
import org.common.util.page.PageModel;
import org.oa.sys.domain.Dept;
import org.oa.sys.domain.Module;
import org.oa.sys.domain.Popedom;
import org.oa.sys.domain.Role;
import org.oa.sys.domain.User;
import org.oa.sys.dto.UserModule;
import org.oa.sys.repository.DeptRepository;
import org.oa.sys.repository.JobRepository;
import org.oa.sys.repository.ModuleRepository;
import org.oa.sys.repository.PopedomRepository;
import org.oa.sys.repository.RoleRepository;
import org.oa.sys.repository.UserRepository;
import org.oa.sys.service.SysService;
import org.oa.sys.vo.TreeData;
import org.oa.util.OaContants;
import org.oa.util.OaException;
import org.oa.util.UserHolder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
@Service
@Transactional
public class SysServiceImpl extends BaseService implements SysService {
@Autowired
private DeptRepository deptRepository;
@Autowired
private JobRepository jobRepository;
@Autowired
private UserRepository userRepository;
@Autowired
private ModuleRepository moduleRepository;
@Autowired
private RoleRepository roleRepository;
@Autowired
private PopedomRepository popedomRepository;
@Transactional(readOnly = true)
@Override
public List<Dept> getAllDepts() {
try {
List<Dept> depts = deptRepository.findAll();
// 取延迟加载的属性 ,会话此时并没有关闭
for (Dept dept : depts) {
if (dept.getCreater() != null)
dept.getCreater().getName();
if (dept.getModifier() != null)
dept.getModifier().getName();
}
return depts;
} catch (Exception e) {
throw new OaException("查询部门失败了", e);
}
}
@Override
public Map<String, Object> login(Map<String, Object> params) {
Map<String, Object> result = new HashMap<>();
try {
/** 处理登录的业务逻辑 */
/** 1.参数非空校验 */
Long id = (Long) params.get("id");
String passWord = (String) params.get("passWord");
String vcode = (String) params.get("vcode");
HttpSession session = (HttpSession) params.get("session");
// userId!=null&&!userId.equals("")
if (id == null || StringUtils.isEmpty(passWord) || StringUtils.isEmpty(vcode)) {
/** 参数有为空的 */
result.put("status", 0);
result.put("tip", "参数有为空的");
} else {
/** 参数不为空 */
/** 校验验证码是否正确
* 获取session中当前用户对应的验证码
* */
String sysCode = (String) session.getAttribute(CommonContants.VERIFY_SESSION);
if (vcode.equalsIgnoreCase(sysCode)) {
/** 验证码正确了 */
/** 根据登录的用户名去查询用户: 判断登录名是否存在 */
User user = getUserById(id);
if (user != null) {
/** 登录名存在 */
/** 判断密码 */
if (user.getPassword().equals(passWord)) {
/** 判断用户是否已经被激活了 */
if (user.getStatus() == 1) {
/** 登录成功 */
/** 1.把登录成功的用户放入当前用户的session会话中 */
session.setAttribute(OaContants.USER_SESSION, user);
System.out.println("设置用户 ---------------->：" + user);
result.put("status", 1);
result.put("tip", "登录成功");
/** 把登录成功的用户存入到UserHolder*/
UserHolder.addCurrentUser(user);
/** 2.当用户一登录进入系统的时候,就应该立即去查询该用户所拥有
的全部操作权限 --> 存入到当前用户的Session会话中 */
Map<String, List<String>> userAllOperasPopedomUrls = getUserAllOperasPopedomUrls();
session.setAttribute(OaContants.USER_ALL_OPERAS_POPEDOM_URLS, userAllOperasPopedomUrls);
} else {
result.put("status", 5);
result.put("tip", "您的账号未被激活,请联系管理员激活!");
}
} else {
/** 密码错误 */
result.put("status", 2);
result.put("tip", "密码错误了");
}
} else {
/** 登录名不存在 */
result.put("status", 3);
result.put("tip", "没有该账户");
}
} else {
/** 验证码不正确 */
result.put("status", 4);
result.put("tip", "验证码不正确");
}
}
return result;
} catch (Exception e) {
throw new OaException("异步登录业务层抛出异常了", e);
}
}
private Map<String, List<String>> getUserAllOperasPopedomUrls() {
try {
/** 查询用户所拥有的所有操作权限编号
* */
List<String> userAllPopedomOperasCodes = popedomRepository
.getUserPopedomOperasCodes(UserHolder.getCurrentUser().getId());
if (userAllPopedomOperasCodes != null && userAllPopedomOperasCodes.size() > 0) {
Map<String, List<String>> userAllOperasPopedomUrls = new HashMap<>();
String moduleUrl = "";
List<String> moduleOperaUrls = null;
for (String operaCode : userAllPopedomOperasCodes) {
/** 先得到模块的编号 */
String parentModuleCode = operaCode.substring(0, operaCode.length() - OaContants.CODE_LEN);
/** 父模块地址 */
moduleUrl = getModuleByCode(parentModuleCode).getUrl();
/** 判断map集合中是否已经存在该父模块地址 */
if (!userAllOperasPopedomUrls.containsKey(moduleUrl)) {
moduleOperaUrls = new ArrayList<String>();
userAllOperasPopedomUrls.put(moduleUrl, moduleOperaUrls);
}
moduleOperaUrls.add(getModuleByCode(operaCode).getUrl());
}
return userAllOperasPopedomUrls;
}
return null;
} catch (Exception e) {
throw new OaException("登录查询用户的操作权限出现异常", e);
}
}
public User getUserById(Long id) {
try {
User user = userRepository.findById(id).get();
if (user != null) {
// 获取延迟加载的属性
if (user.getDept() != null)
user.getDept().getName();
if (user.getJob() != null)
user.getJob().getName();
if (user.getCreater() != null)
user.getCreater().getName();
if (user.getModifier() != null)
user.getModifier().getName();
if (user.getChecker() != null)
user.getChecker().getName();
return user;
}
return null;
} catch (Exception e) {
throw new OaException("查询用户失败了", e);
}
}
@Transactional
@Override
public void updateSelf(User user, HttpSession session) {
try {
/** 1.持久化修改 */
User sessionUser = userRepository.findById(user.getId()).get();
sessionUser.setModifier(user);
sessionUser.setName(user.getName());
// get一下就可以加载延迟加载的属性
if (sessionUser.getDept() != null)
sessionUser.getDept().getName();
if (sessionUser.getJob() != null)
sessionUser.getJob().getName();
session.setAttribute(OaContants.USER_SESSION, sessionUser);
} catch (Exception e) {
throw new OaException("修改用户失败了", e);
}
}
@Override
public Map<String, Object> getAllDeptsAndJobsAjax() {
try {
/** 1.定义一个Map对象封装最终查询出来的部门信息和职位信息 */
Map<String, Object> deptJobDatas = new HashMap<>();
/** 查询部门 ： id name */
List<HashMap<String, Object>> deptsList = deptRepository.findDepts();
/** 查询部门 ： id name */
List<Map<String, Object>> jobLists = jobRepository.findJobs();
deptJobDatas.put("depts", deptsList);
deptJobDatas.put("jobs", jobLists);
return deptJobDatas;
} catch (Exception e) {
throw new OaException("查 询部门与职位信息异常了", e);
}
}
@SuppressWarnings("serial")
@Override
public List<User> getUsersByPage(User user, PageModel pageModel) {
try {
Page<User> usersPager = userRepository.findAll(new Specification<User>() {
@Override
public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
// 本集合用于封装查询条件
List<Predicate> predicates = new ArrayList<Predicate>();
if (user != null) {
/** 是否传入了姓名来查询 */
if (!StringUtils.isEmpty(user.getName())) {
predicates.add(cb.like(root.<String> get("name"), "%" + user.getName() + "%"));
}
/** 是否传入手机号码了来查询 */
if (!StringUtils.isEmpty(user.getMobile())) {
predicates.add(cb.like(root.<String> get("mobile"), "%" + user.getMobile() + "%"));
}
/** 是否传入部门来查询 */
if (user.getDept() != null && user.getDept().getId() != null && user.getDept().getId() != 0) {
root.join("dept", JoinType.INNER);
Path<Long> d_id = root.get("dept").get("id");
predicates.add(cb.equal(d_id, user.getDept().getId()));
}
if (user.getJob() != null && !StringUtils.isEmpty(user.getJob().getCode())
&& !user.getJob().getCode().equals("0")) {
root.join("job", JoinType.INNER);
Path<String> j_id = root.get("job").get("code");
predicates.add(cb.equal(j_id, user.getJob().getCode()));
}
}
return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
}
}, PageRequest.of(pageModel.getPageIndex() - 1, pageModel.getPageSize()));
pageModel.setRecordCount(usersPager.getTotalElements());
/** 取每个用户的延迟加载属性 */
List<User> users = usersPager.getContent();
for (User u : users) {
if (u.getDept() != null)
u.getDept().getName();
if (u.getJob() != null)
u.getJob().getName();
if (u.getChecker() != null)
u.getChecker().getName();
}
return users;
} catch (Exception e) {
throw new OaException("查询用户信息异常了", e);
}
}
@Transactional
@Override
public void deleteUserByUserIds(String ids) {
try {
List<User> users = new ArrayList<User>();
for (String id : ids.split(",")) {
User user = new User();
user.setId(Long.parseLong(id));
users.add(user);
}
userRepository.deleteInBatch(users);
} catch (Exception e) {
throw new OaException("删除用户信息异常了", e);
}
}
@Override
public String isUserValidAjax(Long id) {
try {
User user = userRepository.findById(id).get();
return user == null ? "success" : "error";
} catch (Exception e) {
throw new OaException("校验用户登录名是否注册异常了", e);
}
}
@Transactional
@Override
public void addUser(User user) {
try {
user.setCreater(UserHolder.getCurrentUser());
userRepository.save(user);
} catch (Exception e) {
throw new OaException("添加用户信息异常了", e);
}
}
@Transactional
@Override
public void updateUser(User user) {
try {
/** 1.持久化修改 */
User sessionUser = userRepository.findById(user.getId()).get();
sessionUser.setModifyDate(new Date());
sessionUser.setModifier(UserHolder.getCurrentUser());
sessionUser.setPassword(user.getPassword());
sessionUser.setName(user.getName());
sessionUser.setDept(user.getDept());
sessionUser.setJob(user.getJob());
sessionUser.setSex(user.getSex());
} catch (Exception e) {
throw new OaException("修改用户失败了", e);
}
}
@Transactional
@Override
public void activeUser(User user) {
try {
User sessionUser = userRepository.findById(user.getId()).get();
sessionUser.setCheckDate(new Date());
sessionUser.setChecker(UserHolder.getCurrentUser());
sessionUser.setStatus(user.getStatus());
} catch (Exception e) {
throw new OaException("激活用户失败了", e);
}
}
@Override
public List<TreeData> loadAllModuleTrees() {
try {
/** 查询所有的模块信息 */
List<Module> modules = moduleRepository.findAll();
/** 拼装成dtree需要的树节点 */
List<TreeData> treeDatas = new ArrayList<>();
for (Module m : modules) {
TreeData data = new TreeData();
data.setId(m.getCode());
data.setName(m.getName());
// 长度为4的编号的父节点是0
// 其余节点的父节点是从开始位置一直截取到总长度减去步长的位置。 00010001的父节点是0001
String pid = m.getCode().length() == OaContants.CODE_LEN ? "0"
: m.getCode().substring(0, m.getCode().length() - OaContants.CODE_LEN);
data.setPid(pid);
treeDatas.add(data);
}
return treeDatas;
} catch (Exception e) {
throw new OaException("加载模块树异常", e);
}
}
@SuppressWarnings("serial")
@Override
public List<Module> getModulesByParent(String parentCode, PageModel pageModel) {
try {
parentCode = parentCode == null ? "" : parentCode;
List<Object> values = new ArrayList<>();
values.add(parentCode + "%");
values.add(parentCode.length() + OaContants.CODE_LEN);
// // 子节点的编号的长度是父节点编号长度+步长
// // 子节点前几位的编号必须与父节点编码一致
Page<Module> modulesPager = moduleRepository.findAll(new Specification<Module>() {
@Override
public Predicate toPredicate(Root<Module> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
// 本集合用于封装查询条件
List<Predicate> predicates = new ArrayList<Predicate>();
predicates.add(cb.like(root.<String> get("code"), values.get(0) + ""));
predicates.add(cb.equal(cb.length(root.<String> get("code")), values.get(1)));
return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
}
}, PageRequest.of(pageModel.getPageIndex() - 1, pageModel.getPageSize()));
pageModel.setRecordCount(modulesPager.getTotalElements());
/** 取每个用户的延迟加载属性 */
List<Module> sonModules = modulesPager.getContent();
for (Module m : sonModules) {
if (m.getCreater() != null)
m.getCreater().getName();
if (m.getModifier() != null)
m.getModifier().getName();
}
return sonModules;
} catch (Exception e) {
throw new OaException("查询子模块异常", e);
}
}
@Override
public List<Module> getModulesByParent(String parentCode) {
try {
parentCode = parentCode == null ? "" : parentCode;
List<Module> sonModules = moduleRepository.findModules(parentCode + "%",
parentCode.length() + OaContants.CODE_LEN);
for (Module m : sonModules) {
if (m.getCreater() != null)
m.getCreater().getName();
if (m.getModifier() != null)
m.getModifier().getName();
}
return sonModules;
} catch (Exception e) {
throw new OaException("查询子模块异常", e);
}
}
@Transactional
@Override
public void deleteModules(String ids) {
try {
for (String id : ids.split(",")) {
moduleRepository.deleteById(Long.valueOf(id));
}
} catch (Exception e) {
throw new OaException("批量删除菜单异常", e);
}
}
@Transactional
@Override
public void addModule(String parentCode, Module module) {
try {
/** 维护编号:通用工具类(给你一个父节点,给你一张表,给你那个字段,
* 找出该字段该父节点下的下一个儿子节点的编号 ) */
module.setCode(getNextSonCode(parentCode, OaContants.CODE_LEN));
module.setCreater(UserHolder.getCurrentUser());
moduleRepository.save(module);
} catch (Exception e) {
throw new OaException("添加子菜单异常", e);
}
}
public String getNextSonCode(String parentCode, int codeLen) throws Exception {
/** 判断父节点是否为null */
parentCode = parentCode == null ? "" : parentCode;
/** 1.查询出当前父节点下的最大儿子节点编号 */
String maxSonCode = moduleRepository.findUniqueEntity(parentCode + "%", parentCode.length() + codeLen);
String nextSonCode = ""; // 保存最终的下一个儿子节点编号
/** 4.判断最大儿子节点编号是否存在 ,因为极有可能父节点此时一个子节点都没有 */
if (StringUtils.isEmpty(maxSonCode)) {
/** 儿子节点编号不存在 */
String preSuffix = ""; // 0 需要拼接多少个0
for (int i = 0; i < codeLen - 1; i++) {
preSuffix += "0";
}
nextSonCode = parentCode + preSuffix + 1;
} else {
/** 儿子节点编号存在 */
/** 截取出当前儿子节点编号的步长出来 */
String currentMaxSonCode = maxSonCode.substring(parentCode.length());
/** 得到儿子节点步长编号的整形形式 */
int maxSonCodeInt = Integer.valueOf(currentMaxSonCode);
maxSonCodeInt++;
/** 判断编号是否越界了 */
if ((maxSonCodeInt + "").length() > codeLen) {
throw new OaException("编号越界了！");
} else {
/** 没有越界 */
String preSuffix = ""; // 0 需要拼接多少个0
for (int i = 0; i < codeLen - (maxSonCodeInt + "").length(); i++) {
preSuffix += "0";
}
nextSonCode = parentCode + preSuffix + maxSonCodeInt;
}
}
return nextSonCode;
}
@Override
public Module getModuleByCode(String code) {
try {
return moduleRepository.findByCode(code);
} catch (Exception e) {
throw new OaException("查询模块异常", e);
}
}
@Transactional
@Override
public void updateModule(Module module) {
try {
Module sessionModule = moduleRepository.findById(module.getId()).get();
sessionModule.setModifier(UserHolder.getCurrentUser());
sessionModule.setName(module.getName());
sessionModule.setRemark(module.getRemark());
sessionModule.setUrl(module.getUrl());
} catch (Exception e) {
throw new OaException("修改模块异常", e);
}
}
@Override
public List<Role> getRoleByPage(PageModel pageModel) {
try {
// 指定排序参数对象：根据id，进行降序查询
Sort sort = new Sort(Sort.Direction.ASC, "id");
/**
* 封装分页实体
* 参数一：pageIndex表示当前查询的第几页(默认从0开始，0表示第一页)
* 参数二：表示每页展示多少数据，现在设置每页展示2条数据
* 参数三：封装排序对象，根据该对象的参数指定根据id降序查询
*/
Pageable page = PageRequest.of(pageModel.getPageIndex() - 1, pageModel.getPageSize(), sort);
Page<Role> rolePager = roleRepository.findAll(page);
pageModel.setRecordCount(rolePager.getTotalElements());
/** 取每个用户的延迟加载属性 */
List<Role> roles = rolePager.getContent();
for (Role r : roles) {
if (r.getModifier() != null)
r.getModifier().getName();
if (r.getCreater() != null)
r.getCreater().getName();
}
return roles;
} catch (Exception e) {
throw new OaException("查询角色异常", e);
}
}
@Transactional
@Override
public void addRole(Role role) {
try {
role.setCreateDate(new Date());
role.setCreater(UserHolder.getCurrentUser());
roleRepository.save(role);
} catch (Exception e) {
throw new OaException("添加角色异常", e);
}
}
@Transactional
@Override
public void deleteRole(String ids) {
try {
List<Role> roles = new ArrayList<Role>();
for (String id : ids.split(",")) {
Role role = new Role();
role.setId(Long.valueOf(id));
}
roleRepository.deleteInBatch(roles);
} catch (Exception e) {
throw new OaException("批量删除角色异常", e);
}
}
@Override
public Role getRoleById(Long id) {
try {
return roleRepository.findById(id).get();
} catch (Exception e) {
throw new OaException("根据id查询角色异常", e);
}
}
@Transactional
@Override
public void updateRole(Role role) {
try {
Role r = roleRepository.findById(role.getId()).get();
r.setName(role.getName());
r.setRemark(role.getRemark());
r.setModifier(UserHolder.getCurrentUser());
} catch (Exception e) {
throw new OaException("根据id修改角色异常", e);
}
}
@SuppressWarnings("serial")
@Override
public List<User> selectRoleUser(Role role, PageModel pageModel) {
try {
Page<User> usersPager = userRepository.findAll(new Specification<User>() {
@Override
public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
// 本集合用于封装查询条件
List<Predicate> predicates = new ArrayList<>();
List<String> userIds = userRepository.findRoleUsers(role.getId());
predicates.add(root.<String> get("userId").in(userIds));
return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
}
}, PageRequest.of(pageModel.getPageIndex() - 1, pageModel.getPageSize()));
pageModel.setRecordCount(usersPager.getTotalElements());
List<User> users = usersPager.getContent();
for (User u : users) {
if (u.getDept() != null)
u.getDept().getName();
if (u.getJob() != null)
u.getJob().getName();
if (u.getChecker() != null)
u.getChecker().getName();
}
return users;
} catch (Exception e) {
throw new OaException("查询属于角色下的用户信息异常", e);
}
}
@SuppressWarnings("serial")
@Override
public List<User> selectNotRoleUser(Role role, PageModel pageModel) {
try {
Page<User> usersPager = userRepository.findAll(new Specification<User>() {
@Override
public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
// 本集合用于封装查询条件
List<Predicate> predicates = new ArrayList<Predicate>();
// 先查询出不属于这个角色下的用户
List<String> userId = userRepository.getRolesUsers(role.getId());
predicates.add(root.<String> get("userId").in(userId));
return query.where(predicates.toArray(new Predicate[predicates.size()])).getRestriction();
}
}, PageRequest.of(pageModel.getPageIndex() - 1, pageModel.getPageSize()));
pageModel.setRecordCount(usersPager.getTotalElements());
List<User> users = usersPager.getContent();
for (User u : users) {
if (u.getDept() != null)
u.getDept().getName();
if (u.getJob() != null)
u.getJob().getName();
if (u.getChecker() != null)
u.getChecker().getName();
}
return users;
} catch (Exception e) {
throw new OaException("查询不属于角色下的用户信息异常", e);
}
}
@Transactional
@Override
public void bindUser(Role role, String ids) {
try {
/** 给角色绑定一批用户 */
/** 1.先查询出该角色 */
Role session = roleRepository.findById(role.getId()).get();
/** 2.给角色的users添加需要绑定的用户 */
for (String id : ids.split(",")) {
User user = userRepository.findById(Long.valueOf(id)).get();
session.getUsers().add(user);
}
} catch (Exception e) {
throw new OaException("绑定角色下的用户异常", e);
}
}
@Transactional
@Override
public void unBindUser(Role role, String ids) {
try {
/** 给角色绑定一批用户 */
/** 1.先查询出该角色 */
Role session = roleRepository.findById(role.getId()).get();
/** 2.给角色的users添加需要绑定的用户 */
for (String id : ids.split(",")) {
User user = userRepository.findById(Long.valueOf(id)).get();
session.getUsers().remove(user);
}
} catch (Exception e) {
throw new OaException("绑定角色下的用户异常", e);
}
}
@Override
public List<String> getRoleModuleOperasCodes(Role role, String parentCode) {
try {
List<String> roleModuleOperasCodes = popedomRepository.findByIdAndParentCode(role.getId(), parentCode);
return roleModuleOperasCodes;
} catch (Exception e) {
throw new OaException("查询当前角色在当前模块下拥有的操作权限编号异常", e);
}
}
@Transactional
@Override
public void bindPopedom(String codes, Role role, String parentCode) {
try {
/** 1.先清空此角色在此模块下的所有操作权限 */
popedomRepository.setByIdAndParentCode(role.getId(), parentCode);
/** 2.更新新的角色模块权限 */
if (!StringUtils.isEmpty(codes)) {
Module parent = getModuleByCode(parentCode);
/** 添加一些更新的权限 */
for (String code : codes.split(",")) {
/** 创建一个权限对象 */
Popedom popedom = new Popedom();
popedom.setRole(role);
popedom.setModule(parent);
popedom.setOpera(getModuleByCode(code));
popedom.setCreateDate(new Date());
popedom.setCreater(UserHolder.getCurrentUser());
popedomRepository.save(popedom);
}
}
} catch (Exception e) {
throw new OaException("给角色绑定某个模块的操作权限异常", e);
}
}
@Override
public List<UserModule> getUserPopedomModules() {
try {
/**查询当前用户的权限模块 ：先查用户所有的角色,再查这些角色拥有的所有权限模块 */
List<String> popedomModuleCodes = popedomRepository
.getUserPopedomModuleCodes(UserHolder.getCurrentUser().getId());
if (popedomModuleCodes != null && popedomModuleCodes.size() > 0) {
/** 定义一个Map集合用于保存用户的权限模块
* Map<Module,List<Module>>
* {系统管理=[用户管理,角色管理] , 假期模块=[查询信息,用户请假]}
* */
Map<Module, List<Module>> userModulesMap = new LinkedHashMap<>();
Module fistModule = null;
List<Module> secondModules = null;
for (String moduleCode : popedomModuleCodes) {
/** 截取当前模块的一级模块编号 */
String fistCode = moduleCode.substring(0, OaContants.CODE_LEN);
/** 查询出一级模块对象 */
fistModule = getModuleByCode(fistCode);
fistModule.setName(fistModule.getName().replaceAll("-", ""));
/**如果map集合中没有包含当前一级模块的key,说明是第一次添加一级模块 */
if (!userModulesMap.containsKey(fistModule)) {
secondModules = new ArrayList<Module>();
userModulesMap.put(fistModule, secondModules);
}
Module secondModule = getModuleByCode(moduleCode);
secondModule.setName(secondModule.getName().replaceAll("-", ""));
secondModules.add(secondModule);
}
List<UserModule> userModules = new ArrayList<>();
for (Entry<Module, List<Module>> entry : userModulesMap.entrySet()) {
Module key = entry.getKey();
List<Module> value = entry.getValue();
UserModule userModule = new UserModule();
userModule.setFirstModule(key);
userModule.setSecondModules(value);
userModules.add(userModule);
}
return userModules;
}
return null;
} catch (Exception e) {
throw new OaException("查询当前用户的权限模块", e);
}
}
}4. Web层
4.1 LoginController 登录
package org.my.oa.sys.controller;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpSession;
import org.my.oa.sys.service.SysService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class LoginController {
/** 1.定义业务层对象 */
@Autowired
private SysService sysService;
@ResponseBody // 异步请求的响应结果
@RequestMapping(value = "/loginAjax", produces = "application/json; charset=UTF-8")
public Map<String, Object> login(@RequestParam("mobile") String mobile, @RequestParam("password") String password,
@RequestParam("vcode") String vcode, HttpSession session) {
try {
Map<String, Object> params = new HashMap<>();
params.put("mobile", mobile);
params.put("password", password);
params.put("vcode", vcode);
params.put("session", session);
// 响应数据啊,写回去数据
Map<String, Object> result = sysService.login(params);
return result;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}4.2 RequestController 登录跳转
package org.my.oa.sys.controller;
import java.util.List;
import org.my.oa.sys.dto.UserModule;
import org.my.oa.sys.service.SysService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
@RequestMapping("/oa")
public class RequestController {
/** 1.定义业务层对象 */
@Autowired
private SysService sysService;
@RequestMapping(value="/login")
public String requestLogin(){
return "login";
}
@RequestMapping(value="/main")
public String requestMain(Model model){
try {
//查询出当前用户拥有的所有模块权限
List<UserModule> userModules = sysService.getUserPopedomModules();
model.addAttribute("userPopedomModules", userModules);
} catch (Exception e) {
e.printStackTrace();
}
return "main";
}
@RequestMapping(value="/home")
public String requestHome(){
return "home";
}
}简单列举这两个控制层，业务逻辑层里面的实现已经很详细了，JSP页面不再展示。