SpringBoot后端部分，实现教师、学生两种角色的Api接口
文章目录
1. 项目总览
可移步我的主页查看项目总览博客
2. 后端技术栈
Java、SpringBoot、MySQL、Redis等
API文档使用swagger
3. 系统目录结构
系统主要采用控制层、业务层和数据库操作层三层架构实现整个后端框架。
4. 用户通用功能实现
主要包括：用户注册、用户登录、用户退出、获取用户信息、更新用户信息、上传用户头像等功能
用户注册
基本逻辑：
Controller层接收用户注册数据，封装到UserRegister类中
将数据转移给User类
调用Service层的业务逻辑方法完成注册
将结果封装并返回
Controller层
/**
* 用户注册页
* @param userRegister
* @return
*/
@PostMapping("/register")
@ApiOperation(value = "用户注册", notes = "用户注册")
public Result<User> register(
@ApiParam(name = "userRegister", value = "用户注册信息", required = true)
@Validated @RequestBody UserRegister userRegister) {
User user = new User(userRegister.getUsername(),
userRegister.getPassword(),
userRegister.getEmail(),
userRegister.getGender(),
userRegister.getPhone(),
userRegister.getRole(),
userRegister.getUsername());
userService.register(user);
return Result.success(user);
}
Service层
实现细节：
对用户密码在存储之前进行加密操作，保证安全
在用户首次注册时，设置头像为默认头像
最后调用Mapper层方法，在数据库中插入用户数据
@Override
public void register(User user) {
String salt = IdUtil.simpleUUID();
String password = SecurityUtil.crypto(salt, user.getPassword());
user.setPassword(password);
user.setNickname(user.getUsername());
user.setSalt(salt);
user.setAvatar(aliyunConfig.getTargetUrl() + "/" + aliyunConfig.getTargetPath() + "default.png");
userMapper.insert(user);
}
Mapper层
用户通用功能对于数据库的操作都是简单的增删改查，只需要继承BaseMapper即可
@Mapper
public interface UserMapper extends BaseMapper<User> {
}
用户登录
Controller层
/**
* 用户登录页
* @param username
* @param password
* @return
*/
@PostMapping("/login")
@ApiOperation(value = "用户登录", notes = "用户登录")
public Result<UserLoginVo> login(
@ApiParam(name = "username", value = "用户名", required = true)
@RequestParam("username") String username,
@ApiParam(name = "password", value = "密码", required = true)
@RequestParam("password") String password
) {
User formUser = new User(username, password);
UserLoginVo userLoginVo= userService.login(formUser);
log.info(userLoginVo.getToken());
return Result.success(userLoginVo);
}
Service层
@Override
public UserLoginVo login(User formUser) {
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("username", formUser.getUsername());
User dbUser = userMapper.selectOne(wrapper);
if (dbUser == null || !SecurityUtil.crypto(dbUser.getSalt(), formUser.getPassword()).equals(dbUser.getPassword()))
throw new BizException(LOGIN_ERROR.getResultCode(), LOGIN_ERROR.getResultMsg());
//todo: generate token to user
String token = IdUtil.simpleUUID();
redisTemplate.opsForValue().set(TOKEN_PREFIX + token, JSONUtil.toJsonStr(dbUser), 12, TimeUnit.HOURS);
UserLoginVo userLoginVo = new UserLoginVo(
formUser.getUsername(),
dbUser.getNickname(),
token,
dbUser.getRole(),
dbUser.getEmail(),
dbUser.getPhone(),
dbUser.getGender(),
dbUser.getAvatar()
);
return userLoginVo;
}
Mapper层
用户退出
Controller层
/**
* 用户登出页
* @param token
* @return
*/
@GetMapping("/logout")
@ApiOperation(value = "用户登出", notes = "用户登出")
public Result<Boolean> logout(
@ApiParam(name = "token", value = "用户认证令牌", required = true)
@RequestParam("token") String token) {
userService.logout(token);
return Result.success(true);
}
Service层
@Override
public void logout(String token) {
redisTemplate.delete(TOKEN_PREFIX + token);
}
Mapper层
获取用户信息
Controller层
/**
* 获取用户信息
* @param token
* @return
*/
@GetMapping("/userinfo")
@ApiOperation(value = "获取用户信息", notes = "获取用户信息")
public Result<User> userInfo(
@ApiParam(name = "token", value = "用户认证令牌", required = true)
@RequestParam("token") String token){
User user = userService.getByToken(token);
return Result.success(user);
}
Service层
@Override
public User userInfo(User u) {
if(u == null){
throw new BizException("502", "请先登录");
}
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("username", u.getUsername());
User dbUser = userMapper.selectOne(wrapper);
dbUser.setPassword("");
return dbUser;
}
Mapper层
更新用户信息
Controller层
/**
* 更新用户信息
* @param userUpdateInfo
* @return
*/
@PostMapping("/updateUserInfo")
@ApiOperation(value = "更新用户信息", notes = "更新用户信息")
public Result<User> updateUserInfo(
@ApiParam(name = "userUpdateInfo", value = "用户更新信息", required = true)
@Validated @RequestBody UserUpdateInfo userUpdateInfo){
return userService.updateUserInfo(userUpdateInfo);
}
Service层
@Override
public Result<User> updateUserInfo(UserUpdateInfo userUpdateInfo) {
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("username", userUpdateInfo.getUsername());
User dbUser = userMapper.selectOne(wrapper);
dbUser.setEmail(userUpdateInfo.getEmail());
dbUser.setPhone(userUpdateInfo.getPhone());
dbUser.setNickname(userUpdateInfo.getNickname());
userMapper.updateById(dbUser);
dbUser.setPassword("");
return Result.success(dbUser);
}
Mapper层
上传用户头像
Controller层
/**
* 上传头像
* @param file
* @param token
* @return
*/
@PostMapping("/uploadAvatar")
@ApiOperation(value = "图片文件更新头像", notes = "图片文件更新头像")
public Result<String> uploadAvatar(
@ApiParam(name = "file", value = "图片文件", required = true)
@RequestParam("file") MultipartFile file,
@ApiParam(name = "token", value = "用户认证令牌", required = true)
@RequestParam("token") String token){
User current_user = userService.getByToken(token);
return Result.success(userService.uploadAvatar(current_user, file));
}
Service层
@Override
public String uploadAvatar(User user, MultipartFile file) {
String originalFilename = file.getOriginalFilename();
//获取文件后缀名
String fileSuffix = originalFilename.substring(originalFilename.lastIndexOf("."));
//新生成文件名
//简单使用
String fileName = UUID.randomUUID().toString() + System.currentTimeMillis() + fileSuffix;
String targetPath;
try (InputStream fr = file.getInputStream()) {
// 10年后的日期
Date expiration = new Date(new Date().getTime() + 3600l * 1000 * 24 * 365 * 10);
String savePath = aliyunConfig.getTargetPath() + fileName;
GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(aliyunConfig.getBucketName(), savePath);
request.setExpiration(expiration);
URL url = ossClient.generatePresignedUrl(request);
ossClient.putObject(aliyunConfig.getBucketName(), savePath, fr);
// targetPath = aliyunConfig.getTargetUrl() + "/" + savePath;
targetPath = url.toString();
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("username", user.getUsername());
User dbUser = userMapper.selectOne(wrapper);
dbUser.setAvatar(targetPath);
userMapper.updateById(dbUser);
} catch (IOException e) {
throw new RuntimeException(e);
}
return targetPath;
}
Mapper层
5. 教师功能实现
主要包括：发布新课程、查看开课的选课情况、教师查看自己开设的课程
发布新课程
Controller层
/**
* 教师发布新课程
* @param newCourseInfo
* @param token
* @return
*/
@PostMapping("/releaseCourse")
@ApiOperation(value = "教师发布新课程", notes = "教师发布新课程")
public Result<Course> teacherReleaseCourse(
@ApiParam(name = "newCourseInfo", value = "课程信息", required = true)
@RequestBody NewCourseInfo newCourseInfo,
@ApiParam(name = "token", value = "用户认证令牌", required = true)
@RequestParam("token") String token) {
User current_user = userService.getByToken(token);
Course newCourse = new Course(newCourseInfo.getCourseId(),
newCourseInfo.getCourseName(),
newCourseInfo.getPrerequisites(),
newCourseInfo.getCourseDescription(),
newCourseInfo.getCourseType(),
current_user.getUsername());
courseService.teacherAddCourse(newCourse);
return Result.success(newCourse);
}
Service层
@Override
public void teacherAddCourse(Course newCourse) {
courseMapper.teacherAddCourse(newCourse.getCourseId(),
newCourse.getCourseName(),
newCourse.getPrerequisites(),
newCourse.getCourseDescription(),
newCourse.getCourseType(),
newCourse.getTeacherName());
}
Mapper层
/**
* 教师添加课程
*/
@Select("INSERT INTO course (course_id, course_name, prerequisites, course_description, course_type, teacher_name)\n" +
"VALUES (#{courseId}, #{courseName}, #{prerequisites}, #{courseDescription}, #{courseType}, #{teacherName});\n")
void teacherAddCourse(@Param("courseId") String courseId,
@Param("courseName") String courseName,
@Param("prerequisites") String prerequisites,
@Param("courseDescription") String courseDescription,
@Param("courseType") String courseType,
@Param("teacherName") String teacherName);
查看开课的选课情况
Controller层
/**
* 查看自己开课的选课的情况
* @param token
* @return
*/
@GetMapping("/getCourseStudyInfo")
@ApiOperation(value = "查看自己开课的选课情况", notes = "查看自己开课的选课情况")
public Result<List<CourseStudyInfo>> teacherGetCourseStudyInfo(
@ApiParam(name = "token", value = "用户认证令牌", required = true)
@RequestParam("token") String token){
User current_user = userService.getByToken(token);
List<CourseStudyInfo> courseStudyInfos = courseService.teacherGetCourseStudyInfo(current_user.getUsername());
return Result.success(courseStudyInfos);
}
Service层
@Override
public List<CourseStudyInfo> teacherGetCourseStudyInfo(String teacherName) {
List<CourseChosen> courseChosens = courseChosenMapper.teacherChosenCourseInfo(teacherName);
Map<String, CourseStudyInfo> courseStudyInfoMap = new HashMap<>();
for (CourseChosen courseChosen : courseChosens) {
String courseName = courseChosen.getCourseName();
// 如果Map中还没有该课程信息，则创建新的CourseStudyInfo对象
CourseStudyInfo courseStudyInfo = courseStudyInfoMap.computeIfAbsent(courseName, k -> new CourseStudyInfo(k));
// 更新CourseStudyInfo的选课人数（假设CourseChosen中没有直接的选课人数，需要统计）
courseStudyInfo.setStudentNum(courseStudyInfo.getStudentNum() == null ? 1 : courseStudyInfo.getStudentNum() + 1);
// 创建StudentStudyInfo并添加到CourseStudyInfo的列表中
StudentStudyInfo studentStudyInfo = new StudentStudyInfo(
courseName,
courseChosen.getStudentName(),
courseChosen.getStudyTimeSum(),
courseChosen.getStudyDay(),
courseChosen.getTodayStudyTime(),
courseChosen.getTwoWeekStudy(),
courseChosen.getScore()
);
courseStudyInfo.getStudentStudyInfoList().add(studentStudyInfo);
}
// 将Map的值转换为List并返回
return new ArrayList<>(courseStudyInfoMap.values());
}
Mapper层
/**
* 教师查看自己开的课程的选课情况
*/
@Select("SELECT * FROM student_course " +
"WHERE teacher_name = #{teacherName} " +
"ORDER BY course_name")
List<CourseChosen> teacherChosenCourseInfo(@Param("teacherName")String teacherName);
教师查看自己开设的课程
Controller层
/**
* 教师查看自己开课的课程
* @param token
* @return
*/
@GetMapping("/getCourses")
@ApiOperation(value = "教师查看自己开课的课程", notes = "教师查看自己开课的课程")
public Result<List<Course>> getCourseByTeacherName(
@ApiParam(name = "token", value = "用户认证令牌", required = true)
@RequestParam("token") String token){
User current_user = userService.getByToken(token);
List<Course> courses = courseService.getCourseByTeacherName(current_user.getUsername());
return Result.success(courses);
}
Service层
@Override
public List<Course> getCourseByTeacherName(String teacherName) {
QueryWrapper<Course> wrapper = new QueryWrapper<>();
wrapper.eq("teacher_name", teacherName)
.or()
.eq("teacher_name", teacherName + "\r");
return courseMapper.selectList(wrapper);
}
6. 学生功能实现
主要包括：选课、退选、获取自己的选课信息
选课
Controller层
/**
* 添加选课
* @param courseName
* @param token
* @return
*/
@GetMapping("/selectCourse")
@ApiOperation(value = "学生添加选课", notes = "添加选课")
public Result<CourseChosen> selectCourse(
@ApiParam(name = "courseName", value = "课程名称", required = true)
@RequestParam("courseName") String courseName,
@ApiParam(name = "token", value = "用户认证令牌", required = true)
@RequestParam("token") String token) {
User user = userService.getByToken(token);
CourseChosen courseChosen = courseService.studentAddCourse(courseName, user.getUsername());
return Result.success(courseChosen);
}
Service层
@Override
public CourseChosen studentAddCourse(String courseName, String studentName) {
String teacherName = courseMapper.getCourseDetail(courseName).getTeacherName().replace("\r", "");
for (CourseChosen courseChosen : courseChosenMapper.allChosenCourse(studentName)) {
if (courseChosen.getCourseName().equals(courseName)) {
throw new BizException(Course_Has_Been_Chosen.getResultCode(), Course_Has_Been_Chosen.getResultMsg());
}
}
CourseChosen courseChosen = new CourseChosen(studentName, courseName, teacherName);
courseChosenMapper.insert(courseChosen);
return courseChosen;
}
退选
Controller层
/**
* 删除选课
* @param courseName
* @param token
* @return
*/
@GetMapping("/deleteCourse")
@ApiOperation(value = "学生删除选课", notes = "删除选课")
public Result<String> deleteCourse(
@ApiParam(name = "courseName", value = "课程名称", required = true)
@RequestParam("courseName") String courseName,
@ApiParam(name = "token", value = "用户认证令牌", required = true)
@RequestParam("token") String token) {
User user = userService.getByToken(token);
courseService.studentDeleteCourse(courseName, user.getUsername());
return Result.success("退选成功");
}
Service层
@Override
public void studentDeleteCourse(String courseName, String studentName) {
for (CourseChosen courseChosen : courseChosenMapper.allChosenCourse(studentName)) {
if (courseChosen.getCourseName().equals(courseName)) {
courseChosenMapper.deleteChosenCourse(studentName, courseName);
return;
}
}
throw new BizException(Course_Has_Not_Been_Chosen.getResultCode(), Course_Has_Not_Been_Chosen.getResultMsg());
}
Mapper层
/**
* 删除选课
* @param studentName
* @param courseName
*/
@Delete("DELETE FROM student_course WHERE student_name = #{studentName} AND course_name = #{courseName}")
void deleteChosenCourse(String studentName, String courseName);
获取自己的选课信息
Controller层
/**
* 获取学生选课信息
* @param token
* @return
*/
@GetMapping("/getCourseStudyInfo")
@ApiOperation(value = "学生获取选课信息", notes = "获取学生选课信息")
public Result<List<CourseChosen>> getCourseStudyInfo(
@ApiParam(name = "token", value = "用户认证令牌", required = true)
@RequestParam("token") String token) {
User user = userService.getByToken(token);
List<CourseChosen> courseChosens = courseService.studentGetCourseStudyInfo(user.getUsername());
return Result.success(courseChosens);
}
Service层
@Override
public List<CourseChosen> studentGetCourseStudyInfo(String studentName) {
List<CourseChosen> courseChosens = courseChosenMapper.studentChosenCourseInfo(studentName);
if (courseChosens.isEmpty()){
throw new BizException(NOT_SELECT_ANY_COURSES.getResultCode(), NOT_SELECT_ANY_COURSES.getResultMsg());
}
return courseChosens;
}
Mapper层
/**
* 学生查看自己选课学习情况
*/
@Select("SELECT * FROM student_course " +
"WHERE student_name = #{studentName} " +
"ORDER BY course_name")
List<CourseChosen> studentChosenCourseInfo(@Param("studentName")String studentName);
7. 课程功能实现
主要包括：分页获取所有课程，获取指定类型的课程，获取课程详情，获取所有课程类别
分页获取所有课程
Controller层
/**
* 获取所有课程
* @return
*/
@PostMapping("/list")
@ApiOperation(value = "获取所有课程", notes = "获取所有课程")
public Result<Page<Course>> getAllCourses(
@ApiParam(name = "pageInfo", value = "分页信息", required = true)
@RequestBody PageInfo pageInfo,
@RequestParam(value = "token", required = false) String token,
@RequestParam(value = "courseType", required = false) String courseType) {
Page<Course> coursePage;
if (!"".equals(courseType) && courseType != null){
LambdaQueryWrapper<Course> wrapper = new LambdaQueryWrapper<>();
wrapper.like(Course::getCourseType, courseType);
Page<Course> page = new Page<>(
pageInfo.getPageNum(),
pageInfo.getPageSize()
);
coursePage = courseMapper.selectPage(page, wrapper);
}else {
Page<Course> page = new Page<>(
pageInfo.getPageNum(),
pageInfo.getPageSize()
);
coursePage = courseMapper.selectPage(page, null);
}
return Result.success(coursePage);
}
获取指定类型的课程
Controller层
/**
* 获取指定类型的课程
* @param courseType
* @return
*/
@GetMapping("/getCourseByType")
@ApiOperation(value = "获取指定类型的课程", notes = "获取指定类型的课程")
public Result<String> getCourseByType(
@ApiParam(name = "courseType", value = "课程类型", required = true)
@RequestParam("courseType") String courseType) {
List<Course> courses = courseService.getCourseByType(courseType);
return Result.success(courses);
}
Service层
@Override
public List<Course> getCourseByType(String courseType) {
List<Course> courses = courseMapper.selectCourseByType(courseType);
return courses;
}
Mapper层
/**
* 根据课程类型查询课程
* @param courseType
* @return
*/
@Select("SELECT id, course_id, course_name, prerequisites, course_description, course_type, teacher_name\n" +
"FROM course\n" +
"WHERE course_type = #{courseType};\n")
List<Course> selectCourseByType(@Param("courseType") String courseType);
获取课程详情
Controller层
/**
* 获取课程详情
* @param courseName
* @return
*/
@GetMapping("/courseDetail")
@ApiOperation(value = "获取课程详情", notes = "获取课程详情")
public Result<Course> getCourseDetail(
@ApiParam(name = "courseName", value = "课程名称", required = true)
@RequestParam("courseName") String courseName){
return Result.success(courseService.getCourseDetail(courseName));
}
Service层
@Override
public Course getCourseDetail(String courseName) {
return courseMapper.getCourseDetail(courseName);
}
Mapper层
/**
* 根据课程名查询课程信息
* @param courseName
* @return
*/
@Select("SELECT * FROM course WHERE course_name = #{courseName}")
Course getCourseDetail(@Param("courseName") String courseName);
获取所有课程类别
Controller层
/**
* 获取所有课程类别
* @return
*/
@GetMapping("/getAllCourseType")
@ApiOperation(value = "获取所有课程类别", notes = "获取所有课程类别")
public Result<List<CourseType>> getAllCourseType() {
List<CourseType> courseTypes = courseMapper.getAllCourseType();
return Result.success(courseTypes);
}
Mapper层
/**
* 查询所有课程类别
*/
@Select("SELECT *\n" +
"FROM type\n" +
"ORDER BY \n" +
" CASE \n" +
" WHEN type = '其他' THEN 2 \n" +
" ELSE 1 \n" +
" END,\n" +
" num DESC")
List<CourseType> getAllCourseType();
8. 其他模块
实体类、数据传输对象类、结果返回类
1、pojo文件夹：文件夹内的文件表示与数据库表对应的实体类
2、dto文件夹：文件夹内的文件表示后端将前端传来的数据包装起来的数据传输对象类
3、vo文件夹：文件夹内的文件表示后端处理完成后，将所需数据打包起来返回给前端的结果返回类
为什么需要这样三种类型的对象？
简单来说为了对有些隐私数据进行保护。用注册功能为例，注册时pojo类肯定会包含密码信息，但我们肯定不希望将密码，不论是加密后还是原始密码，暴露给前端，因此我们会用vo包装可以展示的数据进行返回。而dto是为了封装前端传输过来的数据，可以定制化接收参数。
自定义异常类
异常枚举
public enum ExceptionEnum implements BaseErrorInfoInterface{
// 数据操作错误定义
SUCCESS("200", "成功!"),
EXISTED("4001", "账号已存在!"),
INTERNAL_SERVER_ERROR("4002", "服务器内部错误!"),
SERVER_BUSY("4003", "服务器正忙，请稍后再试!"),
AUTH_ERROR("4004", "用户未登录！"),
AUTH_NOT_ENOUGH("4005", "权限不足，请联系管理员!"),
LOGIN_ERROR("4006", "用户名或密码错误!"),
NOT_LOGIN("4007", "用户未登录!"),
Course_Has_Been_Chosen("4008", "该课程已选!"),
Course_Has_Not_Been_Chosen("4009", "请先选择该课程!"),
NOT_SELECT_ANY_COURSES("4010", "还未选课");
/**
* 错误码
*/
private final String resultCode;
/**
* 错误描述
*/
private final String resultMsg;
ExceptionEnum(String resultCode, String resultMsg) {
this.resultCode = resultCode;
this.resultMsg = resultMsg;
}
@Override
public String getResultCode() {
return resultCode;
}
@Override
public String getResultMsg() {
return resultMsg;
}
}
自定义异常类
@ControllerAdvice
public class BizException extends RuntimeException{
private static final long serialVersionUID = 1L;
/**
* 错误码
*/
protected String errorCode;
/**
* 错误信息
*/
protected String errorMsg;
public BizException() {
super();
}
public BizException(BaseErrorInfoInterface errorInfoInterface) {
super(errorInfoInterface.getResultCode());
this.errorCode = errorInfoInterface.getResultCode();
this.errorMsg = errorInfoInterface.getResultMsg();
}
public BizException(BaseErrorInfoInterface errorInfoInterface, Throwable cause) {
super(errorInfoInterface.getResultCode(), cause);
this.errorCode = errorInfoInterface.getResultCode();
this.errorMsg = errorInfoInterface.getResultMsg();
}
public BizException(String errorMsg) {
super(errorMsg);
this.errorMsg = errorMsg;
}
public BizException(String errorCode, String errorMsg) {
super(errorCode);
this.errorCode = errorCode;
this.errorMsg = errorMsg;
}
public BizException(String errorCode, String errorMsg, Throwable cause) {
super(errorCode, cause);
this.errorCode = errorCode;
this.errorMsg = errorMsg;
}
public String getErrorCode() {
return errorCode;
}
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
public String getErrorMsg() {
return errorMsg;
}
public void setErrorMsg(String errorMsg) {
this.errorMsg = errorMsg;
}
@Override
public Throwable fillInStackTrace() {
return this;
}
@ExceptionHandler(value = MethodArgumentNotValidException.class)
@ResponseBody
public Result<?> handleValidException(MethodArgumentNotValidException e) {
String message = e.getBindingResult().getFieldError().getDefaultMessage();
return Result.error(message);
}
@ExceptionHandler(value = SQLIntegrityConstraintViolationException.class)
@ResponseBody
public Result<?> handleValidException(SQLIntegrityConstraintViolationException e) {
return Result.error(Integer.parseInt(EXISTED.getResultCode()), EXISTED.getResultMsg());
}
@ExceptionHandler(value = BizException.class)
@ResponseBody
public Result<?> handleValidException(BizException e) {
return Result.error(Integer.parseInt(e.getErrorCode()),e.getErrorMsg());
}
}
结果返回类
设置结果返回类，统一把返回数据包装起来返回给前端，真是非常J的做法！
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Result<T> {
@ApiModelProperty(value = "状态码")
private int code;
@ApiModelProperty(value = "提示信息")
private String msg;
@ApiModelProperty(value = "返回数据")
private T data;
private Result(BaseErrorInfoInterface errorInfo) {
this.code = Integer.parseInt(errorInfo.getResultCode());
this.msg = errorInfo.getResultMsg();
}
private Result(BaseErrorInfoInterface errorInfo, T data) {
this.code = Integer.parseInt(errorInfo.getResultCode());
this.msg = errorInfo.getResultMsg();
if (data != null && data.getClass() != ExceptionEnum.class) {
this.data = data;
}
}
/**
* 成功时候的调用
*/
public static <T> Result<T> success(T data) {
return new Result<>(ExceptionEnum.SUCCESS, data);
}
public static <T> Result<T> success(List<Course> data) {
return new Result(ExceptionEnum.SUCCESS, data);
}
/**
* 失败
*/
public static <T> Result<T> error(BaseErrorInfoInterface errorInfo) {
Result<T> result = new Result<>(errorInfo);
result.setData(null);
return result;
}
/**
* 失败
*/
public static <T> Result<T> error(Integer code, String message) {
Result<T> result = new Result<T>();
result.setCode(code);
result.setMsg(message);
result.setData(null);
return result;
}
/**
* 失败
*/
public static <T> Result<T> error(String message) {
Result<T> result = new Result<T>();
result.setCode(-1);
result.setMsg(message);
result.setData(null);
return result;
}
}
配置信息类
配置信息可以分为开发时配置和部署时配置，分设两个配置文件dev和prod，在主配置文件中选择即可，这样就避免了频繁debug修改配置。
application.yaml
spring:
profiles:
active: prod
servlet:
multipart:
max-file-size: 10MB
max-request-size: 10MB
aliyun:
endpoint:
accessKeyId:
accessKeySecret:
bucketName:
targetPath:
targetUrl: