基于Springboot+UniApp+Ai实现模拟面试小工具四：后端项目基础框架搭建下

本节接续上节，介绍本项目后端的基础框架搭建，包括基础的增删改查功能，以及权限校验，日志记录，参数校验等基础功能的实现。

源码下载： 点击下载
讲解视频：

Uniapp+Springboot+Kimi实现模拟面试小程序-前端项目搭建

一．基础功能

后端一般包括基础的增删改查/接口开发/事务管理/日志记录/权限管理/接口参数合法性校验等基本功能。

1.1. service 层定义实现

1. IBaseService

package com.junjunjun.aiwork.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.IService;
import com.junjunjun.aiwork.entity.BaseEntity;

public interface IBaseService<T extends BaseEntity> extends IService<T> {
    /**
     * 更新实体数据
     * @param t
     * @return
     */
    boolean update(T t);

    /**
     * 组织搜索参数
     * @param t
     * @return
     */
    QueryWrapper<T> initPageWapper(T t);
}

2. IUserService

package com.junjunjun.aiwork.service.user;

import com.junjunjun.aiwork.entity.user.User;
import com.junjunjun.aiwork.service.IBaseService;
import org.springframework.security.core.userdetails.UserDetailsService;

import java.util.Date;

public interface IUserService extends IBaseService<User>, UserDetailsService {
    /**
     * 修改密码
     * @param oldpwd 旧密码
     * @param newpwd 新密码
     */
    public void updatePwd(String oldpwd,String newpwd) throws Exception;

    /**
     * 重置用户密码
     * @param user
     * @param newpwd
     */
    public void resetPwd(User user,String newpwd);

    /**
     * 修改个人信息
     * @param t
     */
    void updateInfo(User t);

    /**
     * 通过openid获取用户信息
     * @param openid
     * @return
     */
    User getByOpenId(String openid);

    /**
     * 用户注册
     * @param user
     */
    void register(User user);

    /**
     * 查询电话号码对应的用户数据
     * @param phone
     * @return
     */
    User loadUserByPhone(String phone);

    /**
     * 统计角色对应的用户数量
     * @param roleId
     * @return
     */
    long countByRole(long roleId);

    Long countByDayAndRole(Date day, long roleId);
}

3. ILogService

package com.junjunjun.aiwork.service.system;

import com.junjunjun.aiwork.entity.system.Log;
import com.junjunjun.aiwork.entity.system.Setting;
import com.junjunjun.aiwork.service.IBaseService;

public interface ILogService extends IBaseService<Log> {
}

4. IMenuService

package com.junjunjun.aiwork.service.system;

import com.junjunjun.aiwork.entity.system.Menu;
import com.junjunjun.aiwork.entity.user.User;
import com.junjunjun.aiwork.service.IBaseService;

import java.util.List;

public interface IMenuService extends IBaseService<Menu> {
    /**
     * 加载指定用户的菜单数据
     * @param user
     * @return
     */
    List<Menu> listByUser(User user);
}

5. IRoleService

package com.junjunjun.aiwork.service.system;

import com.junjunjun.aiwork.entity.system.Role;
import com.junjunjun.aiwork.entity.user.User;
import com.junjunjun.aiwork.service.IBaseService;

import java.util.List;

public interface IRoleService extends IBaseService<Role> {
    /**
     * 加载用户对应的角色数据
     * @param user
     * @return
     */
    List<Role> listByUser(User user);
}

6. ISettingService

package com.junjunjun.aiwork.service.system;

import com.junjunjun.aiwork.entity.system.Setting;
import com.junjunjun.aiwork.service.IBaseService;

public interface ISettingService extends IBaseService<Setting> {
    /**
     * 获取key对应的参数数据
     * @param key
     * @return
     */
    Setting getByKey(String key);
}

7. IInterviewService

package com.junjunjun.aiwork.service.data;

import com.junjunjun.aiwork.entity.data.Interview;
import com.junjunjun.aiwork.service.IBaseService;

import java.util.Date;

public interface IInterviewService extends IBaseService<Interview> {
    boolean end(Interview t);

    boolean cancel(Long id);

    Long countByDay(Date day);

    Long countByScope(int min, int max);
}

8. IQuestionItemService

package com.junjunjun.aiwork.service.data;

import com.junjunjun.aiwork.entity.data.QuestionItem;
import com.junjunjun.aiwork.service.IBaseService;

import java.io.Serializable;
import java.util.List;

public interface IQuestionItemService extends IBaseService<QuestionItem> {
    /**
     * 面试记录对应的面试题目
     * @param id
     * @return
     */
    List<QuestionItem> listByInterview(Long id);
}

9. IResumeService

package com.junjunjun.aiwork.service.data;

import com.junjunjun.aiwork.entity.data.Resume;
import com.junjunjun.aiwork.service.IBaseService;

public interface IResumeService extends IBaseService<Resume> {
}

11. BaseService

package com.junjunjun.aiwork.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.junjunjun.aiwork.Log;
import com.junjunjun.aiwork.dao.BaseDao;
import com.junjunjun.aiwork.entity.BaseEntity;
import com.junjunjun.aiwork.entity.user.User;
import com.junjunjun.aiwork.service.IBaseService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;

@Slf4j
public  abstract class BaseService<T extends BaseEntity,M extends BaseDao<T>> extends ServiceImpl<M,T> implements IBaseService<T> {
    @Override
    @Log(title = "更新数据",type="更新",msg="更新数据${t}")
    @Transactional(rollbackFor = Exception.class)
    public boolean update(T t) {
        log.info("更新数据${t}");
        UpdateWrapper<T> uw =  initUpdateWrapper(t);
        uw.eq("id",t.getId());
        return getBaseMapper().update(uw)>0;
    }

    @Override
    @Log(title = "保存数据",type="保存",msg="保存数据${entity}")
    @Transactional(rollbackFor = Exception.class)
    public boolean save(T entity) {
        return super.save(entity);
    }

    @Override
    @Log(title = "删除数据",type="删除",msg="删除数据${id}")
    @Transactional(rollbackFor = Exception.class)
    public boolean removeById(Serializable id) {
        return super.removeById(id);
    }

    /**
     * 子类实现具体的修改的数据字段
     * @param t
     * @return
     */
    protected  UpdateWrapper<T> initUpdateWrapper(T t) {
        return new UpdateWrapper<>();
    }

    @Override
    public QueryWrapper<T> initPageWapper(T t) {
        QueryWrapper<T> queryWrapper = new QueryWrapper<>();

        //TODO 在子类中实现对应的搜索参数的限制

        return queryWrapper;
    }
}

12. UserService

package com.junjunjun.aiwork.service.user.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.junjunjun.aiwork.Log;
import com.junjunjun.aiwork.UserUtils;
import com.junjunjun.aiwork.dao.system.MenuDao;
import com.junjunjun.aiwork.dao.user.UserDao;
import com.junjunjun.aiwork.dao.user.UserRoleItemDao;
import com.junjunjun.aiwork.entity.system.Menu;
import com.junjunjun.aiwork.entity.system.Role;
import com.junjunjun.aiwork.entity.system.RoleMenuItem;
import com.junjunjun.aiwork.entity.system.Setting;
import com.junjunjun.aiwork.entity.user.User;
import com.junjunjun.aiwork.entity.user.UserRoleItem;
import com.junjunjun.aiwork.service.impl.BaseService;
import com.junjunjun.aiwork.service.user.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

import java.util.Date;

@Service
public class UserService extends BaseService<User,UserDao> implements IUserService {

    @Autowired
    private MenuDao menuDao;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Autowired
    private UserRoleItemDao userRoleItemDao;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean save(User entity) {
        //保存数据的时候对密码进行加密
        entity.setPassword(passwordEncoder.encode(entity.getPassword()));
        boolean result =  super.save(entity);
        if(result){
            if(entity.getRoles()!=null){
                for (Role role:entity.getRoles()){
                    UserRoleItem item = new UserRoleItem();
                    item.setRoleId(role.getId());
                    item.setUserId(entity.getId());
                    userRoleItemDao.insert(item);
                }
            }
        }
        return  result;
    }

    @Override
    public boolean update(User user) {
        boolean result =  super.update(user);
        if(result){
//            QueryWrapper<UserRoleItem> queryWrapper = new QueryWrapper<>();
//            queryWrapper.eq("user_id",user.getId());
            userRoleItemDao.deleteByUserId(user.getId());
            if(user.getRoles()!=null){
                for (Role role:user.getRoles()){
                    UserRoleItem item = new UserRoleItem();
                    item.setRoleId(role.getId());
                    item.setUserId(user.getId());
                    userRoleItemDao.insert(item);
                }
            }
        }
        return  result;
    }

    @Override
    protected UpdateWrapper<User> initUpdateWrapper(User user) {
        UpdateWrapper<User> uw = super.initUpdateWrapper(user);
        if(!ObjectUtils.isEmpty(user.getName())) {
            uw.set("name", user.getName());
        }
        if(!ObjectUtils.isEmpty(user.getPhone())) {
            uw.set("phone", user.getPhone());
        }
            if(!ObjectUtils.isEmpty(user.getSex())){
        uw.set("sex",user.getSex());}
        return uw;
    }

    @Override
    public QueryWrapper<User> initPageWapper(User user) {
        QueryWrapper<User> qw= super.initPageWapper(user);
        if(!ObjectUtils.isEmpty(user.getName())){
            qw.like("name",user.getName());
        }
        if(!ObjectUtils.isEmpty(user.getAccount())){
            qw.like("account",user.getAccount());
        }
        if(!ObjectUtils.isEmpty(user.getPhone())){
            qw.like("phone",user.getPhone());
        }
        if(!ObjectUtils.isEmpty(user.getSex())){
            qw.eq("sex",user.getSex());
        }
        return qw;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        QueryWrapper<User> qw = new QueryWrapper<>();
        qw.eq("account",username);
        User user = getBaseMapper().selectOne(qw);
        if(user==null){
            throw new UsernameNotFoundException("`${username}`不存在！");
        }
        if(user.getRoles()!=null){
            user.getRoles().forEach(role->{
                role.setMenus(menuDao.selectAllByRoleId(role.getId()));
            });
        }
        return user;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updatePwd(String oldpwd, String newpwd) throws Exception {
        User user = UserUtils.getUser();
        if(!passwordEncoder.matches(oldpwd,user.getPassword())){
            throw new Exception("旧密码不正确！");
        }
        UpdateWrapper<User> uw = new UpdateWrapper<>();
        uw.set("password",passwordEncoder.encode(newpwd));
        uw.eq("id",user.getId());
        getBaseMapper().update(uw);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void resetPwd(User user, String newpwd) {
        UpdateWrapper<User> uw = new UpdateWrapper<>();
        uw.set("password",passwordEncoder.encode(newpwd));
        uw.eq("id",user.getId());
        getBaseMapper().update(uw);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateInfo(User t) {
        UpdateWrapper<User> uw = new UpdateWrapper<>();
        uw.set("name",t.getName());
        uw.set("sex",t.getSex());
        uw.set("phone",t.getPhone());
        uw.set("header",t.getHeader());
        uw.eq("id",UserUtils.getUser().getId());
        getBaseMapper().update(uw);
    }

    @Override
    public User getByOpenId(String openid) {
        QueryWrapper<User> qw = new QueryWrapper<>();
        qw.eq("openid",openid);
        return getBaseMapper().selectOne(qw);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void register(User t) {
        UpdateWrapper<User> uw = new UpdateWrapper<>();
        uw.set("account",t.getPhone());
        uw.set("name",t.getName());
        uw.set("sex",t.getSex());
        uw.set("phone",t.getPhone());
        uw.set("header",t.getHeader());
        uw.eq("id",UserUtils.getUser().getId());
        getBaseMapper().update(uw);
    }

    @Override
    public User loadUserByPhone(String phone) {
        QueryWrapper<User> qw = new QueryWrapper<>();
        qw.eq("phone",phone);
        return getBaseMapper().selectOne(qw);
    }

    @Override
    public long countByRole(long roleId) {
        return getBaseMapper().countByRole(roleId);
    }

    @Override
    public Long countByDayAndRole(Date day, long roleId) {
        return getBaseMapper().countByDayAndRole(day,roleId);
    }
}

13. LogService

package com.junjunjun.aiwork.service.system.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.UpdateChainWrapper;
import com.junjunjun.aiwork.dao.system.LogDao;
import com.junjunjun.aiwork.dao.system.SettingDao;
import com.junjunjun.aiwork.entity.system.Log;
import com.junjunjun.aiwork.entity.system.Setting;
import com.junjunjun.aiwork.service.impl.BaseService;
import com.junjunjun.aiwork.service.system.ILogService;
import com.junjunjun.aiwork.service.system.ISettingService;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.util.Collection;

@Service
public class LogService extends BaseService<Log, LogDao> implements ILogService {


    @Override
    public QueryWrapper<Log> initPageWapper(Log log) {
        QueryWrapper<Log> qw = super.initPageWapper(log);
        if (!ObjectUtils.isEmpty(log.getIp())) {
            qw.like("ip", log.getIp());
        }
        if (!ObjectUtils.isEmpty(log.getMsg())) {
            qw.like("msg", log.getMsg());
        }
        if (!ObjectUtils.isEmpty(log.getParam())) {
            qw.like("param", log.getParam());
        }
        if (!ObjectUtils.isEmpty(log.getMethod())) {
            qw.like("method", log.getMethod());
        }
        if (!ObjectUtils.isEmpty(log.getTarget())) {
            qw.like("target", log.getTarget());
        }
        if (!ObjectUtils.isEmpty(log.getTitle())) {
            qw.like("title", log.getTitle());
        }
        if (!ObjectUtils.isEmpty(log.getUsername())) {
            qw.like("username", log.getUsername());
        }
        if(!ObjectUtils.isEmpty(( log).getStart()) || !ObjectUtils.isEmpty(( log).getEnd())){
            //TODO 特殊处理，使用时间范围进行搜索
            if(log.getStart()!=null&&log.getEnd()!=null){
                qw.between("date",log.getStart(),log.getEnd());
            }else if(log.getStart()!=null){
                qw.ge("date",log.getStart());
            }else if(log.getEnd()!=null){
                qw.le("date",log.getEnd());
            }
        }
        return qw;
    }

}

14. MenuService

package com.junjunjun.aiwork.service.system.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.junjunjun.aiwork.dao.system.MenuDao;
import com.junjunjun.aiwork.entity.system.Menu;
import com.junjunjun.aiwork.entity.system.Role;
import com.junjunjun.aiwork.entity.user.User;
import com.junjunjun.aiwork.service.impl.BaseService;
import com.junjunjun.aiwork.service.system.IMenuService;
import com.junjunjun.aiwork.service.system.IRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.util.ArrayList;
import java.util.List;

@Service
public class MenuService extends BaseService<Menu,MenuDao> implements IMenuService {
    @Autowired
    IRoleService roleService;
    @Override
    public QueryWrapper<Menu> initPageWapper(Menu menu) {
        QueryWrapper<Menu> qw = super.initPageWapper(menu);
        if(!ObjectUtils.isEmpty(menu.getName())){
            qw.like("name",menu.getName());
        }
        if(!ObjectUtils.isEmpty(menu.getPermission())){
         qw.like("permission",menu.getPermission());
        }
        if(!ObjectUtils.isEmpty(menu.getType())){
            qw.eq("type",menu.getType());
        }
            if(!ObjectUtils.isEmpty(menu.getUrl())){
        qw.like("url",menu.getUrl());
            }
        if(menu.getParentId()!=null){
            qw.eq("parent_id",menu.getParentId());
        }
        return qw;
    }

    @Override
    protected UpdateWrapper<Menu> initUpdateWrapper(Menu role) {
        UpdateWrapper<Menu> uw = super.initUpdateWrapper(role);
        uw.set("name",role.getName());
        uw.set("permission",role.getPermission());
        uw.set("parent_id",role.getParentId());
        uw.set("type",role.getType());
        uw.set("url",role.getUrl());
        uw.set("icon",role.getIcon());
        uw.set("compontent",role.getCompontent());
        uw.set("sort_",role.getSort_());

        return uw;
    }

    @Override
    public List<Menu> listByUser(User user) {
        if(user==null||user.getId()==null){
            return null;
        }
        /**
         * 查询用户对应的角色数据
         */
        List<Role> roles = roleService.listByUser(user);
        List<Menu> result =new ArrayList<>();
        roles.forEach(item->{
            List<Menu> itemMneus = getBaseMapper().selectAllByRoleId(item.getId());
            if(itemMneus!=null){
                result.addAll(itemMneus);
            }
        });
        return result;
    }
}

15. RoleService

package com.junjunjun.aiwork.service.system.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.junjunjun.aiwork.dao.system.MenuDao;
import com.junjunjun.aiwork.dao.system.RoleDao;
import com.junjunjun.aiwork.dao.system.RoleMenuItemDao;
import com.junjunjun.aiwork.entity.system.Menu;
import com.junjunjun.aiwork.entity.system.Role;
import com.junjunjun.aiwork.entity.system.RoleMenuItem;
import com.junjunjun.aiwork.entity.system.Setting;
import com.junjunjun.aiwork.entity.user.User;
import com.junjunjun.aiwork.service.impl.BaseService;
import com.junjunjun.aiwork.service.system.IRoleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.io.Serializable;
import java.util.List;

@Service
public class RoleService extends BaseService<Role,RoleDao> implements IRoleService {
    @Autowired
    private RoleMenuItemDao roleMenuItemDao;
    @Autowired
    private MenuDao menuDao;
    @Override
    public QueryWrapper<Role> initPageWapper(Role role) {
        QueryWrapper<Role> qw = super.initPageWapper(role);
        if(!ObjectUtils.isEmpty(role.getName())){
            qw.like("name",role.getName());
        }
        if(!ObjectUtils.isEmpty(role.getPermission())){
            qw.like("permission",role.getPermission());
        }
        return qw;
    }

    @Override
    protected UpdateWrapper<Role> initUpdateWrapper(Role role) {
        UpdateWrapper<Role> uw = super.initUpdateWrapper(role);
        uw.set("name",role.getName());
        uw.set("permission",role.getPermission());
        return uw;
    }

    @Override
    public boolean update(Role role) {
        boolean result =  super.update(role);
        if(result){
//            QueryWrapper<RoleMenuItem> queryWrapper = new QueryWrapper<>();
//            queryWrapper.eq("role_id",role.getId());
            roleMenuItemDao.deleteByRoleId(role.getId());
            if(role.getMenus()!=null){
                for (Menu menu:role.getMenus()){
                    RoleMenuItem item = new RoleMenuItem();
                    item.setRoleId(role.getId());
                    item.setMenuId(menu.getId());
                    roleMenuItemDao.insert(item);
                }
            }
        }
        return  result;
    }

    @Override
    public boolean save(Role entity) {
        boolean result = super.save(entity);
        if(result){
            if(entity.getMenus()!=null){
                for (Menu menu:entity.getMenus()){
                    RoleMenuItem item = new RoleMenuItem();
                    item.setRoleId(entity.getId());
                    item.setMenuId(menu.getId());
                    roleMenuItemDao.insert(item);
                }
            }
        }
        return  result;
    }

    @Override
    public List<Role> listByUser(User user) {
        if(user==null||user.getId()==null){
            return null;
        }
        List<Role> roles =   getBaseMapper().selectAllByUserId(user.getId());
        return roles;
    }
}

16. SettingService

package com.junjunjun.aiwork.service.system.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.junjunjun.aiwork.dao.system.SettingDao;
import com.junjunjun.aiwork.entity.system.Setting;
import com.junjunjun.aiwork.service.impl.BaseService;
import com.junjunjun.aiwork.service.system.ISettingService;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

@Service
public class SettingService extends BaseService<Setting,SettingDao> implements ISettingService {
    @Override
    public QueryWrapper<Setting> initPageWapper(Setting setting) {
        QueryWrapper<Setting> qw = super.initPageWapper(setting);
        if(!ObjectUtils.isEmpty(setting.getKey())){
        qw.like("key_",setting.getKey());}
            if(!ObjectUtils.isEmpty(setting.getValue())){
        qw.like("value",setting.getValue());}
        return qw;
    }

    @Override
    protected UpdateWrapper<Setting> initUpdateWrapper(Setting setting) {
        UpdateWrapper<Setting> uw = super.initUpdateWrapper(setting);
        uw.set("key_",setting.getKey());
        uw.set("value",setting.getValue());
        return uw;
    }

    @Override
    public Setting getByKey(String key) {
        QueryWrapper<Setting> qw = new QueryWrapper<>();
        qw.eq("key_",key);
        return getBaseMapper().selectOne(qw);
    }
}

17. InterviewService

package com.junjunjun.aiwork.service.data.impl;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.junjunjun.aiwork.UserUtils;
import com.junjunjun.aiwork.dao.data.InterviewDao;
import com.junjunjun.aiwork.entity.data.Interview;
import com.junjunjun.aiwork.entity.data.Resume;
import com.junjunjun.aiwork.entity.system.Role;
import com.junjunjun.aiwork.service.data.IInterviewService;
import com.junjunjun.aiwork.service.data.IQuestionItemService;
import com.junjunjun.aiwork.service.data.IResumeService;
import com.junjunjun.aiwork.service.impl.BaseService;
import com.junjunjun.aiwork.service.user.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.io.Serializable;
import java.util.Date;

@Service
public class InterviewService extends BaseService<Interview,InterviewDao> implements IInterviewService {
    @Autowired
    private IUserService userService;
    @Autowired
    private IResumeService resumeService;
    @Autowired
    private IQuestionItemService questionItemService;

    @Override
    public boolean save(Interview entity) {
        entity.setDate(new Date());
        entity.setUser(UserUtils.getUser().getId());
        entity.setStart(new Date());
        entity.setStatus("1");
        entity.setScope(0.0);
        return super.save(entity);
    }

    @Override
    protected UpdateWrapper<Interview> initUpdateWrapper(Interview interview) {
        UpdateWrapper<Interview> uw = super.initUpdateWrapper(interview);
        uw.set("date",interview.getDate());
        uw.set("job",interview.getJob());
        uw.set("user",interview.getUser());
        uw.set("result",interview.getResult());
        uw.set("resume",interview.getResume());
;        return uw;
    }

    @Override
    public QueryWrapper<Interview> initPageWapper(Interview interview) {
        QueryWrapper<Interview>  qw = super.initPageWapper(interview);
        qw.orderByDesc("date");
        if(!ObjectUtils.isEmpty(( interview).getStart()) || !ObjectUtils.isEmpty(( interview).getEnd())){
            //TODO 特殊处理，使用时间范围进行搜索
            if(interview.getStart()!=null&&interview.getEnd()!=null){
                qw.between("date",interview.getStart(),interview.getEnd());
            }else if(interview.getStart()!=null){
                qw.ge("start",interview.getStart());
            }else if(interview.getEnd()!=null){
                qw.le("date",interview.getEnd());
            }
        }
        if(!ObjectUtils.isEmpty(interview.getResult())){
            qw.like("result",interview.getResult());
        }
        if(!ObjectUtils.isEmpty(interview.getType())){
            qw.like("type",interview.getType());
        }
        if(!ObjectUtils.isEmpty(interview.getUser())){
            qw.eq("user",interview.getUser());
        }
        if(!ObjectUtils.isEmpty(interview.getResume())){
            qw.eq("resume",interview.getResume());
        }
        if(!ObjectUtils.isEmpty(interview.getJob())){
            qw.like("job",interview.getJob());
        }
        if(!ObjectUtils.isEmpty(interview.getStatus())){
            qw.eq("status",interview.getStatus());
        }
        boolean isAdmin = false;
        if(UserUtils.getUser()!=null){
            if(UserUtils.getUser().getRoles()!=null){
                for (Role role : UserUtils.getUser().getRoles()) {
                    if("ROLE_ADMIN".equals(role.getAuthority())){
                        isAdmin = true;
                        break;
                    }
                }
            }
            if(!isAdmin){//不是管理员用户需要限制是自己的
                qw.eq("user",UserUtils.getUser().getId());
            }
        }
        return qw;
    }

    @Override
    public Interview getById(Serializable id) {
        Interview result =  super.getById(id);
        if(result.getUser()!=null){
            result.setUserInfo(userService.getById(result.getUser()));
        }
        if(result.getResume()!=null){
            result.setResumeInfo(resumeService.getById(result.getResume()));
        }
        result.setItems(questionItemService.listByInterview((Long) id));
        return result;
    }

    @Override
    public <E extends IPage<Interview>> E page(E page, Wrapper<Interview> queryWrapper) {
        E result =  super.page(page,queryWrapper);
        if(result!=null){
            if(result.getRecords()!=null){
                result.getRecords().forEach(item->{
                    if(item.getUser()!=null){
                        item.setUserInfo(userService.getById(item.getUser()));
                    }
                    if(item.getResume()!=null){
                        item.setResumeInfo(resumeService.getById(item.getResume()));
                    }
                });
            }
        }
        return result;
    }

    @Override
    public boolean end(Interview t) {
        UpdateWrapper<Interview> uw = super.initUpdateWrapper(t);
        uw.set("scope",t.getScope());
        uw.set("status","3");
        uw.set("result",t.getResult());
        uw.eq("id",t.getId());
        int result =  getBaseMapper().update(uw);
        return result>0;
    }

    @Override
    public boolean cancel(Long id) {
        UpdateWrapper<Interview> uw = new UpdateWrapper<>();
//        uw.set("scope",t.getScope());
        uw.set("status","4");
//        uw.set("result",t.getResult());
        uw.eq("id",id);
        int result =  getBaseMapper().update(uw);
        return result>0;
    }

    @Override
    public Long countByDay(Date day) {
        QueryWrapper<Interview>  qw = new QueryWrapper<>();
        Date start = new Date(day.getTime());
        start.setHours(0);
        start.setMinutes(0);
        start.setSeconds(0);
        Date end = new Date(day.getTime());
        end.setHours(23);
        end.setMinutes(59);
        start.setSeconds(59);
        qw.between("date",start,end);
        return getBaseMapper().selectCount(qw);
    }

    @Override
    public Long countByScope(int min, int max) {
        QueryWrapper<Interview>  qw = new QueryWrapper<>();

        qw.between("scope",min,max);
        return getBaseMapper().selectCount(qw);
    }
}

18. QuestionItemService

package com.junjunjun.aiwork.service.data.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.junjunjun.aiwork.dao.data.QuestionItemDao;
import com.junjunjun.aiwork.entity.data.QuestionItem;
import com.junjunjun.aiwork.service.data.IQuestionItemService;
import com.junjunjun.aiwork.service.impl.BaseService;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.util.List;

@Service
public class QuestionItemService extends BaseService<QuestionItem,QuestionItemDao> implements IQuestionItemService {
    @Override
    public QueryWrapper<QuestionItem> initPageWapper(QuestionItem questionItem) {
        QueryWrapper<QuestionItem> qw =  super.initPageWapper(questionItem);
        if(!ObjectUtils.isEmpty(questionItem.getQuestion())){
            qw.like("question",questionItem.getQuestion());
        }
        if(!ObjectUtils.isEmpty(questionItem.getAnswer())){
            qw.like("answer",questionItem.getAnswer());
        }
        if(!ObjectUtils.isEmpty(questionItem.getInterview())){
            qw.eq("interview",questionItem.getInterview());
        }
        return qw;
    }

    @Override
    protected UpdateWrapper<QuestionItem> initUpdateWrapper(QuestionItem questionItem) {
        UpdateWrapper<QuestionItem> uw =  super.initUpdateWrapper(questionItem);
        uw.set("answer",questionItem.getAnswer());
        return uw;
    }

    @Override
    public boolean update(QuestionItem questionItem) {
        return super.update(questionItem);
    }

    @Override
    public List<QuestionItem> listByInterview(Long id) {
        QueryWrapper<QuestionItem> qw =  new QueryWrapper<>();
        qw.eq("interview",id);
        return  getBaseMapper().selectList(qw);
    }
}

19. ResumeService

package com.junjunjun.aiwork.service.data.impl;

import cn.hutool.json.JSON;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.junjunjun.aiwork.UserUtils;
import com.junjunjun.aiwork.dao.data.ResumeDao;
import com.junjunjun.aiwork.entity.data.Interview;
import com.junjunjun.aiwork.entity.data.Resume;
import com.junjunjun.aiwork.entity.system.Role;
import com.junjunjun.aiwork.kimi.MoonshotAiUtils;
import com.junjunjun.aiwork.service.data.IResumeService;
import com.junjunjun.aiwork.service.impl.BaseService;
import com.junjunjun.aiwork.service.user.IUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.io.File;
import java.io.Serializable;
import java.util.Date;

@Service
public class ResumeService extends BaseService<Resume,ResumeDao> implements IResumeService {
@Autowired
    private IUserService userService;
    @Autowired
    ObjectMapper objectMapper;
    @Override
    public boolean save(Resume entity) {
        entity.setCreateDate(new Date());
        //调用kimi接口上传文件，并且读取文件信息
        String rootPath = this.getClass().getResource("/").getPath().substring(1);
        File file = new File(rootPath+entity.getFile());
        String result = MoonshotAiUtils.uploadFile(file);
        entity.setFileinfo(result);
        JSONObject resultJson = JSONUtil.parseObj(result);
        String content =  MoonshotAiUtils.getFileContent(resultJson.getStr("id"));
        entity.setContent(content);
        return super.save(entity);
    }

    @Override
    public Resume getById(Serializable id) {
        Resume result =  super.getById(id);
        if(result.getUser()!=null){
            result.setUserInfo(userService.getById(result.getUser()));
        }
        return result;
    }

    @Override
    public <E extends IPage<Resume>> E page(E page, Wrapper<Resume> queryWrapper) {
        E result =  super.page(page,queryWrapper);
        if(result!=null){
            if(result.getRecords()!=null){
                result.getRecords().forEach(item->{
                    if(item.getUser()!=null){
                        item.setUserInfo(userService.getById(item.getUser()));
                    }
                });
            }
        }
        return result;
    }

    @Override
    protected UpdateWrapper<Resume> initUpdateWrapper(Resume resume) {
        UpdateWrapper<Resume> uw = super.initUpdateWrapper(resume);
        uw.set("name",resume.getName());
        uw.set("file",resume.getFile());
//        uw.set("user",resume.getUser());
        return uw;
    }

    @Override
    public QueryWrapper<Resume> initPageWapper(Resume resume) {
        QueryWrapper<Resume>  qw = super.initPageWapper(resume);
        if(!ObjectUtils.isEmpty(resume.getName())){
            qw.like("name",resume.getName());
        }
        if(!ObjectUtils.isEmpty(resume.getUser())){
            qw.eq("user_id",resume.getUser());
        }
        boolean isAdmin = false;
        if(UserUtils.getUser()!=null){
            if(UserUtils.getUser().getRoles()!=null){
                for (Role role : UserUtils.getUser().getRoles()) {
                    if("ROLE_ADMIN".equals(role.getAuthority())){
                        isAdmin = true;
                        break;
                    }
                }
            }
            if(!isAdmin){//不是管理员用户需要限制是自己的
                qw.eq("user_id",UserUtils.getUser().getId());
            }
        }
        return qw;
    }
}

1.1. controller 层定义实现

1. BaseController

package com.junjunjun.aiwork.api;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.junjunjun.aiwork.entity.BaseEntity;
import com.junjunjun.aiwork.entity.user.User;
import com.junjunjun.aiwork.service.IBaseService;
import com.junjunjun.aiwork.vo.PageInfo;
import com.junjunjun.aiwork.vo.Result;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotNull;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

/**
 * 接口基础类
 */
@Slf4j
public  abstract class BaseController<T extends BaseEntity,S extends IBaseService<T>> {
    @Autowired
    protected S service;

    //@Validated @NotNull(message="id不能为空")
    @GetMapping("/get/{id}")
    @ResponseBody
    @PreAuthorize("hasAuthority('SCOPE_ROLE_ADMIN') or (@authService.checkGet(#root,#id) and hasAuthority('SCOPE_'+#this.this.class.name+':read'))")
    public Result<T> get( @PathVariable("id") Long id){
        log.info("请求用户数据`${id}`");

        T t = service.getById(id);

        return new Result<T>(200,"",t);
    }

    @PostMapping("/page")
    @ResponseBody
    @PreAuthorize("hasAuthority('SCOPE_ROLE_ADMIN') or (hasAuthority('SCOPE_'+#this.this.class.name+':read') and @authService.checkPage(#root,#page))")
    public Result<Page<T>> page(@RequestBody @Validated PageInfo<T> page){
        log.info("请求用户分页数据`${page}`");

        Page<T> pages = service.page(page.getPage(),service.initPageWapper(page.getT()));

        return new Result<Page<T>>(200,"",pages);
    }

    @PostMapping("/save")
    @ResponseBody
    @PreAuthorize("hasAuthority('SCOPE_ROLE_ADMIN') or (hasAuthority('SCOPE_'+#this.this.class.name+':create') and @authService.checkSave(#root,#t))")
    public Result<T> save(@RequestBody @Validated T t, HttpServletResponse response){
        log.info("请求保存用户数据`${t}`");

        try{
            boolean result = service.save(t);

            return new Result<T>(200,"",t);
        } catch (Exception e) {
            log.error("保存数据异常",e);
            response.setStatus(500);
            return new Result<T>(500,e.getMessage(),t);
        }
    }
    @PostMapping("/update")
    @ResponseBody
    @PreAuthorize("hasAuthority('SCOPE_ROLE_ADMIN') or (hasAuthority('SCOPE_'+#this.this.class.name+':write') and @authService.checkUpdate(#root,#t))")
    public Result<T> update(@RequestBody @Validated T t, HttpServletResponse response){
        log.info("请求更新用户数据`${y}`");
        try{
            boolean result = service.update(t);
            return new Result<T>(200,"",t);
        } catch (Exception e) {
            log.error("更新数据异常",e);
            response.setStatus(500);
            return new Result<T>(500,e.getMessage(),null);
        }
    }

    //@Validated @NotNull(message="id不能为空")
    @GetMapping("/delete/{id}")
    @ResponseBody
    @PreAuthorize("hasAuthority('SCOPE_ROLE_ADMIN') or (hasAuthority('SCOPE_'+#this.this.class.name+':delete') and @authService.checkDelete(#root,#id))")
    public Result<Boolean> delete(@PathVariable  Long id, HttpServletResponse response){
        log.info("请求删除用户数据`${id}`");
        try{
            service.removeById(id);
            return new Result<Boolean>(200,"",true);
        } catch (Exception e) {
            log.error("删除数据异常",e);
            response.setStatus(500);
            return new Result<Boolean>(500,e.getMessage(),false);
        }
    }
}

2. UserController

package com.junjunjun.aiwork.api.user;

import com.junjunjun.aiwork.UserUtils;
import com.junjunjun.aiwork.api.BaseController;
import com.junjunjun.aiwork.entity.user.User;
import com.junjunjun.aiwork.service.user.IUserService;
import com.junjunjun.aiwork.vo.ResetPwd;
import com.junjunjun.aiwork.vo.Result;
import com.junjunjun.aiwork.vo.UpdatePwd;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

/**
 * 用户管理的相关接口
 */
@Slf4j
@Validated
@RestController
@RequestMapping("/api/user")
public class UserController extends BaseController<User, IUserService> {
    @PostMapping("/updatepwd")
    @ResponseBody
    @PreAuthorize("isAuthenticated()")
    public Result<Boolean> updatepwd(@RequestBody @Validated UpdatePwd t, HttpServletResponse response){
        log.info("更新用户密码`${y}`");
        try{
            ((IUserService)service).updatePwd(t.getOldpwd(),t.getNewpwd());

            return new Result<Boolean>(200,"",true);
        } catch (Exception e) {
            log.error("密码更新异常",e);
            response.setStatus(500);
            return new Result<Boolean>(500,e.getMessage(),false);
        }
    }
    @PostMapping("/restepwd")
    @ResponseBody
    @PreAuthorize("hasAuthority('SCOPE_ROLE_ADMIN')")
    public Result<Boolean> restepwd(@RequestBody @Validated ResetPwd t, HttpServletResponse response){
        log.info("重置用户密码`${y}`");
        try{
            ((IUserService)service).resetPwd(t.getUser(),t.getNewpwd());

            return new Result<Boolean>(200,"",true);
        } catch (Exception e) {
            log.error("密码重置异常",e);
            response.setStatus(500);
            return new Result<Boolean>(500,e.getMessage(),false);
        }
    }

    @PostMapping("/updateInfo")
    @ResponseBody
    @PreAuthorize("isAuthenticated()")
    public Result<Boolean> updateInfo(@RequestBody @Validated User t, HttpServletResponse response){
        try{
            ((IUserService)service).updateInfo(t);

            return new Result<Boolean>(200,"",true);
        } catch (Exception e) {
            log.error("更新失败",e);
            response.setStatus(500);
            return new Result<Boolean>(500,e.getMessage(),null);
        }
    }
}

3. LogController

package com.junjunjun.aiwork.api.system;

import com.junjunjun.aiwork.api.BaseController;
import com.junjunjun.aiwork.entity.system.Log;
import com.junjunjun.aiwork.entity.system.Setting;
import com.junjunjun.aiwork.service.system.ILogService;
import com.junjunjun.aiwork.service.system.ISettingService;
import com.junjunjun.aiwork.vo.Result;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用户管理的相关接口
 */
@Slf4j
@RestController
@RequestMapping("/api/log")
public class LogController extends BaseController<Log, ILogService> {
    @Override
    public Result<Log> update(Log log, HttpServletResponse response) {
        return new Result<Log>(200,"不能更新日志",null);
    }

    @Override
    public Result<Log> save(Log log, HttpServletResponse response) {
        return new Result<Log>(200,"不能添加日志",log);
    }

    @Override
    public Result<Boolean> delete(Long id, HttpServletResponse response) {
        return new Result<Boolean>(200,"不能删除日志",false);
    }
}

4. MenuController

package com.junjunjun.aiwork.api.system;

import com.junjunjun.aiwork.api.BaseController;
import com.junjunjun.aiwork.entity.system.Menu;
import com.junjunjun.aiwork.service.system.IMenuService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用户管理的相关接口
 */
@Slf4j
@RestController
@RequestMapping("/api/menu")
public class MenuController extends BaseController<Menu, IMenuService> {
}

5. RoleController

package com.junjunjun.aiwork.api.system;

import com.junjunjun.aiwork.api.BaseController;
import com.junjunjun.aiwork.entity.system.Role;
import com.junjunjun.aiwork.service.system.IRoleService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用户管理的相关接口
 */
@Slf4j
@RestController
@RequestMapping("/api/role")
public class RoleController extends BaseController<Role, IRoleService> {
}

6. SettingController

package com.junjunjun.aiwork.api.system;

import com.junjunjun.aiwork.api.BaseController;
import com.junjunjun.aiwork.entity.system.Setting;
import com.junjunjun.aiwork.service.system.ISettingService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用户管理的相关接口
 */
@Slf4j
@RestController
@RequestMapping("/api/setting")
public class SettingController extends BaseController<Setting, ISettingService> {
}

7. InterviewController

package com.junjunjun.aiwork.api.data;

import com.junjunjun.aiwork.api.BaseController;
import com.junjunjun.aiwork.entity.data.Interview;
import com.junjunjun.aiwork.entity.data.QuestionItem;
import com.junjunjun.aiwork.service.data.IInterviewService;
import com.junjunjun.aiwork.vo.Result;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

/**
 * 用户管理的相关接口
 */
@Slf4j
@RestController
@RequestMapping("/api/interview")
public class InterviewController extends BaseController<Interview, IInterviewService> {
    @PostMapping("/end")
    @ResponseBody
    @PreAuthorize("hasAuthority('SCOPE_ROLE_ADMIN') or (hasAuthority('SCOPE_'+#this.this.class.name+':create') and @authService.checkSave(#root,#t))")
    public Result<Interview> end(@RequestBody @Validated Interview t, HttpServletResponse response){
        log.info("请求保存用户数据`${t}`");

        try{
            boolean result = service.end(t);
            return new Result<Interview>(200,"",t);
        } catch (Exception e) {
            log.error("保存数据异常",e);
            response.setStatus(500);
            return new Result<Interview>(500,e.getMessage(),t);
        }
    }
    @GetMapping("/cancel/{id}")
    @ResponseBody
    @PreAuthorize("hasAuthority('SCOPE_ROLE_ADMIN') or (hasAuthority('SCOPE_'+#this.this.class.name+':create') and @authService.checkSave(#root,#t))")
    public Result<Boolean> cancel(@PathVariable("id") @Validated Long id, HttpServletResponse response){
        log.info("请求保存用户数据`${t}`");

        try{
            boolean result = service.cancel(id);

            return new Result<Boolean>(200,"",result);
        } catch (Exception e) {
            log.error("保存数据异常",e);
            response.setStatus(500);
            return new Result<Boolean>(500,e.getMessage(),false);
        }
    }

}

8. QuestionItemController

package com.junjunjun.aiwork.api.data;

import com.junjunjun.aiwork.api.BaseController;
import com.junjunjun.aiwork.entity.data.QuestionItem;
import com.junjunjun.aiwork.service.data.IQuestionItemService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 用户管理的相关接口
 */
@Slf4j
@RestController
@RequestMapping("/api/questionitem")
public class QuestionItemController extends BaseController<QuestionItem, IQuestionItemService> {
}

9. ResumeController

package com.junjunjun.aiwork.api.data;

import com.junjunjun.aiwork.UserUtils;
import com.junjunjun.aiwork.api.BaseController;
import com.junjunjun.aiwork.entity.data.Resume;
import com.junjunjun.aiwork.entity.user.User;
import com.junjunjun.aiwork.service.data.IResumeService;
import com.junjunjun.aiwork.vo.Result;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.security.core.Authentication;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 用户管理的相关接口
 */
@Slf4j
@RestController
@RequestMapping("/api/resume")
public class ResumeController extends BaseController<Resume, IResumeService> {
    //上传简历
    @PostMapping("/savefile")
    @PreAuthorize("hasAuthority('SCOPE_ROLE_ADMIN') or (hasAuthority('SCOPE_'+#this.this.class.name+':create') and @authService.checkSave(#root,#t))")
    public Result savefile(Resume resume, @RequestParam("fileitem") MultipartFile header, Authentication authentication) {
        try{
            if(!authentication.isAuthenticated()){
                return new Result<User>(401,"请先登录",null);
            }
            if (header.isEmpty()) {
                return new Result<User>(400,"文件不能为空",null);
            }
            String day = new SimpleDateFormat("yyyy-MM-dd").format(new Date());

            String rootPath = this.getClass().getResource("/").getPath().substring(1);

            String filePath = "/static/upload/"+day+"/";
            if(!new File(rootPath+"/static/upload/"+day+"/").exists()){
                new File(rootPath+"/static/upload/"+day+"/").mkdirs();
            }
            // Save the file to the server's file system (e.g., /uploaded_files/)
            Path path = Paths.get(rootPath+filePath + header.getOriginalFilename());
            Files.copy(header.getInputStream(), path);

            // Build the response message with the file location (optional)
//            String fileDownloadUri = ServletUriComponentsBuilder.fromCurrentContextPath()
//                    .path(filePath)
//                    .path(header.getOriginalFilename())
//                    .toUriString();
//            user.setHeader(fileDownloadUri);
//            user.setName(new String(user.getName().getBytes(StandardCharsets.ISO_8859_1),StandardCharsets.UTF_8));
//            userService.register(user);

            if(resume == null){
                resume = new Resume();
            }
            if(ObjectUtils.isEmpty(resume.getName())){
                resume.setName(header.getOriginalFilename());
            }
            resume.setFile(filePath + header.getOriginalFilename());
            resume.setUserInfo(UserUtils.getUser());
            resume.setUser(UserUtils.getUser().getId());
            if(resume.getId() == null){
                service.save(resume);
            }else{
                service.update(resume);
            }
            return new Result<Resume>(200,"",resume);
        } catch (Exception e) {
            e.printStackTrace();
            return new Result<Resume>(500,e.getMessage(),null);
        }
    }
}

1.3. vo定义实现

1. Result

package com.junjunjun.aiwork.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import lombok.experimental.Accessors;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
@ToString
public class Result<T> extends  BaseVo{
    private  int code;
    private String msg;
    private T data;
}

2. BaseVo

package com.junjunjun.aiwork.vo;

import com.junjunjun.aiwork.entity.BaseEntity;

import java.io.Serializable;

/**
 * vo的基础类
 */
public abstract class BaseVo extends BaseEntity implements Serializable {
}

3. PageInfo

package com.junjunjun.aiwork.vo;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.junjunjun.aiwork.entity.BaseEntity;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import lombok.experimental.Accessors;

/**
 * 搜索参数
 * @param <T>
 */

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
@ToString
public class PageInfo<T extends BaseEntity> extends BaseVo{
    @NotNull(message = "分页信息不能为空")
    private Page<T> page;
    private T t;
}

1.4. resource定义实现

1. application.properties

spring.application.name=aiwork

server.servlet.context-path=/
server.port=80

spring.web.cors.allowed-methods=GET, POST
#静态资源
spring.mvc.static-path-pattern=/resources/**
spring.web.resources.static-locations=classpath:/static/

#文件上传接口
spring.servlet.multipart.max-file-size=1MB
spring.servlet.multipart.max-request-size=1MB

#JWT的加密秘钥配置
jwt.private.key: classpath:app.key
jwt.public.key: classpath:app.pub

#kimi秘钥：sk-43hnRt0tv3TdvbyT8F82IqmQa5mc9RwkULIfGZwsxktRchmd
#adk.ai.kimi.apikey=sk-43hnRt0tv3TdvbyT8F82IqmQa5mc9RwkULIfGZwsxktRchmd

#数据库相关配置
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/ai_work
spring.datasource.username=root
spring.datasource.password=kxy132469

# HikariCP数据库连接池的配置
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.idle-timeout=300000
spring.datasource.hikari.max-lifetime=1800000

# MyBatis 相关配置
mybatis-plus.configuration.map-underscore-to-camel-case=true
# id类型
mybatis-plus.configuration.db-config.id-type=auto
#MyBatis Mapper
mybatis-plus.mapper-locations = classpath:mapper/**.xml
#MyBatis Mapper 映射文件路径
mybatis-plus.type-aliases-package=com.junjunjun.aiwork.entity
#  实体的基础类
mybatis-plus.type-aliases-super-type= com.junjunjun.aiwork.entity.BaseEntity

# 逻辑删除的字段
mybatis-plus.global-config.db-config.logic-delete-field= deleted
# 已删除
mybatis-plus.global-config.db-config.logic-delete-value= 1
# 未删除
mybatis-plus.global-config.db-config.logic-not-delete-value= 0

#日志打印相关配置
logging.level.root= INFO
logging.level.org.springframework.web= INFO
logging.level.org.springframework.security= INFO

#热部署排除的路径
spring.devtools.restart.exclude=static/**,public/**

2. roleMap.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.junjunjun.aiwork.dao.system.RoleDao">
    <resultMap id="roleResultMap" type="Role">
        <id property="id" column="id" />
        <result property="name" column="name"/>
        <result property="permission" column="permission"/>
        <collection property="menus" javaType="ArrayList" column="id" select="com.junjunjun.aiwork.dao.system.MenuDao.selectAllByRoleId"/>
    </resultMap>

</mapper>

3. userMap.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.junjunjun.aiwork.dao.user.UserDao">
    <resultMap id="userResultMap" type="User">
        <id property="id" column="id" />
        <result property="name" column="name"/>
        <result property="account" column="account"/>
        <result property="header" column="header"/>
        <result property="sex" column="sex"/>
        <result property="phone" column="phone"/>
        <result property="password" column="password"/>
        <result property="openid" column="openid"/>
        <collection property="roles" javaType="ArrayList" column="id" select="com.junjunjun.aiwork.dao.system.RoleDao.selectAllByUserId"/>
    </resultMap>
</mapper>