SpringBoot整合Mybatis mysql数据库增添查改，分页操作实现_springboot结合myqsql进行数据库分页查询例子-CSDN博客

本文链接：https://blog.csdn.net/u013574207/article/details/119460532

无关风月，我题序等你回。

练习的一个小Demo，很适合新手练习
给需要的同学一点参考。
整体框架如下：
在这里插入图片描述
先写基础类
po:

package com.example.springboot.po;

public class User {
    private Integer id;
    private String userName;
    private String userPwd;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserPwd() {
        return userPwd;
    }

    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }
}

dao层
UserMapper接口：

package com.example.springboot.dao;

import com.example.springboot.po.User;
import com.example.springboot.query.UserQuery;

import java.util.List;

/**
 * lbs 2021/8/6
 */
public interface UserMapper {
    //通过用户名查询用户记录，返回用户对象
    public User queryUserByName(String userName);
    //通过用户ID查询用户对象，返回用户对象
    public User queryUserById(Integer userId);
    //添加用户,返回受影响的行数
    int addUser(User user);
    //修改用户信息
    int update(User user);
    //删除用户受影响的行数
    int deleteUser(Integer userId);

    //通过指定条件查询用户集合
    List<User> queryUserByParams(UserQuery userQuery);
}

UserMapper.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="com.example.springboot.dao.UserMapper">
    <select id="queryUserByName" parameterType="string" resultType="com.example.springboot.po.User">
     select * from tb_user where user_name = #{userName}

    </select>

    <select id="queryUserById"  parameterType="int" resultType="com.example.springboot.po.User">
     select * from tb_user where id = #{userId}
    </select>

    <insert id="addUser">
        insert into tb_user (user_name, user_pwd) values (#{userName}, #{userPwd})

    </insert>

    <update id="update">
        update tb_user set user_name = #{userName}, user_pwd= #{userPwd} where id =#{id}
    </update>

    <delete id="deleteUser">
        delete from tb_user where id = #{userId}
    </delete>

    <!--条件查询，返回集合-->
    <select id="queryUserByParams" parameterType="com.example.springboot.query.UserQuery" resultType="com.example.springboot.po.User">
        select * from  tb_user
    <where>
           <if test="null !=userName and '' != userName">
               and user_name like concat('%',#{userName},'%')
           </if>
    </where>
    </select>

</mapper>

服务层
UserService:

package com.example.springboot.service;

import com.example.springboot.dao.UserMapper;
import com.example.springboot.po.User;
import com.example.springboot.query.UserQuery;
import com.example.springboot.util.AssertUtil;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

@Service
public class UserService {

    @Resource
    private UserMapper userMapper;

    public User queryUserByName(String userName){

        return userMapper.queryUserByName(userName);
    }
    public User queryUserById(Integer userId){
        return userMapper.queryUserById(userId);
    }

    public void addUser(User user) {
      //判断是否为空
      //StringUtils.isBlank(str):判断str是否为空
      //判断用户名姓名非空
        AssertUtil.isTure(StringUtils.isBlank(user.getUserName()),"用户姓名不能为空！");
        //判断用户密码是否为空
        AssertUtil.isTure(StringUtils.isBlank(user.getUserPwd()),"用户密码不能为空");
        //通过用户名查询用户对象
        User temp = userMapper.queryUserByName(user.getUserName());
        //判断用户是否存在
        AssertUtil.isTure(temp !=null,"用户名已存在，请重试！");
        //执行添加操作，判断受影响的行数
        AssertUtil.isTure(userMapper.addUser(user)<1,"添加用户失败");


    }
    public void update(User user){
        //判断是否为空
        //StringUtils.isBlank(str):判断str是否为空
        //判断用户名姓名非空
        AssertUtil.isTure(StringUtils.isBlank(user.getUserName()),"用户姓名不能为空！");
        //判断用户密码是否为空
        AssertUtil.isTure(StringUtils.isBlank(user.getUserPwd()),"用户密码不能为空");
        //通过用户名查询用户对象
        User temp = userMapper.queryUserByName(user.getUserName());
        //判断用户是否存在
        AssertUtil.isTure(temp !=null&& !user.getId().equals(temp.getId()),"用户名已存在，请重试！");
        //执行添加操作，判断受影响的行数
        AssertUtil.isTure(userMapper.update(user)<1,"修改用户失败");

    }
    public void deleteUser(Integer userId){
        //判断参数非空，且删除的记录还在
        AssertUtil.isTure(null == userId||userMapper.queryUserById(userId)==null,"待删除的记录不存在");
        //执行删除，判断受影响的行数
        AssertUtil.isTure(userMapper.deleteUser(userId)<1,"删除用户失败");

    }
    public PageInfo<User> queryUserByParams(UserQuery userQuery){
        //开启分页
        PageHelper.startPage(userQuery.getPageNum(),userQuery.getPageSize());
        //查询用户集合
        List<User> userList = userMapper.queryUserByParams(userQuery);

        //分页查询
        PageInfo<User> pageInfo = new PageInfo<>(userList);
        return  pageInfo;
    }

}

控制层：
UserController:

package com.example.springboot.controller;

import com.example.springboot.exceptions.ParamsException;
import com.example.springboot.po.User;
import com.example.springboot.query.UserQuery;
import com.example.springboot.service.UserService;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;

@RestController
public class UserController {
    @Resource
    private UserService userService;

    @GetMapping("/user/nume/{userName}")
//    @ResponseBody
    public User queryUserByName(@PathVariable String userName) {
        return userService.queryUserByName(userName);
    }

    @GetMapping("/user/id/{userId}")
    public User queryUserById(@PathVariable Integer userId) {
        return userService.queryUserById(userId);
    }
   @PostMapping("user")
           public Map<String, Object> addUser(@RequestBody User user){
              Map<String, Object> map = new HashMap<>();
              try{
                  userService.addUser(user);
                  map.put("code",200);
                  map.put("msg","添加用户成功！");
              }
              catch (ParamsException p ){
                  map.put("code",p.getCode());
                  map.put("msg",p.getMsg());
                  p.printStackTrace();
              }
              catch (Exception e){
                  map.put("code",500);
                  map.put("msg","添加用户失败！");
                  e.printStackTrace();
              }
              return map;
        }
    @PutMapping ("user")
    public Map<String, Object> updateUser(@RequestBody User user){
        Map<String, Object> map = new HashMap<>();
        try{
            userService.update(user);
            map.put("code",200);
            map.put("msg","修改用户成功！");
        }
        catch (ParamsException p ){
            map.put("code",p.getCode());
            map.put("msg",p.getMsg());
            p.printStackTrace();
        }
        catch (Exception e){
            map.put("code",500);
            map.put("msg","修改用户失败！");
            e.printStackTrace();
        }
        return map;
    }

    @DeleteMapping ("user/{userId}")
    public Map<String, Object> deleteUser(@PathVariable Integer userId){
        Map<String, Object> map = new HashMap<>();
        try{
            userService.deleteUser(userId);
            map.put("code",200);
            map.put("msg","删除用户成功！");
        }
        catch (ParamsException p ){
            map.put("code",p.getCode());
            map.put("msg",p.getMsg());
            p.printStackTrace();
        }
        catch (Exception e){
            map.put("code",500);
            map.put("msg","删除用户失败！");
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 分页查询
     * @param userQuery
     * @return
     */
    @RequestMapping("list")
    public PageInfo<User> queryUserByPage(UserQuery userQuery){
        return userService.queryUserByParams(userQuery);
    }
}

工具类
AssertUtil:

package com.example.springboot.util;

import com.example.springboot.exceptions.ParamsException;

import java.text.ParseException;

public class AssertUtil {
    /**
     * 判断结果是否为ture
     *   如果是ture，抛出异常
     * @param flag
     * @param msg
     */

    public static void isTure(Boolean flag, String msg){
        if (flag){
            throw new ParamsException(msg);
        }

    }

异常类
ParamsException:

package com.example.springboot.exceptions;
/**
 自定义参数异常
 */
public class ParamsException extends RuntimeException{
    private Integer code =500;
    private String msg = "参数异常!";

    public ParamsException(){
        super("参数异常");
    }
    public ParamsException(String msg){
        super(msg);
        this.msg = msg;

    }
    public ParamsException(Integer code){
        super("参数异常");
        this.code = code;

    }
    public ParamsException(Integer code,String msg){
        super(msg);
        this.code =code;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

分页：
UserQuery:

package com.example.springboot.query;

public class UserQuery {
    /**
    分页参数
     */
    private Integer pageNum=1;//当前页（未传递页数时，默默认查询第一页）
    private Integer pageSize=10;//每页显示的记录数（当未传递数量时，默认每页显示10条记录）

    /**
     * 条件参数
     */
    private String userName;

    public Integer getPageNum() {
        return pageNum;
    }

    public void setPageNum(Integer pageNum) {
        this.pageNum = pageNum;
    }

    public Integer getPageSize() {
        return pageSize;
    }

    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
}

配置文件
application.yml

```java
server:
  #设置项目启动端口号
  port: 8080
  #设置项目的访问路径（上下文路径）
  servlet:
    context-path: /springboot


  #数据源配置
spring:
  #数据源
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=true&characterEncoding=UTF-8
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
    #type: com.mchange.v2.c3p0.ComboPooledDataSource


#mybatis配置
mybatis:
  #映射文件的存放路径
  mapper-locations: classpath:/mappers/*.xml
  type-aliases-package: com.example.springboot.po
  configuration:
    map-underscore-to-camel-case: true

  #typeAliasesPackage: com.example.mybaitsxml.dao.entity
  #mapperLocations: classpath:mapper/*.xml
  #configLocation: classpath:/mybatis-config.xml

pagehelper:
  helper-dialect: mysql

## 显示dao 执行sql语句
logging:
  level:
    com:
      example:
        springboot:
          dao: debug

pom.xml

```java
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.9</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>SpringbootMybatis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringbootMybatis</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.2</version>
        </dependency>
        <dependency>
            <groupId>com.github.jsqlparser</groupId>
            <artifactId>jsqlparser</artifactId>
            <version>0.9.5</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

觉的有用的麻烦点个关注8**