p4vkf3rot
/
j2ee1
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

注释代码

Browse Source
wujiamei_branch
wjm 9 months ago
parent 1e85e38192
commit b723657e0a
24 changed files with 1518 additions and 1038 deletions
Show Stats Download Patch File Download Diff File

148
src/main/java/com/controller/ChatController.java
Unescape View File

@ -42,214 +42,310 @@ import com.utils.CommonUtil;
/**
* 在线咨询
* 后端接口
* @author
* @email
* @author （这里应该填写作者姓名，但代码中未给出具体值）
* @email （这里应该填写作者邮箱，但代码中未给出具体值）
* @date 2023-02-21 09:46:06
*/
@RestController
@RequestMapping("/chat")
public class ChatController {
// 自动注入ChatService实例，用于处理与聊天相关的业务逻辑
@Autowired
private ChatService chatService;
/**
* 后端列表
* 用于获取聊天记录列表，根据不同用户角色（管理员或普通用户）进行数据筛选
* @param params 包含查询参数的Map，例如分页参数、筛选条件等
* @param chat ChatEntity对象，可能包含一些额外的查询条件
* @param request HttpServletRequest对象，用于获取当前会话信息
* @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, ChatEntity chat,
HttpServletRequest request) {
// 如果当前用户不是管理员角色，设置查询条件，只查询当前用户的聊天记录
if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
chat.setUserid((Long) request.getSession().getAttribute("userId"));
}
// 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
// 调用chatService的queryPage方法进行分页查询，传入构建好的查询条件和参数
PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
// 将查询结果设置到请求属性中，可能用于在后续的视图渲染中使用
request.setAttribute("data", page);
// 返回包含查询结果的R对象，通常R对象用于统一封装返回结果的状态和数据
return R.ok().put("data", page);
}
/**
* 前端列表
* 功能与后端列表类似，但可能在前端展示时有不同的处理或用途
* @param params 包含查询参数的Map，例如分页参数、筛选条件等
* @param chat ChatEntity对象，可能包含一些额外的查询条件
* @param request HttpServletRequest对象，用于获取当前会话信息
* @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
*/
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, ChatEntity chat,
HttpServletRequest request) {
// 如果当前用户不是管理员角色,设置查询条件，只查询当前用户的聊天记录
if (!request.getSession().getAttribute("role").toString().equals("管理员")) {
chat.setUserid((Long) request.getSession().getAttribute("userId"));
}
// 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
// 调用chatService的queryPage方法进行分页查询，传入构建好的查询条件和参数
PageUtils page = chatService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, chat), params), params));
// 将查询结果设置到请求属性中，可能用于在后续的视图渲染中使用
request.setAttribute("data", page);
// 返回包含查询结果的R对象，通常R对象用于统一封装返回结果的状态和数据
return R.ok().put("data", page);
}
/**
* 列表
* 用于获取聊天记录列表，根据传入的ChatEntity对象构建查询条件
* @param chat ChatEntity对象，包含查询条件信息
* @return R类型的结果，包含查询到的聊天记录列表数据及相关状态信息
*/
@RequestMapping("/lists")
public R list(ChatEntity chat) {
// 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
// 根据传入的ChatEntity对象构建等值查询条件
ew.allEq(MPUtil.allEQMapPre(chat, "chat"));
// 调用chatService的selectListView方法进行查询，并返回结果
return R.ok().put("data", chatService.selectListView(ew));
}
/**
* 查询
* 用于查询特定条件的在线咨询记录，并返回详细信息视图
* @param chat ChatEntity对象，包含查询条件信息
* @return R类型的结果，包含查询到的在线咨询详细信息视图及相关状态信息
*/
@RequestMapping("/query")
public R query(ChatEntity chat) {
// 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
EntityWrapper<ChatEntity> ew = new EntityWrapper<ChatEntity>();
// 根据传入的ChatEntity对象构建等值查询条件
ew.allEq(MPUtil.allEQMapPre(chat, "chat"));
// 调用chatService的selectView方法进行查询，获取ChatView对象（可能是包含详细信息的视图对象）
ChatView chatView = chatService.selectView(ew);
// 返回包含查询结果的R对象，以及提示信息和查询到的详细信息视图
return R.ok("查询在线咨询成功").put("data", chatView);
}
/**
* 后端详情
* 用于获取指定ID的聊天记录详细信息
* @param id 聊天记录的ID
* @return R类型的结果，包含查询到的聊天记录详细信息及相关状态信息
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
// 调用chatService的selectById方法，根据ID查询聊天记录
ChatEntity chat = chatService.selectById(id);
// 返回包含查询结果的R对象
return R.ok().put("data", chat);
}
/**
* 前端详情
* 功能与后端详情类似，但可能在前端展示时有不同的处理或用途，且此方法标注了@IgnoreAuth，表示忽略权限验证
* @param id 聊天记录的ID
* @return R类型的结果，包含查询到的聊天记录详细信息及相关状态信息
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id) {
// 调用chatService的selectById方法，根据ID查询聊天记录
ChatEntity chat = chatService.selectById(id);
// 返回包含查询结果的R对象
return R.ok().put("data", chat);
}
/**
* 后端保存
* 用于保存新的聊天记录，包括设置一些默认值和根据聊天内容更新相关状态
* @param chat 包含聊天记录信息的ChatEntity对象
* @param request HttpServletRequest对象，用于获取当前会话信息
* @return R类型的结果，用于表示保存操作的结果状态
*/
@RequestMapping("/save")
public R save(@RequestBody ChatEntity chat, HttpServletRequest request) {
// 设置聊天记录的ID，由当前时间戳加上一个随机数生成
chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 此处原本可能用于验证ChatEntity对象的合法性，但被注释掉了
//ValidatorUtils.validateEntity(chat);
// 如果聊天记录的提问内容不为空
if (StringUtils.isNotBlank(chat.getAsk())) {
// 更新当前用户的未回复状态为0，表示有新提问
chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
// 设置聊天记录的用户ID为当前用户ID
chat.setUserid((Long) request.getSession().getAttribute("userId"));
// 设置回复状态为1，表示已提问等待回复
chat.setIsreply(1);
}
// 如果聊天记录的回复内容不为空
if (StringUtils.isNotBlank(chat.getReply())) {
// 更新当前用户（提问用户）的未回复状态为0，表示有新回复
chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid()));
// 设置聊天记录的管理员ID为当前用户ID（可能表示回复的管理员）
chat.setAdminid((Long) request.getSession().getAttribute("userId"));
}
// 调用chatService的insert方法插入新的聊天记录
chatService.insert(chat);
// 返回表示保存成功的R对象
return R.ok();
}
/**
* 前端保存
* 功能与后端保存类似，但可能在前端保存时有不同的处理或用途
* @param chat 包含聊天记录信息的ChatEntity对象
* @param request HttpServletRequest对象，用于获取当前会话信息
* @return R类型的结果，用于表示保存操作的结果状态
*/
@RequestMapping("/add")
public R add(@RequestBody ChatEntity chat, HttpServletRequest request) {
// 设置聊天记录的ID，由当前时间戳加上一个随机数生成
chat.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
//ValidatorUtils.validateEntity(chat);
// 设置聊天记录的用户ID为当前用户ID
chat.setUserid((Long) request.getSession().getAttribute("userId"));
// 如果聊天记录的提问内容不为空
if (StringUtils.isNotBlank(chat.getAsk())) {
// 更新当前用户的未回复状态为0，表示有新提问
chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", request.getSession().getAttribute("userId")));
chat.setUserid((Long)request.getSession().getAttribute("userId"));
// 设置聊天记录的用户ID为当前用户ID
chat.setUserid((Long) request.getSession().getAttribute("UserId"));
// 设置回复状态为1，表示已提问等待回复
chat.setIsreply(1);
}
// 如果聊天记录的回复内容不为空
if (StringUtils.isNotBlank(chat.getReply())) {
// 更新当前用户（提问用户）的未回复状态为0，表示有新回复
chatService.updateForSet("isreply=0", new EntityWrapper<ChatEntity>().eq("userid", chat.getUserid()));
chat.setAdminid((Long)request.getSession().getAttribute("userId"));
// 设置聊天记录的管理员ID为当前用户ID（可能表示回复的管理员）
chat.setAdminid((Long) request.getSession().getAttribute("UserId"));
}
// 调用chatService的insert方法插入新的聊天记录
chatService.insert(chat);
// 返回表示保存成功的R对象
return R.ok();
}
/**
* 修改
* 用于修改已存在的聊天记录
* @param chat 包含修改后聊天记录信息的ChatEntity对象
* @param request HttpServletRequest对象，可能用于获取一些额外信息（此处未体现具体用途）
* @return R类型的结果，用于表示修改操作的结果状态
*/
@RequestMapping("/update")
@Transactional
public R update(@RequestBody ChatEntity chat, HttpServletRequest request) {
// 此处原本可能用于验证ChatEntity对象的合法性，但被注释掉了
//ValidatorUtils.validateEntity(chat);
// 调用chatService的updateById方法，根据ID更新聊天记录
chatService.updateById(chat); //全部更新
// 返回表示修改成功的R对象
return R.ok();
}
/**
* 删除
* 用于删除指定ID的聊天记录
* @param ids 包含要删除聊天记录ID的数组
* @return R类型的结果，用于表示删除操作的结果状态
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
// 调用chatService的deleteBatchIds方法，批量删除指定ID的聊天记录
chatService.deleteBatchIds(Arrays.asList(ids));
// 返回表示删除成功的R对象
return R.ok();
}
/**
* 提醒接口
* 根据指定的列名、类型以及其他查询条件，统计符合条件的聊天记录数量
* @param columnName 要进行条件判断的列名
* @param request HttpServletRequest对象，用于获取当前会话信息等
* @param type 提醒类型，可能用于区分不同的统计逻辑
* @param map 包含其他查询条件的Map，例如时间范围等
* @return R类型的结果，包含统计到的符合条件的聊天记录数量及相关状态信息
*/
@RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@PathVariable("type") String type, @RequestParam Map<String, Object> map) {
// 将列名和类型添加到查询条件Map中
map.put("column", columnName);
map.put("type", type);
// 如果提醒类型为2
if (type.equals("2")) {
// 创建SimpleDateFormat对象，用于日期格式化
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 获取Calendar实例，用于日期计算
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
// 如果查询条件Map中包含remindstart（开始提醒时间）
if (map.get("remindstart")!= null) {
// 将remindstart转换为整数，表示要添加的天数
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
// 设置当前日期为基础日期
c.setTime(new Date());
// 根据提醒开始天数添加到当前日期上
c.add(Calendar.DAY_OF_MONTH, remindStart);
// 获取计算后的提醒开始日期
remindStartDate = c.getTime();
// 将提醒开始日期格式化为指定格式，并更新到查询条件Map中
map.put("remindstart", sdf.format(remindStartDate));
}
// 如果查询条件Map中包含remindend（结束提醒时间）
if (map.get("remindend")!= null) {
// 将remindend转换为整数，表示要添加的天数
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
// 设置当前日期为基础日期
c.setTime(new Date());
// 根据提醒结束天数添加到当前日期上
c.add(Calendar.DAY_OF_MONTH, remindEnd);
// 获取计算后的提醒结束日期
remindEndDate = c.getTime();
// 将提醒结束日期格式化为指定格式，并更新到查询条件Map中
map.put("remindend", sdf.format(remindEndDate));
}
}
// 创建一个EntityWrapper对象，用于构建MyBatis Plus的查询条件
Wrapper<ChatEntity> wrapper = new EntityWrapper<ChatEntity>();
// 如果查询条件Map中包含remindstart（开始提醒时间），添加大于等于条件到查询条件中
if (map.get("remindstart")!= null) {
wrapper.ge(columnName, map.get("remindstart"));
}
// 如果查询条件Map中包含remindend（结束提醒时间），添加小于等于条件到查询条件中
if (map.get("remindend")!= null) {
wrapper.le(columnName, map.get("remindend"));
}
// 调用chatService的selectCount方法，根据构建好的查询条件统计符合条件的聊天记录数量
int count = chatService.selectCount(wrapper);
// 返回包含统计结果的R对象
return R.ok().put("count", count);
}
}

132
src/main/java/com/controller/CommonController.java
Unescape View File

@ -28,33 +28,51 @@ import com.baidu.aip.face.MatchRequest;
import com.baidu.aip.util.Base64Util;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.ConfigEntity;
// 导入相关的服务类和工具类
import com.service.CommonService;
import com.service.ConfigService;
import com.utils.BaiduUtil;
import com.utils.FileUtil;
import com.utils.R;
import com.utils.CommonUtil;
/**
* 通用接口
* 该类作为一个Spring的RestController，提供了一系列通用的接口方法，用于处理不同类型的业务逻辑，
* 如获取数据选项、根据条件获取记录、修改数据状态、统计数据等操作。
*/
@RestController
public class CommonController {
// 自动注入CommonService，用于处理通用的业务逻辑
@Autowired
private CommonService commonService;
// 定义百度AI人脸识别客户端对象，初始化为null
private static AipFace client = null;
// 自动注入ConfigService，可能用于获取配置相关信息
@Autowired
private ConfigService configService;
/**
* 获取table表中的column列表(联动接口)
* @param table
* @param column
* @return
* 获取table表中的column列表（联动接口）
* 根据传入的表名、列名以及一些可选的条件参数，获取指定表中指定列的列表数据，可能用于下拉框等联动选择场景。
*
* @param tableName 表名
* @param columnName 列名
* @param conditionColumn 可选的条件列名，用于进一步筛选数据
* @param conditionValue 可选的条件值，与conditionColumn配合使用来筛选数据
* @param level 可选的层级参数，可能用于表示数据的层次结构相关的筛选
* @param parent 可选的父级参数，可能用于表示数据的父子关系相关的筛选
* @return 返回包含获取到的列列表数据的R对象，R对象通常用于封装返回结果信息
*/
@RequestMapping("/option/{tableName}/{columnName}")
@IgnoreAuth
public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,@RequestParam(required = false) String conditionColumn,@RequestParam(required = false) String conditionValue,String level,String parent) {
public R getOption(@PathVariable("tableName") String tableName, @PathVariable("tableName") String columnName,
@RequestParam(required = false) String conditionColumn,
@RequestParam(required = false) String conditionValue, String level, String parent) {
// 创建一个用于存储参数的Map对象
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
@ -70,32 +88,47 @@ public class CommonController{
if (StringUtils.isNotBlank(conditionValue)) {
params.put("conditionValue", conditionValue);
}
// 调用commonService的getOption方法获取数据列表
List<String> data = commonService.getOption(params);
// 返回包含数据列表的R对象，结果状态为成功
return R.ok().put("data", data);
}
/**
* 根据table中的column获取单条记录
* @param table
* @param column
* @return
* 根据传入的表名、列名以及指定的列值，从指定表中获取满足条件的单条记录数据。
*
* @param tableName 表名
* @param columnName 列名
* @param columnValue 用于筛选的列值，根据该值在指定列中查找匹配的记录
* @return 返回包含获取到的单条记录数据的R对象
*/
@RequestMapping("/follow/{tableName}/{columnName}")
@IgnoreAuth
public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, @RequestParam String columnValue) {
public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
@RequestParam String columnValue) {
// 创建一个用于存储参数的Map对象
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
params.put("columnValue", columnValue);
// 调用commonService的getFollowByOption方法获取单条记录数据
Map<String, Object> result = commonService.getFollowByOption(params);
// 返回包含单条记录数据的R对象，结果状态为成功
return R.ok().put("data", result);
}
/**
* 修改table表的sfsh状态
* @param table
* @param map
* @return
* 根据传入的表名和一个包含修改信息的Map对象，调用commonService的sh方法来修改指定表的sfsh状态。
*
* @param tableName 表名
* @param map 包含修改信息的Map对象，具体内容由调用方确定，通常包含要修改的字段和对应的值等信息
* @return 返回表示修改操作成功的R对象
*/
@RequestMapping("/sh/{tableName}")
public R sh(@PathVariable("tableName") String tableName, @RequestBody Map<String, Object> map) {
@ -106,11 +139,14 @@ public class CommonController{
/**
* 获取需要提醒的记录数
* @param tableName
* @param columnName
* @param type 1:数字 2:日期
* @param map
* @return
* 根据传入的表名、列名、类型以及一个包含其他条件的Map对象，计算并获取满足条件的需要提醒的记录数量。
* 当类型为2时，会根据传入的提醒开始时间和结束时间进行日期范围的计算和筛选。
*
* @param tableName 表名
* @param columnName 列名
* @param type 类型参数，1表示数字类型的提醒条件，2表示日期类型的提醒条件
* @param map 包含其他条件的Map对象，如提醒开始时间、提醒结束时间等（当type为2时相关）
* @return 返回包含需要提醒的记录数的R对象
*/
@RequestMapping("/remind/{tableName}/{columnName}/{type}")
@IgnoreAuth
@ -133,20 +169,28 @@ public class CommonController{
map.put("remindstart", sdf.format(remindStartDate));
}
if (map.get("remindend")!= null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
Integer recommendEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH,remindEnd);
c.add(Calendar.DAY_OF_MONTH, recommendEnd);
remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
}
}
// 调用commonService的remindCount方法获取需要提醒的记录数
int count = commonService.remindCount(map);
// 返回包含记录数的R对象，结果状态为成功
return R.ok().put("count", count);
}
/**
* 单列求和
* 根据传入的表名和列名，调用commonService的selectCal方法对指定表中的指定列进行求和操作，并返回结果。
*
* @param tableName 表名
* @param columnName 列名
* @return 返回包含求和结果的R对象
*/
@RequestMapping("/cal/{tableName}/{columnName}")
@IgnoreAuth
@ -154,12 +198,22 @@ public class CommonController{
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
// 调用commonService的selectCal方法进行求和操作并获取结果
Map<String, Object> result = commonService.selectCal(params);
// 返回包含求和结果的R对象，结果状态为成功
return R.ok().put("data", result);
}
/**
* 分组统计
* 根据传入的表名和列名，调用commonService的selectGroup方法对指定表中的指定列进行分组统计操作，
* 并对结果中的日期类型数据进行格式化处理后返回。
*
* @param tableName 表名
， @param columnName 列名
* @return 返回包含分组统计结果的R对象
*/
@RequestMapping("/group/{tableName}/{columnName}")
@IgnoreAuth
@ -167,7 +221,10 @@ public class CommonController{
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
// 调用commonService的selectGroup方法进行分组统计操作并获取结果
List<Map<String, Object>> result = commonService.selectGroup(params);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) {
for (String k : m.keySet()) {
@ -176,20 +233,33 @@ public class CommonController{
}
}
}
// 返回包含分组统计结果的R对象，结果状态为成功
return R.ok().put("data", result);
}
/**
* （按值统计）
* 根据传入的表名、x列名和y列名，调用commonService的selectValue方法对指定表中的指定列进行按值统计操作，
* 并对结果中的日期类型数据进行格式化处理后返回。
*
* @param tableName 表名
* @param yColumnName 用于统计的y列名
* @param xColumnName 用于分组的x列名
* @return 返回包含按值统计结果的R对象
*/
@RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}")
@IgnoreAuth
public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName) {
public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName,
@PathVariable("xColumnName") String xColumnName) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName);
// 调用commonService的selectValue方法进行按值统计操作并获取结果
List<Map<String, Object> > result = commonService.selectValue(params);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) {
for (String k : m.keySet()) {
@ -198,21 +268,35 @@ public class CommonController{
}
}
}
// 返回包含按值统计结果的R对象，结果状态为成功
return R.ok().put("data", result);
}
/**
* （按值统计）时间统计类型
* 根据传入的表名、x列名、y列名和时间统计类型，调用commonService的selectTimeStatValue方法对指定表中的指定列进行按值统计操作，
* 并对结果中的日期类型数据进行格式化处理后返回。
*
* @param tableName 表名
* @param yColumnName 用于统计的y列名
* @param xColumnName 用于分组的x列名
* @param timeStatType 时间统计类型参数
* @return 返回包含按值统计结果的R对象
*/
@IgnoreAuth
@RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}/{timeStatType}")
public R valueDay(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType) {
@IgnoreAuth
public R valueDay(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName,
@PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName);
params.put("timeStatType", timeStatType);
// 调用commonService的selectTimeStatValue方法进行按值统计操作并获取结果
List<Map<String, Object> > result = commonService.selectTimeStatValue(params);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for (Map<String, Object> m : result) {
for (String k : m.keySet()) {
@ -221,9 +305,9 @@ public class CommonController{
}
}
}
// 返回包含按值统计结果的R对象，结果状态为成功
return R.ok().put("data", result);
}
}

188
src/main/java/com/controller/YonghuController.java
Unescape View File

@ -49,99 +49,135 @@ import com.utils.CommonUtil;
@RestController
@RequestMapping("/yonghu")
public class YonghuController {
// 自动注入用户服务类，用于处理与用户相关的业务逻辑
@Autowired
private YonghuService yonghuService;
// 自动注入令牌服务类，用于生成和管理用户令牌
@Autowired
private TokenService tokenService;
/**
* 登录
* 用户登录方法
* @param username 用户名
* @param password 密码
* @param captcha 验证码（此处未在代码中看到对验证码的实际验证逻辑）
* @param request Http请求对象
* @return 返回包含登录结果信息的R对象，若登录成功则包含生成的令牌
*/
@IgnoreAuth
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
// 根据用户名查询用户实体
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
if (u == null ||!u.getMima().equals(password)) {
// 若用户不存在或密码不匹配，返回错误信息
return R.error("账号或密码不正确");
}
// 生成用户令牌
String token = tokenService.generateToken(u.getId(), username, "yonghu", "用户");
return R.ok().put("token", token);
}
/**
* 注册
* 用户注册方法
* @param yonghu 包含用户注册信息的YonghuEntity对象
* @return 返回包含注册结果信息的R对象
*/
@IgnoreAuth
@RequestMapping("/register")
public R register(@RequestBody YonghuEntity yonghu) {
// 此处原本应有对用户实体的验证逻辑，但被注释掉了
//ValidatorUtils.validateEntity(yonghu);
// 根据用户名查询是否已存在该用户
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
if (u!= null) {
// 若用户已存在，返回错误信息
return R.error("注册用户已存在");
}
// 设置用户ID为当前时间戳
Long uId = new Date().getTime();
yonghu.setId(uId);
// 插入新用户信息到数据库
yonghuService.insert(yonghu);
return R.ok();
}
/**
* 退出
* 用户退出方法
* @param request Http请求对象
* @return 返回包含退出成功信息的R对象
*/
@RequestMapping("/logout")
public R logout(HttpServletRequest request) {
// 使当前会话失效，实现用户退出
request.getSession().invalidate();
return R.ok("退出成功");
}
/**
* 获取用户的session用户信息
* 获取当前用户的会话信息方法
* @param request Http请求对象
* @return 返回包含当前用户信息的R对象
*/
@RequestMapping("/session")
public R getCurrUser(HttpServletRequest request) {
// 从会话中获取用户ID
Long id = (Long) request.getSession().getAttribute("userId");
// 根据用户ID查询用户实体
YonghuEntity u = yonghuService.selectById(id);
return R.ok().put("data", u);
}
/**
* 密码重置
* 用户密码重置方法
* @param username 用户名
* @param request Http请求对象
* @return 返回包含密码重置结果信息的R对象
*/
@IgnoreAuth
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) {
// 根据用户名查询用户实体
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", username));
if (u == null) {
// 若用户不存在，返回错误信息
return R.error("账号不存在");
}
// 将用户密码重置为"123456"
u.setMima("123456");
// 更新用户信息到数据库
yonghuService.updateById(u);
return R.ok("密码已重置为：123456");
}
/**
* 后端列表
* 获取用户列表（后端）方法
* @param params 查询参数的Map对象
* @param yonghu YonghuEntity对象，可能用于条件筛选等
* @param request Http请求对象
* @return 返回包含用户列表分页信息的R对象
*/
@RequestMapping("/page")
public R page(@RequestParam Map<String, Object> params, YonghuEntity yonghu,
HttpServletRequest request) {
// 创建用于构建查询条件的EntityWrapper对象
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
// 调用服务类的方法进行分页查询，并进行排序、条件筛选等操作
PageUtils page = yonghuService.queryPage(params, MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
request.setAttribute("data", page);
return R.ok().put("data", page);
}
/**
* 前端列表
* 获取用户列表（前端）方法
* 与page方法类似，只是多了@IgnoreAuth注解，可能表示前端访问此接口无需认证
* @param params 查询参数的Map对象
* @param yonghu YonghuEntity对象，可能用于条件筛选等
* @param request Http请求对象
* @return 返回包含用户列表分页信息的R对象
*/
@IgnoreAuth
@RequestMapping("/list")
@ -155,7 +191,9 @@ public class YonghuController {
}
/**
* 列表
* 获取用户列表方法（另一种实现方式，可能用于特定场景）
* @param yonghu YonghuEntity对象，用于构建查询条件
* @return 返回包含用户列表信息的R对象
*/
@RequestMapping("/lists")
public R list(YonghuEntity yonghu) {
@ -165,7 +203,9 @@ public class YonghuController {
}
/**
* 查询
* 查询单个用户信息方法
* @param yonghu YonghuEntity对象，用于构建查询条件
* @return 返回包含查询到的用户视图信息的R对象
*/
@RequestMapping("/query")
public R query(YonghuEntity yonghu) {
@ -176,7 +216,9 @@ public class YonghuController {
}
/**
* 后端详情
* 获取用户详细信息（后端）方法
* @param id 用户ID
* @return 返回包含用户详细信息的R对象
*/
@RequestMapping("/info/{id}")
public R info(@PathVariable("id") Long id) {
@ -185,7 +227,10 @@ public class YonghuController {
}
/**
* 前端详情
* 获取用户详细信息（前端）方法
* 与info方法类似，多了@IgnoreAuth注解，可能表示前端访问此接口无需认证
* @param id 用户ID
* @return 返回包含用户详细信息的R对象
*/
@IgnoreAuth
@RequestMapping("/detail/{id}")
@ -194,18 +239,21 @@ public class YonghuController {
return R.ok().put("data", yonghu);
}
/**
* 后端保存
* 保存用户信息（后端）方法
* @param yonghu 包含用户信息的YonghuEntity对象
* @param request Http请求对象
* @return 返回包含保存结果信息的R对象
*/
@RequestMapping("/save")
public R save(@RequestBody YonghuEntity yonghu, HttpServletRequest request) {
// 设置用户ID为当前时间戳加上一个随机数
yonghu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 此处原本应有对用户实体的验证逻辑，但被注释掉了
//ValidatorUtils.validateEntity(yonghu);
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
if (u!= null) {
// 若用户已存在，返回错误信息
return R.error("用户已存在");
}
@ -215,14 +263,20 @@ public class YonghuController {
}
/**
* 前端保存
* 保存用户信息（前端）方法
* 与save方法类似，可能在前端页面操作保存用户信息时调用
* @param yonghu 包含用户信息的YonghuEntity对象
* @param request Http请求对象
* @return 返回包含保存结果信息的R对象
*/
@RequestMapping("/add")
public R add(@RequestBody YonghuEntity yonghu, HttpServletRequest request) {
yonghu.setId(new Date().getTime() + new Double(Math.floor(Math.random() * 1000)).longValue());
// 此处原本应有对用户实体的验证逻辑，但被注释掉了
//ValidatorUtils.validateEntity(yonghu);
YonghuEntity u = yonghuService.selectOne(new EntityWrapper<YonghuEntity>().eq("zhanghao", yonghu.getZhanghao()));
if (u!= null) {
// 若用户已存在，返回错误信息
return R.error("用户已存在");
}
@ -231,22 +285,25 @@ public class YonghuController {
return R.ok();
}
/**
* 修改
* 更新用户信息方法
* @param yonghu 包含更新后用户信息的YonghuEntity对象
* @param request Http请求对象
* @return 返回包含更新结果信息的R对象
*/
@RequestMapping("/update")
@Transactional
public R update(@RequestBody YonghuEntity yonghu, HttpServletRequest request) {
// 此处原本应有对用户实体的验证逻辑，但被注释掉了
//ValidatorUtils.validateEntity(yonghu);
yonghuService.updateById(yonghu); // 全部更新
return R.ok();
}
/**
* 删除
* 删除用户信息方法
* @param ids 要删除的用户ID数组
* @return 返回包含删除结果信息的R对象
*/
@RequestMapping("/delete")
public R delete(@RequestBody Long[] ids) {
@ -255,7 +312,12 @@ public class YonghuController {
}
/**
* 提醒接口
* 提醒接口方法，根据指定条件统计符合要求的用户数量
* @param columnName 用于筛选的列名
* @param request Http请求对象
* @param type 类型参数，可能用于区分不同的提醒逻辑
* @param map 查询参数的Map对象
* @return 返回包含符合条件的用户数量的R对象
*/
@RequestMapping("/remind/{columnName}/{type}")
public R remindCount(@PathVariable("columnName") String columnName, HttpServletRequest request,
@ -292,19 +354,16 @@ public class YonghuController {
wrapper.le(columnName, map.get("remindend"));
}
int count = yonghuService.selectCount(wrapper);
return R.ok().put("count", count);
}
/**
* （按值统计）
* （按值统计）方法，根据指定的列进行统计并返回结果
* @param yColumnName 用于统计的列名（纵坐标相关）
* @param xColumnName 用于分组的列名（横坐标相关）
* @param request Http请求对象
* @return 返回包含统计结果的R对象
*/
@RequestMapping("/value/{xColumnName}/{yColumnName}")
public R value(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, HttpServletRequest request) {
@ -325,7 +384,12 @@ public class YonghuController {
}
/**
* （按值统计）时间统计类型
* （按值统计）时间统计类型方法，根据指定的列和时间统计类型进行统计并返回结果
* @param yColumnName 用于统计的列名（纵坐标相关）
* @param xColumnName 用于分组的列名（横坐标相关）
* @param timeStatType 时间统计类型参数
* @param request Http请求对象
* @return 返回包含统计结果的R对象
*/
@RequestMapping("/value/{xColumnName}/{yColumnName}/{timeStatType}")
public R valueDay(@PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName, @PathVariable("timeStatType") String timeStatType, HttpServletRequest request) {
@ -334,50 +398,4 @@ public class YonghuController {
params.put("yColumn", yColumnName);
params.put("timeStatType", timeStatType);
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
List<Map<String, Object>> result = yonghuService.selectTimeStatValue(params, ew);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for(Map<String, Object> m : result) {
for(String k : m.keySet()) {
if(m.get(k) instanceof Date) {
m.put(k, sdf.format((Date)m.get(k)));
}
}
}
return R.ok().put("data", result);
}
/**
* 分组统计
*/
@RequestMapping("/group/{columnName}")
public R group(@PathVariable("columnName") String columnName,HttpServletRequest request) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("column", columnName);
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
List<Map<String, Object>> result = yonghuService.selectGroup(params, ew);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
for(Map<String, Object> m : result) {
for(String k : m.keySet()) {
if(m.get(k) instanceof Date) {
m.put(k, sdf.format((Date)m.get(k)));
}
}
}
return R.ok().put("data", result);
}
/**
* 总数量
*/
@RequestMapping("/count")
public R count(@RequestParam Map<String, Object> params,YonghuEntity yonghu, HttpServletRequest request){
EntityWrapper<YonghuEntity> ew = new EntityWrapper<YonghuEntity>();
int count = yonghuService.selectCount(MPUtil.sort(MPUtil.between(MPUtil.likeOrEq(ew, yonghu), params), params));
return R.ok().put("data", count);
}
}
List<Map<String, Object>> result

4
src/main/java/com/dao/ChatDao.java
Unescape View File

@ -21,9 +21,9 @@ import com.entity.view.ChatView;
*/
public interface ChatDao extends BaseMapper<ChatEntity> {
List<ChatVO> selectListVO(@Param("ew") Wrapper<ChatEntity> wrapper);
List<ChatVO> selectListVO(@Param("ew") Wrapper<ChatEntity> wrapper);//根据给定的条件包装器（Wrapper）查询并返回符合条件的ChatVO列表
ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper);
ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper);//根据给定的条件包装器（Wrapper）查询并返回符合条件的ChatView列表
List<ChatView> selectListView(@Param("ew") Wrapper<ChatEntity> wrapper);

47
src/main/java/com/dao/CommonDao.java
Unescape View File

@ -5,24 +5,69 @@ import java.util.List;
import java.util.Map;
/**
* 通用接口
* 通用接口，定义了一组用于数据库操作的方法。
*/
public interface CommonDao {
/**
* 根据给定的参数获取选项列表。
* @param params 包含查询条件的参数映射
* @return 返回一个字符串列表，表示查询结果
*/
List<String> getOption(Map<String, Object> params);
/**
* 根据给定的参数获取关注信息。
* @param params 包含查询条件的参数映射
* @return 返回一个包含关注信息的映射
*/
Map<String, Object> getFollowByOption(Map<String, Object> params);
/**
* 根据给定的参数获取另一种形式的关注信息列表。
* @param params 包含查询条件的参数映射
* @return 返回一个字符串列表，表示查询结果
*/
List<String> getFollowByOption2(Map<String, Object> params);
/**
* 执行某种操作（具体操作未明确）。
* @param params 包含操作所需参数的映射
*/
void sh(Map<String, Object> params);
/**
* 计算提醒的数量。
* @param params 包含查询条件的参数映射
* @return 返回提醒的数量
*/
int remindCount(Map<String, Object> params);
/**
* 根据给定的参数进行某种计算。
* @param params 包含计算所需参数的映射
* @return 返回一个包含计算结果的映射
*/
Map<String, Object> selectCal(Map<String, Object> params);
/**
* 根据给定的参数分组查询。
* @param params 包含查询条件的参数映射
* @return 返回一个包含分组查询结果的映射列表
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params);
/**
* 根据给定的参数查询值。
* @param params 包含查询条件的参数映射
* @return 返回一个包含查询结果的映射列表
*/
List<Map<String, Object>> selectValue(Map<String, Object> params);
/**
* 根据给定的参数查询时间统计值。
* @param params 包含查询条件的参数映射
* @return 返回一个包含时间统计值的映射列表
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params);
}

21
src/main/java/com/dao/YonghuDao.java
Unescape View File

@ -6,38 +6,37 @@ import java.util.List;
import java.util.Map;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.pagination.Pagination;
import org.apache.ibatis.annotations.Param;
import com.entity.vo.YonghuVO;
import com.entity.view.YonghuView;
/**
* 用户
*
* @author
* @email
* @date 2023-02-21 09:46:06
* 用户数据访问对象接口，继承自MyBatis-Plus的BaseMapper。
* 提供对用户实体（YonghuEntity）的数据库操作方法。
*/
public interface YonghuDao extends BaseMapper<YonghuEntity> {
// 根据条件查询用户视图对象列表
List<YonghuVO> selectListVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据条件查询单个用户视图对象
YonghuVO selectVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据条件查询用户视图对象列表
List<YonghuView> selectListView(@Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据分页信息和条件查询用户视图对象列表
List<YonghuView> selectListView(Pagination page, @Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据条件查询单个用户视图对象
YonghuView selectView(@Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据参数和条件查询值映射列表
List<Map<String, Object>> selectValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据参数和条件查询时间统计值映射列表
List<Map<String, Object>> selectTimeStatValue(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
// 根据参数和条件分组查询映射列表
List<Map<String, Object>> selectGroup(@Param("params") Map<String, Object> params, @Param("ew") Wrapper<YonghuEntity> wrapper);
}

2
src/main/java/com/entity/model/ChatModel.java
Unescape View File

@ -12,8 +12,6 @@ import java.io.Serializable;
/**
* 在线咨询
* 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自ModelAndView 的model名称
* @author
* @email
* @date 2023-02-21 09:46:06

1
src/main/java/com/entity/model/YonghuModel.java
Unescape View File

@ -12,7 +12,6 @@ import java.io.Serializable;
/**
* 用户
* 接收传参的实体类
*（实际开发中配合移动端接口开发手动去掉些没用的字段， 后端一般用entity就够用了）
* 取自ModelAndView 的model名称
* @author
* @email

44
src/main/java/com/service/ChatService.java
Unescape View File

@ -10,9 +10,9 @@ import com.entity.vo.ChatVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.ChatView;
/**
* 在线咨询
* 在线咨询服务接口，提供对在线咨询相关数据的操作方法。
* 继承自 IService<ChatEntity>，利用 MyBatis-Plus 提供的通用 CRUD 操作。
*
* @author
* @email
@ -20,18 +20,52 @@ import com.entity.view.ChatView;
*/
public interface ChatService extends IService<ChatEntity> {
/**
* 根据参数查询分页信息。
*
* @param params 包含查询条件的参数集合。
* @return 返回封装了分页信息的 PageUtils 对象。
*/
PageUtils queryPage(Map<String, Object> params);
/**
* 根据条件查询视图对象列表。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的视图对象列表。
*/
List<ChatVO> selectListVO(Wrapper<ChatEntity> wrapper);
/**
* 根据条件查询单个视图对象。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的单个视图对象。
*/
ChatVO selectVO(@Param("ew") Wrapper<ChatEntity> wrapper);
/**
* 根据条件查询视图对象列表。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的视图对象列表。
*/
List<ChatView> selectListView(Wrapper<ChatEntity> wrapper);
/**
* 根据条件查询单个视图对象。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的单个视图对象。
*/
ChatView selectView(@Param("ew") Wrapper<ChatEntity> wrapper);
/**
* 根据参数和条件查询分页信息。
*
* @param params 包含查询条件的参数集合。
* @param wrapper 查询条件包装器。
* @return 返回封装了分页信息的 PageUtils 对象。
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<ChatEntity> wrapper);
}

43
src/main/java/com/service/CommonService.java
Unescape View File

@ -3,20 +3,63 @@ package com.service;
import java.util.List;
import java.util.Map;
/**
* CommonService 接口定义了一组通用的服务方法，用于处理各种数据操作。
*/
public interface CommonService {
/**
* 根据给定的参数获取选项列表。
* @param params 包含查询条件的参数集合。
* @return 返回一个字符串列表，表示选项。
*/
List<String> getOption(Map<String, Object> params);
/**
* 根据给定的参数获取关注信息。
* @param params 包含查询条件的参数集合。
* @return 返回一个包含关注信息的映射。
*/
Map<String, Object> getFollowByOption(Map<String, Object> params);
/**
* 执行某种操作（具体操作未明确）。
* @param params 包含操作所需参数的映射。
*/
void sh(Map<String, Object> params);
/**
* 计算提醒的数量。
* @param params 包含查询条件的参数集合。
* @return 返回提醒的数量。
*/
int remindCount(Map<String, Object> params);
/**
* 根据给定的参数选择并计算某些值。
* @param params 包含查询条件的参数集合。
* @return 返回一个包含计算结果的映射。
*/
Map<String, Object> selectCal(Map<String, Object> params);
/**
* 根据给定的参数选择分组信息。
* @param params 包含查询条件的参数集合。
* @return 返回一个包含分组信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params);
/**
* 根据给定的参数选择值信息。
* @param params 包含查询条件的参数集合。
* @return 返回一个包含值信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectValue(Map<String, Object> params);
/**
* 根据给定的参数选择时间统计值信息。
* @param params 包含查询条件的参数集合。
* @return 返回一个包含时间统计值信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params);
}

68
src/main/java/com/service/YonghuService.java
Unescape View File

@ -10,9 +10,10 @@ import com.entity.vo.YonghuVO;
import org.apache.ibatis.annotations.Param;
import com.entity.view.YonghuView;
/**
* 用户
* 用户服务接口，定义了对用户实体进行操作的方法。
* 继承自 IService<YonghuEntity>，提供基本的 CRUD 操作。
* 包含分页查询、条件查询、视图对象查询等方法。
*
* @author
* @email
@ -20,26 +21,79 @@ import com.entity.view.YonghuView;
*/
public interface YonghuService extends IService<YonghuEntity> {
/**
* 根据参数查询分页信息。
*
* @param params 包含查询条件的参数集合。
* @return 返回封装了分页信息的 PageUtils 对象。
*/
PageUtils queryPage(Map<String, Object> params);
/**
* 根据条件查询视图对象列表。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的视图对象列表。
*/
List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper);
/**
* 根据条件查询单个视图对象。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的单个视图对象。
*/
YonghuVO selectVO(@Param("ew") Wrapper<YonghuEntity> wrapper);
/**
* 根据条件查询视图对象列表。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的视图对象列表。
*/
List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper);
/**
* 根据条件查询单个视图对象。
*
* @param wrapper 查询条件包装器。
* @return 返回符合条件的单个视图对象。
*/
YonghuView selectView(@Param("ew") Wrapper<YonghuEntity> wrapper);
/**
* 根据参数和条件查询分页信息。
*
* @param params 包含查询条件的参数集合。
* @param wrapper 查询条件包装器。
* @return 返回封装了分页信息的 PageUtils 对象。
*/
PageUtils queryPage(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
/**
* 根据参数和条件选择值信息。
*
* @param params 包含查询条件的参数集合。
* @param wrapper 查询条件包装器。
* @return 返回一个包含值信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
/**
* 根据参数和条件选择时间统计值信息。
*
* @param params 包含查询条件的参数集合。
* @param wrapper 查询条件包装器。
* @return 返回一个包含时间统计值信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
/**
* 根据参数和条件选择分组信息。
*
* @param params 包含查询条件的参数集合。
* @param wrapper 查询条件包装器。
* @return 返回一个包含分组信息的列表，每个元素是一个映射。
*/
List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<YonghuEntity> wrapper);
}

45
src/main/java/com/service/impl/ChatServiceImpl.java
Unescape View File

@ -11,7 +11,6 @@ import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.ChatDao;
import com.entity.ChatEntity;
import com.service.ChatService;
@ -21,43 +20,81 @@ import com.entity.view.ChatView;
@Service("chatService")
public class ChatServiceImpl extends ServiceImpl<ChatDao, ChatEntity> implements ChatService {
/**
* 分页查询方法，返回分页后的ChatEntity数据。
* @param params 包含分页参数的Map对象
* @return 封装了分页信息的PageUtils对象
*/
@Override
public PageUtils queryPage(Map<String, Object> params) {
// 使用Query类获取分页信息，并调用selectPage方法进行数据库查询
Page<ChatEntity> page = this.selectPage(
new Query<ChatEntity>(params).getPage(),
new EntityWrapper<ChatEntity>()
);
// 将查询结果封装到PageUtils对象中并返回
return new PageUtils(page);
}
/**
* 分页查询方法，返回分页后的ChatView数据。
* @param params 包含分页参数的Map对象
* @param wrapper 查询条件包装器
* @return 封装了分页信息的PageUtils对象
*/
// 使用Query类获取分页信息，调用自定义的selectListView方法进行数据库查询，并将结果设置到page对象中
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<ChatEntity> wrapper) {
Page<ChatView> page = new Query<ChatView>(params).getPage();
page.setRecords(baseMapper.selectListView(page, wrapper));
// 将查询结果封装到PageUtils对象中并返回
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
/**
* 根据条件查询ChatVO列表。
* @param wrapper 查询条件包装器
* @return 符合条件的ChatVO列表
*/
@Override
public List<ChatVO> selectListVO(Wrapper<ChatEntity> wrapper) {
// 调用自定义的selectListVO方法进行数据库查询并返回结果
return baseMapper.selectListVO(wrapper);
}
/**
* 根据条件查询单个ChatVO对象。
* @param wrapper 查询条件包装器
* @return 符合条件的单个ChatVO对象
*/
@Override
public ChatVO selectVO(Wrapper<ChatEntity> wrapper) {
// 调用自定义的selectVO方法进行数据库查询并返回结果
return baseMapper.selectVO(wrapper);
}
/**
* @param wrapper 查询条件包装器
* @return 符合条件的ChatView列表
*/
// 调用自定义的selectListView方法进行数据库查询并返回结果
@Override
public List<ChatView> selectListView(Wrapper<ChatEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
/**
* 根据条件查询单个ChatView对象。
* @param wrapper 查询条件包装器
* @return 符合条件的单个ChatView对象
*/
@Override
public ChatView selectView(Wrapper<ChatEntity> wrapper) {
// 调用自定义的selectView方法进行数据库查询并返回结果
return baseMapper.selectView(wrapper);
}
}

23
src/main/java/com/service/impl/CommonServiceImpl.java
Unescape View File

@ -1,7 +1,5 @@
package com.service.impl;
import java.util.List;
import java.util.Map;
@ -11,54 +9,53 @@ import org.springframework.stereotype.Service;
import com.dao.CommonDao;
import com.service.CommonService;
/**
* 系统用户
* 系统用户服务实现类
*/
@Service("commonService")
public class CommonServiceImpl implements CommonService {
@Autowired
private CommonDao commonDao;
private CommonDao commonDao; // 自动注入数据访问对象
@Override
public List<String> getOption(Map<String, Object> params) {
return commonDao.getOption(params);
return commonDao.getOption(params); // 获取选项列表
}
@Override
public Map<String, Object> getFollowByOption(Map<String, Object> params) {
return commonDao.getFollowByOption(params);
return commonDao.getFollowByOption(params); // 根据选项获取关注信息
}
@Override
public void sh(Map<String, Object> params) {
commonDao.sh(params);
commonDao.sh(params); // 执行某种操作（具体操作未明）
}
@Override
public int remindCount(Map<String, Object> params) {
return commonDao.remindCount(params);
return commonDao.remindCount(params); // 获取提醒数量
}
@Override
public Map<String, Object> selectCal(Map<String, Object> params) {
return commonDao.selectCal(params);
return commonDao.selectCal(params); // 选择并计算某些值
}
@Override
public List<Map<String, Object>> selectGroup(Map<String, Object> params) {
return commonDao.selectGroup(params);
return commonDao.selectGroup(params); // 按组选择数据
}
@Override
public List<Map<String, Object>> selectValue(Map<String, Object> params) {
return commonDao.selectValue(params);
return commonDao.selectValue(params); // 选择特定值
}
@Override
public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params) {
return commonDao.selectTimeStatValue(params);
return commonDao.selectTimeStatValue(params); // 选择并统计时间相关的值
}
}

15
src/main/java/com/service/impl/YonghuServiceImpl.java
Unescape View File

@ -11,7 +11,6 @@ import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.YonghuDao;
import com.entity.YonghuEntity;
import com.service.YonghuService;
@ -21,7 +20,7 @@ import com.entity.view.YonghuView;
@Service("yonghuService")
public class YonghuServiceImpl extends ServiceImpl<YonghuDao, YonghuEntity> implements YonghuService {
// 分页查询用户信息
@Override
public PageUtils queryPage(Map<String, Object> params) {
Page<YonghuEntity> page = this.selectPage(
@ -31,6 +30,7 @@ public class YonghuServiceImpl extends ServiceImpl<YonghuDao, YonghuEntity> impl
return new PageUtils(page);
}
// 分页查询用户视图信息
@Override
public PageUtils queryPage(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
Page<YonghuView> page = new Query<YonghuView>(params).getPage();
@ -39,42 +39,45 @@ public class YonghuServiceImpl extends ServiceImpl<YonghuDao, YonghuEntity> impl
return pageUtil;
}
// 查询用户值对象列表
@Override
public List<YonghuVO> selectListVO(Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectListVO(wrapper);
}
// 查询单个用户值对象
@Override
public YonghuVO selectVO(Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectVO(wrapper);
}
// 查询用户视图列表
@Override
public List<YonghuView> selectListView(Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
// 查询单个用户视图
@Override
public YonghuView selectView(Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectView(wrapper);
}
// 根据条件查询特定值
@Override
public List<Map<String, Object>> selectValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectValue(params, wrapper);
}
// 根据条件查询时间统计值
@Override
public List<Map<String, Object>> selectTimeStatValue(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectTimeStatValue(params, wrapper);
}
// 根据条件分组查询数据
@Override
public List<Map<String, Object>> selectGroup(Map<String, Object> params, Wrapper<YonghuEntity> wrapper) {
return baseMapper.selectGroup(params, wrapper);
}
}

4
src/main/java/com/utils/BaiduUtil.java
Unescape View File

@ -135,11 +135,11 @@ public class BaiduUtil {
if(jsonObject == null){
return "";
}
// 检查 JSON 对象中是否包含 "words_result" 和 "words_result_num" 键
if(jsonObject.has("words_result") && jsonObject.has("words_result_num")){
int wordsResultNum = jsonObject.getInt("words_result_num");
if(wordsResultNum > 0){
StringBuilder sb = new StringBuilder();
StringBuilder sb = new StringBuilder();// 用于拼接字符串
JSONArray jsonArray = jsonObject.getJSONArray("words_result");
int len = jsonArray.length();

22
src/main/java/com/utils/FileUtil.java
Unescape View File

@ -7,21 +7,27 @@ import java.io.IOException;
import java.io.InputStream;
/**
* 类说明 :
* 类说明 : FileUtil 是一个工具类，用于处理文件相关的操作。
*/
public class FileUtil {
/**
* 将文件转换为字节数组。
* @param file 要转换的文件对象。
* @return 返回文件内容的字节数组。
* @throws IOException 如果读取文件时发生错误。
*/
public static byte[] FileToByte(File file) throws IOException {
// 将数据转为流
@SuppressWarnings("resource")
InputStream content = new FileInputStream(file);
// 使用 try-with-resources 语句确保 InputStream 被正确关闭
try (InputStream content = new FileInputStream(file)) {
ByteArrayOutputStream swapStream = new ByteArrayOutputStream();
byte[] buff = new byte[100];
int rc = 0;
byte[] buff = new byte[100]; // 缓冲区大小为100字节
int rc; // 读取的字节数
while ((rc = content.read(buff, 0, 100)) > 0) {
swapStream.write(buff, 0, rc);
swapStream.write(buff, 0, rc); // 将读取的数据写入 ByteArrayOutputStream
}
// 获得二进制数组
return swapStream.toByteArray();
}
}
}

25
src/main/java/com/utils/HttpClientUtils.java
Unescape View File

@ -5,38 +5,45 @@ import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
/**
* HttpClient工具类
*/
public class HttpClientUtils {
/**
* @param uri
* @return String
* @description get请求方式
* 发送GET请求并返回响应内容
* @param uri 请求的URL地址
* @return 响应内容的字符串形式
* @description 使用GET方法发送HTTP请求
* @author: long.he01
*/
public static String doGet(String uri) {
// 用于存储响应结果的StringBuilder对象
StringBuilder result = new StringBuilder();
try {
// 初始化一个空字符串用于存储每一行读取的内容
String res = "";
// 创建URL对象
URL url = new URL(uri);
// 打开连接
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
// 设置请求方法为GET
conn.setRequestMethod("GET");
// 获取输入流并包装成BufferedReader
BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
String line;
// 逐行读取响应内容
while ((line = in.readLine()) != null) {
res += line + "\n";
}
// 关闭BufferedReader
in.close();
// 返回完整的响应内容
return res;
} catch (Exception e) {
// 捕获异常并打印堆栈信息
e.printStackTrace();
return null;
}
}
}

16
src/main/java/com/utils/JQPageInfo.java
Unescape View File

@ -1,54 +1,68 @@
package com.utils;
public class JQPageInfo {
// 当前页码
private Integer page;
// 每页显示的记录数
private Integer limit;
// 排序字段
private String sidx;
// 排序方式（升序或降序）
private String order;
// 偏移量，用于计算分页查询时的起始位置
private Integer offset;
// 获取当前页码
public Integer getPage() {
return page;
}
// 设置当前页码
public void setPage(Integer page) {
this.page = page;
}
// 获取每页显示的记录数
public Integer getLimit() {
return limit;
}
// 设置每页显示的记录数
public void setLimit(Integer limit) {
this.limit = limit;
}
// 获取排序字段
public String getSidx() {
return sidx;
}
// 设置排序字段
public void setSidx(String sidx) {
this.sidx = sidx;
}
// 获取排序方式
public String getOrder() {
return order;
}
// 设置排序方式
public void setOrder(String order) {
this.order = order;
}
// 获取偏移量
public Integer getOffset() {
return offset;
}
// 设置偏移量
public void setOffset(Integer offset) {
this.offset = offset;
}
}

33
src/main/java/com/utils/MPUtil.java
Unescape View File

@ -17,32 +17,32 @@ import com.baomidou.mybatisplus.mapper.Wrapper;
public class MPUtil {
public static final char UNDERLINE = '_';
//mybatis plus allEQ 表达式转换
// mybatis plus allEQ 表达式转换，带前缀
public static Map allEQMapPre(Object bean, String pre) {
Map<String, Object> map = BeanUtil.beanToMap(bean);
return camelToUnderlineMap(map, pre);
}
//mybatis plus allEQ 表达式转换
// mybatis plus allEQ 表达式转换，不带前缀
public static Map allEQMap(Object bean) {
Map<String, Object> map = BeanUtil.beanToMap(bean);
return camelToUnderlineMap(map, "");
}
// mybatis plus allLike 表达式转换，带前缀
public static Wrapper allLikePre(Wrapper wrapper, Object bean, String pre) {
Map<String, Object> map = BeanUtil.beanToMap(bean);
Map result = camelToUnderlineMap(map, pre);
return genLike(wrapper, result);
}
// mybatis plus allLike 表达式转换，不带前缀
public static Wrapper allLike(Wrapper wrapper, Object bean) {
Map result = BeanUtil.beanToMap(bean, true, true);
return genLike(wrapper, result);
}
// 生成LIKE查询条件
public static Wrapper genLike(Wrapper wrapper, Map param) {
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
int i = 0;
@ -57,11 +57,13 @@ public class MPUtil {
return wrapper;
}
// 生成LIKE或EQ查询条件
public static Wrapper likeOrEq(Wrapper wrapper, Object bean) {
Map result = BeanUtil.beanToMap(bean, true, true);
return genLikeOrEq(wrapper, result);
}
// 生成LIKE或EQ查询条件的具体实现
public static Wrapper genLikeOrEq(Wrapper wrapper, Map param) {
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
int i = 0;
@ -79,12 +81,13 @@ public class MPUtil {
return wrapper;
}
// 生成EQ查询条件
public static Wrapper allEq(Wrapper wrapper, Object bean) {
Map result = BeanUtil.beanToMap(bean, true, true);
return genEq(wrapper, result);
}
// 生成EQ查询条件的具体实现
public static Wrapper genEq(Wrapper wrapper, Map param) {
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
int i = 0;
@ -98,7 +101,7 @@ public class MPUtil {
return wrapper;
}
// 生成BETWEEN查询条件
public static Wrapper between(Wrapper wrapper, Map<String, Object> params) {
for (String key : params.keySet()) {
String columnName = "";
@ -118,6 +121,7 @@ public class MPUtil {
return wrapper;
}
// 生成排序查询条件
public static Wrapper sort(Wrapper wrapper, Map<String, Object> params) {
String order = "";
if (params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) {
@ -133,13 +137,7 @@ public class MPUtil {
return wrapper;
}
/**
* 驼峰格式字符串转换为下划线格式字符串
*
* @param param
* @return
*/
// 驼峰格式字符串转换为下划线格式字符串
public static String camelToUnderline(String param) {
if (param == null || "".equals(param.trim())) {
return "";
@ -159,12 +157,12 @@ public class MPUtil {
}
public static void main(String[] ages) {
System.out.println(camelToUnderline("ABCddfANM"));
System.out.println(camelToUnderline("ABCddfANM")); // 输出：a_b_cddf_anm
}
// 将驼峰格式的Map键转换为下划线格式，并添加前缀（如果有）
public static Map camelToUnderlineMap(Map param, String pre) {
Map<String, Object> newMap = new HashMap<String, Object>();
Map<String, Object> newMap = new HashMap<>();
Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<String, Object> entry = it.next();
@ -175,7 +173,6 @@ public class MPUtil {
} else if (StringUtils.isEmpty(pre)) {
newMap.put(newKey, entry.getValue());
} else {
newMap.put(pre + "." + newKey, entry.getValue());
}
}

34
src/main/java/com/utils/PageUtils.java
Unescape View File

@ -1,4 +1,3 @@
package com.utils;
import java.io.Serializable;
@ -8,10 +7,10 @@ import java.util.Map;
import com.baomidou.mybatisplus.plugins.Page;
/**
* 分页工具类
* 分页工具类，用于处理分页相关的数据和操作。
*/
public class PageUtils implements Serializable {
private static final long serialVersionUID = 1L;
private static final long serialVersionUID = 1L; // 序列化版本号
// 总记录数
private long total;
// 每页记录数
@ -24,7 +23,7 @@ public class PageUtils implements Serializable {
private List<?> list;
/**
* 分页
* 构造函数，通过传入的列表数据、总记录数、每页记录数和当前页数进行初始化。
* @param list 列表数据
* @param totalCount 总记录数
* @param pageSize 每页记录数
@ -35,29 +34,31 @@ public class PageUtils implements Serializable {
this.total = totalCount;
this.pageSize = pageSize;
this.currPage = currPage;
this.totalPage = (int)Math.ceil((double)totalCount/pageSize);
this.totalPage = (int)Math.ceil((double)totalCount/pageSize); // 计算总页数
}
/**
* 分页
* 构造函数，通过MyBatis Plus的Page对象进行初始化。
* @param page MyBatis Plus的Page对象
*/
public PageUtils(Page<?> page) {
this.list = page.getRecords();
this.total = page.getTotal();
this.pageSize = page.getSize();
this.currPage = page.getCurrent();
this.totalPage = page.getPages();
this.list = page.getRecords(); // 获取当前页的数据列表
this.total = page.getTotal(); // 获取总记录数
this.pageSize = page.getSize(); // 获取每页记录数
this.currPage = page.getCurrent(); // 获取当前页码
this.totalPage = page.getPages(); // 获取总页数
}
/*
* 空数据的分页
/**
* 构造函数，通过传入的参数Map进行初始化。
* @param params 包含分页参数的Map对象
*/
public PageUtils(Map<String, Object> params) {
Page page =new Query(params).getPage();
new PageUtils(page);
Page page =new Query(params).getPage(); // 根据参数创建Page对象
new PageUtils(page); // 调用另一个构造函数进行初始化
}
// Getter和Setter方法
public int getPageSize() {
return pageSize;
}
@ -97,5 +98,4 @@ public class PageUtils implements Serializable {
public void setTotal(long total) {
this.total = total;
}
}

51
src/main/java/com/utils/Query.java
Unescape View File

@ -1,4 +1,3 @@
package com.utils;
import java.util.LinkedHashMap;
@ -9,25 +8,26 @@ import org.apache.commons.lang3.StringUtils;
import com.baomidou.mybatisplus.plugins.Page;
/**
* 查询参数
* 查询参数类，用于封装分页和排序信息
*/
public class Query<T> extends LinkedHashMap<String, Object> {
private static final long serialVersionUID = 1L;
/**
* mybatis-plus分页参数
*/
// mybatis-plus分页参数
private Page<T> page;
/**
* 当前页码
*/
// 当前页码
private int currPage = 1;
/**
* 每页条数
*/
// 每页条数
private int limit = 10;
/**
* 构造函数，使用JQPageInfo对象初始化查询参数
* @param pageInfo 包含分页和排序信息的JQPageInfo对象
*/
public Query(JQPageInfo pageInfo) {
//分页参数
// 设置分页参数
if (pageInfo.getPage() != null) {
currPage = pageInfo.getPage();
}
@ -35,27 +35,28 @@ public class Query<T> extends LinkedHashMap<String, Object> {
limit = pageInfo.getLimit();
}
// 防止SQL注入（因为sidx、order是通过拼接SQL实现排序的，会有SQL注入风险）
String sidx = SQLFilter.sqlInject(pageInfo.getSidx());
String order = SQLFilter.sqlInject(pageInfo.getOrder());
// mybatis-plus分页
this.page = new Page<>(currPage, limit);
//排序
// 设置排序字段和顺序
if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) {
this.page.setOrderByField(sidx);
this.page.setAsc("ASC".equalsIgnoreCase(order));
}
}
/**
* 构造函数，使用Map对象初始化查询参数
* @param params 包含分页和排序信息的Map对象
*/
public Query(Map<String, Object> params) {
this.putAll(params);
//分页参数
// 设置分页参数
if (params.get("page") != null) {
currPage = Integer.parseInt((String) params.get("page"));
}
@ -63,6 +64,7 @@ public class Query<T> extends LinkedHashMap<String, Object> {
limit = Integer.parseInt((String) params.get("limit"));
}
// 计算偏移量并放入Map中
this.put("offset", (currPage - 1) * limit);
this.put("page", currPage);
this.put("limit", limit);
@ -76,22 +78,33 @@ public class Query<T> extends LinkedHashMap<String, Object> {
// mybatis-plus分页
this.page = new Page<>(currPage, limit);
//排序
// 设置排序字段和顺序
if (StringUtils.isNotBlank(sidx) && StringUtils.isNotBlank(order)) {
this.page.setOrderByField(sidx);
this.page.setAsc("ASC".equalsIgnoreCase(order));
}
}
/**
* 获取mybatis-plus分页对象
* @return mybatis-plus分页对象
*/
public Page<T> getPage() {
return page;
}
/**
* 获取当前页码
* @return 当前页码
*/
public int getCurrPage() {
return currPage;
}
/**
* 获取每页条数
* @return 每页条数
*/
public int getLimit() {
return limit;
}

10
src/main/java/com/utils/R.java
Unescape View File

@ -4,23 +4,27 @@ import java.util.HashMap;
import java.util.Map;
/**
* 返回数据
* 返回数据类，用于封装API响应结果。
*/
public class R extends HashMap<String, Object> {
private static final long serialVersionUID = 1L;
// 默认构造函数，初始化code为0表示成功
public R() {
put("code", 0);
}
// 静态方法：返回一个错误响应，默认code为500，msg为"未知异常，请联系管理员"
public static R error() {
return error(500, "未知异常，请联系管理员");
}
// 静态方法：返回一个错误响应，code为500，msg为传入的参数msg
public static R error(String msg) {
return error(500, msg);
}
// 静态方法：返回一个错误响应，code和msg由传入的参数指定
public static R error(int code, String msg) {
R r = new R();
r.put("code", code);
@ -28,22 +32,26 @@ public class R extends HashMap<String, Object> {
return r;
}
// 静态方法：返回一个成功响应，msg为传入的参数msg
public static R ok(String msg) {
R r = new R();
r.put("msg", msg);
return r;
}
// 静态方法：返回一个成功响应，包含传入的map中的所有键值对
public static R ok(Map<String, Object> map) {
R r = new R();
r.putAll(map);
return r;
}
// 静态方法：返回一个默认的成功响应（仅包含code）
public static R ok() {
return new R();
}
// 重写put方法，使其返回当前对象以支持链式调用
public R put(String key, Object value) {
super.put(key, value);
return this;

39
src/main/java/com/utils/SpringContextUtils.java
Unescape View File

@ -6,38 +6,67 @@ import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
* Spring Context 工具类
* Spring Context 工具类，用于获取Spring容器中的Bean。
*/
@Component
public class SpringContextUtils implements ApplicationContextAware {
// 静态变量，保存Spring应用上下文
public static ApplicationContext applicationContext;
/**
* 实现ApplicationContextAware接口的方法，设置Spring应用上下文。
* @param applicationContext Spring应用上下文
* @throws BeansException 如果设置上下文失败抛出异常
*/
@Override
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringContextUtils.applicationContext = applicationContext;
}
/**
* 根据Bean名称获取Bean对象。
* @param name Bean的名称
* @return 返回对应的Bean对象
*/
public static Object getBean(String name) {
return applicationContext.getBean(name);
}
/**
* 根据Bean名称和类型获取Bean对象。
* @param name Bean的名称
* @param requiredType Bean的类型
* @return 返回对应类型的Bean对象
*/
public static <T> T getBean(String name, Class<T> requiredType) {
return applicationContext.getBean(name, requiredType);
}
/**
* 检查Spring容器中是否包含指定名称的Bean。
* @param name Bean的名称
* @return 如果包含返回true，否则返回false
*/
public static boolean containsBean(String name) {
return applicationContext.containsBean(name);
}
/**
* 检查指定名称的Bean是否是单例模式。
* @param name Bean的名称
* @return 如果是单例返回true，否则返回false
*/
public static boolean isSingleton(String name) {
return applicationContext.isSingleton(name);
}
/**
* 获取指定名称的Bean的类型。
* @param name Bean的名称
* @return 返回Bean的类型
*/
public static Class<? extends Object> getType(String name) {
return applicationContext.getType(name);
}
}

15
src/main/java/com/utils/ValidatorUtils.java
Unescape View File

@ -1,21 +1,19 @@
package com.utils;
import java.util.Set;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import com.entity.EIException;
/**
* hibernate-validator校验工具类
*/
public class ValidatorUtils {
// 静态变量，用于存储验证器实例
private static Validator validator;
// 在静态块中初始化验证器实例
static {
validator = Validation.buildDefaultValidatorFactory().getValidator();
}
@ -26,14 +24,15 @@ public class ValidatorUtils {
* @param groups 待校验的组
* @throws EIException 校验不通过，则报EIException异常
*/
public static void validateEntity(Object object, Class<?>... groups)
throws EIException {
public static void validateEntity(Object object, Class<?>... groups) throws EIException {
// 执行校验操作，返回违反约束的集合
Set<ConstraintViolation<Object>> constraintViolations = validator.validate(object, groups);
// 如果存在违反约束的情况
if (!constraintViolations.isEmpty()) {
// 获取第一个违反约束的信息
ConstraintViolation<Object> constraint = (ConstraintViolation<Object>)constraintViolations.iterator().next();
// 抛出自定义异常，并传递错误信息
throw new EIException(constraint.getMessage());
}
}
}

Write Preview
Loading…
Cancel
Save