p4vb9jpo3
/
homestay
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

无 (#6)

Browse Source 
accept
Co-authored-by: pfgkalsmu <loftykingsecret@163.com>
Co-committed-by: pfgkalsmu <loftykingsecret@163.com>
develop
pfgkalsmu 3 months ago committed by p4vb9jpo3
parent c4545d0e20
commit 3edad0c2a7
9 changed files with 1262 additions and 503 deletions
Show Stats Download Patch File Download Diff File

153
minsu/minsuguanliw/src/main/java/com/ServletContextListener/DictionaryServletContextListener.java
Unescape View File

@ -17,45 +17,174 @@ import java.util.List;
import java.util.Map; import java.util.Map;
/** /**
* 字典初始化监视器 用的是服务器监听,每次项目启动,都会调用这个类 * 字典初始化监视器
* 用的是服务器监听机制，实现了 `ServletContextListener`
*
*
*
*
*
*
*
* 接口，意味着该类会监听 Servlet 上下文的相关事件（启动和销毁）。
* 每次项目启动时，Servlet 容器都会自动调用这个类的相应方法，
*
*
*
*
* 用于执行一些初始化操作，例如加载字典表数据并进行预处理，以及启动相关的线程等，
* 确保在项目运行过程中相关的字典数据和线程等资源处于可用状态，为后续业务逻辑的正常执行提供支持。
*/ */
@WebListener @WebListener
public class DictionaryServletContextListener implements ServletContextListener { public class DictionaryServletContextListener implements ServletContextListener {
// 创建一个日志记录器，用于记录该类在执行过程中的相关信息，
//
// 比如服务器启动、停止时的状态，字典表初始化的进度以及线程启动等操作情况，
// 方便在开发、调试以及运行时查看操作详情、排查问题等。
private static final Logger logger = LoggerFactory.getLogger(DictionaryServletContextListener.class); private static final Logger logger = LoggerFactory.getLogger(DictionaryServletContextListener.class);
// 定义一个 `MyThreadMethod` 类型的成员变量，
//
// 从名称推测可能是用于执行特定业务逻辑的线程相关类，
// 在后续的 `contextInitialized` 方法中会根据情况实例化并启动该线程，
//
//
//
// 用于在项目启动后执行一些异步或者后台持续运行的任务（具体取决于 `MyThreadMethod` 类的实现逻辑）。
private MyThreadMethod myThreadMethod; private MyThreadMethod myThreadMethod;
/**
* 当 Servlet 上下文销毁时（例如服务器关闭），
*
* 会调用该方法，用于执行一些清理或者资源释放相关的操作，
* 当前代码中主要是通过日志记录器记录服务器停止的相关信息，方便后续查看服务器的关闭情况以及是否有异常等问题。
*
* @param sce `ServletContextEvent` 对象，
*
* 包含了与 Servlet 上下文销毁事件相关的信息，不过在当前方法中暂时未使用到该对象的具体属性或方法，
* 只是作为方法的参数按照接口规范传入，用于满足对上下文销毁事件响应的要求。
*/
@Override @Override
public void contextDestroyed(ServletContextEvent sce) { public void contextDestroyed(ServletContextEvent sce) {
logger.info("----------服务器停止----------"); logger.info("----------服务器停止----------");
} }
/**
* 当 Servlet 上下文初始化时（也就是项目启动时），
* 会调用该方法，用于执行一系列的初始化操作，主要包括以下几个部分：
* 1. 获取 Spring 应用上下文，
*
* 以便从上下文中获取相关的 Bean（如 `DictionaryService`）来进行后续的业务操作。
* 2. 从数据库中查询所有的字典表数据，
*
* 并对其进行处理，构建一个便于后续查询使用的数据结构（以 `dictionaryMap` 的形式存储在 Servlet 上下文中）。
* 3. 根据情况实例化并启动 `MyThreadMethod` 线程，
*
* 用于执行特定的业务逻辑任务，使得该线程在项目启动后就开始运行。
*
* @param sce `ServletContextEvent` 对象，
*
*
* 包含了与 Servlet 上下文初始化事件相关的信息，通过该对象可以获取到 Servlet 上下文对象，
* 进而用于获取 Spring 应用上下文以及设置共享的属性等操作，
*
*
* 是整个初始化流程中与 Servlet 容器交互的关键参数。
*/
@Override @Override
public void contextInitialized(ServletContextEvent sce) { public void contextInitialized(ServletContextEvent sce) {
// 通过 `WebApplicationContextUtils` 工具类，
//
// 基于传入的 `ServletContext`（从 `ServletContextEvent` 中获取）获取 Spring 的应用上下文对象，
// 应用上下文对象包含了 Spring 容器管理的所有 Bean 以及相关的配置信息，
//
// 后续可以通过它获取到需要的业务逻辑组件（如 `DictionaryService`）来执行具体的操作。
ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(sce.getServletContext()); ApplicationContext appContext = WebApplicationContextUtils.getWebApplicationContext(sce.getServletContext());
logger.info("----------字典表初始化开始----------"); logger.info("----------字典表初始化开始----------");
DictionaryService dictionaryService = (DictionaryService)appContext.getBean("dictionaryService");
// 从 Spring 应用上下文中获取 `DictionaryService`
// 类型的 Bean，用于调用字典表相关的业务逻辑方法，
// 这里通过强制类型转换将获取到的 `Object` 类型的
//
// Bean 转换为 `DictionaryService` 类型，以便后续进行数据库查询等操作，
// 因为 `DictionaryService` 应该是实现了对字典表数据进行增删改查等操作的服务层接口，
//
// 在项目中负责与数据库交互获取字典表数据。
DictionaryService dictionaryService = (DictionaryService) appContext.getBean("dictionaryService");
// 调用 `dictionaryService` 的 `selectList` 方法，
//
// 传入一个空的 `EntityWrapper`（用于构建查询条件，这里为空表示查询所有记录），
// 从数据库中获取所有的 `DictionaryEntity`（字典表实体类）对象列表，
//
// 即获取字典表中的全部数据记录，用于后续的初始化处理操作。
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>()); List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
Map<String, Map<Integer,String>> map = new HashMap<>();
for(DictionaryEntity d :dictionaryEntities){ // 创建一个 `HashMap` 类型的对象，用于存储字典表数据按照字典代码
//
// （`dic_code`）分组后的信息，每个 `dic_code` 对应一个内部的 `Map`，
// 内部 `Map` 的键是 `code_index`（编码索引），值是 `index_name`（索引名称），
//
//
//
//
// 方便后续根据字典代码快速查找对应的索引信息等操作，
// 这个数据结构会被存储到 Servlet 上下文中，供整个项目中其他地方方便地获取和使用字典表相关信息。
Map<String, Map<Integer, String>> map = new HashMap<>();
// 遍历从数据库中查询出来的字典表数据列表，
//
// 对每个 `DictionaryEntity` 对象进行处理，构建上述的分组数据结构。
for (DictionaryEntity d : dictionaryEntities) {
// 根据当前字典数据对象的 `dic_code` 获取对应的内部 `Map`，
//
//
// 如果不存在则创建一个新的空 `Map`。
Map<Integer, String> m = map.get(d.getDicCode()); Map<Integer, String> m = map.get(d.getDicCode());
if(m ==null || m.isEmpty()){ if (m == null || m.isEmpty()) {
m = new HashMap<>(); m = new HashMap<>();
} }
m.put(d.getCodeIndex(),d.getIndexName()); // 将当前字典数据对象的 `code_index` 和
map.put(d.getDicCode(),m); //
// `index_name` 放入对应的内部 `Map` 中，建立索引关系。
m.put(d.getCodeIndex(), d.getIndexName());
// 将包含当前字典数据对象索引信息的内部 `Map`
//
// 重新放入外层的 `map` 中，以 `dic_code` 为键进行关联，完成分组存储。
map.put(d.getDicCode(), m);
} }
sce.getServletContext().setAttribute("dictionaryMap", map);
logger.info("----------字典表初始化完成----------");
// 将构建好的包含字典表数据分组信息的 `map`
//
// 对象存入 `ServletContext` 中，设置一个名为 `dictionaryMap` 的属性，
// 这样在整个项目的其他地方（如不同的 Servlet、JSP
//
//
// 页面或者其他组件）可以通过该属性名获取到最新的字典表数据分组信息，实现数据共享，
// 方便在后续的业务逻辑中根据字典代码快速查找对应的索引名称等操作，
//
// 提高了数据的访问效率和复用性。
sce.getServletContext().setAttribute("dictionaryMap", map);
logger.info("----------字典表初始化完成----------");
logger.info("----------线程执行开始----------"); logger.info("----------线程执行开始----------");
// 判断 `myThreadMethod` 线程对象是否为空，
//
// 如果为空则进行实例化操作，这样可以确保线程对象只被创建一次，
// 避免多次重复创建线程导致的资源浪费或者逻辑错误等问题，
//
// 在项目启动的初始化阶段启动该线程，使其开始执行特定的业务逻辑任务（具体由 `MyThreadMethod` 类的 `run` 方法定义）。
if (myThreadMethod == null) { if (myThreadMethod == null) {
myThreadMethod = new MyThreadMethod(); myThreadMethod = new MyThreadMethod();
myThreadMethod.start(); // servlet 上下文初始化时启动线程myThreadMethod myThreadMethod.start(); // servlet
// 上下文初始化时启动线程 myThreadMethod
} }
logger.info("----------线程执行结束----------"); logger.info("----------线程执行结束----------");
} }
}
}

397
minsu/minsuguanliw/src/main/java/com/controller/DictionaryController.java
Unescape View File

@ -1,4 +1,3 @@
package com.controller; package com.controller;
import java.io.File; import java.io.File;
@ -35,246 +34,276 @@ import com.alibaba.fastjson.*;
/** /**
* 字典表 * 字典表
* 后端接口 * 后端接口
*
*
*
*
*
*
*
*
*
* 该类作为 Spring MVC 的控制器，用
* 于处理与字典表相关的各种后端接口请求，
* 包含了对字典表数据的查询、新增、修改、删除以及一些其他相关操作的接口
* 方法，
* 通过依赖注入相关的服务层接口，调用对应的业务逻辑方法来实现具体功能，并使用日志记录操作信息，方便调试和问题排查。
* @author * @author
* @email * @email
*/ */
@RestController @RestController
@Controller @Controller
@RequestMapping("/dictionary") @RequestMapping("/dictionary")
public class DictionaryController { public class DictionaryController {
// 创建一个日志记录器，
// 用于记录该控制器类中各个方法执行过程中的相关信息，
// 方便在开发、调试以及运行时查看操作情况、排查问题等。
private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class); private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class);
// 通过 Spring 的依赖注入机制，
// 自动注入 DictionaryService 接口的实现类实例，用于调用字典表相关的业务逻辑方法，
// 比如查询分页数据、保存字典数据、
// 更新字典数据等操作，实现与数据库中字典表的交互。
@Autowired @Autowired
private DictionaryService dictionaryService; private DictionaryService dictionaryService;
// 通过 Spring 的依赖注入机制，
// 自动注入 TokenService 接口的实现类实例，可能用于与用户身份验证相关的操作，
// 例如验证请求中携带的 token
// 是否有效等，确保接口访问的安全性（虽然在当前代码中未看到明确的使用场景，但具备这种依赖注入的可能性）。
@Autowired @Autowired
private TokenService tokenService; private TokenService tokenService;
//级联表service // 通过 Spring 的依赖注入机制，自动注入
// YonghuService 接口的实现类实例，这应该是与用户相关的服务层接口，
// 从名称来看可能用于处理用户相关的业务逻辑
// （在当前代码中虽未体现具体使用，但为后续扩展或关联用户操作预留了可能），属于级联表相关的服务注入。
@Autowired @Autowired
private YonghuService yonghuService; private YonghuService yonghuService;
/** /**
* 后端列表 * 后端列表
*/ * 用于处理获取字典表数据列表的请求，
*
*
* 支持分页查询以及按照指定字段排序，同时会对查询结果中的字典表数据进行转换处理（通过 `dictionaryConvert` 方法）。
*
* @param params 一个 Map 类型的参数，
* 用于接收前端传递过来的各种查询条件、分页参数以及排序相关信息等，例如页码、每页显示数量、筛选条件、排序字段等。
* @param request HttpServletRequest
* 对象，用于获取请求相关的上下文信息，在后续的数据转换等操作中可能会用到，比如获取用户相关信息等。
* @return 返回一个 `R` 类型的结果对象
* （从 `com.utils.R` 类获取，可能是自定义的统一返回结果封装类），里面包含了操作状态信息以及查询到的分页后的字典表数据（封装在 `PageUtils` 中），
* 如果操作成功则状态码为成功标识，
* 且 `data` 字段中存放分页数据；若出现问题则返回相应的错误信息和状态码。
*/
@RequestMapping("/page") @RequestMapping("/page")
@IgnoreAuth @IgnoreAuth
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){ public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params)); // 使用日志记录器记录当前
if(params.get("orderBy")==null || params.get("orderBy")==""){ // `page` 方法的执行情况，记录控制器类的名称以及传入的查询参数信息
params.put("orderBy","id"); // （将参数转换为 JSON 字符串格式记录），方便调试查看请求参数是否正确等情况。
logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
// 如果传入的参数中没有指定排序字段
// （`orderBy`）或者排序字段为空字符串，则默认按照 `id` 字段进行排序，设置默认的排序规则。
if (params.get("orderBy") == null || params.get("orderBy") == "") {
params.put("orderBy", "id");
} }
// 调用 `dictionaryService` 的
// `queryPage` 方法，传入查询参数 `params`，
// 获取分页后的字典表数据，该方法内部会与数据库交互进行查询操作，返回 `PageUtils` 对象，
// 里面包含了分页数据以及分页相关的元信息（如总记录数、总页数等）。
PageUtils page = dictionaryService.queryPage(params); PageUtils page = dictionaryService.queryPage(params);
//字典表数据转换 // 获取分页数据中的字典表数据列表，
List<DictionaryView> list =(List<DictionaryView>)page.getList(); // 将其转换为 `DictionaryView` 类型的列表，
for(DictionaryView c:list){ // `DictionaryView` 可能是适合前端展示或者其他业务场景需求的视图实体类，
//修改对应字典表字段 // 用于承载更丰富、更便于展示的字典表相关信息（相较于直接的数据库实体类）。
List<DictionaryView> list = (List<DictionaryView>) page.getList();
// 遍历字典表数据列表，对每个 `DictionaryView`
// 对象调用 `dictionaryService` 的 `dictionaryConvert` 方法进行数据转换操作，
// 可能是对字典表中的某些字段进行值的转换、
// 格式调整或者关联其他数据等处理，以满足前端展示或业务规则要求。
for (DictionaryView c : list) {
dictionaryService.dictionaryConvert(c, request); dictionaryService.dictionaryConvert(c, request);
} }
// 返回包含操作成功状态信息（通过 `R.ok()`）
// 以及处理后的分页数据（通过 `put("data", page)`
// 将分页数据放入返回结果对象的 `data` 字段中）的 `R` 类型结果对象，
// 以便将结果返回给前端或者其他调用该接口的地方进行后续处理。
return R.ok().put("data", page); return R.ok().put("data", page);
} }
/** /**
* 后端详情 * 后端详情
*/ * 用于处理获取指定 `id` 的字典表数据详情的请求，
* 先从数据库中查询出对应的数据实体，
* 然后转换为视图实体类并进行相应的数据转换操作后返回给前端。
*
* @param id 通过 `@PathVariable` 注解获取路径中的 `id` 参数，
* 该参数用于指定要查询详情的字典表数据记录的唯一标识，通常对应数据库表中的主键值。
* @param request HttpServletRequest 对象，
* 用于获取请求相关的上下文信息，例如在后续的数据转换操作中可能需要获取用户相关信息等情况时会用到。
* @return 返回一个 `R` 类型的结果对象，若查询到对应的数据记录，
* 则将转换后的视图实体类（包含字典表数据详情以及经过转换后的相关字段信息）放入 `data` 字段中，
* 并设置操作状态为成功返回；若未查询到对应数据，
* 则返回包含错误信息和相应错误状态码（这里是 `511`）的 `R` 类型结果对象，表示查不到数据的情况。
*/
@RequestMapping("/info/{id}") @RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id, HttpServletRequest request){ public R info(@PathVariable("id") Long id, HttpServletRequest request) {
logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id); // 使用日志记录器记录当前 `info`
// 方法的执行情况，记录控制器类的名称以及传入的 `id` 参数值，
// 方便调试查看请求的参数情况。
logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
// 调用 `dictionaryService` 的 `selectById` 方法，
// 根据传入的 `id` 参数从数据库中查询对应的 `DictionaryEntity`（字典表实体类）对象，
// 如果查询到则返回该对象，若不存在则返回 `null`。
DictionaryEntity dictionary = dictionaryService.selectById(id); DictionaryEntity dictionary = dictionaryService.selectById(id);
if(dictionary !=null){ if (dictionary!= null) {
//entity转view // 创建一个 `DictionaryView` 类型的视图实体类对象，
// 用于承载适合返回给前端展示的字典表数据详情信息。
DictionaryView view = new DictionaryView(); DictionaryView view = new DictionaryView();
BeanUtils.copyProperties( dictionary , view );//把实体数据重构到view中 // 使用 Spring 的 `BeanUtils` 工具类，
// 将查询到的 `DictionaryEntity` 实体类中的属性值复制到 `DictionaryView` 视图实体类对象中，
//修改对应字典表字段 // 实现数据的转换和整合，以便返回更符合前端展示需求的数据结构。
BeanUtils.copyProperties(dictionary, view);
// 调用 `dictionaryService` 的 `dictionaryConvert` 方法，
// 对转换后的视图实体类对象进行数据转换操作，
// 可能是对字典表中的某些字段进行进一步的处理，
// 以满足前端展示或者业务规则要求，确保返回的数据格式和内容符合预期。
dictionaryService.dictionaryConvert(view, request); dictionaryService.dictionaryConvert(view, request);
// 返回包含操作成功状态信息（通过 `R.ok()`）以及处理后的视图实体类对象
// （通过 `put("data", view)` 将视图对象放入返回结果对象的 `data` 字段中）的 `R` 类型结果对象，
// 以便将字典表数据详情返回给前端或者其他调用该接口的地方进行后续处理。
return R.ok().put("data", view); return R.ok().put("data", view);
}else { } else {
return R.error(511,"查不到数据"); // 如果未查询到对应的数据记录，
// 则返回包含错误信息（“查不到数据”）和错误状态码 `511` 的 `R` 类型结果对象，表示查询失败的情况，
// 以便前端或者其他调用方能够知晓并做出相应的处理。
return R.error(511, "查不到数据");
} }
} }
/** /**
* 后端保存 * 后端保存
*/ * 用于处理新增字典表数据的请求，
* 会先进行一些数据重复性校验，若数据不存在重复则将新数据插入数据库，并在插入成功后进行一些后续的数据处理操作（如更新监听器中的数据）。
*
* @param dictionary 通过 `@RequestBody`
* 注解接收前端传递过来的 JSON 格式的 `DictionaryEntity` 类型数据，该对象包含了要新增的字典表数据信息，
* 例如字典代码、名称、索引等相关字段的值，用于构建新的字典表记录。
* @param request HttpServletRequest 对象，
* 用于获取请求相关的上下文信息，在这里主要用于获取用户相关的会话信息（如角色信息），
* 判断用户是否有权限进行操作等情况，
* 同时在后续的数据处理操作（如更新监听器中的数据）中也会用到请求上下文相关的信息。
* @return 返回一个 `R` 类型的结果对象，若数据成功插入数据库且后续处理无异常，
* 则返回操作成功的状态信息（通过 `R.ok()`）；
* 若插入的数据存在重复（通过查询判断），
* 则返回包含错误信息（“表中有相同数据”）和相应错误状态码（`511`）的 `R` 类型结果对象，
* 表示新增数据失败的情况。
*/
@RequestMapping("/save") @RequestMapping("/save")
public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){ public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) {
logger.debug("save方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString()); // 使用日志记录器记录当前 `save` 方法的执行情况，
// 记录控制器类的名称以及传入的要保存的字典表数据对象信息（将对象转换为字符串格式记录），
// 方便调试查看请求的数据情况。
logger.debug("save方法:,,Controller:{},,dictionary:{}", this.getClass().getName(), dictionary.toString());
// 从请求的会话中获取用户的角色信息，将其转换为字符串类型，
// 虽然当前代码中 `if(false)` 这个条件永远为假，
// 可能是后续会添加基于角色判断是否有权限进行保存操作的逻辑，
// 这里先预留了代码结构，
// 暂时不会进入到后面的 `return R.error(511,"永远不会进入");` 这一行代码执行。
String role = String.valueOf(request.getSession().getAttribute("role")); String role = String.valueOf(request.getSession().getAttribute("role"));
if(false) if (false)
return R.error(511,"永远不会进入"); return R.error(511, "永远不会进入");
// 创建一个 `EntityWrapper`
// 类型的查询条件包装器对象，用于构建查询字典表中是否已存在相同数据的条件，
// 通过 `eq` 方法设置相等条件，
// 分别按照 `dic_code`（字典代码）和 `index_name`
// （索引名称）字段与要保存的字典数据对象中的对应字段值进行相等匹配查询，
// 以此来判断是否存在重复数据
// （后续还可能根据具体情况添加更多条件判断，如针对特定字典代码类型添加额外条件等）。
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>() Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.eq("dic_code", dictionary.getDicCode()) .eq("dic_code", dictionary.getDicCode())
.eq("index_name", dictionary.getIndexName()) .eq("index_name", dictionary.getIndexName())
; ;
if(dictionary.getDicCode().contains("_erji_types")){ // 如果要保存的字典数据对象的 `dic_code`
queryWrapper.eq("super_id",dictionary.getSuperId()); // 字段包含 `_erji_types` 字符串（可能表示二级类型相关的字典数据，这里根据业务规则进行额外的条件判断），
// 则在查询条件包装器中添加一个相等条件，按照 `super_id`
// （父字段 `id`）字段与要保存的字典数据对象中的 `super_id` 值进行匹配查询，进一步细化重复数据的判断条件。
if (dictionary.getDicCode().contains("_erji_types")) {
queryWrapper.eq("super_id", dictionary.getSuperId());
} }
logger.info("sql语句:"+queryWrapper.getSqlSegment()); // 使用日志记录器记录构建好的查询条件对应的 SQL 语句片段（通过 `getSqlSegment` 方法获取），
// 方便调试查看查询条件是否正确构建，是否符合预期的数据库查询逻辑。
logger.info("sql语句:" + queryWrapper.getSqlSegment());
// 调用 `dictionaryService` 的 `selectOne` 方法，
// 传入构建好的查询条件包装器对象，从数据库中查询是否存在符合条件的字典表数据记录，
// 如果存在则返回对应的 `DictionaryEntity` 对象，
// 若不存在则返回 `null`，以此来判断要保存的数据是否已存在重复情况。
DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper); DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
if(dictionaryEntity==null){ if (dictionaryEntity == null) {
// 如果要保存的数据不存在重复情况，则设置该字典数据对象的
// `createTime`（创建时间）字段为当前时间，用于记录数据的创建时间信息。
dictionary.setCreateTime(new Date()); dictionary.setCreateTime(new Date());
// 调用 `dictionaryService` 的 `insert` 方法，
// 将设置好创建时间的字典数据对象插入到数据库中，完成新数据的新增操作。
dictionaryService.insert(dictionary); dictionaryService.insert(dictionary);
//字典表新增数据,把数据再重新查出,放入监听器中
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
ServletContext servletContext = request.getServletContext();
Map<String, Map<Integer,String>> map = new HashMap<>();
for(DictionaryEntity d :dictionaryEntities){
Map<Integer, String> m = map.get(d.getDicCode());
if(m ==null || m.isEmpty()){
m = new HashMap<>();
}
m.put(d.getCodeIndex(),d.getIndexName());
map.put(d.getDicCode(),m);
}
servletContext.setAttribute("dictionaryMap",map);
return R.ok();
}else {
return R.error(511,"表中有相同数据");
}
}
/** // 字典表新增数据后，把字典表中的所有数据重新查询出来，
* 后端修改 // 用于放入监听器中（可能是为了在其他地方能够获取到最新的字典表数据，保持数据一致性等业务需求）。
*/
@RequestMapping("/update")
public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){
logger.debug("update方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString());
String role = String.valueOf(request.getSession().getAttribute("role"));
// if(false)
// return R.error(511,"永远不会进入");
//根据字段查询是否有相同数据
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.notIn("id",dictionary.getId())
.eq("dic_code", dictionary.getDicCode())
.eq("index_name", dictionary.getIndexName())
;
if(dictionary.getDicCode().contains("_erji_types")){
queryWrapper.eq("super_id",dictionary.getSuperId());
}
logger.info("sql语句:"+queryWrapper.getSqlSegment());
DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
if(dictionaryEntity==null){
dictionaryService.updateById(dictionary);//根据id更新
//如果字典表修改数据的话,把数据再重新查出,放入监听器中
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>()); List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
// 获取当前请求的 `ServletContext` 对象，
// 它可以用于在整个应用程序的不同组件之间共享数据，在这里用于存放字典表数据信息，供监听器等其他组件使用。
ServletContext servletContext = request.getServletContext(); ServletContext servletContext = request.getServletContext();
Map<String, Map<Integer,String>> map = new HashMap<>(); // 创建一个 `HashMap` 类型的对象，
for(DictionaryEntity d :dictionaryEntities){ // 用于存储字典表数据按照字典代码（`dic_code`）分组后的信息，每个 `dic_code` 对应一个内部的 `Map`，
// 内部 `Map` 的键是 `code_index`（编码索引），
// 值是 `index_name`（索引名称），方便后续根据字典代码快速查找对应的索引信息等操作。
Map<String, Map<Integer, String>> map = new HashMap<>();
// 遍历重新查询出来的字典表数据列表，
// 对每个 `DictionaryEntity` 对象进行处理，构建上述的分组数据结构。
for (DictionaryEntity d : dictionaryEntities) {
// 根据当前字典数据对象的 `dic_code` 获取对应的内部 `Map`，如果不存在则创建一个新的空 `Map`。
Map<Integer, String> m = map.get(d.getDicCode()); Map<Integer, String> m = map.get(d.getDicCode());
if(m ==null || m.isEmpty()){ if (m == null || m.isEmpty()) {
m = new HashMap<>(); m = new HashMap<>();
} }
m.put(d.getCodeIndex(),d.getIndexName()); // 将当前字典数据对象的 `code_index` 和
map.put(d.getDicCode(),m); // `index_name` 放入对应的内部 `Map` 中，建立索引关系。
m.put(d.getCodeIndex(), d.getIndexName());
// 将包含当前字典数据对象索引信息的内部 `Map`
// 重新放入外层的 `map` 中，以 `dic_code` 为键进行关联，完成分组存储。
map.put(d.getDicCode(), m);
} }
servletContext.setAttribute("dictionaryMap",map); // 将构建好的包含字典表数据分组信息的 `map` 对象存入
//
//
//
// `ServletContext` 中，设置一个名为 `dictionaryMap` 的属性，
// 以便其他组件（如监听器等）可以通过该属性名获取到最新的字典表数据分组信息，实现数据共享和后续的业务逻辑处理。
servletContext.setAttribute("dictionaryMap", map);
// 返回操作成功的状态信息（通过 `R.ok()`），表示字典表数据新增成功，
//
//
// 以便前端或者其他调用该接口的地方知晓操作结果并进行后续处理。
return R.ok(); return R.ok();
}else { } else {
return R.error(511,"表中有相同数据");
}
}
/**
* 删除
*/
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
dictionaryService.deleteBatchIds(Arrays.asList(ids));
return R.ok();
}
/**
* 最大值
*/
@RequestMapping("/maxCodeIndex")
public R maxCodeIndex(@RequestBody DictionaryEntity dictionary){
logger.debug("maxCodeIndex:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString());
List<String> descs = new ArrayList<>();
descs.add("code_index");
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.eq("dic_code", dictionary.getDicCode())
.orderDesc(descs);
logger.info("sql语句:"+queryWrapper.getSqlSegment());
List<DictionaryEntity> dictionaryEntityList = dictionaryService.selectList(queryWrapper);
if(dictionaryEntityList != null ){
return R.ok().put("maxCodeIndex",dictionaryEntityList.get(0).getCodeIndex()+1);
}else{
return R.ok().put("maxCodeIndex",1);
} }
} // 如果查询到要保存的数据已存在重复情况，
//
/** // 则返回包含错误信息（“表中有相同数据”）和相应错误状态码（`511`）的 `R` 类型结果对象，
* 批量上传 // 表示新增数据失败，以便前端或者其他调用方能够知晓并做出相应的处理。
*/ return R.error(511, "表中有相同数据");
@RequestMapping("/batchInsert")
public R save( String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
List<DictionaryEntity> dictionaryList = new ArrayList<>();//上传的东西
Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
Date date = new Date();
int lastIndexOf = fileName.lastIndexOf(".");
if(lastIndexOf == -1){
return R.error(511,"该文件没有后缀");
}else{
String suffix = fileName.substring(lastIndexOf);
if(!".xls".equals(suffix)){
return R.error(511,"只支持后缀为xls的excel文件");
}else{
URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
File file = new File(resource.getFile());
if(!file.exists()){
return R.error(511,"找不到上传文件，请联系管理员");
}else{
List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
dataList.remove(0);//删除第一行，因为第一行是提示
for(List<String> data:dataList){
//循环
DictionaryEntity dictionaryEntity = new DictionaryEntity();
// dictionaryEntity.setDicCode(data.get(0)); //字段 要改的
// dictionaryEntity.setDicName(data.get(0)); //字段名 要改的
// dictionaryEntity.setCodeIndex(Integer.valueOf(data.get(0))); //编码 要改的
// dictionaryEntity.setIndexName(data.get(0)); //编码名字 要改的
// dictionaryEntity.setSuperId(Integer.valueOf(data.get(0))); //父字段id 要改的
// dictionaryEntity.setBeizhu(data.get(0)); //备注 要改的
// dictionaryEntity.setCreateTime(date);//时间
dictionaryList.add(dictionaryEntity);
//把要查询是否重复的字段放入map中
}
//查询是否重复
dictionaryService.insertBatch(dictionaryList);
return R.ok();
}
}
}
}catch (Exception e){
e.printStackTrace();
return R.error(511,"批量插入数据异常，请联系管理员");
} }
} }
/**
* 后端修改
* 用于处理修改字典表数据的请求，先进行数据重复性校验，若不存在重复数据
}

38
minsu/minsuguanliw/src/main/java/com/dao/DictionaryDao.java
Unescape View File

@ -11,11 +11,39 @@ import com.entity.view.DictionaryView;
/** /**
* 字典表 Dao 接口 * 字典表 Dao 接口
* * 该接口继承自 MyBatis Plus
* @author * 的 `BaseMapper` 接口，用于定义与字典表数据持久化操作相关的方法，
* 这些方法主要涉及到对数据库中字典表数据的
* 查询、插入、更新、删除等操作（继承了 `BaseMapper` 中已有的通用方法），
* 同时在此基础上可以自定义扩展针对字典表的特定查询方法，
* 方便与数据库进行交互，以满足业务需求。
* @author
*/ */
public interface DictionaryDao extends BaseMapper<DictionaryEntity> { public interface DictionaryDao extends BaseMapper<DictionaryEntity> {
List<DictionaryView> selectListView(Pagination page,@Param("params")Map<String,Object> params); /**
* 根据分页信息以及查询参数，获取符合条件的字典表数据列表，
} * 并转换为适合展示的视图实体类列表返回。
* 此方法通常用于实现分页查询功能，
* 根据传入的分页设置（如页码、每页显示数量等）以及其他自定义的查询条件参数，
* 从数据库中检索出对应的字典表数据记录，并将其封装为 `DictionaryView` 类型的列表，
* `DictionaryView` 可能包含了字典表数据以及关联的其他相关信息，
* 更适合在前端展示或者其他业务场景下使用。
*
* @param page 分页对象，类型为 `Pagination`，
* 通过该对象可以获取分页相关的参数信息（如当前页码、每页显示数量等），
* 用于控制数据库查询时的分页逻辑，以获取指定页的数据记录。
* @param params 查询参数，是一个 `Map` 类型的数据结构，
* 用于传递各种自定义的查询条件，例如可以包含用于筛选字典表数据的关键字、
* 按照特定字段进行范围筛选的条件等信息，方便灵活地构建复杂的查询逻辑，
* 以获取符合业务需求的字典表数据子集。
* @return 返回一个 `List<DictionaryView>` 类型的列表，
* 其中包含了符合分页和查询条件的字典表数据记录对应的视图实体类对象，
* 列表中的每个 `DictionaryView` 对象都承载了一条字典表数据以及相关的展示信息，
*
*
*
* 方便后续在业务逻辑中进行处理和展示给前端等操作。
*/
List<DictionaryView> selectListView(Pagination page, @Param("params") Map<String, Object> params);
}

51
minsu/minsuguanliw/src/main/java/com/dao/TokenDao.java
Unescape View File

@ -1,4 +1,3 @@
package com.dao; package com.dao;
import java.util.List; import java.util.List;
@ -12,11 +11,53 @@ import com.entity.TokenEntity;
/** /**
* token * token
* 该接口是与 `token` 相关的数据访问对象（DAO）接口，
* 继承自 MyBatis Plus 的 `BaseMapper` 接口，
* 意味着它具备了 `BaseMapper`
* 提供的通用数据库操作方法（如根据主键查询、插入、更新、删除等操作），
* 同时在此基础上自定义扩展了针对 `token`
* 数据的特定查询方法，用于满足与 `token` 相关的业务场景下对数据库操作的需求，
* 方便与数据库进行交互，获取或操作 `token` 相关的数据记录。
*/ */
public interface TokenDao extends BaseMapper<TokenEntity> { public interface TokenDao extends BaseMapper<TokenEntity> {
/**
* 根据给定的条件包装器（Wrapper）查询并返回符合条件的 `TokenEntity` 列表。
* 条件包装器（Wrapper）在 MyBatis Plus 中是一种灵活构建查询条件的方式，
* 它可以组合多个字段的筛选条件（如等于、大于、小于等关系判断）、
* 排序条件以及分组条件等，通过传入的 `Wrapper<TokenEntity>`
* 对象能够精确地定义查询 `token` 数据的逻辑，
* 从数据库中获取满足这些条件的 `TokenEntity` 记录列表。
*
* @param wrapper 用于构建查询条件的包装器对象，
* 它详细定义了查询 `TokenEntity` 列表的具体条件，
* 例如可以通过它设置只查询某个用户的有效 `token`
* 、特定角色对应的 `token` 等各种复杂的筛选逻辑，
* 作为从数据库中获取期望的 `token` 实体列表的依据。
* @return 返回一个包含符合条件的 `TokenEntity` 对象的列表，
* 列表中的每个 `TokenEntity` 代表了一条符合设定条件的 `token` 相关记录，
* 方便后续在业务逻辑中对这些查询到的 `token` 实体进行进一步处理，如验证、更新等操作。
*/
List<TokenEntity> selectListView(@Param("ew") Wrapper<TokenEntity> wrapper); List<TokenEntity> selectListView(@Param("ew") Wrapper<TokenEntity> wrapper);
List<TokenEntity> selectListView(Pagination page,@Param("ew") Wrapper<TokenEntity> wrapper); /**
* 根据给定的分页信息以及条件包装器（Wrapper）查询并返回符合条件的 `TokenEntity` 列表。
} * 此方法结合了分页功能与复杂查询条件构建功能，
* 在获取符合特定条件的 `token` 数据的同时，
* 能够按照设定的分页参数（如页码、每页显示数量等）进行分页处理，
* 方便在需要展示大量 `token` 数据时进行分页展示，提高数据查询和展示的效率与用户体验。
*
* @param page 分页对象，类型为 `Pagination`，
* 通过该对象可以获取分页相关的参数信息（如当前页码、每页显示数量等），
* 用于控制数据库查询时的分页逻辑，
* 以获取指定页的数据记录，确保返回的数据符合分页展示的需求。
* @param wrapper 用于构建查询条件的包装器对象，
* 同样可以定义复杂的查询条件，如筛选特定状态、关联特定用户或角色的 `token` 等，
* 与分页对象配合使用，
* 共同确定从数据库中获取哪些符合条件的 `token` 数据记录以及返回的分页范围。
* @return 返回一个包含符合条件的 `TokenEntity` 对象的列表，
* 该列表中的数据是经过分页处理后符合给定查询条件的 `token` 记录，
* 方便后续在前端分页展示或者其他业务场景下对分页后的 `token` 数据进行处理操作。
*/
List<TokenEntity> selectListView(Pagination page, @Param("ew") Wrapper<TokenEntity> wrapper);
}

390
minsu/minsuguanliw/src/main/java/com/entity/DictionaryEntity.java
Unescape View File

@ -22,212 +22,374 @@ import com.baomidou.mybatisplus.enums.IdType;
/** /**
* 字典表 * 字典表
* * 该类用于表示字典表相关的数据实体，
* @author * 对应数据库中的 `dictionary` 表结构，存储字典表中的各项数据信息，
* 实现了 `Serializable` 接口，以便能在网络传输、
* 持久化存储（如保存到文件、数据库等情况）时进行序列化和反序列化操作，保证数据的完整性和可恢复性。
* @author
* @email * @email
*/ */
@TableName("dictionary") @TableName("dictionary")
public class DictionaryEntity<T> implements Serializable { public class DictionaryEntity<T> implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
// **
// * 默认构造函数，用于创建一个空的 `DictionaryEntity`
// 对象实例，在需要先创建对象再逐步设置属性值的场景下使用，
// * 例如在一些复杂业务逻辑中，先实例化对象，
// 后续根据不同的数据源或条件来分别为各个属性赋值，提供了一种灵活构建对象的方式。
// */
public DictionaryEntity() {
public DictionaryEntity() { }
}
public DictionaryEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// **
// * 构造函数，用于根据传入的对象 `t`，通过 `BeanUtils`
// 工具类将其属性值复制到当前 `DictionaryEntity` 对象中，
// * 方便基于已有的数据对象来初始化 `DictionaryEntity`，
// 实现数据的传递和复用，避免重复设置属性，提高代码效率，
// * 常用于将其他相关对象的数据转换为 `DictionaryEntity`
// 类型的数据对象，不过在使用过程中需要注意传入对象的属性与当前类属性的兼容性以及可能出现的异常情况（已在代码中对异常进行了简单处理）。
// * @param t 要复制属性值的对象，其类型为泛型 `T`，
//
//
//
//
// 表示可以传入各种符合要求的对象类型，只要其属性能够通过 `BeanUtils` 进行复制操作即可。
// */
public DictionaryEntity(T t) {
try {
BeanUtils.copyProperties(this, t);
} catch (IllegalAccessException | InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/** // **
* 主键 // * 主键，用于唯一标识字典表中的每一条记录，
*/ //
// 通过 `@TableId` 注解指定该字段为主键，并设置主键的生成策略为自增长（`IdType.AUTO`），
// * 在向数据库插入新记录时，系统会按照自增长规则自动为该字段赋予唯一的值，
//
// 方便在数据库操作（如查询、更新、删除等）中精准定位到特定的字典表数据行，确保数据的唯一性和可操作性。
// * @TableField 注解用于明确该字段在数据库表中对应的列名，
//
// 这里对应 `id` 列，使得对象属性与数据库表字段之间建立准确的映射关系。
// */
@TableId(type = IdType.AUTO) @TableId(type = IdType.AUTO)
@TableField(value = "id") @TableField(value = "id")
private Integer id; private Integer id;
// **
/** // * 字段，用于存储字典表中某个条目的特定代码或者标识信息，
* 字段 //
*/ // 通过 `@TableField` 注解指定其在数据库表中对应的列名为 `dic_code`，
// * 例如该字段可以是代表不同分类、类型等的代码值，
//
// 在业务逻辑中可基于此字段进行相关的查询、匹配等操作，以区分不同的字典项。
// */
@TableField(value = "dic_code") @TableField(value = "dic_code")
private String dicCode; private String dicCode;
// **
/** // * 字段名，与 `dicCode` 相对应，
* 字段名 //
*/ // 用于存储该字段对应的直观的名称描述，通过 `@TableField` 注解对应数据库表中的 `dic_name` 列，
// * 方便在前端展示或者业务逻辑处理中让人更容易理解该字段所代表的含义，
//
// 例如如果 `dicCode` 是分类代码，那 `dicName` 就是具体的分类名称，增强了数据的可读性。
// */
@TableField(value = "dic_name") @TableField(value = "dic_name")
private String dicName; private String dicName;
// **
/** // * 编码，可能是对字典表中各项进行编号的一个整数值，
* 编码 //
*/ // 通过 `@TableField` 注解对应数据库表中的 `code_index` 列，
// * 用于在内部对字典项进行排序、索引或者作为另一种标识方式，
//
// 在一些需要按照特定顺序处理字典数据或者通过编号快速查找字典项的业务场景中会发挥作用。
// */
@TableField(value = "code_index") @TableField(value = "code_index")
private Integer codeIndex; private Integer codeIndex;
// **
/** // * 编码名字，与 `codeIndex` 相对应，
* 编码名字 //
*/ // 是对该编码所代表含义的文字描述，通过 `@TableField` 注解对应数据库表中的 `index_name` 列，
// * 同样是为了提高数据的可读性和可理解性，
//
// 便于在展示给用户或者业务逻辑处理中清晰地知晓该编码具体对应的内容。
// */
@TableField(value = "index_name") @TableField(value = "index_name")
private String indexName; private String indexName;
// **
/** // * 父字段id，用于表示当前字典项在层级结构中的上级字段的唯一标识（如果字典表存在层级关系的话），
* 父字段id //
*/ // 通过 `@TableField` 注解对应数据库表中的 `super_id` 列，
// * 借助这个 `superId` 可以构建字典项之间的父子关联关系，
//
// 方便进行树形结构数据的展示、查询以及相关业务逻辑处理（比如查找某个分类下的子分类等情况）。
// */
@TableField(value = "super_id") @TableField(value = "super_id")
private Integer superId; private Integer superId;
// **
/** // * 备注，用于存储一些对该字典项的额外说明信息，
* 备注 //
*/ // 通过 `@TableField` 注解对应数据库表中的 `beizhu` 列，
// * 例如该项的特殊用途、适用范围、创建背景等内容，
//
// 在需要详细了解字典项相关细节或者进行一些辅助性的业务逻辑判断时，可以参考备注中的信息。
// */
@TableField(value = "beizhu") @TableField(value = "beizhu")
private String beizhu; private String beizhu;
// **
// * 创建时间，记录该字典表记录的创建时间点，
//
// 通过 `@JsonFormat` 和 `@DateTimeFormat` 注解来规范时间格式的序列化与格式化处理，
// * 确保在前后端交互以及数据存储等场景下时间格式的一致性，
//
// 同时使用 `@TableField` 注解指定其在数据库表中对应的列名为 `create_time`，并设置了 `FieldFill.INSERT` 填充策略，
// * 意味着在向数据库插入新记录时，
//
// 该字段会自动填充当前时间（通常由 MyBatis Plus 根据配置来完成），例如在按照时间顺序查询字典表数据、统计不同时间段创建的数据量等业务场景中会用到该时间信息。
// * @JsonFormat 注解用于控制在将对象转换为JSON格式时时间的显示格式，
//
// 这里设置为中文（`locale="zh"`）、东八区时间（`timezone="GMT+8"`）以及指定的时间格式（`pattern="yyyy-MM-dd HH:mm:ss"`）。
// * @DateTimeFormat 注解用于在接收前端传入时间格式数据时进行解析转换。
// */
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
@TableField(value = "create_time", fill = FieldFill.INSERT)
private Date createTime;
/** // **
* 创建时间 // * 获取：主键，
*/ //
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 对外提供获取主键值（`id`）的方法，方便在其他类中访问该 `DictionaryEntity` 对象的主键信息，
@DateTimeFormat
@TableField(value = "create_time",fill = FieldFill.INSERT)
private Date createTime;
/** // * 例如在进行数据库查询结果映射或者业务逻辑处理中需要用到字典表记录主键时可调用此方法获取，返回对应的整数值。
* 设置：主键 // * @return 返回主键对应的整数值。
*/ // */
public Integer getId() { public Integer getId() {
return id; return id;
} }
/**
* 获取：主键
*/
// **
// * 设置：主键，用于设置该对象的主键值，
//
// 通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用，
// * 不过由于主键一般是自增长且由数据库管理，
//
// 实际业务中手动设置的情况相对较少，但保留此方法以满足可能的特殊需求（如数据迁移等场景），
// * 通过传入对应的整数值来更新主键信息。
// * @param id 要设置的主键整数值。
// */
public void setId(Integer id) { public void setId(Integer id) {
this.id = id; this.id = id;
} }
/**
* 设置：字段 // **
*/ // * 获取：字段，
//
//
// 对外提供获取字段值（`dicCode`）的方法，以便在业务逻辑中根据该字段进行相关操作，比如查询特定代码的字典项、
// * 根据代码进行匹配判断等情况时可调用此方法获取字段值，
//
// 返回对应的字符串内容。
// * @return 返回字段对应的字符串值。
// */
public String getDicCode() { public String getDicCode() {
return dicCode; return dicCode;
} }
/**
* 获取：字段
*/
// **
// * 设置：字段，用于更新字段值（`dicCode`），
//
//
// 例如在修改字典表记录中该字段的代码内容后，调用此方法来保存新的代码信息，以反映字典项的变化。
// * @param dicCode 要设置的字段字符串值。
// */
public void setDicCode(String dicCode) { public void setDicCode(String dicCode) {
this.dicCode = dicCode; this.dicCode = dicCode;
} }
/**
* 设置：字段名 // **
*/ // * 获取：字段名，对外提供获取字段名（`dicName`）的方法，
//
//
// 在需要展示字典项的名称给用户或者在业务逻辑中基于名称进行相关处理（如筛选、排序等）时，
// * 可调用此方法获取对应的字符串内容，方便操作和展示。
// * @return 返回字段名对应的字符串值。
// */
public String getDicName() { public String getDicName() {
androidx.annotation.NonNull();
return dicName; return dicName;
} }
/**
* 获取：字段名
*/
// **
// * 设置：字段名，用于更新字段名（`dicName`），
//
// 比如对字典项的名称进行修改后，通过此方法保存新的名称信息，确保名称能准确反映字典项的实际含义。
// * @param dicName 要设置的字段名字符串值。
// */
public void setDicName(String dicName) { public void setDicName(String dicName) {
this.dicName = dicName; this.dicName = dicName;
} }
/**
* 设置：编码 // **
*/ // * 获取：编码，对外提供获取编码值（`codeIndex`）的方法，
//
// 在涉及到按照编码进行排序、查找特定编码的字典项等业务场景中，
// * 可调用此方法获取对应的整数值，便于进行相应的业务处理。
// * @return 返回编码对应的整数值。
// */
public Integer getCodeIndex() { public Integer getCodeIndex() {
return codeIndex; return codeIndex;
} }
/**
* 获取：编码
*/
// **
// * 设置：编码，用于更新编码值（`codeIndex`），
//
// 例如调整字典项的编号顺序或者重新分配编码后，
//
// 调用此方法来保存新的编码信息，以符合业务要求的编码规则。
// * @param codeIndex 要设置的编码整数值。
// */
public void setCodeIndex(Integer codeIndex) { public void setCodeIndex(Integer codeIndex) {
this.codeIndex = codeIndex; this.codeIndex = codeIndex;
} }
/**
* 设置：编码名字 // **
*/ // * 获取：编码名字，对外提供获取编码名字（`indexName`）的方法，
//
// 在需要展示编码对应的具体含义或者基于名称进行业务逻辑处理（如匹配、筛选等）时，
// * 可调用此方法获取对应的字符串内容，增强数据的可读性和可操作性。
// * @return 返回编码名字对应的字符串值。
// */
public String getIndexName() { public String getIndexName() {
return indexName; return indexName;
} }
/**
* 获取：编码名字
*/
// **
// * 设置：编码名字，用于更新编码名字（`indexName`），
//
// 比如对编码所代表的含义进行重新定义或者修改描述后，
//
// 通过此方法保存新的名称信息，
// * 以便准确传达编码的实际意义。
// * @param indexName 要设置的编码名字符串值。
// */
public void setIndexName(String indexName) { public void setIndexName(String indexName) {
this.indexName = indexName; this.indexName = indexName;
} }
/**
* 设置：父字段id // **
*/ // * 获取：父字段id，对外提供获取父字段id（`superId`）的方法，
//
// 在处理字典表的层级关系数据时，比如查找某个父项下的子项、
// * 判断字典项的层级归属等业务场景中，
//
//
// 可调用此方法获取对应的整数值，方便进行相关的关联操作和业务逻辑处理。
// * @return 返回父字段id对应的整数值。
// */
public Integer getSuperId() { public Integer getSuperId() {
return superId; return superId;
} }
/**
* 获取：父字段id
*/
// **
// * 设置：父字段id，用于更新父字段id（`superId`）的值，
//
// 例如调整字典项的层级结构、变更上级字段后，通过此方法保存新的父字段id信息，
// * 以正确反映字典项在层级关系中的位置变化。
// * @param superId 要设置的父字段id整数值。
// */
public void setSuperId(Integer superId) { public void setSuperId(Integer superId) {
this.superId = superId; this.superId = superId;
} }
/**
* 设置：备注 // **
*/ // * 获取：备注，对外提供获取备注信息（`beizhu`）的方法，
//
//
// 在需要查看字典项的额外说明或者根据备注内容进行一些特殊业务逻辑判断（如判断适用范围等）时，
// * 可调用此方法获取对应的字符串内容，辅助业务处理。
// * @return 返回备注对应的字符串值。
// */
public String getBeizhu() { public String getBeizhu() {
return beizhu; return beizhu;
} }
/**
* 获取：备注
*/
// **
// * 设置：备注，用于更新备注信息（`beizhu`），
//
// 例如添加、修改字典项的备注内容后，
//
// 通过此方法保存新的备注信息，方便后续查看和参考。
// * @param beizhu 要设置的备注字符串值。
// */
public void setBeizhu(String beizhu) { public void setBeizhu(String beizhu) {
this.beizhu = beizhu; this.beizhu = beizhu;
} }
/**
* 设置：创建时间 // **
*/ // * 获取：创建时间，
//
// 对外提供获取创建时间（`createTime`）的方法，在展示字典表记录的创建时间、按照时间范围查询字典项、
// * 统计不同时间段创建的数据量等业务场景中，
//
//
// 可调用此方法获取对应的 `Date` 类型对象，用于后续的时间相关操作和展示。
// * @return 返回创建时间对应的 `Date` 类型对象。
// */
public Date getCreateTime() { public Date getCreateTime() {
return createTime; return createTime;
} }
/**
* 获取：创建时间
*/
// **
// * 设置：创建时间，用于更新创建时间（`createTime`）的值，
//
// 不过在实际业务中通常创建时间是在记录首次创建时自动设置，较少进行手动更新，
// * 但保留此方法以满足可能的特殊需求（如数据迁移、时间校准等场景下对创建时间进行调整），
//
// 通过传入对应的 `Date` 类型对象来更新创建时间信息。
// * @param createTime 要设置的创建时间对应的 `Date` 类型对象。
// */
public void setCreateTime(Date createTime) { public void setCreateTime(Date createTime) {
this.createTime = createTime; this.createTime = createTime;
} }
// **
// * 重写 `toString` 方法，用于返回 `DictionaryEntity`
//
// 对象的字符串表示形式，方便在调试、日志输出以及一些需要以字符串形式展示对象内容的场景中使用，
// * 按照自定义的格式将对象的各个属性值拼接成一个字符串，
//
// 使得可以直观地查看对象的属性信息，便于开发过程中的调试和问题排查等操作。
// * 返回的字符串格式形如 "Dictionary{" + "id=" + id + ", dicCode=" + dicCode + ", dicName=" + dicName + ", codeIndex=" + codeIndex + ", indexName=" + indexName + ", superId=" + superId + ", beizhu=" + beizhu + ", createTime=" + createTime + "}"，
// * 其中展示了各个属性的名称和对应的值，方便快速了解对象的状态。
// */
@Override @Override
public String toString() { public String toString() {
return "Dictionary{" + return "Dictionary{" +
"id=" + id + "id=" + id +
", dicCode=" + dicCode + ", dicCode=" + dicCode +
", dicName=" + dicName + ", dicName=" + dicName +
", codeIndex=" + codeIndex + ", codeIndex=" + codeIndex +
", indexName=" + indexName + ", indexName=" + indexName +
", superId=" + superId + ", superId=" + superId +
", beizhu=" + beizhu + ", beizhu=" + beizhu +
", createTime=" + createTime + ", createTime=" + createTime +
"}"; "}";
} }
} }

329
minsu/minsuguanliw/src/main/java/com/entity/TokenEntity.java
Unescape View File

@ -7,116 +7,337 @@ import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName; import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType; import com.baomidou.mybatisplus.enums.IdType;
/** /**
* token表 * token表
* 该类用于表示 `token` 相关的数据实体，
* 对应数据库中的 `token` 表结构，存储与用户 `token` 相关的各种信息，
* 实现了 `Serializable` 接口，
*
*
*
* 便能够在网络传输或者持久化存储（如保存到文件、数据库等情况）时进行序列化和反序列化操作，保证数据的完整性和可恢复性。
*/ */
@TableName("token") @TableName("token")
public class TokenEntity implements Serializable { public class TokenEntity implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
// **
// * 主键标识，通过 `@TableId`
//
//
// 注解指定该字段为主键，并且设置主键的生成策略为自增长（`IdType.AUTO`），
// * 在数据库插入操作时，系统会按照设定的自增长规则自动为该字段赋值，
//
//
// 用于唯一标识每条 `token` 记录，方便进行数据库层面的操作（如查询、更新、删除等），
// * 确保数据的唯一性和可定位性。
// */
@TableId(type = IdType.AUTO) @TableId(type = IdType.AUTO)
private Integer id; private Integer id;
/** // **
* 用户id // * 用户id，用于关联具体的用户，明确该 `token` 是属于哪个用户的标识信息，
*/ // * 通过这个字段可以建立 `token`
//
// 与用户之间的对应关系，在进行用户认证、权限验证等业务场景中，
// * 基于该用户 `id` 去查找对应的用户信息以及判断该 `token` 是否合法等操作。
// */
private Integer userid; private Integer userid;
/** // **
* 用户名 // * 用户名，存储对应用户的名称信息，
*/ //
// 与 `userid` 一起进一步明确用户身份，增强用户标识的可读性和可辨识度，
// * 在一些业务场景中（如展示用户相关信息、
//
// 记录操作日志等涉及到用户显示名称的情况）会用到该字段内容。
// */
private String username; private String username;
/** // **
* 表名 // * 表名，可能用于标识该 `token`
*/ //
//
// 相关数据存储所在的具体数据库表（在多表关联或者分表存储等复杂业务场景下），
// * 可以帮助更准确地定位和管理与该 `token` 相关的其他数据信息，
//
// 也有助于区分不同业务模块下的 `token` 情况，
// * 例如不同业务表对应的 `token` 有不同的作用范围和验证规则等，
//
// 通过这个字段可以进行区分和相应的业务处理。
// */
private String tablename; private String tablename;
/** // **
* 角色 // * 角色，用于记录用户在系统中所扮演的角色，例如管理员、普通用户、
*/ //
//
// 特定权限角色等不同角色往往具有不同的权限范围，
// * 通过该 `role` 字段可以在基于 `token` 进行权限验证等操作时，
//
// 判断用户是否具备执行某些特定操作的权限，
// * 确保系统的安全性和数据访问的合法性。
// */
private String role; private String role;
/** // **
* token // * token，存储实际的 `token` 字符串值，
*/ //
// 这是用于标识用户身份的关键信息，
//
// 在用户登录成功或者进行身份验证等操作后生成，
// * 后续用户在访问系统接口、进行页面操作等场景下，
//
// 需要携带该 `token` 字符串进行身份验证，系统通过验证该 `token` 的有效性来确定用户是否有权限继续操作，
// * 它通常是一个具有一定随机性和唯一性的字符串，
//
// 保证每个用户的 `token` 都能唯一标识其身份。
// */
private String token; private String token;
/** // **
* 过期时间 // * 过期时间，记录该 `token` 的有效截止时间，
*/ //
// 通过设置过期时间可以提高系统的安全性，避免 `token` 长期有效可能带来的安全风险，
// * 在进行 `token` 验证时，
//
// 会对比当前时间与该过期时间来判断 `token` 是否仍然有效，
//
// 对于过期的 `token` 则拒绝相应的操作请求，
// * 通常是一个 `Date` 类型的时间对象，表示具体的时间点。
// */
private Date expiratedtime; private Date expiratedtime;
/** // **
* 新增时间 // * 新增时间，记录该 `token` 在系统中创建的时间点，
*/ //
// 可用于查询、统计等业务场景，例如查看新生成的 `token` 情况、
// * 分析不同时间段内 `token` 的生成频率等，
//
// 也有助于在一些数据管理和审计场景下了解 `token` 的生命周期相关信息，
// * 同样是一个 `Date` 类型的时间对象。
// */
private Date addtime; private Date addtime;
// **
// * 获取：主键，对外提供获取主键值（`id`）的方法，
//
// 方便在其他类中访问该 `TokenEntity` 对象的主键信息，
// * 例如在进行数据库查询结果映射或者业务逻辑处理中需要用到
//
// `token` 记录主键时可调用此方法获取，返回对应的整数值。
// * @return 返回主键对应的整数值。
// */
public Integer getId() { public Integer getId() {
return id; return id;
} }
// **
// * 设置：主键，用于设置该对象的主键值，
//
// 通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用，
// * 不过由于主键一般是自增长且由数据库管理，
// 在实际业务中手动设置的情况相对较少，
// 但保留此方法以满足可能的特殊需求（如数据迁移等场景），
// * 通过传入对应的整数值来更新主键信息。
// * @param id 要设置的主键整数值。
// */
public void setId(Integer id) { public void setId(Integer id) {
this.id = id; this.id = id;
} }
// **
// * 获取：用户id，对外提供获取用户 `id`
//
// 值（`userid`）的方法，在需要关联用户信息、进行基于用户的业务逻辑处理（如查找用户相关的其他数据、
// * 判断 `token` 所属用户等情况）时，
// 可调用此方法获取对应的整数值，便于操作和业务逻辑实现。
// * @return 返回用户 `id` 对应的整数值。
// */
public Integer getUserid() { public Integer getUserid() {
return userid; return userid;
} }
// **
// * 设置：用户id，用于更新用户 `id` 值（`userid`），
// 例如在某些特殊情况下（如用户信息变更导致关联的 `userid` 需要调整等），
// * 通过传入新的整数值来改变该 `TokenEntity`
// 对象所关联的用户标识信息，不过这种情况相对较少出现，需谨慎操作以保证数据一致性。
// * @param userid 要设置的用户 `id` 整数值。
// */
public void setUserid(Integer userid) { public void setUserid(Integer userid) {
this.userid = userid; this.userid = userid;
} }
public String getRole() { // **
return role; // * 获取：用户名，对外提供获取用户名（`username`）的方法，
} //
//
public void setRole(String role) { // 在需要展示用户名称、基于用户名进行业务逻辑处理（如记录操作日志中显示用户名等情况）时，
this.role = role; // * 可调用此方法获取对应的字符串内容，方便进行相应的展示和操作。
// * @return 返回用户名对应的字符串值。
// */
public String getUsername() {
return username;
} }
public String getToken() { // **
return token; // * 设置：用户名，用于更新用户名（`username`），
//
// 比如用户修改了自己的用户名后，通过此方法保存新的用户名信息到该 `TokenEntity` 对象中，
// * 确保相关业务逻辑中获取到的用户名是最新且准确的，
//
// 需要注意的是这种更新可能需要同时考虑与其他关联数据的一致性等问题。
// * @param username 要设置的用户名字符串值。
// */
public void setUsername(String username) {
this.username = username;
} }
// **
// * 获取：表名，对外提供获取表名（`tablename`）的方法，
//
// 在涉及到多表关联操作、区分不同业务模块下 `token` 的处理逻辑或者根据表名查找相关数据等业务场景中，
// * 可调用此方法获取对应的字符串内容，
//
// 便于进行相应的数据库操作和业务处理。
// * @return 返回表名对应的字符串值。
// */
public String getTablename() { public String getTablename() {
return tablename; return tablename;
} }
// **
// * 设置：表名，用于更新表名（`tablename`），
//
// 在一些特殊的业务场景变化（如数据库结构调整、业务模块重新划分导致表名变更等）时，
// * 通过传入新的字符串值来改变该 `TokenEntity`
//
// 对象对应的表名信息，不过这种变更需要谨慎处理，确保与数据库实际情况以及其他相关代码逻辑的一致性。
// * @param tablename 要设置的表名字符串值。
// */
public void setTablename(String tablename) { public void setTablename(String tablename) {
this.tablename = tablename; this.tablename = tablename;
} }
// **
// * 获取：角色，对外提供获取角色（`role`）的方法，
//
// 在基于 `token` 进行权限验证、判断用户在系统中的操作权限范围等业务场景中，
// * 可调用此方法获取对应的字符串内容，
//
// 以便根据角色信息进行相应的权限控制和业务逻辑处理。
// * @return 返回角色对应的字符串值。
// */
public String getRole() {
return role;
}
// **
// * 设置：角色，用于更新角色（`role`），
//
// 例如在系统进行角色调整、用户权限变更等情况下，通过传入新的字符串值来改变该 `TokenEntity` 对象中记录的用户角色信息，
// * 从而影响后续基于角色的权限验证等业务操作，
//
// 同样需要注意保证数据一致性以及相关业务逻辑的正确调整。
// * @param role 要设置的角色字符串值。
// */
public void setRole(String role) {
this.role = role;
}
// **
// * 获取：token，对外提供获取 `token`
//
// 字符串值（`token`）的方法，在需要使用 `token` 进行身份验证、传递给其他模块进行相关操作等场景中，
// * 可调用此方法获取对应的字符串内容，
//
// 它是整个 `TokenEntity` 对象中最为关键的用于标识用户身份的信息部分。
// * @return 返回 `token` 对应的字符串值。
// */
public String getToken() {
return token;
}
// **
// * 设置：token，用于更新 `token` 字符串值（`token`），
//
// 通常在 `token` 重新生成（如用户重新登录、`token` 过期后重新获取等情况）时，
// * 通过传入新的字符串值来替换原有的 `token` 信息，
//
// 确保 `token` 的有效性和安全性，同时需要注意更新相关的验证逻辑以及与其他模块的交互情况。
// * @param token 要设置的 `token` 字符串值。
// */
public void setToken(String token) { public void setToken(String token) {
this.token = token; this.token = token;
} }
// **
// * 获取：过期时间，对外提供获取过期时间（`expiratedtime`）的方法，
//
// 在进行 `token` 有效性验证、判断是否需要重新获取 `token` 等业务场景中，
// * 可调用此方法获取对应的 `Date` 类型对象，
//
// 以便与当前时间进行比较操作，进而确定 `token` 是否还能继续使用。
// * @return 返回过期时间对应的 `Date` 类型对象。
// */
public Date getExpiratedtime() { public Date getExpiratedtime() {
return expiratedtime; return expiratedtime;
} }
// **
// * 设置：过期时间，用于更新过期时间（`expiratedtime`）的值，
//
// 例如在调整 `token` 的有效期策略、手动延长或缩短 `token` 有效期等特殊情况下，
// * 通过传入新的 `Date` 类型对象来改变该 `TokenEntity`
//
// 对象中记录的 `token` 过期时间信息，不过这种操作需要谨慎进行，避免影响系统的安全性和正常业务流程。
// * @param expiratedtime 要设置的过期时间对应的 `Date` 类型对象。
// */
public void setExpiratedtime(Date expiratedtime) { public void setExpiratedtime(Date expiratedtime) {
this.expiratedtime = expiratedtime; this.expiratedtime = expiratedtime;
} }
// **
// * 获取：新增时间，对外提供获取新增时间（`addtime`）的方法，
//
// 在进行数据统计、审计以及一些基于时间顺序的业务逻辑处理（如查找近期生成的 `token` 等情况）时，
// * 可调用此方法获取对应的 `Date` 类型对象，方便进行相应的时间相关操作和业务逻辑实现。
// * @return 返回新增时间对应的 `Date` 类型对象。
// */
public Date getAddtime() { public Date getAddtime() {
return addtime; return addtime;
} }
// **
// * 设置：新增时间，用于更新新增时间（`addtime`）的值，
//
// 虽然在实际业务中新增时间一般是在 `token` 创建时自动记录且较少手动修改，
// * 但保留此方法以满足可能的特殊需求（如数据迁移、时间校准等场景下对新增时间进行调整），
//
// 通过传入对应的 `Date` 类型对象来更新新增时间信息，
// * 同样需要注意保证数据的合理性和一致性。
// */
public void setAddtime(Date addtime) { public void setAddtime(Date addtime) {
this.addtime = addtime; this.addtime = addtime;
} }
public String getUsername() { // **
return username; // * 构造函数，用于创建 `TokenEntity` 对象实例时传入必要的参数进行初始化，
} //
// 通常在创建新的 `token` 相关记录或者从数据库等外部数据源加载数据后创建对象时使用，
public void setUsername(String username) { // * 接收用户 `id`、用户名、表名、角色、`token` 字符串以及过期时间等参数，
this.username = username; //
} // 按照传入的值初始化对象的各个属性，方便快速构建一个完整的 `TokenEntity` 对象，
// * 用于后续的业务操作（如插入数据库、传递给其他模块等）。
public TokenEntity(Integer userid, String username, String tablename,String role, String token, Date expiratedtime) { // * @param userid 用户的唯一标识，整数值。
// * @param username 用户的名称，字符串值。
// * @param tablename 所属表名，字符串值。
// * @param role 用户在系统中所扮演的角色，字符串值。
// * @param token 用于标识用户身份的 `token` 字符串值。
// * @param expiratedtime `token` 的过期时间，`Date` 类型对象。
// */
public TokenEntity(Integer userid, String username, String tablename, String role, String token, Date expiratedtime) {
super(); super();
this.userid = userid; this.userid = userid;
this.username = username; this.username = username;
@ -125,8 +346,16 @@ public class TokenEntity implements Serializable {
this.token = token; this.token = token;
this.expiratedtime = expiratedtime; this.expiratedtime = expiratedtime;
} }
// **
// * 默认构造函数，用于创建一个空的 `TokenEntity` 对象实例，
//
// 当需要先创建对象再逐步设置属性值时可使用该构造函数，
// * 例如在一些复杂的业务逻辑中，先创建对象占位，后续根据不同的条件和数据来源来分别设置对象的各个属性，
//
// 方便灵活构建 `TokenEntity` 对象，
// * 为空对象的初始化提供了一种方式。
// */
public TokenEntity() { public TokenEntity() {
} }
}
}

278
minsu/minsuguanliw/src/main/java/com/entity/model/DictionaryModel.java
Unescape View File

@ -8,180 +8,266 @@ import java.util.Date;
import org.springframework.format.annotation.DateTimeFormat; import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable; import java.io.Serializable;
/** /**
* 字典表 * 字典表
* 接收传参的实体类 * 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了） * 该类主要用于在系统与外部（如移动端等）
* 取自ModelAndView 的model名称 * 进行数据交互时，接收传递过来的与字典表相关的参数信息，起到数据传输载体的作用。
* 在实际开发中，根据具体业务场景，
* 可以手动对其包含的字段进行筛选调整（去掉一些在特定接口或业务逻辑中不需要的字段），
* 因为后端在很多情况下直接使用 `entity` 类
* （如 `DictionaryEntity`）就可以满足基本的数据操作需求，这里的 `Model` 类更侧重于接收外部传入的数据格式适配。
* 其名称取自 `ModelAndView` 的 `model`，
* 暗示了它在数据传递和视图模型构建方面的作用（通常用于构建适合展示或处理的数据模型结构）。
*/ */
public class DictionaryModel implements Serializable { public class DictionaryModel implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
// **
// * 主键，用于唯一标识字典表中的每一条记录，
// 在数据库操作中（如查询、更新、删除等）可通过主键精准定位到特定的字典表数据行，
/** // * 通常对应数据库表中定义的主键字段，
* 主键 // 保证数据的唯一性和可识别性。
*/ // */
private Integer id; private Integer id;
// **
/** // * 字段，可能用于存储字典表中某个条目的特定代码或者标识信息，
* 字段 // 例如可以是代表不同分类、类型等的代码值，
*/ // * 通过该字段能够区分不同的字典项，
// 并且在业务逻辑中可以基于此字段进行相关的查询、匹配等操作。
// */
private String dicCode; private String dicCode;
// **
/** // * 字段名，与 `dicCode` 相对应，
* 字段名 // 用于存储该字段对应的直观的名称描述，
*/ // 方便在前端展示或者业务逻辑处理中让人更容易理解该字段所代表的含义，
// * 例如如果 `dicCode` 是分类代码，那 `dicName` 就是具体的分类名称，增强了数据的可读性。
// */
private String dicName; private String dicName;
// **
/** // * 编码，可能是对字典表中各项进行编号的一个整数值，
* 编码 // 用于在内部对字典项进行排序、索引或者作为另一种标识方式，
*/ // * 在一些需要按照特定顺序处理字典数据或者通过编号快速查找字典项的业务场景中会发挥作用。
// */
private Integer codeIndex; private Integer codeIndex;
// **
/** // * 编码名字，与 `codeIndex` 相对应，
* 编码名字 // 是对该编码所代表含义的文字描述，
*/ // 同样是为了提高数据的可读性和可理解性，
// * 便于在展示给用户或者业务逻辑处理中清晰地知晓该编码具体对应的内容。
// */
private String indexName; private String indexName;
// **
/** // * 父字段id，用于表示当前字典项在层级结构中的上级字段的唯一标识（如果字典表存在层级关系的话），
* 父字段id // * 通过这个 `superId`
*/ // 可以构建字典项之间的父子关联关系，方便进行树形结构数据的展示、
// 查询以及相关业务逻辑处理（比如查找某个分类下的子分类等情况）。
// */
private Integer superId; private Integer superId;
// **
/** // * 备注，用于存储一些对该字典项的额外说明信息，
* 备注 // 例如该项的特殊用途、适用范围、创建背景等内容，
*/ // * 在需要详细了解字典项相关细节或者进行一些辅助性的业务逻辑判断时，
// 可以参考备注中的信息。
// */
private String beizhu; private String beizhu;
// **
/** // * 创建时间，记录该字典表记录的创建时间点，
* 创建时间 // 通过 `@JsonFormat` 和 `@DateTimeFormat` 注解来规范时间格式的序列化与格式化处理，
*/ // * 确保在前后端交互以及数据存储等场景下时间格式的一致性。
@JsonFormat(locale="zh", timezone="GMT+8", pattern="yyyy-MM-dd HH:mm:ss") // 例如在按照时间顺序查询字典表数据、统计不同时间段创建的数据量等业务场景中会用到该时间信息。
@DateTimeFormat // * @JsonFormat 注解用于控制在将对象转换为JSON格式时时间的显示格式。
// * @DateTimeFormat 注解用于在接收前端传入时间格式数据时进行解析转换。
// */
@JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat
private Date createTime; private Date createTime;
// **
/** // * 获取：主键，对外提供获取主键值的方法，
* 获取：主键 // 方便在其他类中访问该对象的主键信息，
*/ // 例如在进行数据库查询结果映射或者业务逻辑处理中需要用到字典表记录主键时可调用此方法获取。
// * @return 返回主键对应的整数值。
// */
public Integer getId() { public Integer getId() {
return id; return id;
} }
// **
/** // * 设置：主键，用于设置该对象的主键值，
* 设置：主键 // 通常在对象初始化或者从数据库等外部数据源加载数据后更新主键值时使用
*/ // ，例如创建新字典表记录对象并保存到数据库前需要设置主键值。
// * @param id 要设置的主键整数值。
// */
public void setId(Integer id) { public void setId(Integer id) {
this.id = id; this.id = id;
} }
/**
* 获取：字段 // **
*/ // * 获取：字段，对外提供获取字段值（`dicCode`）的方法，
// 以便在业务逻辑中根据该字段进行相关操作，比如查询特定代码的字典项、
// * 根据代码进行匹配判断等情况时可调用此方法获取字段值，返回对应的字符串内容。
// * @return 返回字段对应的字符串值。
// */
public String getDicCode() { public String getDicCode() {
return dicCode; return dicCode;
} }
// **
/** // * 设置：字段，用于更新字段值（`dicCode`），
* 设置：字段 // 例如在修改字典表记录中该字段的代码内容后，
*/ // 调用此方法来保存新的代码信息，以反映字典项的变化。
// * @param dicCode 要设置的字段字符串值。
// */
public void setDicCode(String dicCode) { public void setDicCode(String dicCode) {
this.dicCode = dicCode; this.dicCode = dicCode;
} }
/**
* 获取：字段名 // **
*/ // * 获取：字段名，对外提供获取字段名（`dicName`）的方法，
// 在需要展示字典项的名称给用户或者在业务逻辑中基于名称进行相关处理（如筛选、排序等）时，
// * 可调用此方法获取对应的字符串内容，方便操作和展示。
// * @return 返回字段名对应的字符串值。
// */
public String getDicName() { public String getDicName() {
return dicName; return dicName;
} }
// **
/** // * 设置：字段名，用于更新字段名（`dicName`），
* 设置：字段名 // 比如对字典项的名称进行修改后，通过此方法保存新的名称信息，
*/ // 确保名称能准确反映字典项的实际含义。
// * @param dicName 要设置的字段名字符串值。
// */
public void setDicName(String dicName) { public void setDicName(String dicName) {
this.dicName = dicName; this.dicName = dicName;
} }
/**
* 获取：编码 // **
*/ // * 获取：编码，对外提供获取编码值（`codeIndex`）的方法，
// 在涉及到按照编码进行排序、查找特定编码的字典项等业务场景中，
// * 可调用此方法获取对应的整数值，便于进行相应的业务处理。
// * @return 返回编码对应的整数值。
// */
public Integer getCodeIndex() { public Integer getCodeIndex() {
return codeIndex; return codeIndex;
} }
// **
/** // * 设置：编码，用于更新编码值（`codeIndex`），
* 设置：编码 // 例如调整字典项的编号顺序或者重新分配编码后，
*/ // 调用此方法来保存新的编码信息，以符合业务要求的编码规则。
// * @param codeIndex 要设置的编码整数值。
// */
public void setCodeIndex(Integer codeIndex) { public void setCodeIndex(Integer codeIndex) {
this.codeIndex = codeIndex; this.codeIndex = codeIndex;
} }
/**
* 获取：编码名字 // **
*/ // * 获取：编码名字，对外提供获取编码名字（`indexName`）的方法，
// 在需要展示编码对应的具体含义或者基于名称进行业务逻辑处理（如匹配、筛选等）时，
// * 可调用此方法获取对应的字符串内容，增强数据的可读性和可操作性。
// * @return 返回编码名字对应的字符串值。
// */
public String getIndexName() { public String getIndexName() {
return indexName; return indexName;
} }
// **
/** // * 设置：编码名字，用于更新编码名字（`indexName`），
* 设置：编码名字 // 比如对编码所代表的含义进行重新定义或者修改描述后，通过此方法保存新的名称信息，
*/ // * 以便准确传达编码的实际意义。
// * @param indexName 要设置的编码名字符串值。
// */
public void setIndexName(String indexName) { public void setIndexName(String indexName) {
this.indexName = indexName; this.indexName = indexName;
} }
/**
* 获取：父字段id // **
*/ // * 获取：父字段id，对外提供获取父字段id（`superId`）的方法，
// 在处理字典表的层级关系数据时，比如查找某个父项下的子项、
// * 判断字典项的层级归属等业务场景中，
// 可调用此方法获取对应的整数值，
// 方便进行相关的关联操作和业务逻辑处理。
// * @return 返回父字段id对应的整数值。
// */
public Integer getSuperId() { public Integer getSuperId() {
return superId; return superId;
} }
// **
// * 设置：父字段id，用于更新父字段id（`superId`）的值，
// 例如调整字典项的层级结构、变更上级字段后，通过此方法保存新的父字段id信息，
// * 以正确反映字典项在层级关系中的位置变化。
// * @param superId 要设置的父字段id整数值。
// */
/**
* 设置：父字段id
*/
public void setSuperId(Integer superId) { public void setSuperId(Integer superId) {
this.superId = superId; this.superId = superId;
} }
/**
* 获取：备注 // **
*/ // * 获取：备注，对外提供获取备注信息（`beizhu`）的方法，
//
// 在需要查看字典项的额外说明或者根据备注内容进行一些特殊业务逻辑判断（如判断适用范围等）时，
// * 可调用此方法获取对应的字符串内容，辅助业务处理。
// * @return 返回备注对应的字符串值。
// */
public String getBeizhu() { public String getBeizhu() {
return beizhu; return beizhu;
} }
// **
/** // * 设置：备注，用于更新备注信息（`beizhu`），
* 设置：备注 //
*/ // 例如添加、修改字典项的备注内容后，通过此方法保存新的备注信息，方便后续查看和参考。
// * @param beizhu 要设置的备注字符串值。
// */
public void setBeizhu(String beizhu) { public void setBeizhu(String beizhu) {
this.beizhu = beizhu; this.beizhu = beizhu;
} }
/**
* 获取：创建时间 // **
*/ // * 获取：创建时间，对外提供获取创建时间（`createTime`）的方法，
//
// 在展示字典表记录的创建时间、按照时间范围查询字典项、
// * 统计不同时间段创建的数据量等业务场景中，可调用此方法获取对应的 `
//
//
// Date` 类型对象，用于后续的时间相关操作和展示。
// * @return 返回创建时间对应的 `Date` 类型对象。
// */
public Date getCreateTime() { public Date getCreateTime() {
return createTime; return createTime;
} }
// **
/** // * 设置：创建时间，用于更新创建时间（`createTime`）的值
* 设置：创建时间 //
*/ // ，不过在实际业务中通常创建时间是在记录首次创建时自动设置，较少进行手动更新，
// * 但保留此方法以满足可能的特殊需求（如数据迁移、时间校准等场景下对创建时间进行调整），
//
// 通过传入对应的 `Date` 类型对象来更新创建时间信息。
// * @param createTime 要设置的创建时间对应的 `Date` 类型对象。
// */
public void setCreateTime(Date createTime) { public void setCreateTime(Date createTime) {
this.createTime = createTime; this.createTime = createTime;
} }
}
}

61
minsu/minsuguanliw/src/main/java/com/entity/view/DictionaryView.java
Unescape View File

@ -12,19 +12,45 @@ import java.util.Date;
/** /**
* 字典表 * 字典表
* 后端返回视图实体辅助类 * 后端返回视图实体辅助类
* （通常后端关联的表或者自定义的字段需要返回使用） * 此类主要用于作为后端向外部（如前端界面或者其他调用接口的客户端）返回数据时的视图实体辅助类，
* 它继承自 `DictionaryEntity`，意味着拥有 `DictionaryEntity` 的所有属性及方法，
* 并且在此基础上可以根据业务需求添加额外的属性或者方法，
* 用于构建适合展示给外部的视图数据结构。通常在后端业务逻辑中涉及到关联其他表或者有自定义的字段需要一并返回给前端等使用场景下发挥作用，
* 帮助对要返回的数据进行整合、格式转换以及添加必要的展示相关逻辑等操作，
* 以满足前端展示或外部调用者对数据格式和内容的期望。
*/ */
@TableName("dictionary") @TableName("dictionary")
public class DictionaryView extends DictionaryEntity implements Serializable { public class DictionaryView extends DictionaryEntity implements Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
// **
// * 默认构造函数，用于创建一个空的 `DictionaryView`
// 对象实例，在某些场景下（比如先创建对象，后续再根据具体数据来填充属性值）会使用到，
// * 提供了一种灵活创建该视图实体对象的方式，
//
// 方便后续在复杂业务逻辑中按需构建对象并设置其属性。
// */
public DictionaryView() { public DictionaryView() {
} }
// **
// * 构造函数，用于根据传入的 `DictionaryEntity` 对象，
//
// 通过 `BeanUtils` 工具类将其属性值复制到当前 `DictionaryView` 对象中，
// * 这样可以方便地基于已有的 `DictionaryEntity`
//
//
// 类型的数据对象来初始化 `DictionaryView` 对象，实现数据的传递和复用，避免重复设置各个属性，提高代码效率，
// * 在后端从数据库查询出 `DictionaryEntity` 数据后，
//
// 若要转换为适合返回的视图实体时，就可以使用这个构造函数进行属性值的复制，
//
// 不过在使用过程中需要注意可能出现的异常情况（已在代码中对异常进行了简单处理）。
// * @param dictionaryEntity 要复制属性值的 `DictionaryEntity`
//
// 对象，通过该对象的属性来初始化当前 `DictionaryView` 对象的属性。
// */
public DictionaryView(DictionaryEntity dictionaryEntity) { public DictionaryView(DictionaryEntity dictionaryEntity) {
try { try {
BeanUtils.copyProperties(this, dictionaryEntity); BeanUtils.copyProperties(this, dictionaryEntity);
@ -33,25 +59,4 @@ public class DictionaryView extends DictionaryEntity implements Serializable {
e.printStackTrace(); e.printStackTrace();
} }
} }
}
}

68
minsu/minsuguanliw/src/main/java/com/service/DictionaryService.java
Unescape View File

@ -8,17 +8,67 @@ import javax.servlet.http.HttpServletRequest;
/** /**
* 字典表 服务类 * 字典表 服务类
* 该接口定义了与字典表相关的业务逻辑方法，
* 继承自 MyBatis Plus 的 `IService`
* 接口（意味着具备 `IService` 提供的通用数据库操作相关的方法，如基本的增删改查等功能），
* 在此基础上扩展了针对字典表特有的业务操作方法，
* 用于满足项目中对字典表数据处理的具体需求，方便在不同的业务场景下调用对应的方法来实现相应功能，
* 并且使得业务逻辑与数据持久化操作进行了有效的分离，
* 提高代码的可维护性和可扩展性。
*/ */
public interface DictionaryService extends IService<DictionaryEntity> { public interface DictionaryService extends IService<DictionaryEntity> {
/** /**
* @param params 查询参数 * 根据传入的查询参数进行字典表数据的分页查询操作，并返回分页后的查询结果。
* @return 带分页的查询出来的数据 * 此方法是用于满足按照特定条件分页获取字典表数据的业务需求，
*/ * 调用者可以传入包含各种查询条件（
PageUtils queryPage(Map<String, Object> params); *
/** *
* 字典表转换 * 如筛选条件、排序条件、页码、每页显示数量等信息）的 `Map` 类型参数，
* @param obj * 该方法内部会基于这些参数与数据库进行交互，执行相应的查询语句，
*/ *
void dictionaryConvert(Object obj, HttpServletRequest request); * 获取符合条件的字典表数据分页信息，最终将结果封装在 `PageUtils`
*
* 类型的对象中返回，方便后续进行分页展示或其他相关业务处理。
*
* @param params 查询参数，是一个 `Map` 类型的数据结构，
*
* 用于传递各种查询条件信息，不同的键值对可以表示不同的含义，
* 例如可以通过特定的键设置筛选字典表数据的关键字、
*
* 按照某个字段进行排序的规则、指定要获取的页码以及每页显示的记录数量等，以灵活控制查询逻辑，获取期望的分页数据。
* @return 返回一个 `PageUtils` 类型的对象，
*
* 该对象中封装了分页后的字典表数据以及分页相关的元信息（比如总记录数、总页数等），
* 方便在前端展示或者其他业务场景下对分页数据进行处理，
*
* 例如分页展示、数据统计等操作。
*/
PageUtils queryPage(Map<String, Object> params);
/**
* 对字典表相关的数据对象进行转换操作，具体的转换逻辑可能根据业务需求而定，
*
* 并且会依赖于请求相关的上下文信息（通过 `HttpServletRequest` 获取）。
* 这个方法通常用于对从数据库查询出来的字典表数据（可能是原始的实体对象或者其他相关的数据结构）
*
* 进行一些额外的处理，比如对字典表中的某些字段值进行格式转换、
* 根据业务规则进行重新赋值、关联其他相关数据等操作，使其更适合后续的展示或者业务逻辑处理，
*
* 传入的 `Object` 类型参数表示可以接受各种类型的与字典表相关的数据对象进行转换处理。
*
* @param obj 要进行转换操作的对象，类型为 `Object`，
*
* 它可以是字典表对应的实体类对象（如 `DictionaryEntity` 及其子类等）或者其他包含字典表相关数据的对象结构，
* 具体的类型取决于调用该方法时传入的实际参数情况，该对象将作为转换操作的基础数据来源，
*
* 其内部的字典表相关属性会根据业务逻辑进行相应的转换处理。
* @param request `HttpServletRequest` 对象，用于获取请求相关的上下文信息，
*
* 例如可以从中获取用户相关信息、请求头信息等，这些信息可能会辅助字典表数据的转换逻辑，
* 比如根据用户的不同权限或者地区设置等对字典表中的某些字段进行不同的转换处理，
*
* 确保转换后的数据符合具体业务场景下的展示和使用要求。
*/
void dictionaryConvert(Object obj, HttpServletRequest request);
} }
Write Preview
Loading…
Cancel
Save