从0开始学springboot 项目后端实战开发与员工管理有关的内容，新增员工，分页查询，修改员工信息和查询员工信息

悦悦小仙女

已于 2024-07-08 10:44:50 修改

阅读量979

点赞数 23

分类专栏：以实战项目为线索从0开始学springboot 由浅入深文章标签： spring boot 后端 java

于 2024-07-08 10:44:35 首次发布

本文链接：https://blog.csdn.net/m0_73759273/article/details/140204075

版权

以实战项目为线索从0开始学springboot 由浅入深专栏收录该内容

5 篇文章 0 订阅

订阅专栏

后面的笔记我更多是写我自己不会的部分和重点，大部分会直接附上代码，但是这个项目写完以后，我会把完整代码的放到github并出一篇讲解如何运行该项目，有需要的可以等一下，最迟这周应该会把该项目写完并调试到可运行状态。

新增员工：（也是直接写controller层）

通过HTTP POST请求接收一个Employee对象，设置初始密码和时间戳，获取当前登录用户的ID，设置创建和更新用户，然后将员工信息保存到数据库，并返回一个成功的响应消息

@PostMapping: 指定这个方法处理HTTP POST请求。
public R<String> save(...): 方法返回类型是R<String>，表示返回一个包含字符串信息的响应对象。
HttpServletRequest request: 用于获取当前HTTP请求的对象。
@RequestBody Employee employee: 将请求体中的JSON数据转换为Employee对象。
DigestUtils.md5DigestAsHex("123456".getBytes()): 将初始密码123456进行MD5加密。
employee.setCreateTime(LocalDateTime.now()): 设置创建时间为当前时间。
employee.setUpdateTime(LocalDateTime.now()): 设置更新时间为当前时间。
从当前HTTP会话中获取登录用户的Employee对象，并提取其ID。
设置创建用户和更新用户的ID为当前登录用户的ID。
调用employeeService.save(employee)方法将员工信息保存到数据库。
返回一个成功的响应对象，包含消息"新增员工成功"。

  /**
     * 新增员工
     * @param employee
     * @return
     */
    @PostMapping
    public  R<String>sava(HttpServletRequest request,@RequestBody Employee employee) {
        log.info("新增员工，员工信息：{}", employee.toString());
        /**
         * 设置初始密码123456，需要进行md5加密
         */
        employee.setPassword(DigestUtils.md5DigestAsHex("123456".getBytes()));
        employee.setCreateTime(LocalDateTime.now());
        employee.setUpdateTime(LocalDateTime.now());
        /**
         * 获得当前登陆用户的id
         */
         Long empId = ((Employee) request.getSession().getAttribute("employee")).getId();

        employee.setCreateUser(empId);
        employee.setUpdateUser(empId);

        employeeService.save(employee);
        return R.success("新增员工成功");

    }

添加全局异常捕获：

因为在新增员工信息的时候，如果增加的员工账号已存在，就会抛出异常
在common中创建一个类名为GlobalExceptionHandler

处理Spring Boot应用中的SQL完整性约束违规异常。

if (ex.getMessage().contains("Duplicate entry")): 检查异常信息是否包含"Duplicate entry"（重复条目），这是MySQL中常见的错误信息。
String[] split = ex.getMessage().split(":"): 使用冒号分割异常信息字符串。
String msg = split[2] + "已存在": 提取重复条目的具体信息，并拼接成用户友好的错误消息。
return R.error(msg): 返回包含错误信息的响应对象。
return R.error("未知错误"): 如果不包含"Duplicate entry"，返回一个通用的错误信息。

代码为：

package com.cyx.reggie.common;

 
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.sql.SQLIntegrityConstraintViolationException;

/**
 * 全局异常处理
 */
@ControllerAdvice(annotations =  {RestController.class, Controller.class})
@ResponseBody
@Slf4j
public class GlobalExceptionHandler {
    /**
     * 异常处理方法
     * @param ex
     * @return
     * 在Java中，String.split() 方法用于根据匹配给定的正则表达式来拆分此字符串。
     * 这是一个非常强大的方法，可以灵活地根据不同的分隔符来分割字符串，不仅仅限于固定的字符。
     */
    @ExceptionHandler(SQLIntegrityConstraintViolationException.class)
    public  R<String> exceptionHandler(SQLIntegrityConstraintViolationException ex){
        log.error(ex.getMessage());
        if(ex.getMessage().contains("Duplicate entry")){
            String[] split = ex.getMessage().split(":");
            String msg = split[2]+"已存在";
           return R.error(msg);
        }
        return R.error("未知错误");

    }
}

员工信息分页查询：

系统中员工很多，一个页面展示出来就比较乱，不便于查看，所以一般用分页的方式来展示列表数据。

代码开发：

程序执行过程：

1.页面发送请求，要考虑是什么样的请求，请求地址是什么样子的，请求方式什么样子，提交什么样的参数，这是第一步，具体到分页查询就是：页面发送ajax请求，将分页查询参数（page，pagesize,name）提交到服务端

2.服务端controller接收页面提交的数据并调用service查询数据

3.service调用mapper操作数据库，查询分页数据

4.controller将查询到的分页数据响应给页面

5.页面接受到分页数据并通过ElementUI的Table组件展示到页面上979

这是前后端交互项目，所以还需要看前端需要获取的数据是什么，这里需要去看前端的list.html文件和request.js，这里我还需要再理清一下

先配置分页插件mybatis

在config中添加类名为MybatisPlusConfig

代码为：

package com.cyx.reggie.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

 

/**
 * 配置MP的分页插件
 */
@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

分页查询的controller代码：

这个方法通过HTTP GET请求接收分页参数和过滤条件，构造分页查询和条件查询的构造器，执行分页查询，并返回包含分页结果的响应对象。

  /**
     * 员工信息分页查询
     * @param page
     * @param pageSize
     * @param name
     * @return
     */
    @GetMapping("/page")
    public R<Page> page(int page,int pageSize,String name ) {
        log.info("page={},pageSize={}，name={}", page, pageSize, name);
        /**
         * 构造分页查询构造器
         */
        Page pageInfo = new Page(page, pageSize);
        /**
         * 构造条件构造器条件
         * 添加过滤条件
         * 添加排序
         */
        LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.like(StringUtils.isNotEmpty(name), Employee::getName, name);
        queryWrapper.orderByDesc(Employee::getUpdateTime);
        /**
         * 执行查询
         */
        employeeService.page(pageInfo, queryWrapper);
        return R.success(pageInfo);

    }

启用禁用员工账号：

员工管理列表可以对某个用户账号进行启用和禁用操作

如果某个员工账号为正常，则按钮显示为禁用，如果员工状态为已禁用，则按钮显示为启用

普通员工登陆系统后，启用禁用不显示，权限区分

是否显示按钮其实是前端页面定义的，只有管理员可以看见按钮：

代码开发：1.页面发送ajax ,将参数（id，status）提交到服务器

2.服务器controller接收页面提交的数据并调用service更新数据

3.service调用mapper操作数据库

本质上是更新数据库中status状态字段进行操作，在controller中创建update方法，此方法是一个通用的修改员工信息的方法

  /**
     * 根据id修改员工信息
     * 这个代码写起来是非常简单的，为什么简单是因为我们调用的函数都是mybatis已经封装好的
     * @param request
     * @param employee
     * @return
     */
    @PutMapping
    public R<String> update(HttpServletRequest request,@RequestBody Employee employee) {
        log.info(employee.toString());

        Long empId = ((Employee)request.getSession().getAttribute("employee")).getId();
        employee.setUpdateTime(LocalDateTime.now());
        employee.setUpdateUser(empId);
        employeeService.updateById(employee);
        return R.success("员工信息修改成功");

    }

    /**
     * 根据id查询员工信息
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public R<Employee> get(@PathVariable Long id){
        log.info("根据id查询信息.......");
        Employee employee = employeeService.getById(id);
        if(employee!=null){
            return R.success(employee);
        }
        return null;
    }
}

直接按上述写好以后，会发现禁用状态并没有被更改，为什么嘞就是因为，禁用按钮发送id的时候，

扩展消息转换器，以字符串传输，因为js最多只能传16位，多了它会四舍五入

所以为了解决这个问题，再添加一个类：

这个类不用自己写，直接用就行了

package com.cyx.reggie.common;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import java.math.BigInteger;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import static com.fasterxml.jackson.databind.DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES;

/**
 * 对象映射器:基于jackson将Java对象转为json，或者将json转为Java对象
 * 将JSON解析为Java对象的过程称为 [从JSON反序列化Java对象]
 * 从Java对象生成JSON的过程称为 [序列化Java对象到JSON]
 */
public class JacksonObjectMapper extends ObjectMapper {

    public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
    public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

    public JacksonObjectMapper() {
        super();
        //收到未知属性时不报异常
        this.configure(FAIL_ON_UNKNOWN_PROPERTIES, false);

        //反序列化时，属性不存在的兼容处理
        this.getDeserializationConfig().withoutFeatures(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);


        SimpleModule simpleModule = new SimpleModule()
                .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)))

                .addSerializer(BigInteger.class, ToStringSerializer.instance)
                .addSerializer(Long.class, ToStringSerializer.instance)//序列化器
                .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)))
                .addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)))
                .addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));

        //注册功能模块 例如，可以添加自定义序列化器和反序列化器
        this.registerModule(simpleModule);
    }
}

编辑员工信息：需求分析，代码开发，功能测试

由于之前已经写了修改员工信息，所以这里只需要写查询实现在修改页面进行回显


    /**
     * 根据id查询员工信息
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public R<Employee> get(@PathVariable Long id){
        log.info("根据id查询信息.......");
        Employee employee = employeeService.getById(id);
        if(employee!=null){
            return R.success(employee);
        }
        return null;
    }
}

和之前所有代码加起来完整代码为：（包括员工管理的所有代码）

后面应该不会写这种笔记了，会更多的写思路和报错解决，然后这周内会写完该项目放到github便于你们在自己环境下运行。

package com.cyx.reggie.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.cyx.reggie.common.R;
import com.cyx.reggie.entity.Employee;
import com.cyx.reggie.service.EmployeeService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.DigestUtils;

import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;

 
 
@Slf4j
@RestController
@RequestMapping("/employee")
public class EmployeeController{
    @Autowired
    private EmployeeService  employeeService;

    /**
     * 员工登陆
     * @param request
     * @param employee
     * @return
     */
    @PostMapping("/login")
    public R<Employee> login(HttpServletRequest request, @RequestBody Employee employee){
        /**
         * 1.将页面提交的密码password进行md5加密
         */
        String password= employee.getPassword();
        password= DigestUtils.md5DigestAsHex(password.getBytes());

        /**
         * 2.根据页面提交的用户名username查询数据库
         */
        LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Employee::getUsername,employee.getUsername());
        Employee emp= employeeService.getOne(queryWrapper);

        /**
         * 3.如果没有查询到则返回登陆失败结果
         */
        if(emp==null){
            return R.error("登陆失败");
        }
        /**
         * 4，密码比对，如果不一致则返回登陆失败结果
         */
        if(!emp.getPassword().equals(password)){
            return R.error("登陆失败");
        }
        /**
         * 5.查看员工状态，如果为已禁用状态，则返回员工已禁用结果
         */
        if(emp.getStatus()==0){
            return R.error("账号已禁用");
        }
        /**
         * 6.登陆成功，将员工id存入Session并返回登陆成功结果
         */
        request.getSession().setAttribute("employee",emp);
        return R.success(emp);
    }

    /**
     * 员工退出功能
     * @param request
     * @return
     */
    @PostMapping("logout")
    public R<String> logout(HttpServletRequest request){
        /**
         * 清理Session中保存的当前登陆员工的ID
         */
        request.getSession().removeAttribute("employee");
        return  R.success("退出成功");
    }

    /**
     * 新增员工
     * @param employee
     * @return
     */
    @PostMapping
    public  R<String>sava(HttpServletRequest request,@RequestBody Employee employee) {
        log.info("新增员工，员工信息：{}", employee.toString());
        /**
         * 设置初始密码123456，需要进行md5加密
         */
        employee.setPassword(DigestUtils.md5DigestAsHex("123456".getBytes()));
        employee.setCreateTime(LocalDateTime.now());
        employee.setUpdateTime(LocalDateTime.now());
        /**
         * 获得当前登陆用户的id
         */
         Long empId = ((Employee) request.getSession().getAttribute("employee")).getId();

        employee.setCreateUser(empId);
        employee.setUpdateUser(empId);

        employeeService.save(employee);
        return R.success("新增员工成功");

    }

    /**
     * 员工信息分页查询
     * @param page
     * @param pageSize
     * @param name
     * @return
     */
    @GetMapping("/page")
    public R<Page> page(int page,int pageSize,String name ) {
        log.info("page={},pageSize={}，name={}", page, pageSize, name);
        /**
         * 构造分页查询构造器
         */
        Page pageInfo = new Page(page, pageSize);
        /**
         * 构造条件构造器条件
         * 添加过滤条件
         * 添加排序
         */
        LambdaQueryWrapper<Employee> queryWrapper = new LambdaQueryWrapper();
        queryWrapper.like(StringUtils.isNotEmpty(name), Employee::getName, name);
        queryWrapper.orderByDesc(Employee::getUpdateTime);
        /**
         * 执行查询
         */
        employeeService.page(pageInfo, queryWrapper);
        return R.success(pageInfo);

    }

    /**
     * 根据id修改员工信息
     * 这个代码写起来是非常简单的，为什么简单是因为我们调用的函数都是mybatis已经封装好的
     * @param request
     * @param employee
     * @return
     */
    @PutMapping
    public R<String> update(HttpServletRequest request,@RequestBody Employee employee) {
        log.info(employee.toString());

        Long empId = ((Employee)request.getSession().getAttribute("employee")).getId();
        employee.setUpdateTime(LocalDateTime.now());
        employee.setUpdateUser(empId);
        employeeService.updateById(employee);
        return R.success("员工信息修改成功");

    }

    /**
     * 根据id查询员工信息
     * @param id
     * @return
     */
    @GetMapping("/{id}")
    public R<Employee> get(@PathVariable Long id){
        log.info("根据id查询信息.......");
        Employee employee = employeeService.getById(id);
        if(employee!=null){
            return R.success(employee);
        }
        return null;
    }
}

悦悦小仙女

关注

23
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
从0开始学springboot 项目后端实战开发与员工管理有关的内容，新增员工，分页查询，修改员工信息和查询员工信息

后面的笔记我更多是写我自己不会的部分和重点，大部分会直接附上代码，但是这个项目写完以后，我会把完整代码的放到github并出一篇讲解如何运行该项目，有需要的可以等一下，最迟这周应该会把该项目写完并调试到可运行状态。
复制链接

扫一扫