devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

分享一个基于easyui前端框架开发的后台管理系统模板_easyui框架

作者：知新_RL | 2024-08-21 10:50:48

赞

踩

easyui框架

这是博主自己在使用的一套easyui前端框架的后台管理系统模版，包含了后端的Java代码，已经实现了菜单控制、权限控制功能，可以直接拿来使用。

基于jquery easyui前端框架实现的管理系统项目icon-default.png?t=N7T8https://gitee.com/muyu-chengfeng/easyui-admin.git

目录

功能介绍

一、菜单管理

菜单列表

角色-菜单列表

二、权限管理

权限列表

角色-权限列表

三、用户管理

用户列表

用户-角色列表

四、歌曲管理

歌曲列表

五、系统功能

系统设置

初始化权限

代码介绍

响应状态码

响应实体类

全局异常处理类

统一响应数据处理类

分页查询结果对象

用户信息工具类

表格过滤实体类

分页实体对象

排序实体对象

功能介绍

这是对本系统的一些简单的功能介绍。

一、菜单管理

菜单列表

点击表格头部工具栏的【添加】按钮，会添加一条模板数据

  1. /**
  2.  * 添加
  3.  */
  4. function insert() {
  5. 	requestUrl = "/menu/insert";
  6.  
  7. 	ajaxPost(requestUrl, {
  8. 		type: 1,
  9. 		name: "xxx",
  10. 		url: "/html/xxx_list.html",
  11. 		icon: "icon-script"
  12. 	}, function (response) {
  13. 		showMsg(response.message);
  14.  
  15. 		$("#menu_list").datagrid("reload");
  16. 	}, error);
  17. }

修改功能是基于easyui的表格行内编辑完成的，鼠标选择一行数据，点击头部工具栏的【修改】按钮，会开启该行的编辑。

点击保存会向后台控制器提交修改后的数据，点击取消则只会取消行内编辑。

通过给表格添加结束编辑事件，当表格行结束编辑，也就是调用了endEdit方法时触发事件，会把data修改为修改后的行数据。

  1. let data = {};
  2.  
  3. /**
  4.  * 保存
  5.  */
  6. function save() {
  7. 	if (editingId != null) {
  8. 		let datagrid = $("#menu_list");
  9.  
  10. 		// 只有结束编辑才能获取到最新的值
  11. 		datagrid.datagrid("endEdit", editingId);
  12.  
  13. 		ajaxPost(requestUrl, data, function () {
  14. 			editingId = null;
  15.  
  16. 			datagrid.datagrid("reload");
  17. 		}, error);
  18. 	}
  19. }
  20.  
  21. $(document).ready(function() {    
  22.     $("#menu_list").datagrid({
  23. 		url: "/menu/selectByPage",
  24. 		method: "get",
  25. 		height: 680,
  26. 		fitColumns: true,
  27. 		pagination: true,
  28. 		onAfterEdit: function (index, row, changes) {
  29. 			data = {
  30. 				id: row.id,
  31. 				type: row.type,
  32. 				parentId: row.parentId,
  33. 				url: changes.url ? changes.url : row.url,
  34. 				name: changes.name ? changes.name : row.name,
  35. 				icon: changes.icon ? changes.icon : row.icon
  36. 			};
  37. 		},
  38.         .....
  39.     };
  40.  
  41. };

删除功能比较简单，就不介绍了~

角色-菜单列表

就是对角色的菜单进行管理，目前只是基于父级菜单实现，只需要给角色添加对应的父类菜单即可让该角色获得该菜单下的所有子菜单的权限。

二、权限管理

权限列表

对系统资源权限（也就是控制器接口权限）进行管理

父级权限的编号格式为为服务名_控制器名，子级权限的编号为服务名_控制器名_方法名。

权限初始化功能：一键自动完成权限的初始化功能，会先删除原来的权限，然后扫描控制器类的包，获取所有控制器接口信息，并保存到数据库。

涉及的后端代码

  1.     @Override
  2.     public void resources() throws ClassNotFoundException {
  3.         // 删除原来的权限
  4.         permissionMapper.delete(null);
  5.  
  6.         // 扫描路径
  7.         String basePackage = "cn.edu.sgu.www.controller";
  8.         // 获取扫描结果
  9.         List<Permission> permissions = resourceScanner.scan(basePackage);
  10.  
  11.         for (Permission permission : permissions) {
  12.             permissionMapper.insert(permission);
  13.         }
  14.     }

扫描工具类的代码

  1. package cn.edu.sgu.www.util;
  2.  
  3. import cn.edu.sgu.www.EasyuiCrud;
  4. import cn.edu.sgu.www.annotation.AnonymityAccess;
  5. import cn.edu.sgu.www.entity.Permission;
  6. import cn.edu.sgu.www.enums.RequestMethod;
  7. import io.swagger.annotations.Api;
  8. import io.swagger.annotations.ApiOperation;
  9. import org.springframework.beans.factory.annotation.Value;
  10. import org.springframework.stereotype.Component;
  11. import org.springframework.web.bind.annotation.GetMapping;
  12. import org.springframework.web.bind.annotation.PostMapping;
  13. import org.springframework.web.bind.annotation.RequestMapping;
  14.  
  15. import java.io.File;
  16. import java.lang.reflect.Method;
  17. import java.util.ArrayList;
  18. import java.util.List;
  19.  
  20. /**
  21.  * 接口资源扫描工具类
  22.  * @author heyunlin
  23.  * @version 1.0
  24.  */
  25. @Component
  26. public class ResourceScanner {
  27.  
  28.     /**
  29.      * 服务名
  30.      */
  31.     @Value("${spring.application.name}")
  32.     private String SERVICE_NAME;
  33.  
  34.     private static List<String> classPaths = new ArrayList<>();
  35.     private static final List<Permission> resources = new ArrayList<>();
  36.  
  37.     /**
  38.      * 扫描controller包下的目录，生成权限
  39.      * @param basePackage controller包
  40.      * @return List<Permission>
  41.      * @throws ClassNotFoundException 类找不到时抛出异常
  42.      */
  43.     public List<Permission> scan(String basePackage) throws ClassNotFoundException {
  44.         // 删除掉上一次的数据
  45.         if (!resources.isEmpty()) {
  46.             resources.clear();
  47.         }
  48.         if (!classPaths.isEmpty()) {
  49.             classPaths.clear();
  50.         }
  51.  
  52.         String classpath = EasyuiCrud.class.getResource("/").getPath();
  53.         String searchPath = classpath + basePackage.replace(".", "/");
  54.  
  55.         classpath = classpath.replaceFirst("/", "");
  56.         classPaths = getClassPaths(new File(searchPath));
  57.  
  58.         for(String classPath : classPaths) {
  59.             // 得到类的全限定名
  60.             classPath = classPath.replace(classpath.replace("/", "\\")
  61.                     .replaceFirst("\\\\", ""), "")
  62.                     .replace("\\", ".")
  63.                     .replace(".class", "");
  64.             classpath = classPath.substring(classPath.indexOf(basePackage));
  65.  
  66.             // 通过反射获取类的信息
  67.             Class<?> cls = Class.forName(classpath);
  68.  
  69.             // 获取标注在类上的@RequestMapping注解
  70.             RequestMapping requestMapping = cls.getAnnotation(RequestMapping.class);
  71.  
  72.             // 构建父权限
  73.             Permission parent = new Permission();
  74.             // 控制器类上的路径
  75.             String prefix = "";
  76.  
  77.             if(requestMapping != null) {
  78.                 // path或者value
  79.                 prefix = requestMapping.value().length > 0 ? requestMapping.value()[0] : requestMapping.path()[0];
  80.  
  81.                 parent.setType(0);
  82.                 parent.setUrl(prefix);
  83.                 parent.setId(SERVICE_NAME + "_" + cls.getSimpleName());
  84.  
  85.                 // 设置name
  86.                 if (cls.isAnnotationPresent(Api.class)) {
  87.                     Api api = cls.getAnnotation(Api.class);
  88.  
  89.                     if (api != null) {
  90.                         // 类的接口文档@Api注解的tags属性值
  91.                         String name = api.tags()[0];
  92.  
  93.                         parent.setName(name);
  94.                     }
  95.                 }
  96.  
  97.                 resources.add(parent);
  98.             }
  99.  
  100.             Method[] methods = cls.getDeclaredMethods();
  101.  
  102.             for (Method method : methods) {
  103.                 getClassAnnotation(method, prefix, cls.getSimpleName(), parent.getId());
  104.             }
  105.         }
  106.  
  107.         return resources;
  108.     }
  109.  
  110.     /**
  111.      * 得到类上面的注解信息
  112.      * @param method Method
  113.      * @param prefix String 控制器类上@RequestMapping注解指定的路径
  114.      * @param controllerName 控制器名称
  115.      * @param parentId String 父级权限ID
  116.      */
  117.     public void getClassAnnotation(Method method, String prefix, String controllerName, String parentId) {
  118.         // 构建子权限
  119.         Permission permission = new Permission();
  120.         String url = null;
  121.  
  122.         // 获取url
  123.         if (method.isAnnotationPresent(RequestMapping.class)) {
  124.             RequestMapping requestMapping = method.getAnnotation(RequestMapping.class);
  125.             url = prefix + (requestMapping.value().length > 0 ? requestMapping.value()[0] : requestMapping.path()[0]);
  126.             String requestMethod = requestMapping.method().length > 0 ? requestMapping.method()[0].name() : "get";
  127.  
  128.             permission.setMethod(RequestMethod.getValueByName(requestMethod));
  129.         } else if (method.isAnnotationPresent(GetMapping.class)) {
  130.             GetMapping getMapping = method.getAnnotation(GetMapping.class);
  131.             url = prefix + getMapping.value()[0];
  132.  
  133.             permission.setMethod(RequestMethod.GET.getValue());
  134.         } else if (method.isAnnotationPresent(PostMapping.class)) {
  135.             PostMapping postMapping = method.getAnnotation(PostMapping.class);
  136.             url = prefix + postMapping.value()[0];
  137.  
  138.             permission.setMethod(RequestMethod.POST.getValue());
  139.         }
  140.  
  141.         // 处理URL
  142.         if(url != null && url.endsWith("/")) {
  143.             url = url.substring(0, url.length() - 1);
  144.         }
  145.         permission.setUrl(url);
  146.  
  147.         // 设置value
  148.         if (method.isAnnotationPresent(ApiOperation.class)) {
  149.             ApiOperation operation = method.getAnnotation(ApiOperation.class);
  150.  
  151.             if (operation != null) {
  152.                 String name = operation.value();
  153.  
  154.                 permission.setName(name);
  155.             }
  156.         }
  157.         // 默认值0
  158.         permission.setAnonymity(0);
  159.  
  160.         if (method.isAnnotationPresent(AnonymityAccess.class)) {
  161.             AnonymityAccess annotation = method.getAnnotation(AnonymityAccess.class);
  162.  
  163.             if (annotation != null) {
  164.                 permission.setAnonymity(annotation.value() ? 1 : 0);
  165.             }
  166.         }
  167.  
  168.         permission.setType(1);
  169.         permission.setParentId(parentId);
  170.         permission.setId(SERVICE_NAME + "_" + controllerName + "_" + method.getName());
  171.  
  172.         resources.add(permission);
  173.     }
  174.  
  175.     private List<String> getClassPaths(File path) {
  176.         if (path.isDirectory()) {
  177.             File[] files = path.listFiles();
  178.  
  179.             if (files != null) {
  180.                 for (File file : files) {
  181.                     getClassPaths(file);
  182.                 }
  183.             }
  184.         } else {
  185.             if (path.getName().endsWith(".class")) {
  186.                 classPaths.add(path.getPath());
  187.             }
  188.         }
  189.  
  190.         return classPaths;
  191.     }
  192.  
  193. }

角色-权限列表

角色权限的维护，包括简单的增删改和基于easyui树实现的授权功能，以及超管账户的权限初始化功能。

授权功能：通过简单的复选框勾选/取消勾选来给角色分配权限

权限初始化功能：其实非常简单，就是查询所有的资源权限，然后分配给超管用户。

  1.     @Override
  2.     public void init(String userId) {
  3.         // 删除用当前户所有角色的权限
  4.         rolePermissionMapper.deleteByUserId(userId);
  5.  
  6.         // 查询全部子权限
  7.         List<Permission> list = permissionMapper.selectByType(PermissionType.ZQX.getValue());
  8.  
  9.         list.forEach(permission -> {
  10.             RolePermission rolePermission = new RolePermission();
  11.  
  12.             rolePermission.setId(null);
  13.             rolePermission.setRoleId(1);
  14.             rolePermission.setPermissionId(permission.getId());
  15.  
  16.             rolePermissionMapper.insert(rolePermission);
  17.         });
  18.     }

三、用户管理

因为这个部分的功能很简单，只有简单的crud，不做过多介绍。

用户列表

用户-角色列表

四、歌曲管理

歌曲列表

歌曲的维护、歌单导入/导出功能。

五、系统功能

系统设置

鼠标移动到右上方的下拉菜单，点击【系统设置】打开系统设置窗口。

修改密码功能

 对密码进行加密存储

  1.     @Override
  2. 	public void updatePassword(UserPassUpdateDTO userPassUpdateDTO) {
  3. 		// 用户名
  4. 		String username = userPassUpdateDTO.getUsername();
  5. 		// 旧密码
  6. 		String oldPass = userPassUpdateDTO.getOldPass();
  7. 		// 新密码
  8. 		String password = userPassUpdateDTO.getPassword();
  9.  
  10. 		// 验证两次输入的密码是否相等
  11. 		if (password.equals(userPassUpdateDTO.getRePass())) {
  12. 			// 查询用户信息
  13. 			String encodedPassword = selectByUsername(username).getPassword();
  14.  
  15. 			// 验证输入的旧密码是否正确
  16. 			if (PasswordEncoder.matches(oldPass, encodedPassword)) {
  17. 				UpdateWrapper<User> wrapper = new UpdateWrapper<>();
  18.  
  19. 				wrapper.eq("username", username);
  20. 				wrapper.set("password", PasswordEncoder.encode(password));
  21.  
  22. 				userMapper.update(wrapper.getEntity(), wrapper);
  23. 			} else {
  24. 				throw new GlobalException(ResponseCode.FORBIDDEN, "输入的密码不正确");
  25. 			}
  26. 		} else {
  27. 			throw new GlobalException(ResponseCode.FORBIDDEN, "两次输入的密码不一样");
  28. 		}
  29. 	}

菜单控制功能：就是控制左侧菜单的显示，勾选/取消勾选对应的菜单，然后点击窗口右下角的【确定】按钮提交修改。

初始化权限

这个按钮的功能和权限列表的【初始化】按钮是一样的。

代码介绍

前面已经对这个系统做了一些简单的介绍，接下来介绍一下博主经过多次实践产出的一部分公共的Java代码，可以直接使用。

响应状态码

在枚举中自定义了几种响应状态码

  1. package cn.edu.sgu.www.restful;
  2.  
  3. /**
  4.  * 响应状态码
  5.  * @author heyunlin
  6.  * @version 1.0
  7.  */
  8. public enum ResponseCode {
  9.  
  10.     /**
  11.      * 请求成功
  12.      */
  13.     OK(200),
  14.     /**
  15.      * 失败的请求
  16.      */
  17.     BAD_REQUEST(400),
  18.     /**
  19.      * 未授权
  20.      */
  21.     UNAUTHORIZED(401),
  22.     /**
  23.      * 禁止访问
  24.      */
  25.     FORBIDDEN(403),
  26.     /**
  27.      * 找不到
  28.      */
  29.     NOT_FOUND(404),
  30.     /**
  31.      * 不可访问
  32.      */
  33.     NOT_ACCEPTABLE(406),
  34.     /**
  35.      * 冲突
  36.      */
  37.     CONFLICT(409),
  38.     /**
  39.      * 服务器发生异常
  40.      */
  41.     ERROR(500);
  42.  
  43.     private final Integer value;
  44.  
  45.     ResponseCode(Integer value) {
  46.         this.value = value;
  47.     }
  48.  
  49.     public Integer getValue() {
  50.         return value;
  51.     }
  52.  
  53. }

响应实体类

包含提示信息、响应数据和响应状态码的web响应实体类。

  1. package cn.edu.sgu.www.restful;
  2.  
  3. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
  4. import lombok.Data;
  5.  
  6. import java.io.Serializable;
  7.  
  8. /**
  9.  * 响应实体类
  10.  * @param <T>
  11.  * @author heyunlin
  12.  * @version 1.0
  13.  */
  14. @Data
  15. public class JsonResult<T> implements Serializable {
  16.     private static final long serialVersionUID = 18L;
  17.  
  18.     /**
  19.      * 响应数据
  20.      */
  21.     private T data;
  22.  
  23.     /**
  24.      * 响应状态码
  25.      */
  26.     private Integer code;
  27.  
  28.     /**
  29.      * 响应提示信息
  30.      */
  31.     private String message;
  32.  
  33.     /**
  34.      * 成功提示
  35.      */
  36.     private static final String successMessage = "请求成功";
  37.  
  38.     public static JsonResult<Void> success() {
  39.         return success(successMessage);
  40.     }
  41.  
  42.     public static JsonResult<Void> success(String message) {
  43.         return success(message, null);
  44.     }
  45.  
  46.     public static <T> JsonResult<T> success(String message, T data) {
  47.         JsonResult<T> jsonResult = new JsonResult<>();
  48.  
  49.         jsonResult.setCode(ResponseCode.OK.getValue());
  50.         jsonResult.setMessage(message);
  51.         jsonResult.setData(data);
  52.  
  53.         return jsonResult;
  54.     }
  55.  
  56.     public static JsonResult<Void> error(String message) {
  57.         JsonResult<Void> jsonResult = new JsonResult<>();
  58.  
  59.         jsonResult.setCode(ResponseCode.ERROR.getValue());
  60.         jsonResult.setMessage(message);
  61.  
  62.         return jsonResult;
  63.     }
  64.  
  65.     public static JsonResult<Void> error(ResponseCode responseCode, Throwable e) {
  66.         return error(responseCode, e.getMessage() != null ? e.getMessage() : "系统发生异常，请联系管理员！");
  67.     }
  68.  
  69.     public static JsonResult<Void> error(ResponseCode responseCode, String message) {
  70.         JsonResult<Void> jsonResult = new JsonResult<>();
  71.  
  72.         jsonResult.setCode(responseCode.getValue());
  73.         jsonResult.setMessage(message);
  74.  
  75.         return jsonResult;
  76.     }
  77.  
  78.     public static <T> JsonResult<JsonPage<T>> restPage(Page<T> page) {
  79.         JsonPage<T> jsonPage = JsonPage.restPage(page);
  80.  
  81.         return success(successMessage, jsonPage);
  82.     }
  83.  
  84. }

全局异常处理类

  1. package cn.edu.sgu.www.restful.handler;
  2.  
  3. import cn.edu.sgu.www.exception.GlobalException;
  4. import cn.edu.sgu.www.restful.JsonResult;
  5. import cn.edu.sgu.www.restful.ResponseCode;
  6. import cn.edu.sgu.www.util.UserUtils;
  7. import org.springframework.http.HttpStatus;
  8. import org.springframework.validation.BindException;
  9. import org.springframework.validation.BindingResult;
  10. import org.springframework.validation.FieldError;
  11. import org.springframework.web.bind.annotation.ExceptionHandler;
  12. import org.springframework.web.bind.annotation.ResponseStatus;
  13. import org.springframework.web.bind.annotation.RestControllerAdvice;
  14.  
  15. import javax.servlet.http.HttpServletResponse;
  16. import java.util.Objects;
  17.  
  18. /**
  19.  * 全局异常处理类
  20.  * @author heyunlin
  21.  * @version 1.0
  22.  */
  23. @RestControllerAdvice
  24. public class GlobalExceptionHandler {
  25.  
  26.     /**
  27.      * 处理GlobalException
  28.      * @param e GlobalException
  29.      * @return JsonResult<Void>
  30.      */
  31.     @ExceptionHandler
  32.     public JsonResult<Void> handleGlobalException(GlobalException e) {
  33.         printMessage(e);
  34.  
  35.         HttpServletResponse response = UserUtils.getResponse();
  36.         response.setStatus(e.getResponseCode().getValue());
  37.  
  38.         return JsonResult.error(e.getResponseCode(), e);
  39.     }
  40.  
  41.     /**
  42.      * 处理BindException
  43.      * @param e BindException
  44.      * @return JsonResult<Void>
  45.      */
  46.     @ExceptionHandler
  47.     @ResponseStatus(HttpStatus.BAD_REQUEST)
  48.     public JsonResult<Void> handleBindException(BindException e) {
  49.         printMessage(e);
  50.  
  51.         BindingResult bindingResult = e.getBindingResult();
  52.         FieldError fieldError = bindingResult.getFieldError();
  53.         String defaultMessage = Objects.requireNonNull(fieldError).getDefaultMessage();
  54.  
  55.         return JsonResult.error(ResponseCode.BAD_REQUEST, defaultMessage);
  56.     }
  57.  
  58.     /**
  59.      * 处理Exception
  60.      * @param e Exception
  61.      * @return JsonResult<Void>
  62.      */
  63.     @ExceptionHandler
  64.     @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
  65.     public JsonResult<Void> handleException(Exception e) {
  66.         printMessage(e);
  67.  
  68.         return JsonResult.error(ResponseCode.ERROR, e);
  69.     }
  70.  
  71.     private void printMessage(Exception e) {
  72.         e.printStackTrace();
  73.     }
  74.  
  75. }

统一响应数据处理类

这个类需要注意的是，knife4j的接口路径不能被处理，否则接口文档的页面内容不能正常显示。

  1. # 配置统一数据格式返回处理类忽略的路径
  2. response:
  3.   ignore:
  4.     - /error
  5.     - /v2/api-docs
  6.     - /swagger-resources
  1. package cn.edu.sgu.www.restful.handler;
  2.  
  3. import cn.edu.sgu.www.config.property.ResponseProperties;
  4. import cn.edu.sgu.www.restful.JsonResult;
  5. import cn.edu.sgu.www.util.UserUtils;
  6. import com.alibaba.fastjson.JSON;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.core.MethodParameter;
  10. import org.springframework.http.MediaType;
  11. import org.springframework.http.server.ServerHttpRequest;
  12. import org.springframework.http.server.ServerHttpResponse;
  13. import org.springframework.web.bind.annotation.RestControllerAdvice;
  14. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
  15.  
  16. import java.util.List;
  17.  
  18. /**
  19.  * 统一数据格式返回处理类
  20.  * @author heyunlin
  21.  * @version 1.0
  22.  */
  23. @Slf4j
  24. @RestControllerAdvice
  25. public class GlobalResponseHandler implements ResponseBodyAdvice {
  26.  
  27.     private final List<String> ignore;
  28.  
  29.     @Autowired
  30.     public GlobalResponseHandler(ResponseProperties responseProperties) {
  31.         ignore = responseProperties.getIgnore();
  32.     }
  33.  
  34.     @Override
  35.     public boolean supports(MethodParameter parameter, Class type) {
  36.         return true;
  37.     }
  38.  
  39.     @Override
  40.     public Object beforeBodyWrite(Object body, MethodParameter parameter, MediaType mediaType, Class type
  41.             , ServerHttpRequest request, ServerHttpResponse response) {
  42.         // 返回值类型为JsonResult，则直接返回
  43.         if (body instanceof JsonResult) {
  44.             return body;
  45.         }
  46.  
  47.         // 忽略的请求地址
  48.         String requestURI = UserUtils.getRequest().getRequestURI();
  49.  
  50.         if (ignore.contains(requestURI)) {
  51.             return body;
  52.         }
  53.  
  54.         log.debug("接口{}的返回值为：{}", requestURI, body.toString());
  55.  
  56.         // 将返回值类型修改为JsonResult
  57.         JsonResult<Object> jsonResult = JsonResult.success(null, body);
  58.  
  59.         if (body instanceof String) {
  60.             return JSON.toJSONString(jsonResult);
  61.         }
  62.  
  63.         return jsonResult;
  64.     }
  65.  
  66. }

分页查询结果对象

基于easyui的datagrid组件要求返回的数据格式，封装成的对象。

  1. package cn.edu.sgu.www.restful;
  2.  
  3. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
  4. import lombok.Data;
  5.  
  6. import java.io.Serializable;
  7. import java.util.List;
  8.  
  9. /**
  10.  * easyui datagrid数据格式对象
  11.  * @param <T>
  12.  * @author heyunlin
  13.  * @version 1.0
  14.  */
  15. @Data
  16. public class JsonPage<T> implements Serializable {
  17.     private static final long serialVersionUID = 18L;
  18.  
  19.     /**
  20.      * 总记录数
  21.      */
  22.     private Long total;
  23.  
  24.     /**
  25.      * 查询结果
  26.      */
  27.     private List<T> rows;
  28.  
  29.     /**
  30.      * 页脚数据
  31.      */
  32.     private T footer;
  33.  
  34.     public static <T> JsonPage<T> restPage(Page<T> page) {
  35.         JsonPage<T> jsonPage = new JsonPage<>();
  36.  
  37.         jsonPage.setTotal(page.getTotal());
  38.         jsonPage.setRows(page.getRecords());
  39.  
  40.         return jsonPage;
  41.     }
  42.  
  43. }

用户信息工具类

基于shiro的获取用户登录信息的工具类

  1. package cn.edu.sgu.www.util;
  2.  
  3. import cn.edu.sgu.www.entity.User;
  4. import cn.edu.sgu.www.exception.GlobalException;
  5. import cn.edu.sgu.www.restful.ResponseCode;
  6. import org.apache.shiro.SecurityUtils;
  7. import org.apache.shiro.subject.Subject;
  8. import org.springframework.web.context.request.RequestAttributes;
  9. import org.springframework.web.context.request.RequestContextHolder;
  10. import org.springframework.web.context.request.ServletRequestAttributes;
  11.  
  12. import javax.servlet.http.HttpServletRequest;
  13. import javax.servlet.http.HttpServletResponse;
  14.  
  15. /**
  16.  * 获取用户信息的工具类
  17.  * @author heyunlin
  18.  * @version 1.0
  19.  */
  20. public class UserUtils {
  21.  
  22.     /**
  23.      * 得到Subject对象
  24.      * @return Subject
  25.      */
  26.     public static Subject getSubject() {
  27.         return SecurityUtils.getSubject();
  28.     }
  29.  
  30.     /**
  31.      * 获取登录的用户信息
  32.      * @return User
  33.      */
  34.     public static User getUserInfo() {
  35.         Object object =  getSubject().getPrincipal();
  36.  
  37.         if (object == null) {
  38.             throw new GlobalException(ResponseCode.BAD_REQUEST, "获取登录信息失败，当前没有用户登录。");
  39.         }
  40.  
  41.         return (User) object;
  42.     }
  43.  
  44.     /**
  45.      * 获取登录用户的ID
  46.      * @return String
  47.      */
  48.     public static String getUserId() {
  49.         return getUserInfo().getId();
  50.     }
  51.  
  52.     /**
  53.      * 获取登录的用户名
  54.      * @return String
  55.      */
  56.     public static String getLoginUsername() {
  57.         return getUserInfo().getUsername();
  58.     }
  59.  
  60.     public static HttpServletRequest getRequest() {
  61.         RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
  62.  
  63.         if (attributes != null ) {
  64.             return ((ServletRequestAttributes) attributes).getRequest();
  65.         }
  66.  
  67.         throw new GlobalException(ResponseCode.ERROR, "获取request对象失败");
  68.     }
  69.  
  70.     public static HttpServletResponse getResponse() {
  71.         RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
  72.  
  73.         if (attributes != null ) {
  74.             return ((ServletRequestAttributes) attributes).getResponse();
  75.         }
  76.  
  77.         throw new GlobalException(ResponseCode.ERROR, "获取response对象失败");
  78.     }
  79.  
  80. }

表格过滤实体类

  1. package cn.edu.sgu.www.base;
  2.  
  3. import lombok.Data;
  4.  
  5. import java.io.Serializable;
  6.  
  7. /**
  8.  * 过滤规则
  9.  * @author heyunlin
  10.  * @version 1.0
  11.  */
  12. @Data
  13. public class FilterRule implements Serializable {
  14.     private static final long serialVersionUID = 18L;
  15.  
  16.     /**
  17.      * 字段名
  18.      */
  19.     private String field;
  20.  
  21.     /**
  22.      * 比较符
  23.      */
  24.     private Operator op;
  25.  
  26.     /**
  27.      * 字段值
  28.      */
  29.     private String value;
  30. }
  1. package cn.edu.sgu.www.base;
  2.  
  3. /**
  4.  * 比较符
  5.  * @author heyunlin
  6.  * @version 1.0
  7.  */
  8. public enum Operator {
  9.     /**
  10.      * 包含
  11.      */
  12.     contains,
  13.     /**
  14.      * 等于
  15.      */
  16.     equal,
  17.     /**
  18.      * 不等于
  19.      */
  20.     notequal,
  21.     /**
  22.      * 以...开始
  23.      */
  24.     beginwith,
  25.     /**
  26.      * 以...结尾
  27.      */
  28.     endwith,
  29.     /**
  30.      * 小于
  31.      */
  32.     less,
  33.     /**
  34.      * 小于或等于
  35.      */
  36.     lessorequal,
  37.     /**
  38.      * 大于
  39.      */
  40.     greater,
  41.     /**
  42.      * 大于或等于
  43.      */
  44.     greaterorequal
  45. }

分页实体对象

提供了分页的功能，需要分页功能的接口的参数类型只需要继承该类即可，将自动获得分页功能。

  1. package cn.edu.sgu.www.base;
  2.  
  3. import cn.edu.sgu.www.util.StringUtils;
  4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  5. import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
  6. import lombok.Data;
  7. import lombok.EqualsAndHashCode;
  8.  
  9. import java.io.Serializable;
  10. import java.util.List;
  11.  
  12. /**
  13.  * 基础分页参数对象，包含页数和每页的记录数
  14.  * @author heyunlin
  15.  * @version 1.0
  16.  */
  17. @EqualsAndHashCode(callSuper = true)
  18. @Data
  19. public class Pager<T> extends Sorter implements Serializable {
  20.     private static final long serialVersionUID = 18L;
  21.  
  22.     /**
  23.      * 页数
  24.      */
  25.     private Integer page = 1;
  26.  
  27.     /**
  28.      * 每页记录数
  29.      */
  30.     private Integer rows = 10;
  31.  
  32.     /**
  33.      * 过滤规则
  34.      */
  35.     private List<FilterRule> filterRules;
  36.  
  37.     /**
  38.      * 根据Pager创建Page对象
  39.      * @param pager Pager
  40.      * @return Page
  41.      */
  42.     public static <T> Page<T> ofPage(Pager<T> pager) {
  43.         return new Page<>(pager.getPage(), pager.getRows());
  44.     }
  45.  
  46.     /**
  47.      * 根据Pager创建QueryWrapper对象
  48.      * @param pager Pager
  49.      * @return QueryWrapper<T>
  50.      */
  51.     public static <T> QueryWrapper<T> getQueryWrapper(Pager<T> pager, boolean enableSort) {
  52.         QueryWrapper<T> wrapper = new QueryWrapper<>();
  53.  
  54.         List<FilterRule> filterRules = pager.getFilterRules();
  55.  
  56.         if (filterRules != null && !filterRules.isEmpty()) {
  57.             for (FilterRule filterRule : filterRules) {
  58.                 // 字段名：转为小写字母+下划线的格式
  59.                 String field = StringUtils.toLower(filterRule.getField());
  60.                 // 字段值
  61.                 String value = filterRule.getValue();
  62.  
  63.                 if (StringUtils.isNotEmpty(value)) {
  64.                     switch (filterRule.getOp()) {
  65.                         case less:
  66.                             wrapper.lt(field, value);
  67.                             break;
  68.                         case equal:
  69.                             wrapper.eq(field, value);
  70.                             break;
  71.                         case greater:
  72.                             wrapper.gt(field, value);
  73.                             break;
  74.                         case notequal:
  75.                             wrapper.ne(field, value);
  76.                             break;
  77.                         case lessorequal:
  78.                             wrapper.le(field, value);
  79.                             break;
  80.                         case greaterorequal:
  81.                             wrapper.ge(field, value);
  82.                             break;
  83.                         case beginwith:
  84.                             wrapper.likeLeft(field, value);
  85.                             break;
  86.                         case endwith:
  87.                             wrapper.likeRight(field, value);
  88.                             break;
  89.                         case contains:
  90.                             wrapper.like(field, value);
  91.                             break;
  92.                         default:
  93.                             break;
  94.                     }
  95.                 }
  96.             }
  97.         }
  98.  
  99.         if (enableSort) {
  100.             // 得到order by语句
  101.             String statement = getOrderByStatement(pager);
  102.  
  103.             if (StringUtils.isNotEmpty(statement)) {
  104.                 wrapper.last(statement);
  105.             }
  106.         }
  107.  
  108.         return wrapper;
  109.     }
  110.  
  111. }

排序实体对象

因为前端的基础分页器Pager已经继承了Sorter，所以开启了分页功能后自动获得排序功能。

  1. package cn.edu.sgu.www.base;
  2.  
  3. import cn.edu.sgu.www.exception.GlobalException;
  4. import cn.edu.sgu.www.restful.ResponseCode;
  5. import cn.edu.sgu.www.util.StringUtils;
  6. import lombok.Data;
  7.  
  8. import java.io.Serializable;
  9. import java.util.ArrayList;
  10. import java.util.List;
  11.  
  12. /**
  13.  * 基础排序对象，包含排序字段和排序方式
  14.  * @author heyunlin
  15.  * @version 1.0
  16.  */
  17. @Data
  18. public class Sorter implements Serializable {
  19.     private static final long serialVersionUID = 18L;
  20.  
  21.     /**
  22.      * 空字符串
  23.      */
  24.     private static final String EMPTY_STR = "";
  25.  
  26.     /**
  27.      * 分割符
  28.      */
  29.     private static final String SEPARATOR = ",";
  30.  
  31.     /**
  32.      * 排序方式
  33.      */
  34.     private static final List<String> ORDER_STYLES = new ArrayList<>(2);
  35.  
  36.     static {
  37.         ORDER_STYLES.add("asc");
  38.         ORDER_STYLES.add("desc");
  39.     }
  40.  
  41.     /**
  42.      * 排序字段
  43.      */
  44.     private String sort;
  45.  
  46.     /**
  47.      * 排序方式：asc/desc
  48.      */
  49.     private String order;
  50.  
  51.     /**
  52.      * 根据查询条件拼接得到order by语句
  53.      * @param sorter 分页查询条件
  54.      * @return String
  55.      */
  56.     public static String getStatement(Sorter sorter) {
  57.         String sort;
  58.         String sortColumn = sorter.getSort();
  59.  
  60.         // 处理排序字段
  61.         String[] sortArray = {};
  62.  
  63.         if (StringUtils.isNotEmpty(sortColumn)) {
  64.             // 驼峰命名转为下划线
  65.             sort = StringUtils.toLower(sortColumn);
  66.  
  67.             if (sort.contains(SEPARATOR)) {
  68.                 sortArray = sort.split(SEPARATOR);
  69.             }
  70.         } else {
  71.             return EMPTY_STR;
  72.         }
  73.  
  74.         // 处理排序方式
  75.         String[] orderArray = {};
  76.         String order = sorter.getOrder();
  77.  
  78.         if (StringUtils.isNotEmpty(order)) {
  79.             if (order.contains(SEPARATOR)) {
  80.                 orderArray = order.split(SEPARATOR);
  81.             }
  82.         } else {
  83.             return EMPTY_STR;
  84.         }
  85.  
  86.         StringBuilder statement = new StringBuilder();
  87.  
  88.         if (sortArray.length > 0 && orderArray.length > 0) {
  89.             int length = sortArray.length;
  90.  
  91.             for (int i = 0; i < length; i++) {
  92.                 String pagerSort = sortArray[i];
  93.                 String pagerOrder = orderArray[i];
  94.  
  95.                 boolean result = validate(pagerSort, pagerOrder);
  96.  
  97.                 if (result) {
  98.                     statement.append(pagerSort);
  99.                     statement.append(" ");
  100.                     statement.append(pagerOrder);
  101.  
  102.                     if (i < length - 1 ) {
  103.                         statement.append(", ");
  104.                     }
  105.                 }
  106.             }
  107.         } else {
  108.             // " #{sort} #{order}“
  109.             statement.append(sort);
  110.             statement.append(" ");
  111.             statement.append(order);
  112.         }
  113.  
  114.         return statement.toString();
  115.     }
  116.  
  117.     /**
  118.      * 根据查询条件拼接得到order by语句
  119.      * @param sorter 分页查询条件
  120.      * @return String
  121.      */
  122.     public static String getOrderByStatement(Sorter sorter) {
  123.         String statement = getStatement(sorter);
  124.  
  125.         if (StringUtils.isNotEmpty(statement)) {
  126.             return " order by " + statement;
  127.         } else {
  128.             return EMPTY_STR;
  129.         }
  130.     }
  131.  
  132.     /**
  133.      * 往Pager的排序字段中添加排序
  134.      * @param pager Pager Pager对象
  135.      * @param sort String 排序字段
  136.      * @param order String 排序方式
  137.      * @return Pager<?> 返回重新设置排序字段和排序方式后的Pager对象
  138.      */
  139.     public static Pager<?> append(Pager<?> pager, String sort, String order) {
  140.         boolean result = validatePager(pager);
  141.  
  142.         if (result) {
  143.             String pagerSort = pager.getSort();
  144.             String pagerOrder = pager.getOrder();
  145.  
  146.             pager.setSort(pagerSort.concat(SEPARATOR).concat(sort));
  147.             pager.setOrder(pagerOrder.concat(SEPARATOR).concat(order));
  148.  
  149.             return pager;
  150.         }
  151.  
  152.         return null;
  153.     }
  154.  
  155.     /**
  156.      * 验证Pager对象的sort和order的值是否合法
  157.      * @param pager Pager<?>
  158.      * @return boolean
  159.      */
  160.     private static boolean validatePager(Pager<?> pager) {
  161.         String sort = pager.getSort();
  162.         String order = pager.getOrder();
  163.  
  164.         return validate(sort, order);
  165.     }
  166.  
  167.     /**
  168.      * 验证sort和order的值是否合法
  169.      * @param sort 排序字段
  170.      * @param order 排序方式
  171.      * @return boolean
  172.      */
  173.     private static boolean validate(String sort, String order) {
  174.         if (StringUtils.isEmpty(sort)) {
  175.             throw new GlobalException(ResponseCode.FORBIDDEN, "排序字段不允许为空！");
  176.         } else if (StringUtils.isEmpty(order)) {
  177.             throw new GlobalException(ResponseCode.FORBIDDEN, "排序方式不允许为空！");
  178.         } else if(!ORDER_STYLES.contains(order.toLowerCase())) {
  179.             throw new GlobalException(ResponseCode.FORBIDDEN, "排序方式不合法！");
  180.         }
  181.  
  182.         return true;
  183.     }
  184.  
  185. }

好了，文章就分享到这里了，自己的一个小成果，分享给大家，希望对大家有所帮助~

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号