pcjs8mx7g
/
warehouse
1
0
Fork 0
Code Issues Pull Requests 2 Packages Projects Releases Wiki Activity

Merge pull request '合并' (#3) from shaoaoqi_branch into master

Browse Source
master
pcjs8mx7g 9 months ago
parent 53ee69aae5 ecd52163b9
commit 4cb5f185d0
15 changed files with 674 additions and 697 deletions
Show Stats Download Patch File Download Diff File

1
README.md
Unescape View File

@ -100,3 +100,4 @@
![](https://code.educoder.net/api/pcjs8mx7g/warehouse/raw/src%2Fmain%2Fresources%2Fstatic%2Fimages%2Fsales.PNG?ref=master)
商品销售退货管理
![](https://code.educoder.net/api/pcjs8mx7g/warehouse/raw/src%2Fmain%2Fresources%2Fstatic%2Fimages%2Fsalesback.PNG?ref=master)
//这是一个测试

194
src/main/java/com/yeqifu/sys/cache/CacheAspect.java vendored
Unescape View File

@ -14,6 +14,12 @@ import org.springframework.stereotype.Component;
import java.util.Map;
/**
* 缓存切面类
*
* 通过动态缓存实现对部门和用户相关操作的分级缓存。
*
* 此类使用AOP实现与部门和用户相关操作的缓存视图分离。
*
* @Author: 落亦-
* @Date: 2019/11/27 18:42
*/
@ -23,189 +29,89 @@ import java.util.Map;
public class CacheAspect {
/**
* 日志出处
* 日志出处。用于进行日志输出，便于跟踪缓存操作。
*/
private Log log = LogFactory.getLog(CacheAspect.class);
/**
* 声明一个缓存容器
* 缓存容器。通过Map实现动态缓存，用于存储部门和用户数据。
*/
private Map<String,Object> CACHE_CONTAINER = CachePool.CACHE_CONTAINER;
private Map<String, Object> CACHE_CONTAINER = CachePool.CACHE_CONTAINER;
/**
* 声明部门的切面表达式
* 部门操作的切面表达式
*/
private static final String POINTCUT_DEPT_ADD="execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.save(..))";
private static final String POINTCUT_DEPT_UPDATE="execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.updateById(..))";
private static final String POINTCUT_DEPT_GET="execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.getById(..))";
private static final String POINTCUT_DEPT_DELETE="execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.removeById(..))";
private static final String POINTCUT_DEPT_ADD = "execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.save(..))"; // 添加部门
private static final String POINTCUT_DEPT_UPDATE = "execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.updateById(..))"; // 更新部门
private static final String POINTCUT_DEPT_GET = "execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.getById(..))"; // 查询部门
private static final String POINTCUT_DEPT_DELETE = "execution(* com.yeqifu.sys.service.impl.DeptServiceImpl.removeById(..))"; // 删除部门
private static final String CACHE_DEPT_PROFIX="dept:";
/**
* 缓存部门数据的前缀。
*/
private static final String CACHE_DEPT_PROFIX = "dept:";
/**
* 添加部门切入
* @param joinPoint
* @return
*
* @param joinPoint 切面链接点
* @return 操作结果
*/
@Around(value = POINTCUT_DEPT_ADD)
public Object cacheDeptAdd(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
// 取出第一个参数
Dept object = (Dept) joinPoint.getArgs()[0];
Boolean res = (Boolean) joinPoint.proceed();
if (res){
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX + object.getId(),object);
Boolean res = (Boolean) joinPoint.proceed(); // 执行原实现
if (res) {
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX + object.getId(), object);
}
return res;
}
/**
* 查询部门切入
* @param joinPoint
* @return
*
* @param joinPoint 切面链接点
* @return 部门对象
*/
@Around(value = POINTCUT_DEPT_GET)
public Object cacheDeptGet(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Integer object = (Integer) joinPoint.getArgs()[0];
//从缓存里面取
Integer object = (Integer) joinPoint.getArgs()[0]; // 取出第一个参数作为ID
Object res1 = CACHE_CONTAINER.get(CACHE_DEPT_PROFIX + object);
if (res1!=null){
log.info("已从缓存里面找到部门对象"+CACHE_DEPT_PROFIX + object);
return res1;
}else {
log.info("未从缓存里面找到部门对象，从数据库中查询并放入缓存");
Dept res2 =(Dept) joinPoint.proceed();
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX+res2.getId(),res2);
if (res1 != null) {
log.info("已从缓存里面找到部门对象" + CACHE_DEPT_PROFIX + object);
return res1; // 直接返回缓存中的对象
} else {
log.info("\u672a\u4ece\u7f13\u5b58\u91CC\u627E\u5230\u90E8\u95E8\u5BF9\u8C61\uFF0C\u4ECE\u6570\u636E\u5E93\u4E2D\u67E5\u8BE2\u5E76\u653E\u5165\u7F13\u5B58");
Dept res2 = (Dept) joinPoint.proceed(); // 执行原实现
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX + res2.getId(), res2);
return res2;
}
}
/**
* 更新部门切入
* @param joinPoint
* @return
*
* @param joinPoint 切面链接点
* @return 操作结果
*/
@Around(value = POINTCUT_DEPT_UPDATE)
public Object cacheDeptUpdate(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Dept deptVo = (Dept) joinPoint.getArgs()[0];
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
Dept dept =(Dept) CACHE_CONTAINER.get(CACHE_DEPT_PROFIX + deptVo.getId());
if (null==dept){
dept=new Dept();
if (isSuccess) {
Dept dept = (Dept) CACHE_CONTAINER.get(CACHE_DEPT_PROFIX + deptVo.getId());
if (null == dept) {
dept = new Dept();
}
BeanUtils.copyProperties(deptVo,dept);
log.info("部门对象缓存已更新"+CACHE_DEPT_PROFIX + deptVo.getId());
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX+dept.getId(),dept);
BeanUtils.copyProperties(deptVo, dept);
log.info("\u90E8\u95E8\u5BF9\u8C61\u7F13\u5B58\u5DF2\u66F4\u65B0" + CACHE_DEPT_PROFIX + deptVo.getId());
CACHE_CONTAINER.put(CACHE_DEPT_PROFIX + dept.getId(), dept);
}
return isSuccess;
}
/**
* 删除部门切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_DEPT_DELETE)
public Object cacheDeptDelete(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Integer id = (Integer) joinPoint.getArgs()[0];
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
//删除缓存
CACHE_CONTAINER.remove(CACHE_DEPT_PROFIX+id);
}
return isSuccess;
}
/**
* 声明用户的切面表达式
*/
private static final String POINTCUT_USER_UPDATE="execution(* com.yeqifu.sys.service.impl.UserServiceImpl.updateById(..))";
private static final String POINTCUT_USER_ADD="execution(* com.yeqifu.sys.service.impl.UserServiceImpl.updateById(..))";
private static final String POINTCUT_USER_GET="execution(* com.yeqifu.sys.service.impl.UserServiceImpl.getById(..))";
private static final String POINTCUT_USER_DELETE="execution(* com.yeqifu.sys.service.impl.UserServiceImpl.removeById(..))";
private static final String CACHE_USER_PROFIX="user:";
/**
* 添加用户切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_USER_ADD)
public Object cacheUserAdd(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
User object = (User) joinPoint.getArgs()[0];
Boolean res = (Boolean) joinPoint.proceed();
if (res){
CACHE_CONTAINER.put(CACHE_USER_PROFIX + object.getId(),object);
}
return res;
}
/**
* 查询用户切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_USER_GET)
public Object cacheUserGet(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Integer object = (Integer) joinPoint.getArgs()[0];
//从缓存里面取
Object res1 = CACHE_CONTAINER.get(CACHE_USER_PROFIX + object);
if (res1!=null){
log.info("已从缓存里面找到用户对象"+CACHE_USER_PROFIX + object);
return res1;
}else {
log.info("未从缓存里面找到用户对象，从数据库中查询并放入缓存");
User res2 =(User) joinPoint.proceed();
CACHE_CONTAINER.put(CACHE_USER_PROFIX+res2.getId(),res2);
return res2;
}
}
/**
* 更新用户切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_USER_UPDATE)
public Object cacheUserUpdate(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
User userVo = (User) joinPoint.getArgs()[0];
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
User user =(User) CACHE_CONTAINER.get(CACHE_USER_PROFIX + userVo.getId());
if (null==user){
user=new User();
}
BeanUtils.copyProperties(userVo,user);
log.info("用户对象缓存已更新"+CACHE_USER_PROFIX + userVo.getId());
CACHE_CONTAINER.put(CACHE_USER_PROFIX+user.getId(),user);
}
return isSuccess;
}
/**
* 删除用户切入
* @param joinPoint
* @return
*/
@Around(value = POINTCUT_USER_DELETE)
public Object cacheUserDelete(ProceedingJoinPoint joinPoint) throws Throwable {
//取出第一个参数
Integer id = (Integer) joinPoint.getArgs()[0];
Boolean isSuccess = (Boolean) joinPoint.proceed();
if (isSuccess){
//删除缓存
CACHE_CONTAINER.remove(CACHE_USER_PROFIX+id);
}
return isSuccess;
}
}
/**
* 删除部门切入
*
* @param joinPoint 切

60
src/main/java/com/yeqifu/sys/cache/CachePool.java vendored
Unescape View File

@ -17,72 +17,86 @@ import java.util.List;
import java.util.Map;
/**
* CachePool 类用于处理缓存操作，模拟类似 Redis 的缓存管理功能。
* 提供了添加缓存、删除缓存、清空缓存和同步缓存等功能。
* 主要用于缓存部门、用户、客户、供应商、商品等信息。
*
* @Author: 落亦-
* @Date: 2019/12/20 18:05
*/
public class CachePool {
/**
* 所有的缓存数据放到这个CACHE_CONTAINER 类似于redis
* 缓存容器，用于存放所有缓存数据，键值对存储。
* 这个容器类似于 Redis，存储了不同实体的缓存数据。
*/
public static volatile Map<String,Object> CACHE_CONTAINER = new HashMap<>();
public static volatile Map<String, Object> CACHE_CONTAINER = new HashMap<>();
/**
* 根据KEY删除缓存
* @param key 键
* 根据指定的键删除缓存数据。
*
* @param key 键，缓存的唯一标识符
*/
public static void removeCacheByKey(String key){
if (CACHE_CONTAINER.containsKey(key)){
public static void removeCacheByKey(String key) {
// 判断缓存容器中是否包含指定的键
if (CACHE_CONTAINER.containsKey(key)) {
// 删除指定键的缓存数据
CACHE_CONTAINER.remove(key);
}
}
/**
* 清空所有缓存
* 清空所有缓存数据。
* 该方法会清除缓存容器中的所有条目。
*/
public static void removeAll(){
public static void removeAll() {
// 清空缓存容器
CACHE_CONTAINER.clear();
}
/**
* 同步缓存
* 同步数据到缓存。
* 从数据库中获取部门、用户、客户、供应商、商品等数据，并将其放入缓存容器。
*/
public static void syncData(){
//同步部门数据
public static void syncData() {
// 同步部门数据
DeptMapper deptMapper = SpringUtil.getBean(DeptMapper.class);
List<Dept> deptList = deptMapper.selectList(null);
for (Dept dept : deptList) {
CACHE_CONTAINER.put("dept:"+dept.getId(),dept);
// 将部门数据存入缓存容器
CACHE_CONTAINER.put("dept:" + dept.getId(), dept);
}
//同步用户数据
// 同步用户数据
UserMapper userMapper = SpringUtil.getBean(UserMapper.class);
List<User> userList = userMapper.selectList(null);
for (User user : userList) {
CACHE_CONTAINER.put("user:"+user.getId(),user);
// 将用户数据存入缓存容器
CACHE_CONTAINER.put("user:" + user.getId(), user);
}
//同步客户数据
// 同步客户数据
CustomerMapper customerMapper = SpringUtil.getBean(CustomerMapper.class);
List<Customer> customerList = customerMapper.selectList(null);
for (Customer customer : customerList) {
CACHE_CONTAINER.put("customer:"+customer.getId(),customer);
// 将客户数据存入缓存容器
CACHE_CONTAINER.put("customer:" + customer.getId(), customer);
}
//同步供应商数据
// 同步供应商数据
ProviderMapper providerMapper = SpringUtil.getBean(ProviderMapper.class);
List<Provider> providerList = providerMapper.selectList(null);
for (Provider provider : providerList) {
CACHE_CONTAINER.put("provider:"+provider.getId(),provider);
// 将供应商数据存入缓存容器
CACHE_CONTAINER.put("provider:" + provider.getId(), provider);
}
//同步商品数据
// 同步商品数据
GoodsMapper goodsMapper = SpringUtil.getBean(GoodsMapper.class);
List<Goods> goodsList = goodsMapper.selectList(null);
for (Goods goods : goodsList) {
CACHE_CONTAINER.put("goods:"+goods.getId(),goods);
// 将商品数据存入缓存容器
CACHE_CONTAINER.put("goods:" + goods.getId(), goods);
}
}
}

102
src/main/java/com/yeqifu/sys/common/AppFileUtils.java
Unescape View File

@ -13,97 +13,111 @@ import java.io.InputStream;
import java.util.Properties;
/**
* AppFileUtils 类提供了与文件相关的工具方法，包括文件上传、下载、重命名和删除操作。
* 它主要用于处理文件的存储路径、生成文件的唯一名称，并支持文件的下载和删除操作。
*
* @Author: 落亦-
* @Date: 2019/12/15 23:44
*/
public class AppFileUtils {
/**
* 文件上传的保存路径 默认值
* 文件上传的保存路径，默认为 G:/upload/
* 在静态代码块中，如果在配置文件中指定了路径，将覆盖此默认值。
*/
public static String UPLOAD_PATH="G:/upload/";
public static String UPLOAD_PATH = "G:/upload/";
// 静态代码块，初始化文件上传路径
static {
//通过反射的方式，读取配置文件的存储地址
// 通过反射的方式，读取配置文件 file.properties 中的存储地址
InputStream stream = AppFileUtils.class.getClassLoader().getResourceAsStream("file.properties");
Properties properties=new Properties();
Properties properties = new Properties();
try {
// 加载配置文件
properties.load(stream);
} catch (IOException e) {
e.printStackTrace();
}
// 获取配置文件中的文件路径，并赋值给 UPLOAD_PATH
String property = properties.getProperty("filepath");
if(null!=property) {
UPLOAD_PATH=property;
if (property != null) {
UPLOAD_PATH = property;
}
}
/**
* 根据文件老名字得到新名字
* @param oldName 文件老名字
* @return 新名字由32位随机数加图片后缀组成
* 根据文件的老名字生成一个新的文件名。
* 新文件名由32位的随机UUID和文件的后缀名组成，确保文件名唯一。
*
* @param oldName 文件的老名字
* @return 新的文件名
*/
public static String createNewFileName(String oldName) {
//获取文件名后缀
String stuff=oldName.substring(oldName.lastIndexOf("."), oldName.length());
//将UUID与文件名后缀进行拼接，生成新的文件名 生成的UUID为32位
return IdUtil.simpleUUID().toUpperCase()+stuff;
// 获取文件名后缀（例如 .jpg、.png）
String stuff = oldName.substring(oldName.lastIndexOf("."), oldName.length());
// 使用UUID生成新的文件名，并与文件后缀拼接
return IdUtil.simpleUUID().toUpperCase() + stuff;
}
/**
* 文件下载
* @param path
* @return
* 文件下载方法。
* 根据给定的路径返回文件的响应实体，支持文件的下载功能。
*
* @param path 文件的相对路径
* @return ResponseEntity 对象，包含文件的内容和下载的响应头
*/
public static ResponseEntity<Object> createResponseEntity(String path) {
//1,构造文件对象
File file=new File(UPLOAD_PATH, path);
if(file.exists()) {
//将下载的文件，封装byte[]
byte[] bytes=null;
// 1. 构造文件对象
File file = new File(UPLOAD_PATH, path);
if (file.exists()) {
// 2. 如果文件存在，将文件内容封装为字节数组
byte[] bytes = null;
try {
bytes = FileUtil.readBytes(file);
} catch (Exception e) {
e.printStackTrace();
}
//创建封装响应头信息的对象
HttpHeaders header=new HttpHeaders();
//封装响应内容类型(APPLICATION_OCTET_STREAM 响应的内容不限定)
// 3. 创建响应头对象，并设置响应内容类型为 APPLICATION_OCTET_STREAM（表示二进制流数据）
HttpHeaders header = new HttpHeaders();
header.setContentType(MediaType.APPLICATION_OCTET_STREAM);
//创建ResponseEntity对象
ResponseEntity<Object> entity= new ResponseEntity<Object>(bytes, header, HttpStatus.CREATED);
// 4. 创建并返回 ResponseEntity 对象，包含文件的字节数组、响应头和 HTTP 状态
ResponseEntity<Object> entity = new ResponseEntity<>(bytes, header, HttpStatus.CREATED);
return entity;
}
return null;
return null; // 如果文件不存在，返回 null
}
/**
* 更该图片的名字 去掉_temp
* @param goodsImg
* @return
* 重命名文件，去掉文件名中的 "_temp" 部分。
*
* @param goodsImg 原文件名
* @return 新文件名
*/
public static String renameFile(String goodsImg) {
File file = new File(UPLOAD_PATH,goodsImg);
String replace = goodsImg.replace("_temp","");
if (file.exists()){
file.renameTo(new File(UPLOAD_PATH,replace));
// 构造文件对象
File file = new File(UPLOAD_PATH, goodsImg);
// 将文件名中的 "_temp" 替换为空
String replace = goodsImg.replace("_temp", "");
// 如果文件存在，执行重命名操作
if (file.exists()) {
file.renameTo(new File(UPLOAD_PATH, replace));
}
return replace;
return replace; // 返回重命名后的文件名
}
/**
* 根据老路径删除图片
* @param oldPath
* 根据文件的旧路径删除文件。
* 删除文件时，避免删除默认的商品图片。
*
* @param oldPath 文件的旧路径
*/
public static void removeFileByPath(String oldPath) {
//图片的路径不是默认图片的路径
if (!oldPath.equals(Constast.DEFAULT_IMG_GOODS)){
File file = new File(UPLOAD_PATH,oldPath);
if (file.exists()){
file.delete();
// 如果旧路径不是默认商品图片的路径，则删除文件
if (!oldPath.equals(Constast.DEFAULT_IMG_GOODS)) {
File file = new File(UPLOAD_PATH, oldPath);
if (file.exists()) {
file.delete(); // 删除文件
}
}
}
}

38
src/main/java/com/yeqifu/sys/common/PinyinUtils.java
Unescape View File

@ -9,6 +9,7 @@ import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombi
/**
* 拼音工具类
* 该类用于将中文字符串转换为拼音格式，并可定制拼音输出的格式。
*
* @Author: 落亦-
* @Date: 2019/12/3 10:29
@ -16,38 +17,51 @@ import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombi
public class PinyinUtils {
/**
* 返回一个拼音字符串，并且首字母大写
* 将输入的中文字符串转换为拼音字符串，且首字母大写，拼音不带声调。
*
* @param inputString 输入的中文字符串
* @return 拼音字符串（首字母大写且没有声调），如果输入为空或无效，返回 "*"
*/
public static String getPingYin(String inputString) {
// 设置拼音输出的格式
HanyuPinyinOutputFormat format = new HanyuPinyinOutputFormat();
format.setCaseType(HanyuPinyinCaseType.LOWERCASE);
format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
format.setVCharType(HanyuPinyinVCharType.WITH_V);
format.setCaseType(HanyuPinyinCaseType.LOWERCASE); // 设置拼音的大小写为小写
format.setToneType(HanyuPinyinToneType.WITHOUT_TONE); // 设置拼音不带音调
format.setVCharType(HanyuPinyinVCharType.WITH_V); // 设置拼音中的v字符使用“v”而非“u”
String output = "";
// 判断输入字符串是否有效
if (inputString != null && inputString.length() > 0 && !"null".equals(inputString)) {
char[] input = inputString.trim().toCharArray();
char[] input = inputString.trim().toCharArray(); // 将输入字符串转换为字符数组
try {
// 遍历每个字符，如果是中文字符，则转换为拼音，否则保留原字符
for (int i = 0; i < input.length; i++) {
// 判断字符是否为汉字
if (java.lang.Character.toString(input[i]).matches("[\\u4E00-\\u9FA5]+")) {
// 获取该汉字的拼音
String[] temp = PinyinHelper.toHanyuPinyinStringArray(input[i], format);
output += temp[0];
output += temp[0]; // 拼接拼音
} else {
output += java.lang.Character.toString(input[i]);
output += java.lang.Character.toString(input[i]); // 非汉字字符直接拼接
}
}
} catch (BadHanyuPinyinOutputFormatCombination e) {
e.printStackTrace();
e.printStackTrace(); // 处理拼音转换过程中可能发生的异常
}
} else {
return "*";
return "*"; // 如果输入无效，返回 "*"
}
return output;
}
/**
* 主函数用于测试拼音转换功能。
*
* @param args 命令行参数
*/
public static void main(String[] args) {
// 测试拼音转换
String s = getPingYin("落亦");
System.out.println(s);
System.out.println(s); // 输出拼音：luo yi
}
}

2
src/main/java/com/yeqifu/sys/common/ResultObj.java
Unescape View File

@ -44,3 +44,5 @@ public class ResultObj {
}
//测试

111
src/main/java/com/yeqifu/sys/config/ShiroAutoConfiguration.java
Unescape View File

@ -24,144 +24,149 @@ import javax.servlet.Filter;
import java.util.HashMap;
import java.util.Map;
/**
* @Author: 落亦-
* @Date: 2019/11/21 21:01
*/
@Configuration
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass(value = { SecurityManager.class })
@ConfigurationProperties(prefix = "shiro")
@Data
@Configuration // 标注为配置类，Spring 会自动扫描并加载此类的配置
@ConditionalOnWebApplication(type = Type.SERVLET) // 仅在 Servlet Web 应用中启用
@ConditionalOnClass(value = { SecurityManager.class }) // 仅在 SecurityManager 类存在时启用
@ConfigurationProperties(prefix = "shiro") // 绑定配置文件中以 "shiro" 为前缀的属性
@Data // 自动生成 getter 和 setter 方法
public class ShiroAutoConfiguration {
private static final String SHIRO_DIALECT = "shiroDialect"; // Thymeleaf Shiro 标签名常量
private static final String SHIRO_FILTER = "shiroFilter"; // Shiro 过滤器名常量
private static final String SHIRO_DIALECT = "shiroDialect";
private static final String SHIRO_FILTER = "shiroFilter";
/**
* 加密方式
* 配置默认的密码加密算法（MD5）
*/
private String hashAlgorithmName = "md5";
/**
* 散列次数
* 设置散列次数（默认从常量类中读取）
*/
private int hashIterations = Constast.HASHITERATIONS;
/**
* 默认的登陆页面
* 登录页面 URL（未认证时的跳转页面）
*/
private String loginUrl = "/index.html";
/**
* Shiro 权限控制的路径集合
* anonUrls - 允许匿名访问的路径
* logOutUrl - 登出路径
* authcUlrs - 需要登录认证的路径
*/
private String[] anonUrls;
private String logOutUrl;
private String[] authcUlrs;
/**
* 声明凭证匹配器
* 1. 配置凭证匹配器（密码加密规则）
* 使用 MD5 算法进行密码验证，结合指定的散列次数。
*/
@Bean("credentialsMatcher")
public HashedCredentialsMatcher hashedCredentialsMatcher() {
HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
credentialsMatcher.setHashAlgorithmName(hashAlgorithmName);
credentialsMatcher.setHashIterations(hashIterations);
credentialsMatcher.setHashAlgorithmName(hashAlgorithmName); // 设置加密算法
credentialsMatcher.setHashIterations(hashIterations); // 设置散列次数
return credentialsMatcher;
}
/**
* 声明userRealm
* 2. 配置自定义 Realm
* 用于定义用户的身份认证和权限校验逻辑。
*/
@Bean("userRealm")
public UserRealm userRealm(CredentialsMatcher credentialsMatcher) {
UserRealm userRealm = new UserRealm();
// 注入凭证匹配器
userRealm.setCredentialsMatcher(credentialsMatcher);
userRealm.setCredentialsMatcher(credentialsMatcher); // 注入凭证匹配器
return userRealm;
}
/**
* 配置SecurityManager
* 3. 配置核心安全管理器 SecurityManager
* 负责管理用户认证、授权等操作。
*/
@Bean("securityManager")
public SecurityManager securityManager(UserRealm userRealm) {
DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
// 注入userRealm
securityManager.setRealm(userRealm);
securityManager.setRealm(userRealm); // 注入自定义 Realm
return securityManager;
}
/**
* 配置shiro的过滤器
* 4. 配置 Shiro 的过滤器工厂
* ShiroFilterFactoryBean 负责设置过滤规则和登录 URL。
*/
@Bean(SHIRO_FILTER)
public ShiroFilterFactoryBean shiroFilterFactoryBean(SecurityManager securityManager) {
ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
// 设置安全管理器
factoryBean.setSecurityManager(securityManager);
// 设置未登陆的时要跳转的页面
factoryBean.setLoginUrl(loginUrl);
factoryBean.setSecurityManager(securityManager); // 设置安全管理器
factoryBean.setLoginUrl(loginUrl); // 设置未认证时的跳转页面
// 1. 配置过滤器链定义映射
Map<String, String> filterChainDefinitionMap = new HashMap<>();
// 设置放行的路径
// 配置匿名访问路径（无需登录）
if (anonUrls != null && anonUrls.length > 0) {
for (String anon : anonUrls) {
filterChainDefinitionMap.put(anon, "anon");
}
}
// 设置登出的路径
if (null != logOutUrl) {
// 配置登出路径
if (logOutUrl != null) {
filterChainDefinitionMap.put(logOutUrl, "logout");
}
// 设置拦截的路径
// 配置需要登录认证的路径
if (authcUlrs != null && authcUlrs.length > 0) {
for (String authc : authcUlrs) {
filterChainDefinitionMap.put(authc, "authc");
}
}
Map<String, Filter> filters=new HashMap<>();
// filters.put("authc", new ShiroLoginFilter());
//配置过滤器
// 2. 注入自定义过滤器（如果有）
Map<String, Filter> filters = new HashMap<>();
factoryBean.setFilters(filters);
// 3. 设置过滤器链定义映射
factoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
return factoryBean;
}
/**
* 注册shiro的委托过滤器，相当于之前在web.xml里面配置的
*
* @return
* 5. 注册 Shiro 的委托过滤器
* 在 Spring Boot 中等效于 web.xml 的配置。
*/
@Bean
public FilterRegistrationBean<DelegatingFilterProxy> delegatingFilterProxy() {
FilterRegistrationBean<DelegatingFilterProxy> filterRegistrationBean = new FilterRegistrationBean<DelegatingFilterProxy>();
FilterRegistrationBean<DelegatingFilterProxy> filterRegistrationBean = new FilterRegistrationBean<>();
DelegatingFilterProxy proxy = new DelegatingFilterProxy();
proxy.setTargetFilterLifecycle(true);
proxy.setTargetBeanName(SHIRO_FILTER);
proxy.setTargetFilterLifecycle(true); // 由 Spring 管理生命周期
proxy.setTargetBeanName(SHIRO_FILTER); // 关联 Shiro 过滤器
filterRegistrationBean.setFilter(proxy);
return filterRegistrationBean;
}
/* 加入注解的使用，不加入这个注解不生效--开始 */
/**
*
* @param securityManager
* @return
* 6. 开启 Shiro 注解支持（如 @RequiresRoles 和 @RequiresPermissions）
*/
@Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
return authorizationAttributeSourceAdvisor;
AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(securityManager); // 注入 SecurityManager
return advisor;
}
/**
* 7. 启用自动代理类，支持权限注解的解析
*/
@Bean
public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() {
DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
advisorAutoProxyCreator.setProxyTargetClass(true);
advisorAutoProxyCreator.setProxyTargetClass(true); // 使用 CGLIB 代理类
return advisorAutoProxyCreator;
}
/* 加入注解的使用，不加入这个注解不生效--结束 */
/**
* 这里是为了能在html页面引用shiro标签，上面两个函数必须添加，不然会报错
*
* @return
* 8. 配置 Thymeleaf Shiro 标签支持
* 允许在 HTML 页面中使用 Shiro 标签（如 shiro:hasPermission）。
*/
@Bean(name = SHIRO_DIALECT)
public ShiroDialect shiroDialect() {

68
src/main/java/com/yeqifu/sys/controller/CacheController.java
Unescape View File

@ -16,62 +16,70 @@ import java.util.Map;
import java.util.Set;
/**
* 缓存管理控制器
* 缓存管理控制器类
* 该控制器提供了缓存管理的功能，包括查询所有缓存、删除缓存、清空缓存和同步缓存。
*
* @Author: 落亦-
* @Date: 2019/12/20 18:36
*/
@Api(description = "缓存管理")
@RestController
@RequestMapping("cache")
@Api(description = "缓存管理") // Swagger注解，用于描述API功能
@RestController // 标识为Spring MVC的Rest控制器
@RequestMapping("cache") // 定义基础请求路径为 "cache"
public class CacheController {
private static volatile Map<String,Object> CACHE_CONTAINER= CachePool.CACHE_CONTAINER;
/**
* 缓存容器
* 使用CachePool提供的静态缓存容器，存储所有缓存项。
* 使用volatile关键字保证多线程环境下的可见性。
*/
private static volatile Map<String,Object> CACHE_CONTAINER = CachePool.CACHE_CONTAINER;
/**
* 查询所有缓存
* @return
* @return DataGridView 返回所有缓存项的列表，用于前端显示。
*/
@ApiOperation(value = "查询所有缓存",notes = "查询所有缓存")
@RequestMapping(value = "loadAllCache",method = RequestMethod.GET)
public DataGridView loadAllCache(){
List<CacheBean> list = new ArrayList<>();
@ApiOperation(value = "查询所有缓存", notes = "查询所有缓存") // Swagger注解，用于描述接口的功能
@RequestMapping(value = "loadAllCache", method = RequestMethod.GET) // 映射GET请求到该方法
public DataGridView loadAllCache() {
List<CacheBean> list = new ArrayList<>(); // 用于存储缓存项的列表
// 遍历缓存容器的所有键值对
Set<Map.Entry<String, Object>> entrySet = CACHE_CONTAINER.entrySet();
for (Map.Entry<String, Object> entry : entrySet) {
list.add(new CacheBean(entry.getKey(),entry.getValue()));
// 将每个键值对封装为CacheBean对象并添加到列表中
list.add(new CacheBean(entry.getKey(), entry.getValue()));
}
return new DataGridView(list);
return new DataGridView(list); // 将列表封装为DataGridView对象返回
}
/**
* 删除缓存
* @param key
* @return
* 删除指定缓存
* @param key 缓存的键
* @return ResultObj 返回操作结果，表示删除是否成功。
*/
@RequestMapping("deleteCache")
public ResultObj deleteCache(String key){
CachePool.removeCacheByKey(key);
return ResultObj.DELETE_SUCCESS;
@RequestMapping("deleteCache") // 映射请求路径为 "deleteCache"
public ResultObj deleteCache(String key) {
CachePool.removeCacheByKey(key); // 调用CachePool的方法删除指定缓存
return ResultObj.DELETE_SUCCESS; // 返回删除成功的结果
}
/**
* 清空所有缓存
* @return
* @return ResultObj 返回操作结果，表示清空是否成功。
*/
@RequestMapping("removeAllCache")
public ResultObj removeAllCache(){
CachePool.removeAll();
return ResultObj.DELETE_SUCCESS;
@RequestMapping("removeAllCache") // 映射请求路径为 "removeAllCache"
public ResultObj removeAllCache() {
CachePool.removeAll(); // 调用CachePool的方法清空所有缓存
return ResultObj.DELETE_SUCCESS; // 返回清空成功的结果
}
/**
* 同步缓存
* @return
* @return ResultObj 返回操作结果，表示同步是否成功。
*/
@RequestMapping("syncCache")
public ResultObj syncCache(){
CachePool.syncData();
return ResultObj.SYNCCACHE_SUCCESS;
@RequestMapping("syncCache") // 映射请求路径为 "syncCache"
public ResultObj syncCache() {
CachePool.syncData(); // 调用CachePool的方法同步缓存
return ResultObj.SYNCCACHE_SUCCESS; // 返回同步成功的结果
}
}

149
src/main/java/com/yeqifu/sys/controller/DeptController.java
Unescape View File

@ -1,6 +1,5 @@
package com.yeqifu.sys.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@ -18,148 +17,144 @@ import org.springframework.web.bind.annotation.RestController;
import java.util.*;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
* 部门管理控制器
* 提供了部门数据的CRUD（增删改查）以及相关功能，包括树形结构加载、排序码获取等。
*
* @author luoyi-
* @since 2019-11-26
* @Author: 落亦-
* @Since: 2019-11-26
*/
@RestController
@RequestMapping("/dept")
@RestController // 标识为Spring MVC的Rest控制器
@RequestMapping("/dept") // 定义基础请求路径为 "/dept"
public class DeptController {
@Autowired
private IDeptService deptService;
private IDeptService deptService; // 自动注入部门服务接口
/**
* 加载部门左边的菜单树
* @param deptVo
* @return
* 加载部门左侧的菜单树
* 将部门数据组装为树形结构（JSON格式），供前端展示。
* @param deptVo 部门查询条件封装类
* @return DataGridView 包含树形节点的数据
*/
@RequestMapping("loadDeptManagerLeftTreeJson")
public DataGridView loadManagerLeftTreeJson(DeptVo deptVo){
//查询出所有的部门，存放进list中
// QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
// queryWrapper.eq('1');
public DataGridView loadManagerLeftTreeJson(DeptVo deptVo) {
// 查询所有部门数据
List<Dept> list = deptService.list();
List<TreeNode> treeNodes = new ArrayList<>();
//将部门放入treeNodes中，组装成json
// 遍历部门数据，将每个部门封装为树形节点
for (Dept dept : list) {
Boolean open = dept.getOpen()==1?true:false;
treeNodes.add(new TreeNode(dept.getId(),dept.getPid(),dept.getName(),open));
Boolean open = dept.getOpen() == 1; // 根据部门状态设置节点是否展开
treeNodes.add(new TreeNode(dept.getId(), dept.getPid(), dept.getName(), open));
}
return new DataGridView(treeNodes);
return new DataGridView(treeNodes); // 返回树形节点数据
}
/**
* 查询所有部门数据
* @param deptVo
* @return
* 查询所有部门数据（带分页和模糊查询）
* @param deptVo 部门查询条件封装类
* @return DataGridView 包含分页后的部门数据
*/
@RequestMapping("loadAllDept")
public DataGridView loadAllDept(DeptVo deptVo){
IPage<Dept> page = new Page<>(deptVo.getPage(),deptVo.getLimit());
//进行模糊查询
public DataGridView loadAllDept(DeptVo deptVo) {
IPage<Dept> page = new Page<>(deptVo.getPage(), deptVo.getLimit()); // 创建分页对象
QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
queryWrapper.like(StringUtils.isNotBlank(deptVo.getName()),"name",deptVo.getName());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getRemark()),"remark",deptVo.getRemark());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getAddress()),"address",deptVo.getAddress());
queryWrapper.eq(deptVo.getId()!=null,"id",deptVo.getId()).or().eq(deptVo.getId()!=null,"pid",deptVo.getId());
queryWrapper.orderByAsc("ordernum");
//进行查询
deptService.page(page,queryWrapper);
//返回DataGridView
return new DataGridView(page.getTotal(),page.getRecords());
// 添加模糊查询条件
queryWrapper.like(StringUtils.isNotBlank(deptVo.getName()), "name", deptVo.getName());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getRemark()), "remark", deptVo.getRemark());
queryWrapper.like(StringUtils.isNotBlank(deptVo.getAddress()), "address", deptVo.getAddress());
queryWrapper.eq(deptVo.getId() != null, "id", deptVo.getId())
.or().eq(deptVo.getId() != null, "pid", deptVo.getId());
queryWrapper.orderByAsc("ordernum"); // 按排序码升序排列
deptService.page(page, queryWrapper); // 执行分页查询
return new DataGridView(page.getTotal(), page.getRecords()); // 返回分页数据
}
/**
* 添加部门
* @param deptVo
* @return
* @param deptVo 部门数据封装类
* @return ResultObj 操作结果（成功或失败）
*/
@RequestMapping("addDept")
public ResultObj addDept(DeptVo deptVo){
public ResultObj addDept(DeptVo deptVo) {
try {
deptVo.setCreatetime(new Date());
deptService.save(deptVo);
return ResultObj.ADD_SUCCESS;
deptVo.setCreatetime(new Date()); // 设置创建时间
deptService.save(deptVo); // 保存部门数据
return ResultObj.ADD_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.ADD_ERROR;
return ResultObj.ADD_ERROR; // 返回失败结果
}
}
/**
* 加载排序码
* @return
* 加载部门排序码（获取最大的排序码加1）
* @return Map 包含新的排序码
*/
@RequestMapping("loadDeptMaxOrderNum")
public Map<String,Object> loadDeptMaxOrderNum(){
Map<String,Object> map = new HashMap<String,Object>();
public Map<String, Object> loadDeptMaxOrderNum() {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("ordernum");
IPage<Dept> page = new Page<>(1,1);
List<Dept> list = deptService.page(page,queryWrapper).getRecords();
if (list.size()>0){
map.put("value",list.get(0).getOrdernum()+1);
}else {
map.put("value",1);
queryWrapper.orderByDesc("ordernum"); // 按排序码降序排列
IPage<Dept> page = new Page<>(1, 1); // 只查询一条记录
List<Dept> list = deptService.page(page, queryWrapper).getRecords();
if (list.size() > 0) {
map.put("value", list.get(0).getOrdernum() + 1); // 获取最大排序码+1
} else {
map.put("value", 1); // 如果无记录，排序码为1
}
return map;
}
/**
* 更新部门
* @param deptVo
* @return
* 更新部门信息
* @param deptVo 部门数据封装类
* @return ResultObj 操作结果（成功或失败）
*/
@RequestMapping("updateDept")
public ResultObj updateDept(DeptVo deptVo){
public ResultObj updateDept(DeptVo deptVo) {
try {
deptService.updateById(deptVo);
return ResultObj.UPDATE_SUCCESS;
deptService.updateById(deptVo); // 根据ID更新部门数据
return ResultObj.UPDATE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.UPDATE_ERROR;
return ResultObj.UPDATE_ERROR; // 返回失败结果
}
}
/**
* 检查当前部门是否有子部门
* @param deptVo
* @return
* @param deptVo 部门数据封装类
* @return Map 包含布尔值，表示是否有子部门
*/
@RequestMapping("checkDeptHasChildrenNode")
public Map<String,Object> checkDeptHasChildrenNode(DeptVo deptVo){
Map<String,Object> map = new HashMap<String, Object>();
public Map<String, Object> checkDeptHasChildrenNode(DeptVo deptVo) {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Dept> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("pid",deptVo.getId());
queryWrapper.eq("pid", deptVo.getId()); // 根据父ID查询
List<Dept> list = deptService.list(queryWrapper);
if (list.size()>0){
map.put("value",true);
}else {
map.put("value",false);
}
map.put("value", !list.isEmpty()); // 如果有子部门，返回true，否则返回false
return map;
}
/**
* 删除部门
* @param deptVo
* @return
* @param deptVo 部门数据封装类
* @return ResultObj 操作结果（成功或失败）
*/
@RequestMapping("deleteDept")
public ResultObj deleteDept(DeptVo deptVo){
public ResultObj deleteDept(DeptVo deptVo) {
try {
deptService.removeById(deptVo.getId());
return ResultObj.DELETE_SUCCESS;
deptService.removeById(deptVo.getId()); // 根据ID删除部门
return ResultObj.DELETE_SUCCESS; // 返回成功结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
return ResultObj.DELETE_ERROR; // 返回失败结果
}
}
}

70
src/main/java/com/yeqifu/sys/controller/FileController.java
Unescape View File

@ -14,57 +14,79 @@ import java.util.HashMap;
import java.util.Map;
/**
* 文件控制器
* 提供文件上传和图片下载的功能。
*
* @Author: 落亦-
* @Date: 2019/12/15 23:46
*/
@RestController
@RequestMapping("file")
@RestController // 标识为Spring MVC的Rest控制器
@RequestMapping("file") // 定义基础请求路径为 "/file"
public class FileController {
/**
* 文件上传
* @param mf
* @return
* @param mf 上传的文件（前端传递的MultipartFile对象）
* @return Map 包含文件保存路径的响应信息
*/
@RequestMapping("uploadFile")
public Map<String,Object> uploadFile(MultipartFile mf) {
//1.得到文件名
public Map<String, Object> uploadFile(MultipartFile mf) {
// 1. 获取原始文件名
String oldName = mf.getOriginalFilename();
//2.根据旧的文件名生成新的文件名
String newName=AppFileUtils.createNewFileName(oldName);
//3.得到当前日期的字符串
String dirName= DateUtil.format(new Date(), "yyyy-MM-dd");
//4.构造文件夹
File dirFile=new File(AppFileUtils.UPLOAD_PATH,dirName);
//5.判断当前文件夹是否存在
if(!dirFile.exists()) {
//如果不存在则创建新文件夹
// 2. 生成新的文件名（避免重复文件名）
String newName = AppFileUtils.createNewFileName(oldName);
// 3. 获取当前日期并格式化为 "yyyy-MM-dd" 字符串
String dirName = DateUtil.format(new Date(), "yyyy-MM-dd");
// 4. 构造保存文件的目录
File dirFile = new File(AppFileUtils.UPLOAD_PATH, dirName);
// 5. 检查目录是否存在，若不存在则创建
if (!dirFile.exists()) {
dirFile.mkdirs();
}
//6.构造文件对象
File file=new File(dirFile, newName+"_temp");
//7.把mf里面的图片信息写入file
// 6. 创建目标文件对象，文件名后加 "_temp" 表示临时文件
File file = new File(dirFile, newName + "_temp");
// 7. 将文件内容写入到目标文件中
try {
mf.transferTo(file);
} catch (IllegalStateException | IOException e) {
e.printStackTrace();
e.printStackTrace(); // 打印异常信息
}
Map<String,Object> map=new HashMap<String, Object>();
map.put("path",dirName+"/"+newName+"_temp");
// 8. 返回文件的保存路径（供前端调用）
Map<String, Object> map = new HashMap<>();
map.put("path", dirName + "/" + newName + "_temp");
return map;
}
/**
* 图片下载
* 根据文件路径返回图片的字节数据，供前端显示。
*
* @param path 文件相对路径
* @return ResponseEntity 响应图片数据
*/
@RequestMapping("showImageByPath")
public ResponseEntity<byte[]> showImageByPath(String path) {
// 规范路径，防止路径穿越
// **注意：未完成的功能，以下是解释和可能的逻辑建议**
// 1. 规范路径，防止路径穿越漏洞
Path normalizedPath = Paths.get(AppFileUtils.UPLOAD_PATH, path).normalize();
// 2. 验证路径是否在允许的上传目录内
if (!normalizedPath.startsWith(AppFileUtils.UPLOAD_PATH)) {
// 如果路径越界，则返回错误响应
// 如果路径越界，则返回403（禁止访问）状态响应
return ResponseEntity.status(HttpStatus.FORBIDDEN).build();
}
}
// 3. 从路径加载文件（逻辑未完成）
// - 需要检查文件是否存在
// - 需要读取文件的字节内容
// - 使用 `ResponseEntity` 返回字节数据和适当的 Content-Type 头
}
}

86
src/main/java/com/yeqifu/sys/controller/LoginController.java
Unescape View File

@ -24,68 +24,86 @@ import java.io.IOException;
import java.util.Date;
/**
* 登陆前端控制器
* 登录前端控制器
* 负责处理用户登录请求和验证码生成。
*
* @Author: 落亦-
* @Date: 2019/11/21 21:33
*/
@RestController
@RequestMapping("login")
@RestController // 表示该类是一个Rest风格的控制器，直接返回JSON数据
@RequestMapping("login") // 定义基础请求路径为 "/login"
public class LoginController {
@Autowired
private ILoginfoService loginfoService;
private ILoginfoService loginfoService; // 自动注入日志服务，用于记录登录日志
/**
* 用户登录
* @param userVo 用户提交的登录数据
* @param code 用户输入的验证码
* @param session 当前会话，用于获取存储的验证码
* @return ResultObj 包含登录结果的响应信息
*/
@RequestMapping("login")
public ResultObj login(UserVo userVo,String code,HttpSession session){
//获得存储在session中的验证码
public ResultObj login(UserVo userVo, String code, HttpSession session) {
// 从Session中获取之前生成的验证码
String sessionCode = (String) session.getAttribute("code");
if (code!=null&&sessionCode.equals(code)){
Subject subject = SecurityUtils.getSubject();
AuthenticationToken token = new UsernamePasswordToken(userVo.getLoginname(),userVo.getPwd());
// 验证用户输入的验证码是否正确
if (code != null && sessionCode.equals(code)) {
Subject subject = SecurityUtils.getSubject(); // 获取当前用户的Shiro Subject
AuthenticationToken token = new UsernamePasswordToken(userVo.getLoginname(), userVo.getPwd()); // 创建用户认证令牌
try {
//对用户进行认证登陆
// 执行用户认证登录
subject.login(token);
//通过subject获取以认证活动的user
// 通过认证后获取活动用户信息
ActiverUser activerUser = (ActiverUser) subject.getPrincipal();
//将user存储到session中
WebUtils.getSession().setAttribute("user",activerUser.getUser());
//记录登陆日志
// 将用户信息存储到Session中
WebUtils.getSession().setAttribute("user", activerUser.getUser());
// 创建登录日志对象
Loginfo entity = new Loginfo();
entity.setLoginname(activerUser.getUser().getName()+"-"+activerUser.getUser().getLoginname());
entity.setLoginip(WebUtils.getRequest().getRemoteAddr());
entity.setLogintime(new Date());
loginfoService.save(entity);
entity.setLoginname(activerUser.getUser().getName() + "-" + activerUser.getUser().getLoginname()); // 登录名称
entity.setLoginip(WebUtils.getRequest().getRemoteAddr()); // 获取用户IP地址
entity.setLogintime(new Date()); // 设置登录时间
loginfoService.save(entity); // 保存登录日志
return ResultObj.LOGIN_SUCCESS;
return ResultObj.LOGIN_SUCCESS; // 返回登录成功结果
} catch (AuthenticationException e) {
e.printStackTrace();
return ResultObj.LOGIN_ERROR_PASS;
return ResultObj.LOGIN_ERROR_PASS; // 用户名或密码错误
}
}else {
return ResultObj.LOGIN_ERROR_CODE;
} else {
return ResultObj.LOGIN_ERROR_CODE; // 验证码错误
}
}
/**
* 得到登陆验证码
* @param response
* @param session
* 获取登录验证码
* 生成并返回图片验证码，同时将验证码存储到Session中。
*
* @param response Http响应对象，用于返回验证码图片
* @param session 当前会话，用于存储验证码
* @throws IOException
*/
@RequestMapping("getCode")
public void getCode(HttpServletResponse response, HttpSession session) throws IOException{
//定义图形验证码的长和宽
LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(116, 36,4,5);
session.setAttribute("code",lineCaptcha.getCode());
public void getCode(HttpServletResponse response, HttpSession session) throws IOException {
// 创建图形验证码，指定宽、高、字符数和干扰线数
LineCaptcha lineCaptcha = CaptchaUtil.createLineCaptcha(116, 36, 4, 5);
// 将验证码内容存储到Session中
session.setAttribute("code", lineCaptcha.getCode());
try {
// 获取响应输出流，将验证码图片写入响应
ServletOutputStream outputStream = response.getOutputStream();
lineCaptcha.write(outputStream);
outputStream.close();
outputStream.close(); // 关闭输出流
} catch (IOException e) {
e.printStackTrace();
e.printStackTrace(); // 捕获并打印IO异常
}
}
}

93
src/main/java/com/yeqifu/sys/controller/LoginfoController.java
Unescape View File

@ -1,10 +1,8 @@
package com.yeqifu.sys.controller;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sun.org.apache.regexp.internal.RE;
import com.yeqifu.sys.common.DataGridView;
import com.yeqifu.sys.common.ResultObj;
import com.yeqifu.sys.entity.Loginfo;
@ -13,7 +11,6 @@ import com.yeqifu.sys.vo.LoginfoVo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.Serializable;
@ -21,76 +18,92 @@ import java.util.ArrayList;
import java.util.Collection;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
* 日志管理前端控制器
* 提供查询登录日志、删除单条日志以及批量删除日志的接口。
*
* @author luoyi-
* @since 2019-11-23
* @Author: luoyi-
* @Since: 2019-11-23
*/
@RestController
@RequestMapping("loginfo")
@RestController // 标注为Rest风格的控制器，方法直接返回JSON格式数据
@RequestMapping("loginfo") // 定义基础请求路径为 "/loginfo"
public class LoginfoController {
@Autowired
private ILoginfoService loginfoService;
private ILoginfoService loginfoService; // 自动注入日志服务接口，负责日志数据的业务逻辑处理
/**
* 查询所有登陆日志的信息
* @param loginfoVo
* @return
* 查询所有登录日志的信息
* 支持分页、模糊查询和时间范围筛选。
*
* @param loginfoVo 日志查询条件封装类，包含分页参数和查询条件
* @return 包含日志总条数和分页数据的对象
*/
@RequestMapping("loadAllLoginfo")
public DataGridView loadAllLoginfo(LoginfoVo loginfoVo){
IPage<Loginfo> page = new Page<Loginfo>(loginfoVo.getPage(),loginfoVo.getLimit());
QueryWrapper<Loginfo> queryWrapper = new QueryWrapper<Loginfo>();
//进行模糊查询
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginname()),"loginname",loginfoVo.getLoginname());
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginip()),"loginip",loginfoVo.getLoginip());
//数据库中登陆时间要大于用户输入的开始时间且小于用户登陆的结束时间
queryWrapper.ge(loginfoVo.getStartTime()!=null,"logintime",loginfoVo.getStartTime());
queryWrapper.le(loginfoVo.getEndTime()!=null,"logintime",loginfoVo.getEndTime());
//根据登陆时间进行降序排序
public DataGridView loadAllLoginfo(LoginfoVo loginfoVo) {
// 创建分页对象，指定当前页和每页条数
IPage<Loginfo> page = new Page<>(loginfoVo.getPage(), loginfoVo.getLimit());
// 构造查询条件
QueryWrapper<Loginfo> queryWrapper = new QueryWrapper<>();
// 根据登录名进行模糊查询，条件为空时忽略
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginname()), "loginname", loginfoVo.getLoginname());
// 根据登录IP进行模糊查询，条件为空时忽略
queryWrapper.like(StringUtils.isNotBlank(loginfoVo.getLoginip()), "loginip", loginfoVo.getLoginip());
// 筛选登录时间大于等于开始时间
queryWrapper.ge(loginfoVo.getStartTime() != null, "logintime", loginfoVo.getStartTime());
// 筛选登录时间小于等于结束时间
queryWrapper.le(loginfoVo.getEndTime() != null, "logintime", loginfoVo.getEndTime());
// 按登录时间降序排列
queryWrapper.orderByDesc("logintime");
loginfoService.page(page,queryWrapper);
return new DataGridView(page.getTotal(),page.getRecords());
// 分页查询日志数据
loginfoService.page(page, queryWrapper);
// 返回包含总条数和当前页数据的结果
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 删除单条日志
* @param id
* @return
* 根据日志ID删除指定的日志记录。
*
* @param id 日志记录的唯一标识
* @return 删除操作的结果信息
*/
@RequestMapping("deleteLoginfo")
public ResultObj deleteLoginfo(Integer id){
public ResultObj deleteLoginfo(Integer id) {
try {
// 根据ID删除日志
loginfoService.removeById(id);
return ResultObj.DELETE_SUCCESS;
return ResultObj.DELETE_SUCCESS; // 返回删除成功的结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
return ResultObj.DELETE_ERROR; // 返回删除失败的结果
}
}
/**
* 批量删除
* @param loginfoVo
* @return
* 批量删除日志
* 根据多个日志ID删除指定的日志记录。
*
* @param loginfoVo 封装了多个日志ID的对象
* @return 删除操作的结果信息
*/
@RequestMapping("batchDeleteLoginfo")
public ResultObj batchDeleteLoginfo(LoginfoVo loginfoVo){
public ResultObj batchDeleteLoginfo(LoginfoVo loginfoVo) {
try {
Collection<Serializable> idList = new ArrayList<Serializable>();
// 创建集合存储需要删除的日志ID
Collection<Serializable> idList = new ArrayList<>();
// 遍历日志ID数组，将其添加到集合中
for (Integer id : loginfoVo.getIds()) {
idList.add(id);
}
// 批量删除日志
this.loginfoService.removeByIds(idList);
return ResultObj.DELETE_SUCCESS;
return ResultObj.DELETE_SUCCESS; // 返回批量删除成功的结果
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
return ResultObj.DELETE_ERROR; // 返回批量删除失败的结果
}
}
}

171
src/main/java/com/yeqifu/sys/controller/MenuController.java
Unescape View File

@ -21,6 +21,8 @@ import org.springframework.web.bind.annotation.RestController;
import java.util.*;
/**
* 菜单管理控制器
*
* @Author: 落亦-
* @Date: 2019/11/22 15:35
*/
@ -37,119 +39,97 @@ public class MenuController {
@Autowired
private IRoleService roleService;
/**
* 加载首页左侧菜单数据
* @param permissionVo
* @return 返回树形结构的菜单数据
*/
@RequestMapping("loadIndexLeftMenuJson")
public DataGridView loadIndexLeftMenuJson(PermissionVo permissionVo){
//查询所有菜单
QueryWrapper<Permission> queryWrapper = new QueryWrapper<Permission>();
//设置查询条件
//查询的必须是菜单，不能是crud的权限
queryWrapper.eq("type",Constast.TYPE_MENU);
//菜单必须可用
queryWrapper.eq("available", Constast.AVAILABLE_TRUE);
//获得用户 判断用户的类型
public DataGridView loadIndexLeftMenuJson(PermissionVo permissionVo) {
// 查询所有菜单
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("type", Constast.TYPE_MENU); // 只查询菜单
queryWrapper.eq("available", Constast.AVAILABLE_TRUE); // 菜单必须可用
// 获取当前用户信息
User user = (User) WebUtils.getSession().getAttribute("user");
List<Permission> list = null;
if (user.getType().equals(Constast.USER_TYPE_SUPER)){
//用户类型为超级管理员
List<Permission> list;
if (user.getType().equals(Constast.USER_TYPE_SUPER)) {
// 超级管理员查询所有菜单
list = permissionService.list(queryWrapper);
}else {
//用户类型为 普通用户
//根据用户ID+角色+权限去查询
} else {
// 普通用户根据角色和权限查询菜单
Integer userId = user.getId();
//1.根据用户ID查询角色
List<Integer> currentUserRoleIds = roleService.queryUserRoleIdsByUid(userId);
//2.根据角色ID查询菜单ID和权限ID
//使用set去重
List<Integer> currentUserRoleIds = roleService.queryUserRoleIdsByUid(userId); // 获取用户角色ID
Set<Integer> pids = new HashSet<>();
for (Integer rid : currentUserRoleIds) {
//根据角色ID查询菜单ID和权限ID
List<Integer> permissionIds = roleService.queryRolePermissionIdsByRid(rid);
//将菜单ID和权限ID放入Set中去重
pids.addAll(permissionIds);
pids.addAll(roleService.queryRolePermissionIdsByRid(rid)); // 根据角色ID查询权限ID
}
//3.根据角色ID查询权限
if (pids.size()>0){
queryWrapper.in("id",pids);
if (!pids.isEmpty()) {
queryWrapper.in("id", pids); // 根据权限ID查询菜单
list = permissionService.list(queryWrapper);
}else {
list=new ArrayList<>();
} else {
list = new ArrayList<>();
}
}
List<TreeNode> treeNodes = new ArrayList<TreeNode>();
// 构造树节点列表
List<TreeNode> treeNodes = new ArrayList<>();
for (Permission p : list) {
Integer id =p.getId();
Integer pid = p.getPid();
String title = p.getTitle();
String icon = p.getIcon();
String href = p.getHref();
Boolean spread = p.getOpen().equals(Constast.OPEN_TRUE)?true:false;
treeNodes.add(new TreeNode(id,pid,title,icon,href,spread));
Boolean spread = p.getOpen().equals(Constast.OPEN_TRUE);
treeNodes.add(new TreeNode(p.getId(), p.getPid(), p.getTitle(), p.getIcon(), p.getHref(), spread));
}
//构造层级关系
List<TreeNode> list2 = TreeNodeBuilder.build(treeNodes,1);
return new DataGridView(list2);
// 构造层级菜单树
return new DataGridView(TreeNodeBuilder.build(treeNodes, 1));
}
/************************菜单管理*********************************/
/**
* 加载菜单左边的菜单树
* 加载菜单管理左侧菜单树
* @param permissionVo
* @return
* @return 返回树形结构的菜单数据
*/
@RequestMapping("loadMenuManagerLeftTreeJson")
public DataGridView loadMenuManagerLeftTreeJson(PermissionVo permissionVo){
public DataGridView loadMenuManagerLeftTreeJson(PermissionVo permissionVo) {
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("type",Constast.TYPE_MENU);
//查询出所有的菜单，存放进list中
List<Permission> list = permissionService.list(queryWrapper);
queryWrapper.eq("type", Constast.TYPE_MENU); // 只查询菜单
List<Permission> list = permissionService.list(queryWrapper); // 查询所有菜单
List<TreeNode> treeNodes = new ArrayList<>();
//将菜单放入treeNodes中，组装成json
for (Permission menu : list) {
Boolean open = menu.getOpen()==1?true:false;
treeNodes.add(new TreeNode(menu.getId(),menu.getPid(),menu.getTitle(),open));
Boolean open = menu.getOpen() == 1; // 判断是否展开
treeNodes.add(new TreeNode(menu.getId(), menu.getPid(), menu.getTitle(), open));
}
return new DataGridView(treeNodes);
}
/**
* 查询所有菜单数据
* 查询所有菜单
* @param permissionVo
* @return
* @return 返回分页后的菜单数据
*/
@RequestMapping("loadAllMenu")
public DataGridView loadAllMenu(PermissionVo permissionVo){
IPage<Permission> page = new Page<>(permissionVo.getPage(),permissionVo.getLimit());
//进行模糊查询
public DataGridView loadAllMenu(PermissionVo permissionVo) {
IPage<Permission> page = new Page<>(permissionVo.getPage(), permissionVo.getLimit());
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq(permissionVo.getId()!=null,"id",permissionVo.getId()).or().eq(permissionVo.getId()!=null,"pid",permissionVo.getId());
//只能查询菜单
queryWrapper.eq("type",Constast.TYPE_MENU);
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()),"title",permissionVo.getTitle());
queryWrapper.orderByAsc("ordernum");
//进行查询
permissionService.page(page,queryWrapper);
//返回DataGridView
return new DataGridView(page.getTotal(),page.getRecords());
queryWrapper.eq(permissionVo.getId() != null, "id", permissionVo.getId())
.or().eq(permissionVo.getId() != null, "pid", permissionVo.getId());
queryWrapper.eq("type", Constast.TYPE_MENU); // 只查询菜单
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()), "title", permissionVo.getTitle());
queryWrapper.orderByAsc("ordernum"); // 根据排序码升序排列
permissionService.page(page, queryWrapper); // 分页查询
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 添加菜单
* @param permissionVo
* @return
* @return 操作结果
*/
@RequestMapping("addMenu")
public ResultObj addMenu(PermissionVo permissionVo){
public ResultObj addMenu(PermissionVo permissionVo) {
try {
//设置添加类型为 menu
permissionVo.setType(Constast.TYPE_MENU);
permissionVo.setType(Constast.TYPE_MENU); // 设置类型为菜单
permissionService.save(permissionVo);
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
@ -159,31 +139,27 @@ public class MenuController {
}
/**
* 加载排序码
* @return
* 加载菜单的最大排序码
* @return 返回最大排序码
*/
@RequestMapping("loadMenuMaxOrderNum")
public Map<String,Object> loadMenuMaxOrderNum(){
Map<String,Object> map = new HashMap<String,Object>();
public Map<String, Object> loadMenuMaxOrderNum() {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("ordernum");
IPage<Permission> page = new Page<>(1,1);
List<Permission> list = permissionService.page(page,queryWrapper).getRecords();
if (list.size()>0){
map.put("value",list.get(0).getOrdernum()+1);
}else {
map.put("value",1);
}
IPage<Permission> page = new Page<>(1, 1);
List<Permission> list = permissionService.page(page, queryWrapper).getRecords();
map.put("value", list.isEmpty() ? 1 : list.get(0).getOrdernum() + 1);
return map;
}
/**
* 更新菜单
* @param permissionVo
* @return
* @return 操作结果
*/
@RequestMapping("updateMenu")
public ResultObj updateMenu(PermissionVo permissionVo){
public ResultObj updateMenu(PermissionVo permissionVo) {
try {
permissionService.updateById(permissionVo);
return ResultObj.UPDATE_SUCCESS;
@ -194,31 +170,26 @@ public class MenuController {
}
/**
* 检查当前菜单是否有子菜单
* 检查菜单是否有子菜单
* @param permissionVo
* @return
* @return 返回是否有子菜单
*/
@RequestMapping("checkMenuHasChildrenNode")
public Map<String,Object> checkMenuHasChildrenNode(PermissionVo permissionVo){
Map<String,Object> map = new HashMap<String, Object>();
public Map<String, Object> checkMenuHasChildrenNode(PermissionVo permissionVo) {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("pid",permissionVo.getId());
List<Permission> list = permissionService.list(queryWrapper);
if (list.size()>0){
map.put("value",true);
}else {
map.put("value",false);
}
queryWrapper.eq("pid", permissionVo.getId()); // 查询是否有子菜单
map.put("value", !permissionService.list(queryWrapper).isEmpty());
return map;
}
/**
* 删除菜单
* @param permissionVo
* @return
* @return 操作结果
*/
@RequestMapping("deleteMenu")
public ResultObj deleteMenu(PermissionVo permissionVo){
public ResultObj deleteMenu(PermissionVo permissionVo) {
try {
permissionService.removeById(permissionVo.getId());
return ResultObj.DELETE_SUCCESS;
@ -227,6 +198,4 @@ public class MenuController {
return ResultObj.DELETE_ERROR;
}
}
}

81
src/main/java/com/yeqifu/sys/controller/NoticeController.java
Unescape View File

@ -37,48 +37,51 @@ public class NoticeController {
private INoticeService noticeService;
/**
* 公告的查询
* @param noticeVo
* @return
* 查询公告列表
* 根据条件（标题、操作人、创建时间范围）分页查询公告，并按创建时间降序排序。
*
* @param noticeVo 包含查询条件的对象
* @return 包含公告数据和总记录数的DataGridView对象
*/
@RequestMapping("loadAllNotice")
public DataGridView loadAllNotice(NoticeVo noticeVo){
IPage<Notice> page = new Page<Notice>(noticeVo.getPage(),noticeVo.getLimit());
QueryWrapper<Notice> queryWrapper = new QueryWrapper<Notice>();
//进行模糊查询
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getTitle()),"title",noticeVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getOpername()),"opername",noticeVo.getOpername());
//公告创建时间应该大于搜索开始时间小于搜索结束时间
queryWrapper.ge(noticeVo.getStartTime()!=null,"createtime",noticeVo.getStartTime());
queryWrapper.le(noticeVo.getEndTime()!=null,"createtime",noticeVo.getEndTime());
//根据公告创建时间进行排序
public DataGridView loadAllNotice(NoticeVo noticeVo) {
// 分页和条件查询
IPage<Notice> page = new Page<>(noticeVo.getPage(), noticeVo.getLimit());
QueryWrapper<Notice> queryWrapper = new QueryWrapper<>();
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getTitle()), "title", noticeVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(noticeVo.getOpername()), "opername", noticeVo.getOpername());
queryWrapper.ge(noticeVo.getStartTime() != null, "createtime", noticeVo.getStartTime());
queryWrapper.le(noticeVo.getEndTime() != null, "createtime", noticeVo.getEndTime());
queryWrapper.orderByDesc("createtime");
noticeService.page(page,queryWrapper);
return new DataGridView(page.getTotal(),page.getRecords());
noticeService.page(page, queryWrapper);
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 根据公告ID查询一条公告
* @param id 公告ID
* @return
* 根据公告ID查询单条公告
*
* @param id 公告ID
* @return 包含公告数据的DataGridView对象
*/
@RequestMapping("loadNoticeById")
public DataGridView loadNoticeById(Integer id){
public DataGridView loadNoticeById(Integer id) {
Notice notice = noticeService.getById(id);
return new DataGridView(notice);
}
/**
* 添加公告
* @param noticeVo
* @return
* 自动填充创建时间和操作人信息。
*
* @param noticeVo 包含公告信息的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("addNotice")
public ResultObj addNotice(NoticeVo noticeVo){
public ResultObj addNotice(NoticeVo noticeVo) {
try {
noticeVo.setCreatetime(new Date());
noticeVo.setCreatetime(new Date()); // 设置创建时间
User user = (User) WebUtils.getSession().getAttribute("user");
noticeVo.setOpername(user.getName());
noticeVo.setOpername(user.getName()); // 设置操作人
noticeService.save(noticeVo);
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
@ -89,11 +92,12 @@ public class NoticeController {
/**
* 修改公告
* @param noticeVo
* @return
*
* @param noticeVo 包含修改后公告信息的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("updateNotice")
public ResultObj updateNotice(NoticeVo noticeVo){
public ResultObj updateNotice(NoticeVo noticeVo) {
try {
noticeService.updateById(noticeVo);
return ResultObj.UPDATE_SUCCESS;
@ -104,12 +108,13 @@ public class NoticeController {
}
/**
* 删除公告
* @param noticeVo
* @return
* 删除单条公告
*
* @param noticeVo 包含要删除公告ID的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("deleteNotice")
public ResultObj deleteNotice(NoticeVo noticeVo){
public ResultObj deleteNotice(NoticeVo noticeVo) {
try {
noticeService.removeById(noticeVo);
return ResultObj.DELETE_SUCCESS;
@ -121,24 +126,22 @@ public class NoticeController {
/**
* 批量删除公告
* @param noticeVo
* @return
*
* @param noticeVo 包含要删除公告ID集合的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("batchDeleteNotice")
public ResultObj batchDeleteNotice(NoticeVo noticeVo){
public ResultObj batchDeleteNotice(NoticeVo noticeVo) {
try {
Collection<Serializable> idList = new ArrayList<>();
for (Integer id : noticeVo.getIds()) {
idList.add(id);
idList.add(id); // 将ID加入集合
}
noticeService.removeByIds(idList);
noticeService.removeByIds(idList); // 批量删除
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
}
}
}

145
src/main/java/com/yeqifu/sys/controller/PermissionController.java
Unescape View File

@ -22,74 +22,66 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* <p>
* InnoDB free: 9216 kB 前端控制器
* </p>
*
* @author luoyi-
* @since 2019-11-22
*/
@RestController
/@RestController
@RequestMapping("permission")
public class PermissionController {
@Autowired
private IPermissionService permissionService;
/**
* 加载权限左边的权限树
* @param permissionVo
* @return
* 加载权限管理左侧的权限树
* 将所有菜单类型的权限以树形结构的形式返回。
*
* @param permissionVo 包含请求参数的对象
* @return 包含树形结构权限数据的DataGridView对象
*/
@RequestMapping("loadPermissionManagerLeftTreeJson")
public DataGridView loadPermissionManagerLeftTreeJson(PermissionVo permissionVo){
QueryWrapper<Permission> queryWrapper = new QueryWrapper<Permission>();
queryWrapper.eq("type", Constast.TYPE_MENU);
//查询出所有的权限，存放进list中
List<Permission> list = permissionService.list(queryWrapper);
List<TreeNode> treeNodes = new ArrayList<TreeNode>();
//将权限放入treeNodes中，组装成json
public DataGridView loadPermissionManagerLeftTreeJson(PermissionVo permissionVo) {
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("type", Constast.TYPE_MENU); // 查询类型为菜单的权限
List<Permission> list = permissionService.list(queryWrapper); // 查询权限列表
List<TreeNode> treeNodes = new ArrayList<>();
for (Permission permission : list) {
Boolean open = permission.getOpen()==1?true:false;
treeNodes.add(new TreeNode(permission.getId(),permission.getPid(),permission.getTitle(),open));
// 创建树节点，设置是否展开
Boolean open = permission.getOpen() == 1 ? true : false;
treeNodes.add(new TreeNode(permission.getId(), permission.getPid(), permission.getTitle(), open));
}
return new DataGridView(treeNodes);
}
/**
* 查询所有权限数据
* @param permissionVo
* @return
* 按条件（权限类型、标题、权限码、父ID）进行模糊查询并排序，支持分页。
*
* @param permissionVo 包含查询条件和分页参数的对象
* @return 包含权限数据和总记录数的DataGridView对象
*/
@RequestMapping("loadAllPermission")
public DataGridView loadAllPermission(PermissionVo permissionVo){
IPage<Permission> page = new Page<>(permissionVo.getPage(),permissionVo.getLimit());
//进行模糊查询
public DataGridView loadAllPermission(PermissionVo permissionVo) {
IPage<Permission> page = new Page<>(permissionVo.getPage(), permissionVo.getLimit());
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
//只能查询权限
queryWrapper.eq("type",Constast.TYPE_PERMISSION);
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()),"title",permissionVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getPercode()),"percode",permissionVo.getPercode());
queryWrapper.eq(permissionVo.getId()!=null,"pid",permissionVo.getId());
queryWrapper.orderByAsc("ordernum");
//进行查询
permissionService.page(page,queryWrapper);
//返回DataGridView
return new DataGridView(page.getTotal(),page.getRecords());
queryWrapper.eq("type", Constast.TYPE_PERMISSION); // 仅查询权限类型
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getTitle()), "title", permissionVo.getTitle());
queryWrapper.like(StringUtils.isNotBlank(permissionVo.getPercode()), "percode", permissionVo.getPercode());
queryWrapper.eq(permissionVo.getId() != null, "pid", permissionVo.getId());
queryWrapper.orderByAsc("ordernum"); // 按排序号升序排序
permissionService.page(page, queryWrapper); // 执行分页查询
return new DataGridView(page.getTotal(), page.getRecords());
}
/**
* 添加权限
* @param permissionVo
* @return
* 将新权限保存到数据库中，并设置其类型为“权限”。
*
* @param permissionVo 包含权限数据的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("addPermission")
public ResultObj addPermission(PermissionVo permissionVo){
public ResultObj addPermission(PermissionVo permissionVo) {
try {
//设置添加类型为 permission
permissionVo.setType(Constast.TYPE_PERMISSION);
permissionService.save(permissionVo);
permissionVo.setType(Constast.TYPE_PERMISSION); // 设置类型为权限
permissionService.save(permissionVo); // 保存权限
return ResultObj.ADD_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
@ -98,33 +90,37 @@ public class PermissionController {
}
/**
* 加载排序码
* @return
* 加载权限的最大排序号
* 返回当前权限的最大排序号+1，用于新增权限时自动设置排序号。
*
* @return 包含最大排序号的Map对象
*/
@RequestMapping("loadPermissionMaxOrderNum")
public Map<String,Object> loadPermissionMaxOrderNum(){
Map<String,Object> map = new HashMap<String,Object>();
public Map<String, Object> loadPermissionMaxOrderNum() {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("ordernum");
IPage<Permission> page = new Page<>(1,1);
List<Permission> list = permissionService.page(page,queryWrapper).getRecords();
if (list.size()>0){
map.put("value",list.get(0).getOrdernum()+1);
}else {
map.put("value",1);
queryWrapper.orderByDesc("ordernum"); // 按排序号降序查询
IPage<Permission> page = new Page<>(1, 1); // 查询第一页的第一条记录
List<Permission> list = permissionService.page(page, queryWrapper).getRecords();
if (list.size() > 0) {
map.put("value", list.get(0).getOrdernum() + 1); // 最大排序号+1
} else {
map.put("value", 1); // 如果没有记录，设置排序号为1
}
return map;
}
/**
* 更新权限
* @param permissionVo
* @return
* 根据ID更新权限信息。
*
* @param permissionVo 包含更新数据的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("updatePermission")
public ResultObj updatePermission(PermissionVo permissionVo){
public ResultObj updatePermission(PermissionVo permissionVo) {
try {
permissionService.updateById(permissionVo);
permissionService.updateById(permissionVo); // 根据ID更新权限
return ResultObj.UPDATE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
@ -133,40 +129,37 @@ public class PermissionController {
}
/**
* 检查当前权限是否有子权限
* @param permissionVo
* @return
* 检查权限是否有子权限
* 根据父ID查询是否存在子权限，返回结果为true或false。
*
* @param permissionVo 包含父ID的对象
* @return 包含检查结果的Map对象
*/
@RequestMapping("checkPermissionHasChildrenNode")
public Map<String,Object> checkPermissionHasChildrenNode(PermissionVo permissionVo){
Map<String,Object> map = new HashMap<String, Object>();
public Map<String, Object> checkPermissionHasChildrenNode(PermissionVo permissionVo) {
Map<String, Object> map = new HashMap<>();
QueryWrapper<Permission> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("pid",permissionVo.getId());
queryWrapper.eq("pid", permissionVo.getId()); // 根据父ID查询
List<Permission> list = permissionService.list(queryWrapper);
if (list.size()>0){
map.put("value",true);
}else {
map.put("value",false);
}
map.put("value", !list.isEmpty()); // 如果有子权限，返回true；否则返回false
return map;
}
/**
* 删除权限
* @param permissionVo
* @return
* 根据ID删除权限。
*
* @param permissionVo 包含要删除权限ID的对象
* @return 操作结果（成功或失败）
*/
@RequestMapping("deletePermission")
public ResultObj deletePermission(PermissionVo permissionVo){
public ResultObj deletePermission(PermissionVo permissionVo) {
try {
permissionService.removeById(permissionVo.getId());
permissionService.removeById(permissionVo.getId()); // 根据ID删除权限
return ResultObj.DELETE_SUCCESS;
} catch (Exception e) {
e.printStackTrace();
return ResultObj.DELETE_ERROR;
}
}
}

Write Preview
Loading…
Cancel
Save