手把手教你基于SpringBoot+MyBatis实现员工管理系统‍附完整源码

Posted 2021-09-18 灰小猿

一、写在前面

Hello，你好呀，我是灰小猿，一个超会写BUG的程序猿🙊！

近期在学习springboot框架相关的内容，相比于SSM，SpringBoot最大的特点就是集成了Spring和SpringMVC，让之前繁琐的配置工作变得更加简洁，同时对于业务逻辑层的处理也更加的友好，

所以今天就使用SpringBoot整合MyBatis来做一个完整的员工管理系统。实现登录验证、国家化、CRUD等操作。带大家熟悉一下SpringBoot的操作流程，以及整合MyBatis的具体步骤。整个项目你将会学到SpringBoot框架、mybatis框架、BootStrap框架、thymleaf、Lombok插件等技术！

小伙伴们一键三连➕关注！灰小猿带你上高速啦🎉🎉🎉！

先看一个效果视频：

基于springboot+mybatis的员工管理系统

使用springboot+mybatis进行项目开发，我简单的给大家划分了几个步骤。平常的开发我们只需要按照这个过程进行就可以了。

SpringBoot整合Mybatis基本步骤

1. 搭建springboot环境
2. 进行配置处理
   1. 在pom.xml中引入所需依赖
   2. 配置application
3. 进行前端页面布局
4. 引入数据源
5. 配置mybatis操作

二、进行项目配置

（1）引入pom.xml配置

虽然springboot大大的简化的配置的过程，但是不代表所有的配置都可以由springboot自动完成，所以，当我们需要使用其他相关依赖的时候（如thymleaf、lombok），同样需要在pom.xml中引入相应的配置依赖。

在这个项目中我们需要引入的依赖有

Mybatis依赖

        <!--mybatis依赖-->
        <!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>

数据库驱动

        <!--数据库驱动-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.37</version>
            <scope>runtime</scope>
        </dependency>

LomBok依赖

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

Thymleaf依赖

        <!--thymleaf 基于3.x开发-->
        <dependency>
            <groupId>org.thymeleaf</groupId>
            <artifactId>thymeleaf-spring5</artifactId>
        </dependency>
        <dependency>
            <groupId>org.thymeleaf.extras</groupId>
            <artifactId>thymeleaf-extras-java8time</artifactId>
        </dependency>

（2）、配置application

当我们在对项目进行操作的时候，一般需要引入或修改一些springboot的默认配置。方便我们的开发使用，springboot的配置文件可以是properties后缀，也可以是ymal后缀。我这里使用的properties后缀的配置文件。

在这个项目中我们需要引入数据源、并进行以下一些配置。

# 清除thymeleaf的缓存
spring.thymeleaf.cache=false

# 设置一个页面的访问路径
server.servlet.context-path=/gyg

# 告诉springboot国际化放置的位置
spring.messages.basename=i18n.login

# 配置日期格式，自定义日期格式转换器
spring.mvc.format.date=yyyy-MM-dd

# 配置数据源
spring.datasource.username=root
spring.datasource.password=ADMIN
#serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
spring.datasource.url=jdbc:mysql://localhost:3306/springboot_emps?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# 配置mybatis
mybatis.type-aliases-package=com.gyg.pojo
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml

配置完以上这两项之后就算是完成了项目开发的基本工作，其他详细的配置我们在项目中用到的时候接着说，接下来就是布局前端页面和实现数据处理的过程。

三、前端实现

因为整个项目是尽可能采用前后端分离的思想来做的，所以这里我就把前后端分开和大家讲解。首先来做前端部分，包括登录验证、页面布局、国际化、数据传值、注销操作等。

（1）、登录验证

一般的管理系统都是需要使用到登录以及验证操作的，验证用户的登录信息是否正确，判断用户有没有非法的翻越登录界面直接进入主页这些操作。

一般判断用户有没有在未登录的情况下页面的方法的是：在用户第一次登录成功时设置一个session并赋值，同时在请求主页的时候验证session是否存在，如果不存在，则说明用户并没有进行登录操作就直接的访问了主页，这样显然是违法的。

在这里补充一个关于session生命周期的知识点：

Sessinon在用户访问第一次访问服务器时创建，需要注意只有访问JSP、Servlet等程序时才会创建Session，只访问html、IMAGE等静态资源并不会创建Session，但可调用request.getSession(true)强制生成Session。服务器会把长时间没有活动的Session从服务器内存中清除，此时Session便失效。Tomcat中Session的默认失效时间为20分钟。同时还可以调用Session的invalidate方法将session清除。

在这里，用户点击登录时向控制器发送登录请求，判断用户输入的信息是否正确，如果正确就创建session，并重定向到主页；否则就重新回到登录页面。

代码如下：

    @RequestMapping("/user/login")
//    @ResponseBody //返回json字符串
    public String login(@RequestParam("username") String username, @RequestParam("password") String password,
                        Model model, HttpSession session) {
//        如果用户名不为空，且密码正确，就跳转页面
        if (!StringUtils.isEmpty(username) && "666666".equals(password)) {
            session.setAttribute("loginUser", username);
            return "redirect:/main.html";
        } else {
            model.addAttribute("msg", "用户名或密码输入错误！");
            return "index";
        }
     /*   model.addAttribute("username",username);
        model.addAttribute("password",password);*/

    }

（2）WebMvc配置文件

但是由于我们需要返回页面跳转，所以我们需要设置像springmvc中的视图解析器一样的东西，来告诉springboot，对于一般的返回，我们应该如何跳转。

在这里我们需要写一个专门的配置类，来实现这些配置操作，这些配置类都需要使用@Configuration标识，这样系统才会认为这是一个配置类；使用@Configuration标识的类就相当于SSM中的xml配置文件。

Mvc的配置类需要实现WebMvcConfigurer接口，并且根据需要重写接口中的一系列方法。视图解析器的定义方法是这样的：

    /**
     * 配置一个自定义的视图控制器
     *
     * @param registry
     */
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/").setViewName("index");
        registry.addViewController("/index.html").setViewName("index");
        registry.addViewController("/main.html").setViewName("dashboard");

    }

（3）页面布局实现

很多前端项目的布局都会使用到的一个框架bootstrap，这个框架提供了非常多的前端组件，我们可以直接导入相应的代码即可使用，像我们项目的页面中，按钮和表格布局，都是直接使用的bootstrap框架，想要了解如何使用的小伙伴们可以去它的官网查看【bootstrap官网】。然后对于想要快速搭建前端或者后台页面的小伙伴们还可以直接在网上搜索“bootstrap模版”即可。

 （4）国际化操作

实现国际化的操作一般对于大型的网站开发还是非常常见的，所以在这个项目中我也在登录页面做了一个国际化的操作。

Springboot实现国际化需要实现LocaleResolver接口，并实现其中方法，这是springboot规定的语言解析接口，

该类的具体实现是这样的：

package com.gyg.config;

import org.springframework.web.servlet.LocaleResolver;
import org.thymeleaf.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Locale;

/**
 * 国际化配置
 * @author 郭运刚
 */
public class MyLocaleResolver implements LocaleResolver {

    /**
     * 解析请求
     *
     * @param request
     * @return
     */
    @Override
    public Locale resolveLocale(HttpServletRequest request) {
//        获取请求中的语言参数链接
        String language = request.getParameter("l");
//        如果没有就使用默认的
        Locale locale = Locale.getDefault();
//        判断请求中获取到的语言参数链接是否为空，如果不为空，就使用请求的链接
        if (!StringUtils.isEmpty(language)) {
//            zh_CN
            String[] splits = language.split("_");
//            国家  地区
            locale =  new Locale(splits[0], splits[1]);

        }

        return locale;
    }

    @Override
    public void setLocale(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Locale locale) {

    }
}

之后通过mvc的配置类中重写addInterceptors方法，在其中添加实现语言解析的过滤器，addInterceptors方法的作用就是增加springboot访问的拦截器，里面的registry参数后面可以增加过滤器类或者增加需要过滤哪些内容，不需要过滤哪些内容。

如下面我们的方法中，增加了国际化过滤、过滤所有内容，同时还对于css、js、img等内容不过滤。

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginHandlerInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/index.html","/","/user/login","/css/**","/js/**","/img/**");

    }

以上设置完成之后，我们需要在target/classes下建立文件夹i18n,在其中建立三个国际化的配置文件夹，分别是默认语言、汉语、英语，

（5）注销登录

注销登录的操作实现其实还是比较简单的，我们上面也提到了，验证用户是否正常登录的操作是判断是否存在session，那么在进行注销登录的时候，我们只需要将session使用invalidate()方法清除掉即可，同时返回到登录页面。

    /**
     * 页面注销
     * @param session
     * @return
     */
    @RequestMapping("/user/logout")
    public String logout(HttpSession session){
//        使当前session作废
        session.invalidate();
        return "redirect:/index.html";
    }

直到这里，前端页面的一些核心操作才算是基本完成了，📢📢📢中间还有很多页面的代码我没有放出来，完整源码我整理好了，小伙伴们可以下载：【完整源码】

三、后台实现

员工信息管理项目的后台实现主要是采用mybatis框架，使用mybatis框架实现的数据库操作更加的简单明了，数据层和业务逻辑层处理也更加简单，

（1）数据源

我们的数据表结构如

同时我们需要将数据源导入到项目中，方法是直接在application中写入username、password、URL、ClassDriver这些参数就好。

# 配置数据源
spring.datasource.username=root
spring.datasource.password=ADMIN
#serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
spring.datasource.url=jdbc:mysql://localhost:3306/springboot_emps?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

（2）利用LomBok简化bean

Lombok 是一种 Java 实用工具，可用来帮助开发人员消除 Java 的冗长，尤其是对于简单的 Java 对象（POJO）。它通过注释实现这一目的。所以为了简化代码，我们的bean使用lombok插件，其中常用的三个注解是:

• @Data  表示该类是数据，并且默认给该类的参数加上了get和set方法
• @AllArgsConstructor  有参构造
• @NoArgsConstructor  无参构造

使用lombok后的员工类是这样的，是不是简化了很多代码量！

package com.gyg.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

/**
 * 员工表
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private Integer id;
    private String lastName;
    private String email;
    private Integer gender;
    private Integer did;
    private Date birth;

    private Department department;
    
}

 （3）配置SQL

Mybatis的实现关键的几个文件也就是mapper、xml、serveice和controller，在mapper中定义好方法的接口，然后在xml中写入相应的sql语句，移交到service类进行数据处理，controller类直接调用service类，最后通过请求执行controller类即可，

我们在员工的mapper接口中定义了基本的增删改查方法，

package com.gyg.mapper;

import com.gyg.pojo.Employee;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * 定义员工的接口
 */
@Mapper
@Repository
public interface EmployeeMapper {

    List<Employee> queryAllEmp();

    Employee queryEmpById(int id);

    int addEmp(Employee employee);

    int updateEmp(Employee employee);

    int deleteEmpById(int id);

}

 在部门的mapper中定义了查找所有部门的方法。

package com.gyg.mapper;

import com.gyg.pojo.Department;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * 定义部门的接口
 */
@Mapper
@Repository
public interface DepartmentMapper {
    List<Department> queryAllDepart();
}

紧接着我们需要分别在对应的xml中写入执行该操作的sql语句，由于我们需要显示员工和员工的部门，所以我们需要使用连接查询，查询出员工和其对应的部门信息。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gyg.mapper.EmployeeMapper">

    <!--返回员工和对应的部门信息-->
    <resultMap id="withDepartResultMap" type="Employee">
        <id column="id" jdbcType="INTEGER" property="id"/>
        <result column="lastName" jdbcType="VARCHAR" property="lastName"/>
        <result column="email" jdbcType="VARCHAR" property="email"/>
        <result column="gender" jdbcType="INTEGER" property="gender"/>
        <result column="d_id" jdbcType="INTEGER" property="did"/>
        <result column="birth" jdbcType="DATE" property="birth"/>
        <association property="department" javaType="Department">
            <id column="d_id" jdbcType="INTEGER" property="id"/>
            <result column="departmentName" jdbcType="VARCHAR" property="departmentName"/>
        </association>
    </resultMap>

    <!--List<Employee> queryAllEmp();-->
    <select id="queryAllEmp" resultMap="withDepartResultMap">
        SELECT * FROM employee LEFT JOIN department ON employee.d_id=department.id
    </select>

    <!--Employee queryEmpById(int id);-->
    <select id="queryEmpById" resultMap="withDepartResultMap">
        SELECT * FROM employee LEFT JOIN department ON employee.d_id=department.id WHERE employee.id=#{id}
    </select>

    <!--int addEmp(Employee employee);-->
    <insert id="addEmp" parameterType="Employee">
        insert into employee (id,lastName,email,gender,d_id,birth) values (#{id},#{lastName},#{email},#{gender},#{did},#{birth});
    </insert>

    <!-- int updateEmp(Employee employee);-->
    <update id="updateEmp" parameterType="Employee">
        update employee set lastName = #{lastName},email=#{email},gender=#{gender},d_id=#{did},birth=#{birth} where id=#{id};
    </update>

    <!--int deleteEmpById(int id);-->
    <delete id="deleteEmpById" parameterType="int">
        delete from employee where id=#{id}
    </delete>

</mapper>

（4）业务逻辑层实现

业务逻辑层也就是service层，在这里我们可以直接根据mybatis的特性，将对应的mapper自动装配进去，然后直接调用接口的方法就可以实现执行sql语句的操作了，下面的员工类和部门类的service。

package com.gyg.service;

import com.gyg.mapper.EmployeeMapper;
import com.gyg.pojo.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 员工的业务逻辑层
 */
@Service
public class EmployeeService {

    @Autowired
    EmployeeMapper employeeMapper;

    /**
     * 获取到所有的员工信息
     * @return
     */
    public List<Employee> queryAllEmp(){
        return employeeMapper.queryAllEmp();
    };

    /**
     * 根据id查找指定员工
     * @param id
     * @return
     */
    public Employee queryEmpById(int id){
        return employeeMapper.queryEmpById(id);
    };

    /**
     * 添加员工
     * @param employee
     * @return
     */
    public int addEmp(Employee employee){
        return employeeMapper.addEmp(employee);
    };

    /**
     * 修改员工
     * @param employee
     * @return
     */
    public int updateEmp(Employee employee){
        return employeeMapper.updateEmp(employee);
    };

    /**
     * 根据ID删除员工
     * @param id
     * @return
     */
    public int deleteEmpById(int id){
        return employeeMapper.deleteEmpById(id);
    };
}

（5）控制器层

该层可以说是直接和前端界面进行连接的，在每一个方法上面都会标注相应的请求类型，直接将数据请求到对应的方法然后执行。

员工类的控制器层：

/**
 * 员工管理
 */
@Controller
public class EmployeeController {

    @Autowired
    EmployeeService employeeService;

    @Autowired
    DepartmentService departmentService;

    /**
     * 获取所有员工，并返回到显示页
     *
     * @param model
     * @return
     */
    @RequestMapping("/emps")
    public String queryAllEmp(Model model) {
        List<Employee> employees = employeeService.queryAllEmp();
        model.addAttribute("emps", employees);
        System.out.println(employees);
        return "emp/list";
    }

    /**
     * 跳转到添加员工页面
     *
     * @return
     */
    @GetMapping("/toAdd")
    public String toAddPage(Model model) {
        List<Department> departments = departmentService.queryAllDepart();
        System.out.println("查询结果:");
        System.out.println(departments);
        model.addAttribute("departments", departments);
        return "emp/add";
    }

    /**
     * 添加员工
     *
     * @return
     */
    @PostMapping("/emp")
    public String addEmployee(Employee employee) {
        System.out.println("save-------------  " + employee);
        Integer did = employee.getDepartment().getId();
        employee.setDid(did);

        //添加员工
        employeeService.addEmp(employee);

        //重定向到列表页面
        return "redirect:/emps";
    }

    /**
     * 去员工的修改页面
     *
     * @return
     */
    @GetMapping("/emp/{id}")
    public String toUpdateEmp(@PathVariable("id") Integer id, Model model) {
        //获取到该员工信息
        Employee employee = employeeService.queryEmpById(id);
        model.addAttribute("emp", employee);
        System.out.println("empID:" + employee);
        //获取到所有的部门信息
        Collection<Department> departments = departmentService.queryAllDepart();
        model.addAttribute("departments", departments);
        return "emp/update";
    }

    /**
     * 修改员工
     * @return
     */
    @PostMapping("updateEmp")
    public String updateEmp(Employee employee){
        Integer did = employee.getDepartment().getId();
        employee.setDid(did);
        employeeService.updateEmp(employee);
        System.out.println("修改数据：" + employee);
        return "redirect:/emps";
    }

    /**
     * 删除员工
     * @return
     */
    @RequestMapping("/delete/{id}")
    public String deleteEmp(@PathVariable("id") Integer id){
        employeeService.deleteEmpById(id);
        System.out.println("删除成功！" + id);
        return "redirect:/emps";
    }
}

以上就是这个项目的基本构造了！

四、写在最后

由于代码量比较多，所以上面只是贴了一些核心的代码，🔊🔊🔊完整的源码小伙伴们可以在这里下载【完整源码】记得⭐star⭐哟！，

项目中用到的知识点也非常多，小伙伴们在学校的过程中有清楚的，可以在评论区留言或者加我交流。

小伙伴们一键三连➕关注！灰小猿带你上高速啦！🎉🎉🎉

我是灰小猿，我们下期见！