案例01-tlias智能学习辅助系统01-增删改查+参数传递

糊糊熊猫

已于 2023-04-24 17:00:14 修改

阅读量6k

点赞数 20

分类专栏： SpringBoot入门 JavaWeb Mybatis 文章标签：学习 mybatis java

于 2023-04-24 14:27:20 首次发布

本文链接：https://blog.csdn.net/m0_63757196/article/details/130258721

版权

JavaWeb 同时被 3 个专栏收录

9 篇文章 0 订阅

订阅专栏

Mybatis

8 篇文章 0 订阅

订阅专栏

SpringBoot入门

7 篇文章 1 订阅

订阅专栏

1、需求说明：实现对部门表和员工表的增删改查

4.2 分页查询插件-PageHelper

4.3 分页查询（带条件）

4.4 删除员工

4.5 新增员工

该项目是在看完黑马2023年JavaWeb视频，跟着做的一个简单的SpringBoot项目

基于前后端分离模式进行开发，会遵循接口文档的开发规范

开发流程：

1、需求说明：实现对部门表和员工表的增删改查

2、环境搭建

1 准备数据库表（dept、emp）

在本地创建tlias数据库，并复制资料中的两张表

2 创建SpringBoot工程

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>tlias</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.7.RELEASE</version>
    </parent>


    <dependencies>
        <!--        mybatis的起步依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>
        <!--        mysql 驱动包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--        springboot单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>


</project>

启动类tliasquickstartapplication：

package pearl;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication//具有包扫描作用，默认扫描当前包及其子包，即demo01
public class tliasquickstartapplication {
    public static void main(String[] args) {
        
        SpringApplication.run(tliasquickstartapplication.class,args);
    }

}

测试类tliasquickstartapplicationTest：

package pearl;

import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest //springboot整合单元测试的注解
public class tliasquickstartapplicationTest {

}

application.properties配置文件

# 配置数据库的链接信息 -四要素
#驱动类名称
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#数据库连接的url
spring.datasource.url=jdbc:mysql://localhost:3306/tlias?serverTimezone=UTC
#连接数据库的用户名
spring.datasource.username=root
#连接数据库的密码
spring.datasource.password=

# 配置mybatis的日志，指定输出到控制台
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

# 开启mybatis的驼峰命名自动映射开关
mybatis.configuration.map-underscore-to-camel-case = true

创建实体类Emp、Dept

创建对应的Mapper（接口）、Service（接口、实现类）、Controller基础结构

3、部门管理

3.1 查询部门

EmpController: 首先返回一个空的数据测试端口号

@Slf4j //定义一个日志记录对象  等价于下面对log对象的定义1.
@RestController
public class DeptController {
//    1.定义一个日志记录对象
//    1.private static Logger log = LoggerFactory.getLogger(DeptController.class);

//    @RequestMapping(value = "/depts",method = RequestMethod.GET)//指定请求方式为get
    @GetMapping("/depts")// 指定`/depts`路由的请求方式为get 与上一行代码等价
    public Result list(){
        log.info("查询全部部门数据");
        return Result.success();
    }
}

然后运行启动类，在postman中测试：

没毛病，然后定义一个Service层对象，调用Service层方法查询数据

package pearl.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import pearl.pojo.Dept;
import pearl.pojo.Result;
import pearl.service.DeptService;

import java.util.List;

@Slf4j //定义一个日志记录对象  等价于下面对log对象的定义1.
@RestController
public class DeptController {
//    1.定义一个日志记录对象
//    1.private static Logger log = LoggerFactory.getLogger(DeptController.class);

    @Autowired//定义一个Service层对象
    private DeptService deptService;

//    @RequestMapping(value = "/depts",method = RequestMethod.GET)//指定请求方式为get
    @GetMapping("/depts")// 指定`/depts`路由的请求方式为get 与上一行代码等价
    public Result list(){
        log.info("查询全部部门数据");

//      调用service查询部门数据
        List<Dept> deptList = deptService.list();//此时service层中还没定义该方法，需要返回Service层中定义该方法

        return Result.success(deptList);
    }
}

此时DeptService中还没有查询全部数据的list()方法，所以现在去DeptService中定义list()接口

      /*
    * 查询全部部门数据
    * */
    List<Dept> list();

然后去 DeptService中定义list()的实现方法

即定义一个mapper层对象，调用mapper层方法查询数据

package pearl.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import pearl.mapper.DeptMapper;
import pearl.pojo.Dept;

import java.util.List;

@Service
public class DeptService implements pearl.service.DeptService {

//    定义一个Mapper层对象
    @Autowired
    private DeptMapper deptMapper;

    @Override
    public List<Dept> list() {

         List<Dept> deptList = deptMapper.list();//此时service层中还没定义该方法，需要返回Service层中定义该方法
        return deptList;
    }
}

此时mapper层中没有list()方法，需要我们现在去DeptMapper中定义list()接口

   /*
    * 查询全部部门数据
    * */
    @Select("select * from dept")
    List<Dept> list();

由于该SQL语句较简单，所以直接使用注解方式配置

现在需要按mapper-->service--->controller的路径去查看返回数据是否正确

然后运行启动类，查看查询结果

完成！

3.2 前后端联调

前后端联调：将前端工程、后端工程都启动起来，然后访问前端工程，通过前端工程访问服务程序，进而进行调试

1.将资料中提供的“前端工程”文件中的压缩包，拷贝到一个没有中文不带空格的目录下，解压

2.启动nginx，访问测试：http://localhost:90 --ngix占用的是90端口

点击文件中的nginx.exe

然后通过任务管理器的详细信息查看nginx是否启动完成

然后在浏览器访问http://localhost:90：进入前端页面

3.3 删除部门

EmpController：编写删除函数，调用Service删除接口

//    删除
    @DeleteMapping("/depts/{id}")
    public Result delete(@PathVariable Integer id){ //@PathVariable 表示绑定路径中的参数id
        log.info("删除id为"+id+"的数据");
        deptService.delete(id);
        return Result.success();
    }

@PathVariable

可以将 URL 中占位符参数绑定到控制器处理方法的入参中：

URL 中的 {xxx} 占位符可以通过@PathVariable(“xxx“) 绑定到操作方法的入参中

EmpService接口：

    /*
    * 根据ID删除数据
    * */
    void delete(Integer id);

EmpService实现类：编写删除函数，调用mapper 层删除接口

    @Override
    public void delete(Integer id){
        deptMapper.delete(id);
        return ;
    }

EmpMapper: 编写删除接口，与SQL语句

    @Delete("delete from dept where id = #{id}")
    void delete(Integer id);

启动测试类，在postman中测试接口：

完成！

3.4 新增部门

新增部门逻辑与前面相似

注意：新增部门时，使用@RequestBody 将请求参数封装到实体类中，再在service层的实现方法类中补全实体类的属性值，在执行插入到数据库的操作

EmpController:

//    新增部门
    @PostMapping("/depts")
    public Result insert(@RequestBody Dept dept){//@RequestBody 将获取到的请求参数封装到实体类dept中
        log.info("新增部门"+dept);
        deptService.insert(dept);
        return Result.success();
    }

EmpService接口：

    /*
     * 新增数据
     * */
    void insert(Dept dept);

EmpService实现类：

    @Override
    public void insert(Dept dept) {
        dept.setCreateTime(LocalDateTime.now());//补全dept中的属性
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.insert(dept);
    }

EmpMapper：

    @Insert("insert into dept (name,create_time,update_time) values(#{name},#{createTime},#{updateTime})")
    void insert(Dept dept);

运行完成！

3.5 根据ID查询数据

EmpController:

    /*
     * 根据ID查询
     * */
    @GetMapping("/depts/{id}")
    public Result selectById(@PathVariable Integer id){
        log.info("获取id为"+id+"的数据");
        Dept dept = deptService.selectById(id);
        return Result.success(dept);
    }

注意：这里路径中携带参数，一定要使用@PathVariable注解，绑定路径中的参数

EmpService接口：

    /*
     * 根据ID查询数据
     * */
    Dept selectById(Integer id);

EmpService实现类：

    @Override
    public Dept selectById(Integer id){
        Dept dept = deptMapper.selectById(id);
        return dept;
    }

EmpMapper ：

    @Select("select * from dept where id = #{id}")
    Dept selectById(Integer id);

3.5 修改部门

EmpController:

    /*
    * 修改部门
    * */
    @PutMapping("/depts")
    public Result update(@RequestBody Dept dept){
        log.info("修改部门"+dept);
        deptService.update(dept);
        return Result.success();
    }

EmpService接口：

    /*
    * 修改部门
    * */
    void update(Dept dept);

EmpService实现类：

    @Override
    public void update(Dept dept){
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.update(dept);
    }

EmpMapper：

    @Update("update dept set name = #{name}, update_time = #{updateTime} where id = #{id}")
    void update(Dept dept);

完成！

编辑之前：

点击编辑：

这里会自动回显，利用的是通过ID查询数据功能

编辑完成后：

此时部门管理的操作已经完成了，返回来看我们DeptController文件中还可以优化；

优化前：

package pearl.controller;

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.annotations.Insert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import pearl.pojo.Dept;
import pearl.pojo.Result;
import pearl.service.DeptService;

import java.util.List;

@Slf4j //定义一个日志记录对象  等价于下面对log对象的定义1.
@RestController
public class DeptController {
//    1.定义一个日志记录对象
//    1.private static Logger log = LoggerFactory.getLogger(DeptController.class);

    @Autowired//定义一个Service层对象
    private DeptService deptService;

    /*
    * 查询
    * */
//    @RequestMapping(value = "/depts",method = RequestMethod.GET)//指定请求方式为get
    @GetMapping("/depts")// 指定`/depts`路由的请求方式为get 与上一行代码等价
    public Result list(){
        log.info("查询全部部门数据");

//      调用service查询部门数据
        List<Dept> deptList = deptService.list();//此时service层中还没定义该方法，需要返回Service层中定义该方法

        return Result.success(deptList);
    }
    /*
     * 根据ID查询
     * */
    @GetMapping("/depts/{id}")
    public Result selectById(@PathVariable Integer id){
        log.info("获取id为"+id+"的数据");
        Dept dept = deptService.selectById(id);
        return Result.success(dept);
    }

    /*
     * 删除
     * */
    @DeleteMapping("/depts/{id}")
    public Result delete(@PathVariable Integer id){ //@PathVariable 表示绑定路径中的参数id
        log.info("删除id为"+id+"的数据");
        deptService.delete(id);
        return Result.success();
    }

    /*
     * 新增部门
     * */
    @PostMapping("/depts")
    public Result insert(@RequestBody Dept dept){//@RequestBody 将获取到的请求参数封装到实体类dept中
        log.info("新增部门"+dept);
        deptService.insert(dept);
        return Result.success();
    }

    /*
    * 修改部门
    * */
    @PutMapping("/depts")
    public Result update(@RequestBody Dept dept){
        log.info("修改部门"+dept);
        deptService.update(dept);
        return Result.success();
    }




}

由于该文件下的路径都是在`/depts`路径下，所以就把这部分抽出类，简化代码

完整的请求路径为：类上@RequestMappering的路径+方法前的路径

简化后的代码如下

优化后：

package pearl.controller;

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.annotations.Insert;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import pearl.pojo.Dept;
import pearl.pojo.Result;
import pearl.service.DeptService;

import java.util.List;

@Slf4j
@RequestMapping("/depts")
@RestController
public class DeptController {

    @Autowired//定义一个Service层对象
    private DeptService deptService;

    /*
    * 查询
    * */
    @GetMapping// 指定`/depts`路由的请求方式为get 与上一行代码等价
    public Result list(){
        log.info("查询全部部门数据");

//      调用service查询部门数据
        List<Dept> deptList = deptService.list();//此时service层中还没定义该方法，需要返回Service层中定义该方法

        return Result.success(deptList);
    }

    /*
     * 删除
     * */
    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id){ //@PathVariable 表示绑定路径中的参数id
        log.info("删除id为"+id+"的数据");
        deptService.delete(id);
        return Result.success();
    }

    /*
     * 新增部门
     * */
    @PostMapping
    public Result insert(@RequestBody Dept dept){//@RequestBody 将获取到的请求参数封装到实体类dept中
        log.info("新增部门"+dept);
        deptService.insert(dept);
        return Result.success();
    }

}

总结（Controller层参数接收）：

参数格式：路径参数

使用 @PathVariable 表示绑定路径中的参数id
eg1: @DeleteMapping("/{id}")
     public Result delete(@PathVariable Integer id)

参数格式：application/json

使用：@RequestBody 将获取到的请求参数封装到实体类中
eg: 请求参数是Dept类的部分属性值
    @PostMapping
    public Result insert(@RequestBody Dept dept)

参数格式：queryString

@RequestParam(defaultValue = "1")  设置默认值
下面的参数名称和类型一定要和文档中的保持一致，否则传输不了数据
eg: public Result selectByPage(@RequestParam(defaultValue = "1") Integer page,  
                           @RequestParam(defaultValue = "5") Integer pageSize)

4、员工管理

4.1 分页查询

分页查询语法：

-- 参数1 b: 起始索引 = （页码-1）* l

-- 参数2 l: 查询返回记录数 = 每页展示的记录数

select * from emp limit b,l;

首先查看接口文档，发现需要返回的数据类型是Json文件，包含总记录数和数据列表，

我们最好的选择就是把记录数和数据列表封装成一个实体类，然后再返回给前端

PageBean:

package pearl.pojo;


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

import java.util.List;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class PageBean {
    private Long total;//总记录数
    private List rows;//数据列表
}

EmpController: //接收前端的请求参数，并返回Result型数据

package pearl.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import pearl.pojo.PageBean;
import pearl.pojo.Result;
import pearl.service.EmpService;

@RestController
@Slf4j
public class EmpController {
    @Autowired
    private EmpService empService;

    /*
    * 分页查询
    * */
    @GetMapping("/emps")       //@RequestParam(defaultValue = "1") 设置默认值
    public Result selectByPage(@RequestParam(defaultValue = "1") Integer page,  //注意这里的参数名称一定要和文档中的保持一致，否则肯传输不了数据
                               @RequestParam(defaultValue = "5") Integer pageSize){
        log.info("查询数据：第{}页，{}条数据",page,pageSize);
        PageBean pageBean = empService.selectByPage(page,pageSize);
        return Result.success(pageBean);
    }
}

EmpService接口：

     /*
    * 分页查询
    * */
    PageBean selectByPage(Integer page, Integer pageSize);

EmpService实现类：

    @Autowired
    private EmpMapper empMapper;

    /*
    * 分页查询
    * */
    @Override
    public PageBean selectByPage(Integer page, Integer pageSize) {

        List<Emp> rows = empMapper.selectByPage((page-1)*pageSize,pageSize);
        Long total = empMapper.count();
        final PageBean pageBean = new PageBean(total,rows);

        return pageBean;
    }

EmpMapper:

    /*
    * 分页查询，获取列表数据
    * */
    @Select("select * from emp limit #{page},#{pageSize}")
    List<Emp> selectByPage(Integer page, Integer pageSize);

    /*
    * 查询记录数
    * */
    @Select("select count(*) from emp")
    Long count();

完成！

4.2 分页查询插件-PageHelper

使用PageHelper插件实现分页查询功能

pom文件中导入依赖

<!--     pagehelper分页插件依赖   -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.4.0</version>
        </dependency>

EmpController 与EmpService接口代码不变

EmpService实现类：

    @Override
    public PageBean selectByPage(Integer page, Integer pageSize) {
//        1. 设置分页参数
        PageHelper.startPage(page,pageSize);
//        2. 执行查询
        List<Emp> empList = empMapper.list();
        Page<Emp> p = (Page<Emp>) empList;
//        3. 封装成bean对象
        PageBean pageBean = new PageBean(p.getTotal(),p.getResult());
        return pageBean;
    }

EmpMapper:

    /*
    * 分页查询-使用PageHelper插件
    * */
    @Select("select * from emp")
    public List<Emp> list();

完成！

4.3 分页查询（带条件）

条件如上所示：我们需要更改EmpController中的参数

EmpController：

    @GetMapping("/emps")       //@RequestParam(defaultValue = "1") 设置默认值
    public Result selectByPage(@RequestParam(defaultValue = "1") Integer page,  //注意这里的参数名称一定要和文档中的保持一致，否则肯传输不了数据
                               @RequestParam(defaultValue = "5") Integer pageSize,
                               String name, Short gender,
                               @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate begin,//@DateTimeFormat指定日期格式
                               @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate end){
        log.info("查询数据：第{}页，{}条数据,{},{},{},{}",page,pageSize,name,gender,begin,end);
        PageBean pageBean = empService.selectByPage(page,pageSize,name,gender,begin,end);
        return Result.success(pageBean);
    }

EmpService接口：也需要增加参数

    /*
    * 分页查询-带条件
    * */
    PageBean selectByPage(Integer page, Integer pageSize, String name, Short gender,
                          LocalDate begin, LocalDate end);

EmpService实现类：参数

    @Override
    public PageBean selectByPage(Integer page, Integer pageSize, String name, Short gender,
                                 LocalDate begin, LocalDate end) {
//        1. 设置分页参数
        PageHelper.startPage(page,pageSize);
//        2. 执行查询
        List<Emp> empList = empMapper.list(name,gender,begin,end);
        Page<Emp> p = (Page<Emp>) empList;
//        3. 封装成bean对象
        PageBean pageBean = new PageBean(p.getTotal(),p.getResult());
        return pageBean;
    }

EmpMapper接口：

    public List<Emp> list(String name, Short gender,LocalDate begin, LocalDate end);

由于条件参数非必须传递，所以使用动态SQL，配置在XML文件中

EmpMapper.xml

<?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="pearl.mapper.EmpMapper">
    <select id="list" resultType="pearl.pojo.Emp">
        select * from emp
        <where>
            <if test="name != null and name != ''">
                name like concat('%', #{name},'%')
            </if>
            <if test="gender != null">
                and gender = #{gender}
            </if>
            <if test="begin != null and end != null">
                and entrydate between #{begin} and #{end}
            </if>
        </where>
    </select>
</mapper>

完成!

4.4 删除员工

具体代码如下，不做过多描述

4.5 新增员工

具体代码如下，不做过多描述

糊糊熊猫

关注

20
点赞
踩
77

收藏

觉得还不错? 一键收藏
5
评论
案例01-tlias智能学习辅助系统01-增删改查+参数传递

参数格式：路径参数使用 @PathVariable 表示绑定路径中的参数id参数格式：application/json使用：@RequestBody 将获取到的请求参数封装到实体类中eg: 请求参数是Dept类的部分属性值参数格式：queryString@RequestParam(defaultValue = "1") 设置默认值下面的参数名称和类型一定要和文档中的保持一致，否则传输不了数据。
复制链接

扫一扫