auth/auth-server-java
auth
/
auth-server-java
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: 

添加环境构建docker-compose;优化部分代码
This commit is contained in:
Bunny 2025-02-16 23:36:40 +08:00
parent 1b9bf67b41
commit 6caff507f1
25 changed files with 192 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

206
common/service-utils/src/main/java/cn/bunny/common/service/utils/HttpUtil.java
View File

@ -1,206 +0,0 @@
package cn.bunny.common.service.utils;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class HttpUtil {
public static HttpResponse doGet(String host, String path, String method, Map<String, String> headers, Map<String, String> querys) throws Exception {
HttpClient httpClient = wrapClient(host);
HttpGet request = new HttpGet(buildUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
return httpClient.execute(request);
}
public static HttpResponse doPost(String host, String path, String method, Map<String, String> headers, Map<String, String> querys, Map<String, String> bodys) throws Exception {
HttpClient httpClient = wrapClient(host);
HttpPost request = new HttpPost(buildUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
if (bodys != null) {
List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();
for (String key : bodys.keySet()) {
nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
}
UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
request.setEntity(formEntity);
}
return httpClient.execute(request);
}
public static HttpResponse doPost(String host, String path, String method, Map<String, String> headers, Map<String, String> querys, String body) throws Exception {
HttpClient httpClient = wrapClient(host);
HttpPost request = new HttpPost(buildUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
if (StringUtils.isNotBlank(body)) {
request.setEntity(new StringEntity(body, "utf-8"));
}
return httpClient.execute(request);
}
public static HttpResponse doPost(String host, String path, String method, Map<String, String> headers, Map<String, String> querys, byte[] body) throws Exception {
HttpClient httpClient = wrapClient(host);
HttpPost request = new HttpPost(buildUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
if (body != null) {
request.setEntity(new ByteArrayEntity(body));
}
return httpClient.execute(request);
}
public static HttpResponse doPut(String host, String path, String method, Map<String, String> headers, Map<String, String> querys, String body) throws Exception {
HttpClient httpClient = wrapClient(host);
HttpPut request = new HttpPut(buildUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
if (StringUtils.isNotBlank(body)) {
request.setEntity(new StringEntity(body, "utf-8"));
}
return httpClient.execute(request);
}
public static HttpResponse doPut(String host, String path, String method, Map<String, String> headers, Map<String, String> querys, byte[] body) throws Exception {
HttpClient httpClient = wrapClient(host);
HttpPut request = new HttpPut(buildUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
if (body != null) {
request.setEntity(new ByteArrayEntity(body));
}
return httpClient.execute(request);
}
public static HttpResponse doDelete(String host, String path, String method, Map<String, String> headers, Map<String, String> querys) throws Exception {
HttpClient httpClient = wrapClient(host);
HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
for (Map.Entry<String, String> e : headers.entrySet()) {
request.addHeader(e.getKey(), e.getValue());
}
return httpClient.execute(request);
}
private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
StringBuilder sbUrl = new StringBuilder();
sbUrl.append(host);
if (!StringUtils.isBlank(path)) {
sbUrl.append(path);
}
if (null != querys) {
StringBuilder sbQuery = new StringBuilder();
for (Map.Entry<String, String> query : querys.entrySet()) {
if (!sbQuery.isEmpty()) {
sbQuery.append("&");
}
if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
sbQuery.append(query.getValue());
}
if (!StringUtils.isBlank(query.getKey())) {
sbQuery.append(query.getKey());
if (!StringUtils.isBlank(query.getValue())) {
sbQuery.append("=");
sbQuery.append(URLEncoder.encode(query.getValue(), StandardCharsets.UTF_8));
}
}
}
if (!sbQuery.isEmpty()) {
sbUrl.append("?").append(sbQuery);
}
}
return sbUrl.toString();
}
private static HttpClient wrapClient(String host) {
HttpClient httpClient = new DefaultHttpClient();
if (host.startsWith("https://")) {
sslClient(httpClient);
}
return httpClient;
}
private static void sslClient(HttpClient httpClient) {
try {
SSLContext ctx = SSLContext.getInstance("TLS");
X509TrustManager tm = new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return null;
}
public void checkClientTrusted(X509Certificate[] xcs, String str) {
}
public void checkServerTrusted(X509Certificate[] xcs, String str) {
}
};
ctx.init(null, new TrustManager[]{tm}, null);
SSLSocketFactory ssf = new SSLSocketFactory(ctx);
ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
ClientConnectionManager ccm = httpClient.getConnectionManager();
SchemeRegistry registry = ccm.getSchemeRegistry();
registry.register(new Scheme("https", 443, ssf));
} catch (Exception ex) {
throw new RuntimeException();
}
}
}

7
common/service-utils/src/main/java/cn/bunny/common/service/utils/mail/MailSenderUtil.java
View File

@ -13,6 +13,9 @@ import java.util.Objects;
import java.util.Properties;
public class MailSenderUtil {
private MailSenderUtil() {
// 私有化构造器
}
/**
* 如果启用SSL需要配置以下
@ -23,8 +26,8 @@ public class MailSenderUtil {
Properties properties = new Properties();
// 开启认证
properties.setProperty("mail.smtp.auth", "true");
// 启用调试
properties.setProperty("mail.debug", "true");
// 是否启用调试---会输出发送邮件调试内容
properties.setProperty("mail.debug", "false");
// 设置链接超时
properties.setProperty("mail.smtp.timeout", "200000");
// 设置端口

68
docker-compose.yml Normal file
View File

@ -0,0 +1,68 @@
name: auth-dependence # 定义该配置的名称为 auth-dependence
services: # 定义服务列表
# 安装MySQL
mysql: # 定义 MySQL 服务
container_name: mysql_master # 容器名称为 mysql_master
image: mysql:8.0.33 # 使用 MySQL 8.0.33 版本的镜像
ports:
- "3306:3306" # 将宿主机的 3306 端口映射到容器的 3306 端口
environment:
- MYSQL_ROOT_PASSWORD=123456 # 设置 MySQL 的 root 用户密码为 123456
- TZ=Asia/Shanghai # 设置时区为亚洲/上海
volumes:
# - ~/docker/docker_data/mysql/mysql_master/etc/my.cnf:/etc/my.cnf # 如果需要创建配置文件
- ~/docker/docker_data/mysql/mysql_master/etc/mysql:/etc/mysql/conf.d # 挂载 MySQL 配置文件目录
- ~/docker/docker_data/mysql/mysql_master/data:/var/lib/mysql # 挂载 MySQL 数据目录
- ~/docker/docker_data/mysql/mysql_master/backup:/backup # 挂载备份目录
command:
- "--log-bin=mysql-bin" # 启用二进制日志
- "--server-id=1" # 设置服务器 ID 为 1
- "--collation-server=utf8mb4_unicode_ci" # 设置默认的排序规则为 utf8mb4_unicode_ci
- "--character-set-server=utf8mb4" # 设置默认的字符集为 utf8mb4
- "--lower-case-table-names=1" # 设置表名存储为小写
restart: always # 设置容器总是自动重启
privileged: true # 赋予容器特权模式
networks:
- auth # 将 MySQL 服务加入到 auth 网络
# 安装Redis
redis: # 定义 Redis 服务
container_name: redis_master # 容器名称为 redis_master
image: redis:7.0.10 # 使用 Redis 7.0.10 版本的镜像
ports:
- "6379:6379" # 将宿主机的 6379 端口映射到容器的 6379 端口
volumes:
# - ~/docker/docker_data/redis_master/redis.conf:/etc/redis/redis.conf # 需要创建配置文件
- ~/docker/docker_data/redis_master:/etc/redis # 挂载 Redis 配置文件目录
- ~/docker/docker_data/redis_master/data:/data # 挂载 Redis 数据目录
command:
- "--appendonly yes" # 启用 AOF 持久化
- "--daemonize no" # 不以守护进程方式运行
- "--requirepass 123456" # 设置 Redis 访问密码为 123456
- "--tcp-keepalive 300" # 设置 TCP keepalive 时间为 300 秒
restart: always # 设置容器总是自动重启
networks:
- auth # 将 MySQL 服务加入到 auth 网络
# 安装 Minio
minio: # 定义 Minio 服务
image: minio/minio # 使用 Minio 官方镜像
container_name: minio_master # 容器名称为 minio_master
ports:
- "9000:9000" # 将宿主机的 9000 端口映射到容器的 9000 端口
- "9090:9090" # 将宿主机的 9090 端口映射到容器的 9090 端口
volumes:
- ~/docker/docker_data/minio/data:/data # 挂载 Minio 数据目录
environment:
- MINIO_ROOT_USER=bunny # 设置 Minio 的 root 用户名为 bunny
- MINIO_ROOT_PASSWORD=12345678 # 设置 Minio 的 root 用户密码为 123456
command: "server /data --console-address :9090" # 启动 Minio 服务并指定控制台地址
restart: always # 设置容器总是自动重启
networks:
- auth # 将 MySQL 服务加入到 auth 网络
networks: # 定义网络
auth: # 定义名为 auth 的网络
name: auth # 网络名称为 auth
driver: bridge # 使用 bridge 驱动（默认）

2
service/Dockerfile
View File

@ -14,7 +14,7 @@ WORKDIR /home/server
# 复制jar包
COPY target/*.jar /home/server/app.jar
# 程序内部挂在目录
# 程序内部挂在目录，看情况是否需要操作本地docker
VOLUME /usr/bin/docker
VOLUME ["/var/run/docker.sock"]
VOLUME /etc/docker/daemon.json

6
service/pom.xml
View File

@ -35,6 +35,12 @@
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<!-- 消除service utils黄色 -->
<dependency>
<groupId>org.springframework.boot</groupId>

2
service/src/main/java/cn/bunny/services/ServiceApplication.java
View File

@ -1,6 +1,5 @@
package cn.bunny.services;
import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@ -14,7 +13,6 @@ import org.springframework.transaction.annotation.EnableTransactionManagement;
@EnableScheduling
@EnableCaching
@EnableTransactionManagement
@Slf4j
@SpringBootApplication
public class ServiceApplication {
public static void main(String[] args) {

25
service/src/main/java/cn/bunny/services/factory/PowerFactory.java
View File

@ -1,25 +0,0 @@
package cn.bunny.services.factory;
import cn.bunny.dao.vo.system.rolePower.PowerVo;
import org.springframework.stereotype.Component;
import java.util.List;
@Component
public class PowerFactory {
/**
* * 构建权限树形结构
*
* @param id 节点ID
* @param powerVoList 节点列表
* @return 树形列表
*/
public List<PowerVo> handlePowerVoChildren(Long id, List<PowerVo> powerVoList) {
return powerVoList.stream()
.filter(powerVo -> powerVo.getParentId().equals(id))
.peek(powerVo -> powerVo.setChildren(handlePowerVoChildren(powerVo.getId(), powerVoList)))
.toList();
}
}

2
service/src/main/java/cn/bunny/services/security/service/impl/CustomUserDetailsServiceImpl.java
View File

@ -6,9 +6,9 @@ import cn.bunny.dao.entity.system.AdminUser;
import cn.bunny.dao.vo.result.Result;
import cn.bunny.dao.vo.result.ResultCodeEnum;
import cn.bunny.dao.vo.system.user.LoginVo;
import cn.bunny.services.factory.UserFactory;
import cn.bunny.services.mapper.UserMapper;
import cn.bunny.services.security.custom.CustomUser;
import cn.bunny.services.utils.UserFactory;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;

24
service/src/main/java/cn/bunny/services/service/impl/EmailUsersServiceImpl.java
View File

@ -9,10 +9,10 @@ import cn.bunny.dao.entity.system.EmailUsers;
import cn.bunny.dao.vo.result.PageResult;
import cn.bunny.dao.vo.result.ResultCodeEnum;
import cn.bunny.dao.vo.system.email.EmailUsersVo;
import cn.bunny.services.factory.EmailFactory;
import cn.bunny.services.mapper.EmailUsersMapper;
import cn.bunny.services.service.EmailUsersService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import jakarta.validation.Valid;
@ -38,7 +38,7 @@ import java.util.Map;
public class EmailUsersServiceImpl extends ServiceImpl<EmailUsersMapper, EmailUsers> implements EmailUsersService {
@Autowired
private EmailFactory emailFactory;
private EmailUsersMapper emailUsersMapper;
/**
* * 邮箱用户发送配置 服务实现类
@ -67,7 +67,7 @@ public class EmailUsersServiceImpl extends ServiceImpl<EmailUsersMapper, EmailUs
@Override
public void addEmailUsers(EmailUsersAddDto dto) {
// 更新邮箱默认状态
emailFactory.updateEmailUserDefault(dto.getIsDefault());
updateEmailUserDefault(dto.getIsDefault());
// 保存数据
EmailUsers emailUsers = new EmailUsers();
@ -84,7 +84,7 @@ public class EmailUsersServiceImpl extends ServiceImpl<EmailUsersMapper, EmailUs
@Override
public void updateEmailUsers(@Valid EmailUsersUpdateDto dto) {
// 更新邮箱默认状态
emailFactory.updateEmailUserDefault(dto.getIsDefault());
updateEmailUserDefault(dto.getIsDefault());
// 更新内容
EmailUsers emailUsers = new EmailUsers();
@ -113,7 +113,7 @@ public class EmailUsersServiceImpl extends ServiceImpl<EmailUsersMapper, EmailUs
@Override
public void updateEmailUserStatus(EmailUserUpdateStatusDto dto) {
// 更新邮箱默认状态
emailFactory.updateEmailUserDefault(dto.getIsDefault());
updateEmailUserDefault(dto.getIsDefault());
EmailUsers emailUsers = new EmailUsers();
BeanUtils.copyProperties(dto, emailUsers);
@ -134,4 +134,18 @@ public class EmailUsersServiceImpl extends ServiceImpl<EmailUsersMapper, EmailUs
return map;
}).toList();
}
/**
* 判断邮箱是否添加
*
* @param isDefault 邮箱是否为默认
*/
public void updateEmailUserDefault(Boolean isDefault) {
EmailUsers emailUsers = new EmailUsers();
// 判断状态，如果是默认将所有的内容都设为false
if (isDefault) {
emailUsers.setIsDefault(false);
emailUsersMapper.update(emailUsers, Wrappers.<EmailUsers>lambdaUpdate().eq(EmailUsers::getIsDefault, true));
}
}
}

2
service/src/main/java/cn/bunny/services/service/impl/MessageReceivedServiceImpl.java
View File

@ -11,9 +11,9 @@ import cn.bunny.dao.vo.result.PageResult;
import cn.bunny.dao.vo.result.ResultCodeEnum;
import cn.bunny.dao.vo.system.message.MessageReceivedWithMessageVo;
import cn.bunny.dao.vo.system.message.MessageUserVo;
import cn.bunny.services.factory.UserFactory;
import cn.bunny.services.mapper.MessageReceivedMapper;
import cn.bunny.services.service.MessageReceivedService;
import cn.bunny.services.utils.UserFactory;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

2
service/src/main/java/cn/bunny/services/service/impl/MessageServiceImpl.java
View File

@ -14,12 +14,12 @@ import cn.bunny.dao.vo.system.message.MessageDetailVo;
import cn.bunny.dao.vo.system.message.MessageReceivedWithMessageVo;
import cn.bunny.dao.vo.system.message.MessageReceivedWithUserVo;
import cn.bunny.dao.vo.system.message.MessageVo;
import cn.bunny.services.factory.UserFactory;
import cn.bunny.services.mapper.MessageMapper;
import cn.bunny.services.mapper.MessageReceivedMapper;
import cn.bunny.services.mapper.UserMapper;
import cn.bunny.services.service.MessageReceivedService;
import cn.bunny.services.service.MessageService;
import cn.bunny.services.utils.UserFactory;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;

6
service/src/main/java/cn/bunny/services/service/impl/RolePowerServiceImpl.java
View File

@ -4,11 +4,11 @@ import cn.bunny.dao.dto.system.rolePower.AssignPowersToRoleDto;
import cn.bunny.dao.entity.system.AdminUser;
import cn.bunny.dao.entity.system.RolePower;
import cn.bunny.dao.entity.system.UserRole;
import cn.bunny.services.factory.RoleFactory;
import cn.bunny.services.mapper.RolePowerMapper;
import cn.bunny.services.mapper.UserMapper;
import cn.bunny.services.mapper.UserRoleMapper;
import cn.bunny.services.service.RolePowerService;
import cn.bunny.services.utils.RoleUtil;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
@ -33,7 +33,7 @@ public class RolePowerServiceImpl extends ServiceImpl<RolePowerMapper, RolePower
private UserMapper userMapper;
@Autowired
private RoleFactory roleFactory;
private RoleUtil roleUtil;
@Autowired
private UserRoleMapper userRoleMapper;
@ -84,6 +84,6 @@ public class RolePowerServiceImpl extends ServiceImpl<RolePowerMapper, RolePower
// 更新Redis中用户信息
List<Long> userIds = adminUsers.stream().map(AdminUser::getId).toList();
roleFactory.updateUserRedisInfo(userIds);
roleUtil.updateUserRedisInfo(userIds);
}
}

6
service/src/main/java/cn/bunny/services/service/impl/RoleServiceImpl.java
View File

@ -9,12 +9,12 @@ import cn.bunny.dao.entity.system.UserRole;
import cn.bunny.dao.vo.result.PageResult;
import cn.bunny.dao.vo.result.ResultCodeEnum;
import cn.bunny.dao.vo.system.rolePower.RoleVo;
import cn.bunny.services.factory.RoleFactory;
import cn.bunny.services.mapper.RoleMapper;
import cn.bunny.services.mapper.RolePowerMapper;
import cn.bunny.services.mapper.RouterRoleMapper;
import cn.bunny.services.mapper.UserRoleMapper;
import cn.bunny.services.service.RoleService;
import cn.bunny.services.utils.RoleUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@ -49,7 +49,7 @@ public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements Ro
private RouterRoleMapper routerRoleMapper;
@Autowired
private RoleFactory roleFactory;
private RoleUtil roleUtil;
/**
* * 角色 服务实现类
@ -118,7 +118,7 @@ public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements Ro
// 找到所有和当前更新角色相同的用户，并更新Redis中用户信息
List<Long> userIds = userRoleMapper.selectList(Wrappers.<UserRole>lambdaQuery().eq(UserRole::getRoleId, dto.getId()))
.stream().map(UserRole::getUserId).toList();
roleFactory.updateUserRedisInfo(userIds);
roleUtil.updateUserRedisInfo(userIds);
}

2
service/src/main/java/cn/bunny/services/service/impl/RouterServiceImpl.java
View File

@ -15,13 +15,13 @@ import cn.bunny.dao.vo.result.ResultCodeEnum;
import cn.bunny.dao.vo.system.router.RouterManageVo;
import cn.bunny.dao.vo.system.router.RouterMeta;
import cn.bunny.dao.vo.system.router.UserRouterVo;
import cn.bunny.services.factory.RouterServiceFactory;
import cn.bunny.services.mapper.RoleMapper;
import cn.bunny.services.mapper.RolePowerMapper;
import cn.bunny.services.mapper.RouterMapper;
import cn.bunny.services.mapper.RouterRoleMapper;
import cn.bunny.services.security.custom.CustomCheckIsAdmin;
import cn.bunny.services.service.RouterService;
import cn.bunny.services.utils.RouterServiceFactory;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

2
service/src/main/java/cn/bunny/services/service/impl/UserRoleServiceImpl.java
View File

@ -8,10 +8,10 @@ import cn.bunny.dao.entity.system.AdminUser;
import cn.bunny.dao.entity.system.UserRole;
import cn.bunny.dao.vo.result.ResultCodeEnum;
import cn.bunny.dao.vo.system.user.LoginVo;
import cn.bunny.services.factory.UserFactory;
import cn.bunny.services.mapper.UserMapper;
import cn.bunny.services.mapper.UserRoleMapper;
import cn.bunny.services.service.UserRoleService;
import cn.bunny.services.utils.UserFactory;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;

17
service/src/main/java/cn/bunny/services/service/impl/UserServiceImpl.java
View File

@ -10,7 +10,6 @@ import cn.bunny.dao.dto.system.files.FileUploadDto;
import cn.bunny.dao.dto.system.user.*;
import cn.bunny.dao.entity.log.UserLoginLog;
import cn.bunny.dao.entity.system.AdminUser;
import cn.bunny.dao.entity.system.EmailTemplate;
import cn.bunny.dao.entity.system.Role;
import cn.bunny.dao.entity.system.UserDept;
import cn.bunny.dao.enums.EmailTemplateEnums;
@ -19,11 +18,11 @@ import cn.bunny.dao.vo.result.PageResult;
import cn.bunny.dao.vo.result.ResultCodeEnum;
import cn.bunny.dao.vo.system.files.FileInfoVo;
import cn.bunny.dao.vo.system.user.*;
import cn.bunny.services.factory.EmailFactory;
import cn.bunny.services.factory.UserFactory;
import cn.bunny.services.mapper.*;
import cn.bunny.services.service.FilesService;
import cn.bunny.services.service.UserService;
import cn.bunny.services.utils.UserFactory;
import cn.bunny.services.utils.email.ConcreteSenderEmailTemplate;
import cn.hutool.captcha.CaptchaUtil;
import cn.hutool.captcha.CircleCaptcha;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@ -62,7 +61,7 @@ public class UserServiceImpl extends ServiceImpl<UserMapper, AdminUser> implemen
private UserFactory userFactory;
@Autowired
private EmailFactory emailFactory;
private ConcreteSenderEmailTemplate concreteSenderEmailTemplate;
@Autowired
private RedisTemplate<String, Object> redisTemplate;
@ -93,10 +92,10 @@ public class UserServiceImpl extends ServiceImpl<UserMapper, AdminUser> implemen
@Override
public void sendLoginEmail(@NotNull String email) {
// 查询验证码邮件模板
LambdaQueryWrapper<EmailTemplate> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(EmailTemplate::getIsDefault, true);
lambdaQueryWrapper.eq(EmailTemplate::getType, EmailTemplateEnums.VERIFICATION_CODE.getType());
EmailTemplate emailTemplate = emailTemplateMapper.selectOne(lambdaQueryWrapper);
LambdaQueryWrapper<cn.bunny.dao.entity.system.EmailTemplate> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(cn.bunny.dao.entity.system.EmailTemplate::getIsDefault, true);
lambdaQueryWrapper.eq(cn.bunny.dao.entity.system.EmailTemplate::getType, EmailTemplateEnums.VERIFICATION_CODE.getType());
cn.bunny.dao.entity.system.EmailTemplate emailTemplate = emailTemplateMapper.selectOne(lambdaQueryWrapper);
// 生成验证码
CircleCaptcha captcha = CaptchaUtil.createCircleCaptcha(150, 48, 4, 2);
@ -111,7 +110,7 @@ public class UserServiceImpl extends ServiceImpl<UserMapper, AdminUser> implemen
hashMap.put("#companyName#", "BunnyAdmin");
// 发送邮件
emailFactory.sendEmailTemplate(email, emailTemplate, hashMap);
concreteSenderEmailTemplate.sendEmail(email, emailTemplate, hashMap);
// 在Redis中存储验证码
redisTemplate.opsForValue().set(RedisUserConstant.getAdminUserEmailCodePrefix(email), emailCode, RedisUserConstant.REDIS_EXPIRATION_TIME, TimeUnit.MINUTES);

4
service/src/main/java/cn/bunny/services/factory/RoleFactory.java → service/src/main/java/cn/bunny/services/utils/RoleUtil.java
View File

@ -1,4 +1,4 @@
package cn.bunny.services.factory;
package cn.bunny.services.utils;
import cn.bunny.dao.constant.RedisUserConstant;
import cn.bunny.dao.entity.system.AdminUser;
@ -11,7 +11,7 @@ import org.springframework.stereotype.Component;
import java.util.List;
@Component
public class RoleFactory {
public class RoleUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;

2
service/src/main/java/cn/bunny/services/factory/RouterServiceFactory.java → service/src/main/java/cn/bunny/services/utils/RouterServiceFactory.java
View File

@ -1,4 +1,4 @@
package cn.bunny.services.factory;
package cn.bunny.services.utils;
import cn.bunny.dao.vo.system.router.UserRouterVo;
import org.jetbrains.annotations.NotNull;

2
service/src/main/java/cn/bunny/services/factory/UserFactory.java → service/src/main/java/cn/bunny/services/utils/UserFactory.java
View File

@ -1,4 +1,4 @@
package cn.bunny.services.factory;
package cn.bunny.services.utils;
import cn.bunny.common.service.utils.JwtHelper;
import cn.bunny.common.service.utils.ip.IpUtil;

40
service/src/main/java/cn/bunny/services/factory/EmailFactory.java → service/src/main/java/cn/bunny/services/utils/email/AbstractSenderEmailTemplate.java
View File

@ -1,4 +1,4 @@
package cn.bunny.services.factory;
package cn.bunny.services.utils.email;
import cn.bunny.common.service.exception.AuthCustomerException;
import cn.bunny.common.service.utils.mail.MailSenderUtil;
@ -7,7 +7,6 @@ import cn.bunny.dao.entity.system.EmailUsers;
import cn.bunny.dao.model.email.EmailSend;
import cn.bunny.dao.model.email.EmailSendInit;
import cn.bunny.dao.vo.result.ResultCodeEnum;
import cn.bunny.services.mapper.EmailTemplateMapper;
import cn.bunny.services.mapper.EmailUsersMapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import jakarta.mail.MessagingException;
@ -19,19 +18,19 @@ import java.util.HashMap;
import java.util.List;
@Component
public class EmailFactory {
@Autowired
private EmailTemplateMapper emailTemplateMapper;
public abstract class AbstractSenderEmailTemplate {
@Autowired
private EmailUsersMapper emailUsersMapper;
/**
* * 发送邮件模板
* 根据已存在的邮件模板发送邮件
* 基本邮件发送模板
*
* @param email 邮箱
* @param emailTemplate 邮箱模板
* @param params 传入的参数
*/
public void sendEmailTemplate(String email, EmailTemplate emailTemplate, HashMap<String, Object> params) {
public void sendEmail(String email, EmailTemplate emailTemplate, HashMap<String, Object> params) {
// 判断邮件模板是否为空
if (emailTemplate == null) throw new AuthCustomerException(ResultCodeEnum.EMAIL_TEMPLATE_IS_EMPTY);
@ -69,27 +68,4 @@ public class EmailFactory {
throw new AuthCustomerException(ResultCodeEnum.SEND_MAIL_CODE_ERROR);
}
}
/**
* * 发送邮件模板
* 根据邮件模板发送邮件
*/
public void sendEmailTemplate(String email, Long emailTemplateId, HashMap<String, Object> params) {
EmailTemplate emailTemplate = emailTemplateMapper.selectOne(Wrappers.<EmailTemplate>lambdaQuery().eq(EmailTemplate::getId, emailTemplateId));
sendEmailTemplate(email, emailTemplate, params);
}
/**
* 判断邮箱是否添加
*
* @param isDefault 邮箱是否为默认
*/
public void updateEmailUserDefault(Boolean isDefault) {
EmailUsers emailUsers = new EmailUsers();
// 判断状态，如果是默认将所有的内容都设为false
if (isDefault) {
emailUsers.setIsDefault(false);
emailUsersMapper.update(emailUsers, Wrappers.<EmailUsers>lambdaUpdate().eq(EmailUsers::getIsDefault, true));
}
}
}

28
service/src/main/java/cn/bunny/services/utils/email/ConcreteSenderEmailTemplate.java Normal file
View File

@ -0,0 +1,28 @@
package cn.bunny.services.utils.email;
import cn.bunny.dao.entity.system.EmailTemplate;
import cn.bunny.services.mapper.EmailTemplateMapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.HashMap;
@Component
public class ConcreteSenderEmailTemplate extends AbstractSenderEmailTemplate {
@Autowired
private EmailTemplateMapper emailTemplateMapper;
/**
* 发送邮件模板
* 根据邮件模板发送邮件
*
* @param email 邮件
* @param emailTemplateId 模板Id
* @param params 替换参数
*/
public void sendEmailTemplate(String email, Long emailTemplateId, HashMap<String, Object> params) {
EmailTemplate emailTemplate = emailTemplateMapper.selectOne(Wrappers.<EmailTemplate>lambdaQuery().eq(EmailTemplate::getId, emailTemplateId));
sendEmail(email, emailTemplate, params);
}
}

12
service/src/main/resources/application-dev.yml
View File

@ -20,22 +20,22 @@ logging:
bunny:
master:
host: 192.168.3.129
port: 3304
host: 192.168.3.137
port: 3306
database: auth_admin
username: root
password: "02120212"
password: "123456"
redis:
host: 192.168.3.129
host: 192.168.3.137
port: 6379
database: 0
password: "123456"
minio:
endpointUrl: "http://192.168.3.129:9000"
endpointUrl: "http://192.168.3.137:9000"
accessKey: bunny
secretKey: "02120212"
secretKey: "12345678"
bucket-name: auth-admin
backPath: "D:\\MyData\\backup"

7
service/src/main/resources/application-test.yml
View File

@ -45,10 +45,10 @@ knife4j:
bunny:
master:
host: 192.168.3.98
port: 3304
port: 3306
database: auth_admin
username: root
password: "02120212"
password: "123456"
redis:
host: 192.168.3.98
@ -62,5 +62,4 @@ bunny:
secretKey: "02120212"
bucket-name: auth-admin
backPath: "/www/root/backup"
bashPath: "/www/root/server"
backPath: "/www/root/backup"

6
service/src/main/resources/banner.txt
View File

@ -1,10 +1,10 @@
_ _
| |__ _ _ _ __ _ __ _ _ (_) __ ___ ____ _
| '_ \| | | | '_ \| '_ \| | | | | |/ _` \ \ / / _` |
| |_) | |_| | | | | | | | |_| | | | (_| |\ V | (_| |
|_.__/ \__,_|_| |_|_| |_|\__, | _/ |\__,_| \_/ \__,_|
|___/ |__/
${AnsiColor.BRIGHT_GREEN}
${spring-boot.formatted-version}
${application.title}
SpringBoot Version: ${spring-boot.version}${spring-boot.formatted-version}
${AnsiColor.BLACK}

22
service/src/test/java/cn/bunny/services/utils/email/ConcreteSenderEmailTemplateTest.java Normal file
View File

@ -0,0 +1,22 @@
package cn.bunny.services.utils.email;
import cn.bunny.dao.entity.system.EmailTemplate;
import cn.bunny.services.mapper.EmailTemplateMapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.HashMap;
@SpringBootTest
class ConcreteSenderEmailTemplateTest extends AbstractSenderEmailTemplate {
@Autowired
private EmailTemplateMapper emailTemplateMapper;
@Test
void sendEmailTemplate() {
EmailTemplate emailTemplate = emailTemplateMapper.selectOne(Wrappers.<EmailTemplate>lambdaQuery().eq(EmailTemplate::getId, 1791870020197625858L));
sendEmail("1319900154@qq.com", emailTemplate, new HashMap<>());
}
}