目录
项目创建
使用 Idea 创建 SpringBoot 项目，并引入相关依赖：
导入前端页面
前端页面：前端代码/在线抽奖系统 · Echo/project - 码云 - 开源中国
将其导入到 static 目录下：
通用功能模块
错误码
错误码主要用于标识和处理程序运行中的各种异常情况，能够精确的指出问题所在
创建 errorcode 包，并定义错误码类型：
@Data
public class ErrorCode {
/**
* 错误码
*/
private final Integer code;
/**
* 错误描述
*/
private final String message;
public ErrorCode(Integer code, String message) {
this.code = code;
this.message = message;
}
}定义全局错误码：
public interface GlobalErrorCodeConstants {
// 成功
ErrorCode SUCCESS = new ErrorCode(200, "成功");
ErrorCode BAD_REQUEST = new ErrorCode(400, "客户端请求错误");
ErrorCode INTERNAL_SERVER_ERROR = new ErrorCode(500, "系统异常");
ErrorCode NOT_IMPLEMENTED = new ErrorCode(501, "功能未实现/未开启");
ErrorCode ERROR_CONFIGURATION = new ErrorCode(502, "配置项错误");
ErrorCode UNKNOWN = new ErrorCode(999, "未知错误");
}定义 controller 层业务错误码：
public interface ControllerErrorCodeConstants {
}其中的错误码信息随着后续业务代码的完成补充
定义 service 层业务错误码：
public interface ServiceErrorCodeConstants {
}其中的错误码信息随着后续业务代码的完成补充
自定义异常类
自定义异常类是为了在程序中处理特定的错误或异常情境，使得异常处理更加清晰和灵活。通过自定义异常类，可以根据业务需求定义特定的异常类型，方便捕获和处理特定的错误
创建 exception 包，自定义异常类：
controller 层异常类：
@Data
@EqualsAndHashCode(callSuper = true)
public class ControllerException extends RuntimeException {
/**
* controller 层错误码
* @see com.example.lotterysystem.common.errorcode.ControllerErrorCodeConstants
*/
private Integer code;
/**
* 错误描述信息
*/
private String message;
/**
* 无参构造方法，为了后续进行序列化
*/
public ControllerException() {
}
public ControllerException(Integer code, String message) {
this.code = code;
this.message = message;
}
public ControllerException(ErrorCode errorCode) {
this.code = errorCode.getCode();
this.message = errorCode.getMessage();
}
}service 层异常类：
@Data
@EqualsAndHashCode(callSuper = true)
public class ServiceException extends RuntimeException {
/**
* controller 层错误码
* @see com.example.lotterysystem.common.errorcode.ServiceErrorCodeConstants
*/
private Integer code;
/**
* 错误描述信息
*/
private String message;
/**
* 无参构造方法，为了后续进行序列化
*/
public ServiceException() {
}
public ServiceException (Integer code, String message) {
this.code = code;
this.message = message;
}
public ServiceException (ErrorCode errorCode) {
this.code = errorCode.getCode();
this.message = errorCode.getMessage();
}
}
CommonResult<T>
CommonResult<T> 作为 控制层 方法的 返回类型，封装接口调用结果，包括成功数据、错误数据 和 状态码，可以被 SpringBoot 框架自动转化为 JSON 或其他格式的响应体，发送给客户端
定义业务处理成功和失败时返回的 CommonResult<T>：
@Data
public class CommonResult<T> implements Serializable {
/**
* 错误码
*/
private Integer code;
/**
* 返回数据
*/
private T data;
/**
* 错误描述信息
*/
private String errorMessage;
public CommonResult() {
}
/**
* 运行成功时返回结果
* @param data
* @return
* @param <T>
*/
public static <T> CommonResult<T> success(T data) {
CommonResult<T> result = new CommonResult<>();
result.code = GlobalErrorCodeConstants.SUCCESS.getCode();
result.data = data;
result.errorMessage = "";
return result;
}
/**
* 运行失败时返回结果
* @param code
* @param errorMessage
* @return
* @param <T>
*/
public static <T> CommonResult<T> fail(Integer code, String errorMessage) {
Assert.isTrue(!GlobalErrorCodeConstants.SUCCESS.getCode().equals(code),
"code = 200, 运行成功");
CommonResult<T> result = new CommonResult<>();
result.code = code;
result.errorMessage = errorMessage;
return result;
}
/**
* 运行失败时返回结果
* @param errorCode
* @return
* @param <T>
*/
public static <T> CommonResult<T> fail(ErrorCode errorCode) {
return fail(errorCode.getCode(), errorCode.getMessage());
}
}其中，serializable 接口是 java 提供的一个标记接口（空接口），用于指示一个类的对象可以被序列化，无需实现任何方法，定义在 java.io 包中
此外，若想在 idea 中使用断言，需要先开启断言功能，可参考：
如何开启idea中的断言功能？_idea开启断言-CSDN博客
jackson
在前后端交互的过程中，经常会使用 JSON 格式来传递数据，这也就涉及到 序列化 和 反序列化，此外，我们在进行日志打印时，也会涉及到序列化
因此，我们可以定义一个工具类，来专门处理 序列化
在 java 中，通常使用 ObjectMapper 来处理 Java 对象与 JSON 数据之间的转换
查看 SpringBoot 框架中是如何实现的：
不同类型的对象序列化是基本相同的，都是使用 writeValueAsString 方法来进行序列化，因此我们主要来看反序列化：
可以看到，反序列化 Map 和 List 都调用了 tryParse 方法，并传递了两个参数：一个 lambda 表达式，一个 Exception
我们继续看 tryParse 方法：
其中，最主要的方法就是 parse.call()，通过 call() 方法，来执行定义的任务
且 tryParse 方法中对异常进行了处理：
check.isAssignableFrom(var4.getClass()) 判断抛出的异常是否是传入的 check 异常，若是，则抛出 JsonParseException 异常；若不是，则抛出 IllegalStateException 异常
可以看到，框架中通过 tryParse() 方法，巧妙地对异常进行了处理
因此，我们可以借鉴上述方法来进行实现
由于只需要使用一个 ObjectMapper 实例，因此可以创建 单例 ObjectMapper：
public class JacksonUtil {
private JacksonUtil() {}
private final static ObjectMapper OBJECT_MAPPER;
static {
OBJECT_MAPPER = new ObjectMapper();
}
private static ObjectMapper getObjectMapper() {
return OBJECT_MAPPER;
}
}实现 tryParse 方法：
private static <T> T tryParse(Callable<T> parser, Class<? extends Exception> check) {
try {
return parser.call();
} catch (Exception e) {
if (check.isAssignableFrom(e.getClass())) {
throw new JsonParseException(e);
}
throw new IllegalStateException(e);
}
}
private static <T> T tryParse(Callable<T> parser) {
return tryParse(parser, JsonParseException.class);
}实现序列化方法：
/**
* 序列化
* @param value
* @return
*/
public static String writeValueAsString(Object value) {
return tryParse(() -> getObjectMapper().writeValueAsString(value));
}反序列化：
/**
* 反序列化
* @param content
* @param valueType
* @return
* @param <T>
*/
public static <T> T readValue(String content, Class<T> valueType) {
return tryParse(() -> {
return getObjectMapper().readValue(content, valueType);
});
}
/**
* 反序列化 List
* @param content
* @param param List 中元素类型
* @return
*/
public static <T> T readListValue(String content, Class<?> param) {
JavaType javaType = getObjectMapper().getTypeFactory()
.constructParametricType(List.class, param);
return tryParse(() -> {
return getObjectMapper().readValue(content, javaType);
});
}在对 List 类型进行反序列化时，不能直接将 List 类型传递给 valueType，而是需要构造一个 JavaType 类型
完整代码：
public class JacksonUtil {
private JacksonUtil() {}
private final static ObjectMapper OBJECT_MAPPER;
static {
OBJECT_MAPPER = new ObjectMapper();
}
private static ObjectMapper getObjectMapper() {
return OBJECT_MAPPER;
}
/**
* 序列化
* 对象 -> 字符串
* @param value
* @return
*/
public static String writeValueAsString(Object value) {
return JacksonUtil.tryParse(() -> JacksonUtil.getObjectMapper().writeValueAsString(value));
}
/**
* 反序列化
* 字符串 -> 对象
* @param content
* @param valueType
* @return
* @param <T>
*/
public static <T> T readValue(String content, Class<T> valueType) {
return JacksonUtil.tryParse(() -> {
return JacksonUtil.getObjectMapper().readValue(content, valueType);
});
}
/**
* 反序列化 List
* @param content
* @param param
* @return
*/
public static <T> T readListValue(String content, Class<?> param) {
JavaType javaType = JacksonUtil.getObjectMapper().getTypeFactory()
.constructParametricType(List.class, param);
return JacksonUtil.tryParse(() -> {
return JacksonUtil.getObjectMapper().readValue(content, javaType);
});
}
/**
* 进行序列化/反序列化
* @param parser
* @param check
* @return
* @param <T>
*/
private static <T> T tryParse(Callable<T> parser, Class<? extends Exception> check) {
try {
return parser.call();
} catch (Exception e) {
if (check.isAssignableFrom(e.getClass())) {
throw new JsonParseException(e);
}
throw new IllegalStateException(e);
}
}
private static <T> T tryParse(Callable<T> parser) {
return tryParse(parser, JsonParseException.class);
}
}加密工具
在对敏感信息（如密码、手机号等）进行存储时，需要进行加密，从而保证数据的安全性，若直接明文存储，当黑客入侵数据库时，就可以轻松拿到用户的相关信息，从而造成信息泄露或财产损失
在这里，可以使用 md5 对用户密码进行加密：
采用 判断哈希值是否一致 的方法来判断密码是否正确
除了密码以外，手机号也是重要的隐私数据，但手机号与密码不同：对于后端来说，不知道密码的明文也不会对业务逻辑造成影响；但后端需要明文的手机号，在一些情况下给用户发送短信
因此，对于手机号这样的信息，需要采用相对安全的做法：先对手机号进行对称加密，再将加密结果存储在数据库中；在使用时再使用密钥对其进行解密
在这里，我们使用 Hutool 的加密工具：加密解密工具-SecureUtil
引入依赖：
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.16</version>
</dependency>上述引入的是所有模块，但其实绝大部分项目可能都用不上，因此可以只引入需要的模块
使用对应方法进行加解密：
@SpringBootTest
public class SecurityTest {
/**
* 使用 aes 对用户手机号进行加密
*/
@Test
void test() {
// 密钥
String key = "1234567890abcdefghijklmn";
AES aes = SecureUtil.aes(key.getBytes());
String encrypt = aes.encryptHex("12345678").toString();
System.out.println("加密结果：" +encrypt);
String decrypt = aes.decryptStr(encrypt);
System.out.println("解密结果：" + decrypt);
}
/**
* 使用 md5 对用户密码进行加密
*/
@Test
void md5Test() {
// 生成随机盐值
String salt = UUID.randomUUID().toString().replace("-", "");
System.out.println("salt: " + salt);
String password = "123456";
// 进行加密
String encrypt = DigestUtil.md5Hex(password +salt);
System.out.println("加密结果：" + encrypt);
}
}测试结果：
实现 SecurityUtil 工具类：
@Slf4j
public class SecurityUtil {
// 密钥
private static final String AES_KEY = "3416b730f0f244128200c59fd07e6249";
/**
* 使用 md5 对密码进行加密
* @param password 输入的密码
* @return 密码 + 盐值
*/
public static String encipherPassword(String password) {
String salt = UUID.randomUUID().toString().replace("-", "");
String secretPassword = DigestUtil.md5Hex(password + salt);
return secretPassword + salt;
}
/**
* 验证用户输入的密码是否正确
* @param inputPassword 用户输入密码
* @param sqlPassword 数据库中存储密码
* @return
*/
public static Boolean verifyPassword(String inputPassword, String sqlPassword) {
log.info("用户输入密码：{}， 数据库获取密码：{}", inputPassword, sqlPassword);
if (!StringUtils.hasLength(inputPassword)) {
return false;
}
if (!StringUtils.hasLength(sqlPassword) || sqlPassword.length() != 64) {
return false;
}
String salt = sqlPassword.substring(32, 64);
String secretPassword = DigestUtil.md5Hex(inputPassword + salt);
return sqlPassword.substring(0, 32).equals(secretPassword);
}
/**
* 使用 aes 对用户手机号进行加密
* @param phone
* @return
*/
public static String encipherPhone(String phone) {
return SecureUtil.aes(AES_KEY.getBytes()).encryptHex(phone);
}
/**
* 对加密的手机号进行解密
* @param encryptPhone
* @return
*/
public static String decryptPhone(String encryptPhone) {
// log.info("解析 encryptPhone：{}", encryptPhone);
return SecureUtil.aes(AES_KEY.getBytes()).decryptStr(encryptPhone);
}
}AES 使用的密钥可以使用 UUID 生成
日志配置
在 logback-spring.xml 中进行配置：
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="60 seconds" debug="false">
<springProfile name="dev">
<!--输出到控制台-->
<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n%ex</pattern>
</encoder>
</appender>
<root level="info">
<appender-ref ref="console" />
</root>
</springProfile>
<springProfile name="prod,test">
<!--ERROR级别的日志放在logErrorDir目录下，INFO级别的日志放在logInfoDir目录下-->
<property name="logback.logErrorDir" value="/root/lottery-system/logs/error"/>
<property name="logback.logInfoDir" value="/root/lottery-system/logs/info"/>
<property name="logback.appName" value="lotterySystem"/>
<contextName>${logback.appName}</contextName>
<!--ERROR级别的日志配置如下-->
<appender name="fileErrorLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
<!--日志名称，如果没有File 属性，那么只会使用FileNamePattern的文件路径规则
如果同时有<File>和<FileNamePattern>，那么当天日志是<File>，明天会自动把今天
的日志改名为今天的日期。即，<File> 的日志都是当天的。
-->
<File>${logback.logErrorDir}/error.log</File>
<!-- 日志level过滤器，保证error.***.log中只记录ERROR级别的日志-->
<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>ERROR</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
<!--滚动策略，按照时间滚动 TimeBasedRollingPolicy-->
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--文件路径,定义了日志的切分方式——把每一天的日志归档到一个文件中,以防止日志填满整个磁盘空间-->
<FileNamePattern>${logback.logErrorDir}/error.%d{yyyy-MM-dd}.log</FileNamePattern>
<!--只保留最近14天的日志-->
<maxHistory>14</maxHistory>
<!--用来指定日志文件的上限大小，那么到了这个值，就会删除旧的日志-->
<!--<totalSizeCap>1GB</totalSizeCap>-->
</rollingPolicy>
<!--日志输出编码格式化-->
<encoder>
<charset>UTF-8</charset>
<pattern>%d [%thread] %-5level %logger{36} %line - %msg%n%ex</pattern>
</encoder>
</appender>
<!--INFO级别的日志配置如下-->
<appender name="fileInfoLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
<!--日志名称，如果没有File 属性，那么只会使用FileNamePattern的文件路径规则
如果同时有<File>和<FileNamePattern>，那么当天日志是<File>，明天会自动把今天
的日志改名为今天的日期。即，<File> 的日志都是当天的。
-->
<File>${logback.logInfoDir}/info.log</File>
<!--自定义过滤器，保证info.***.log中只打印INFO级别的日志, 填写全限定路径-->
<filter class="com.example.lotterysystem.common.filter.InfoLevelFilter"/>
<!--滚动策略，按照时间滚动 TimeBasedRollingPolicy-->
<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<!--文件路径,定义了日志的切分方式——把每一天的日志归档到一个文件中,以防止日志填满整个磁盘空间-->
<FileNamePattern>${logback.logInfoDir}/info.%d{yyyy-MM-dd}.log</FileNamePattern>
<!--只保留最近14天的日志-->
<maxHistory>14</maxHistory>
<!--用来指定日志文件的上限大小，那么到了这个值，就会删除旧的日志-->
<!--<totalSizeCap>1GB</totalSizeCap>-->
</rollingPolicy>
<!--日志输出编码格式化-->
<encoder>
<charset>UTF-8</charset>
<pattern>%d [%thread] %-5level %logger{36} %line - %msg%n%ex</pattern>
</encoder>
</appender>
<root level="info">
<appender-ref ref="fileErrorLog" />
<appender-ref ref="fileInfoLog"/>
</root>
</springProfile>
</configuration>若当前处于开发环境，则将日志直接输出到控制台
若当前位于生产及测试环境，则分开存放 error 级别和 info 级别的日志，并采用基于时间的日志滚动策略，设置日志保留周期为14天
由于需要过滤 info 级别的日志，因此我们需要新增一个自定义过滤器：
在 com.example.lotterysystem.common.filter 路径下新增 InfoLevelFilter：
public class InfoLevelFilter extends Filter<ILoggingEvent> {
@Override
public FilterReply decide(ILoggingEvent iLoggingEvent) {
if (iLoggingEvent.getLevel().toInt() == Level.INFO.toInt()){
return FilterReply.ACCEPT;
}
return FilterReply.DENY;
}
}在 application.yml 中新增配置：
logging:
config: classpath:logback-spring.xml