EasyExcel简单的导出和下载

springboot整合mybatis-plus

一、简单了解

0、前言

我是再IT技术上探索的求知者，刚进入IT这扇大门，希望能够通过每天的总结，让自己变得更加优秀。写一些，我遇到的一些技术问题，其他的问题，等以后遇到的时候再整理，希望自己能够坚持下去，并且能给你带来一些帮助。

1 mybais-plus简介

MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window) 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

2 框架结构

二、开始实战

1 创建数据库

CREATE DATABASE db_test CHARSET=utf8;
USE db_test;
DROP TABLE tab_student;
CREATE TABLE tab_student(
	sid INT PRIMARY KEY AUTO_INCREMENT,
	sname VARCHAR(20),
	sage INT,
	sex VARCHAR(2)
);
INSERT INTO tab_student 
VALUES(NULL,SUBSTR(UUID(),1,5),
 TRUNCATE(RAND()*10+10,0),IF(RAND()>0.5,"男","女"));

2 创建项目

3 引入依赖

<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>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
    <version>5.1.45</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.2</version>
</dependency>
<!--引入fastjson-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.58</version>
</dependency>

4 配置文件

#链接数据库的四大参数
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3306/db_test?useUnicode=true&characterEncoding=UTF-8

#显示sql
logging.level.com.baizhou.mapper=debug
server.port=8081

5 创建实体类

• Student

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "tab_student")
public class Student implements Serializable {
    @TableId(value = "sid",type = IdType.AUTO)//指定主键，主键自增策略，数据库自增
    private Integer sid;
    @TableField(value = "sname")
    private String  sname;
    @TableField(value = "sage")
    private Integer sage;
    @TableField(value = "sex")
    private String sex;
}

6 创建dao层

• StudentMapper

@Repository
public interface StudentMapper extends BaseMapper<Student> {
}

7 创建service层

• StudentService

public interface StudentService {
    //增删改查
    int addOne(Student student);
    int deleteOne(Integer sid);
    int updateOne(Student student);
    Student getOne(Integer sid);
    List<Student> getAll();
    //通过请求进行模糊查询查询，通过名字，或者性别，id进行查询
    IPage<Student> getAllByResquest(String request);
    //通过名字进行模糊查询
    List<Student> getAllByLike(String sname);
}

• StudentServiceImp

import com.alibaba.fastjson.JSONObject;
import com.baizhou.entity.Student;
import com.baizhou.mapper.StudentMapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.val;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class StudentServiceImp implements StudentService {
    @Autowired
    private StudentMapper studentMapper;//自动装配
    @Override
    public int addOne(Student student) {
        return studentMapper.insert(student);
    }
    //@Transactional(isolation = Isolation.READ_UNCOMMITTED)：读取未提交数据(会出现脏读,
    //@Transactional(isolation = Isolation.READ_COMMITTED)：读取已提交数据(会出现不可重复读和幻读)
    //@Transactional(isolation = Isolation.REPEATABLE_READ)：可重复读(会出现幻读)
    //@Transactional(isolation = Isolation.SERIALIZABLE)：串行化
    @Override
    public int deleteOne(Integer sid) {
        val student = studentMapper.selectById(sid);//查询是否存在
        if (student == null) {
            return 0;//不存在，删除失败
        }
        studentMapper.deleteById(sid);
        return 1;//删除成功
    }
    @Override
    public int updateOne(Student student) {
        return studentMapper.updateById(student);
    }
    @Override
    public Student getOne(Integer sid) {
        if (sid == null) {
            return null;
        }
        Student student = studentMapper.selectById(sid);
        if (student == null) {
            return null;
        }
        return student;
    }
    @Override
    public List<Student> getAll() {
        return studentMapper.selectList(null);
    }

    /**
     * 请求格式：进行分页查询，模糊查询，有sid根据sid查询，没有则不根据sid查询
     * {
     * "sid":1,
     * "sname":"x",
     * "sex":"男",
     * "pageNum":1,
     * "pageSize":1
     * }
     */
    @Override
    public IPage<Student> getAllByResquest(String request) {
        //request是json字符串
        //把json串转换成json对象
        val requestJson = JSONObject.parseObject(request);
        LambdaQueryWrapper<Student> queryWrapper = new LambdaQueryWrapper();
        //进行模糊查询
        queryWrapper.eq(requestJson.getString("sid") != null, Student::getSid, requestJson.getString("sid"))
                .and(wrapper -> wrapper.like(Student::getSname, requestJson.getString("sname"))
                        .or().like(Student::getSex, requestJson.getString("sex")
                        ));
        //进行分页查询
        Page page=new Page(requestJson.getInteger("pageNum"),requestJson.getInteger("pageSize"));
        IPage<Student> ipage=studentMapper.selectPage(page,queryWrapper);

        return ipage;
    }
    @Override
    public List<Student> getAllByLike(String sname) {
        val queryWrapper=new LambdaQueryWrapper<Student>();
        queryWrapper.like(Student::getSname,sname);
        return studentMapper.selectList(queryWrapper);
    }
}

8 测试

@SpringBootTest
class SpringbootMybatisPlusApplicationTests {
    @Autowired
    private StudentService studentService;
    @Test
    void setStudentServiceTest() {
        studentService.getAll();
        studentService.getAllByLike("3");

        String requestJson=  "{ \"sid\":1, \"sname\":\"x\", \"sex\":\"男\", \"pageNum\":1, \"pageSize\":1 }";
        String requestJson2=  "{ \"sname\":\"3\", \"sex\":\"男\", \"pageNum\":1, \"pageSize\":5 }";
        studentService.getAllByResquest(requestJson);
        studentService.getAllByResquest(requestJson2);
    }
}

• 结果

studentService.getAll();
==>  Preparing: SELECT sid,sname,sage,sex FROM tab_student 
2021-07-27 23:35:45.005 DEBUG 1600 --- [           main] c.b.mapper.StudentMapper.selectList      : ==> Parameters: 
2021-07-27 23:35:45.026 DEBUG 1600 --- [           main] c.b.mapper.StudentMapper.selectList      : <==      Total: 9
 

studentService.getAllByLike("3");
==>  Preparing: SELECT sid,sname,sage,sex FROM tab_student WHERE (sname LIKE ?) 
2021-07-27 23:35:45.069 DEBUG 1600 --- [           main] c.b.mapper.StudentMapper.selectList      : ==> Parameters: %3%(String)
2021-07-27 23:35:45.073 DEBUG 1600 --- [           main] c.b.mapper.StudentMapper.selectList      : <==      Total: 9

studentService.getAllByResquest(requestJson);
2021-07-27 23:35:45.159 DEBUG 1600 --- [           main] c.b.mapper.StudentMapper.selectPage      : ==>  Preparing: SELECT sid,sname,sage,sex FROM tab_student WHERE (sid = ? AND (sname LIKE ? OR sex LIKE ?)) 
2021-07-27 23:35:45.159 DEBUG 1600 --- [           main] c.b.mapper.StudentMapper.selectPage      : ==> Parameters: 1(String), %x%(String), %男%(String)
2021-07-27 23:35:45.160 DEBUG 1600 --- [           main] c.b.mapper.StudentMapper.selectPage      : <==      Total: 0

studentService.getAllByResquest(requestJson2);
2021-07-27 23:35:45.163 DEBUG 1600 --- [           main] c.b.mapper.StudentMapper.selectPage      : ==>  Preparing: SELECT sid,sname,sage,sex FROM tab_student WHERE ((sname LIKE ? OR sex LIKE ?)) 
2021-07-27 23:35:45.163 DEBUG 1600 --- [           main] c.b.mapper.StudentMapper.selectPage      : ==> Parameters: %3%(String), %男%(String)
2021-07-27 23:35:45.164 DEBUG 1600 --- [           main] c.b.mapper.StudentMapper.selectPage      : <==      Total: 9

三、总结

今天遇到了使用mybatis-plus，进行模糊查询是and和or进行嵌套的问题，所以写下了一个小案例。

// A or (B and C)
.eq("a", "A").or(i -> i.eq("b", "B").eq("c", "C"));

// A or (B or C)
.eq("a", "A").or(i -> i.eq("b", "B").or().eq("c", "C"));

// A and (B and C)
.eq("a", "A").and(i -> i.eq("b", "B").eq("c", "C"));

// A and (B or C)
.eq("a", "A").and(i -> i.eq("b", "B").or().eq("c", "C"));