SpringBoot整合Mybatis/MybatisPlus
文章目录
-
- 一、SpringBoot整合Mybatis
-
- - 1.跳过测试类打包
-
- - - 1.1 需求说明
- - - 1.2 跳过测试类打包
- - 2.创建项目
-
- - - 2.1 新建Maven项目
- - - 2.2 编辑主启动类
- - 3.导入数据库
-
- - - 3.1 链接数据库
- - - 3.2 导入数据库
- - 4.整合mybatis
-
- - - 4.0 序列化作用
- - - 4.1 导入jar包
- - - 4.2 编辑YML文件
-
- - - - 4.2.1 在yml文件中进行 数据源的配置
- - - - 4.2.2 在yml文件中 整合mybatis
- - - 4.3 编辑映射文件
- - - 4.4 编辑主启动类
-
- - - - 4.4.1 Spring管理Mapper接口(方式一)
- - - - 4.4.2 Spring管理Mapper接口(方式二)
- - - 4.5 编辑测试类
- - 5.关于整合的BUG
-
- - - 5.1 关于xml映射文件位置说明
- - - 5.2 关于路径问题
- - 6.IDEA关于Mapper注入问题
- 二、MybatisPlus学习
-
- - 1.ORM思想
- - 2.Mybatis优点/缺点
- - 3.MybatisPlus介绍
-
- - - 3.1什么是MP
- - 4.MP入门案例
-
- - - 4.1 在pom.xml文件中 导入jar包
- - - 4.2 在pojo包中的实体类User.java里 使用注解实现映射
- - - 4.3 在mapper包中的接口UserMapper.java里 继承特定的接口BaseMapper
- - - 4.4 编辑xml映射文件 UserMapper.xml(如果自己不需要写SQL语句，则不需要创建)
- - - 4.5 编辑yml文件 application.yml
- - - 4.6 测试类 TestMP .java
- - - - 4.6.1 MP中关于查询总结
- - 5.MP操作原理
-
- - - 5.1 核心理论
- - - 5.2 MP理论流程
- 三、前后端交互
-
- - 1.框架之间的关系
- - 2.完成后端层级代码
- - 3.查询案例
-
- - - 1.业务需求
- - - 2.编辑UserController
- - - 3.编辑UserServiceImpl
- - - 4页面效果展现
查看jar包版本
https://www.mvnrepository.com/
一、SpringBoot整合Mybatis
- 1.跳过测试类打包
- - 1.1 需求说明
说明: maven执行打包命令时, 默认条件下,会执行测试类中的方法. 并且这些方法都要执行. 隐患 可能某些测试方法由于种种原因 执行报错. 则install的操作执行失败.
矛盾点: 项目打包与test类之间的问题.
解决方案: 要求install时 不要执行test方法,
- - 1.2 跳过测试类打包
<properties>
<java.version>1.8java.version>
<skipTests>trueskipTests>
properties>
- 2.创建项目
- - 2.1 新建Maven项目
1.选择maven新建项目
2.编辑maven 坐标
3.导入pom.xml文件
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.5.3version>
<relativePath/>
parent>
<properties>
<java.version>1.8java.version>
<skipTests>trueskipTests>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
dependency>
dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
<version>2.5.3version>
plugin>
plugins>
build>
- - 2.2 编辑主启动类
@SpringBootApplication
public class RunAPP {
public static void main(String[] args) {
SpringApplication.run(RunAPP.class,args);
}
}
- 3.导入数据库
- - 3.1 链接数据库
- - 3.2 导入数据库
说明: 导入数据库之后,需要刷新数据库即可.
注意事项: 使用资料中提供的版本.
- 4.整合mybatis
步骤：
- 添加jar包文件依赖
- SpringBoot整合Mybatis 添加配置文件 1.连接数据库 2.SpringBoot整合Mybatis
- 创建Mapper接口
- 创建XML映射文件.
- - 4.0 序列化作用
序列化：保证了数据传输的完整性
序列号作用：一般如果需要对象进行传递时,要求POJO对象必须实现序列化接口.否则数据传输必然报错.
说明: 一般实体对象只需要添加get/set/toString等方法,无需添加构造方法.
- - 4.1 导入jar包
导入3个jar包
- mybatis包
- 数据库驱动包
- JDBC包
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.5.3version>
<relativePath/>
parent>
<properties>
<java.version>1.8java.version>
<skipTests>trueskipTests>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<scope>runtimescope>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-jdbcartifactId>
dependency>
<dependency>
<groupId>org.mybatis.spring.bootgroupId>
<artifactId>mybatis-spring-boot-starterartifactId>
<version>2.2.0version>
dependency>
dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
<version>2.5.3version>
plugin>
plugins>
build>
- - 4.2 编辑YML文件
编辑 1.数据源 2.整合mybatis
#端口配置
server:
port: 8090
#配置数据源
spring:
datasource:
#如果使用高版本驱动 则添加cj
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/jt?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
username: root
password: root
#Spring整合Mybatis
mybatis:
#定义别名包
type-aliases-package: com.jt.pojo
#导入映射文件
mapper-locations: classpath:/mappers/*.xml
#开启驼峰映射
configuration:
map-underscore-to-camel-case: true
- - - 4.2.1 在yml文件中进行 数据源的配置
#配置数据源
spring:
datasource:
#如果使用高版本驱动 则添加cj
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/jt?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
username: root
password: root
数据库配置参数:
1.serverTimezone=GMT%2B8& 时区
2.useUnicode=true& 是否使用unicode编码
3.characterEncoding=utf8& 字符集使用utf-8
4.autoReconnect=true& 自动重连
5.allowMultiQueries=true 运行批量操作
- - - 4.2.2 在yml文件中 整合mybatis
#Spring整合Mybatis
mybatis:
#定义别名包
type-aliases-package: com.jt.pojo
#导入映射文件
mapper-locations: classpath:/mappers/*.xml
#开启驼峰映射
configuration:
map-underscore-to-camel-case: true
- - 4.3 编辑映射文件
关键词: namespace id 标签 别名 resultType resultMap
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.com.jt.mapper.UserMapper">
<select id="findAll" resultType="User">
select * from demo_user
select>
<select id="findList" resultType="User">
select * from demo_user
where
age < #{age}
and
sex = #{sex}
select>
<select id="findWhere" resultType="User">
select * from demo_user
where
sex = #{sex}
and
age > #{age}
select>
<select id="findAge" resultType="User">
select * from demo_user
where
age < #{minAge}
or
age > #{maxAge}
select>
<select id="findName" resultType="User">
select * from demo_user where name = #{name}
select>
mapper>
- - 4.4 编辑主启动类
关键词: mapper/dao(接口) Spring为接口创建对象
- - - 4.4.1 Spring管理Mapper接口(方式一)
说明：@Mapper注解 一般标识在接口中，如果有多个接口，则应该标识多次。
优化：可以采用 @MapperScan(“接口的路径”)进行优化.
package com.jt.mapper;
import com.jt.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper //将该接口交给Spring容器管理
public interface UserMapper {
//查询所有的user用户
List<User> findAll();
//整理方法参数
List<User> findList(Integer age,String sex);
/**
* 规则:
* 1.Mybatis 原生只支持单值传参
* 2.如果是多值,则想办法封装为单值
* 方法: 1.封装为对象
* 2.封装为Map集合 ={minAge: 18,maxAge:100}
* 补充说明: 现在mybatis版本 如果多值传参 则自动封装为Map集合
* Key:参数名称 value: 参数的值
*/
//List findWhere(String name,Integer age,String sex);
List<User> findWhere(User user);
List<User> findAge(int minAge,int maxAge);
//List findAge(@Param("minAge") int minAge,@Param("maxAge") int maxAge);
List<User> findName(String name);
}
- - - 4.4.2 Spring管理Mapper接口(方式二)
说明：删掉Mapper接口中的@Mapper注解，在启动类中加入@MapperScan(“com.jt.mapper”)
package com.jt;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
@MapperScan("com.jt.mapper")
public class RunApp {
public static void main(String[] args) {
SpringApplication.run(RunApp.class, args);
}
}
- - 4.5 编辑测试类
package com.jt.test;
import com.jt.mapper.UserMapper;
import com.jt.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
@SpringBootTest
public class TestMybatis {
@Autowired
private UserMapper mapper;
@Test
public void test01(){
List<User> userList = mapper.findAll();
System.out.println(userList);
}
/**
* Mybatis 参数传递说明
* 查询: sex="男" age > 18岁
*/
@Test
public void testMybatis(){
//参数使用对象进行封装
User user = new User();
user.setSex("男").setAge(18);
List<User> userList = mapper.findWhere(user);
System.out.println(userList);
}
/**
* Mybatis 参数传递说明
* 查询: age < 18 or age > 100
* 思考: 1.是否可以封装为对象?? 不可以!!
*
*/
@Test
public void testMybatis2(){
int minAge = 18;
int maxAge = 100;
List<User> userList = mapper.findAge(minAge,maxAge);
System.out.println(userList);
}
/**
* Mybatis 参数传递说明
* 查询name="王昭君"
*/
@Test
public void testMybatis3(){
String name = "王昭君";
List<User> userList = mapper.findName(name);
System.out.println(userList);
}
}
- 5.关于整合的BUG
- - 5.1 关于xml映射文件位置说明
说明: 如果xml的映射文件在根目录下(不建议), 则加载时采用classpath*.xml的结构.
强制加载根目录下的所有的xml文件.
- - 5.2 关于路径问题
- 6.IDEA关于Mapper注入问题
说明: 通过包扫描的路径，在运行期间实现对象的创建，实现了数据的绑定。所以下边的红线属于误报…
解决方案(一):
修改IDEA 数据校验 将√号去除即可.
解决方案(二):
如果是最新版本的IDEA 则修改如下的选项
二、MybatisPlus学习
MybatisPlus学习网站
- 1.ORM思想
对象关系映射（英语：Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。如今已有很多免费和付费的ORM产品，而有些程序员更倾向于创建自己的ORM工具。
宗旨： 以面向对象的方式操作数据库。
1.要求查询的结果集可以自动的封装为对象 (读)
2.利用对象封装数据，之后(自动)动态的生成SQL语句执行相关操作. (更新)
知识升华:
- 以对象的方式实现数据库CRUD操作.
- 要求通过某种机制将对象动态的转化为SQL，之后实现数据库操作。(自己不写SQL)
- 2.Mybatis优点/缺点
SpringBoot整合Mybatis流程
1.导入依赖jar包 数据库驱动、JDBC包、Spring整合Mybatis包
2.编辑application.yml文件 配置数据源、配置Spring整合Mybatis
3.编辑Mybatis 接口文件、编辑xxx.xml映射文件
4.通过@MapperScan为接口创建代理对象.
优点:
1.Mybatis 内部整合了JDBC, 简化了持久层开发.
2.Mybatis可以自动的封装结果集的对象 满足ORM中的一个条件.所以将Mybatis称之为半自动化的ORM映射框架.
3.Mybatis有缓存机制 一级缓存/二级缓存.提高用户得查询效率.
4.Mybatis支持多种类型的数据库. 整合简单.
缺点:
1.实现数据的封装 resultMap 封装复杂!!!
2.针对于单表的CRUD的操作 不够便捷. Sql都需要手写!!!
3.个别的情况下二级缓存配置不生效!!!
- 3.MybatisPlus介绍
- - 3.1什么是MP
MyBatis-Plus (opens new window)（简称 MP）是一个 MyBatis (opens new window)的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
特性:
无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作
- 4.MP入门案例
核心思想: 利用对象操作数据库 单表查询几乎不写SQL
- - 4.1 在pom.xml文件中 导入jar包
说明:MybatisPlus对Mybatis的增强(包含),所有jar包只需要导入MP的即可.原有的Mybatis需要删除.
<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.0modelVersion>
<groupId>com.jtgroupId>
<artifactId>springboot_demo3artifactId>
<version>1.0-SNAPSHOTversion>
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.5.3version>
<relativePath/>
parent>
<properties>
<java.version>1.8java.version>
<skipTests>trueskipTests>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-configuration-processorartifactId>
<optional>trueoptional>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-devtoolsartifactId>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<scope>runtimescope>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-jdbcartifactId>
dependency>
<dependency>
<groupId>com.baomidougroupId>
<artifactId>mybatis-plus-boot-starterartifactId>
<version>3.4.3version>
dependency>
dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
plugin>
plugins>
build>
project>
- - 4.2 在pojo包中的实体类User.java里 使用注解实现映射
关键词：对象 表 属性 字段 一一映射
对象关系映射：
1.User对象需要与demo_user表绑定
2.User对象中的属性与表中的字段一一对应
package com.jt.pojo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.experimental.Accessors;
import java.io.Serializable;
@Data
@Accessors(chain = true)
//1.将对象与表进行关联
//规则1：如果表明与对象名一致，则名称可以省略
//规则2：如果字段名与属性名一致，则注解可以省略
@TableName("demo_user")
//序列化接口的作用：保证对象网络传输的有效性！！！
public class User implements Serializable {
//2.主键 --- 主键自增[AUTO]、非空、UUID[ASSIGN_UUID](生成唯一编号)
@TableId(type = IdType.AUTO) //主键的意思
private Integer id;
//3.标识属性与字段的映射
// @TableField("name")
private String name;
private Integer age;
private String sex;
}
- - 4.3 在mapper包中的接口UserMapper.java里 继承特定的接口BaseMapper
关键字：封装 — 多态 — 继承
说明：MP在内部准备了一个BaseMapper的接口BaseMapper内部几乎将单表的CRUD操作都进行了编辑，用户自己的Mapper
package com.jt.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
/**
* 1.规则1：继承BaseMapper时，必须添加泛型对象，否则映射表报错
* 2.规则2：自己的方法不要与接口方法重名
*/
public interface UserMapper extends BaseMapper<User> {
//MP规则：以对象的方式操作数据库，CURD操作
//查询所有的user用户
List<User> findAll();
}
- - 4.4 编辑xml映射文件 UserMapper.xml(如果自己不需要写SQL语句，则不需要创建)
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jt.mapper.UserMapper">
<select id="findAll" resultType="User">
select * from demo_user
select>
<select id="findList" resultType="User">
select * from demo_user
where
age < #{age}
and
sex = #{sex}
select>
mapper>
- - 4.5 编辑yml文件 application.yml
说明：将mybatis改成mybatis-plus
# 端口配置
Server:
port: 8090
#配置数据源
spring:
datasource:
#如果使用高版本驱动 则添加cj
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/jt?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
username: root
password: root
#Spring整合MP
mybatis-plus:
#定义别名包
type-aliases-package: com.jt.pojo
#导入映射文件
mapper-locations: classpath:/mappers/*.xml
#开启驼峰映射
configuration:
map-underscore-to-camel-case: true
#为com.jt.mapper包下的SQL执行打印日志
logging:
level:
com.jt.mapper: debug
- - 4.6 测试类 TestMP .java
package com.jt.test;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.jt.mapper.UserMapper;
import com.jt.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
@SpringBootTest
public class TestMP {
@Autowired
private UserMapper mapper;
//MP底层原理
// insert into 表名 (字段名...) value (属性值...);
// @Test
// public void test(){
// // 获取user的类型
// Class userClass = user.getClass();
// // 通过反射获取User类里的@TableName("demo_user")注解
// TableName tablename = userClass.getAnnotation(TableName.class);
// // 获取表名
// String name = tablename.value();
// // 获取字段名
// Field[] fieldsname = userClass.getFields();
// //获取属性值 -- 用get方法
// }
/**
* 0.完成数据的入库操作
* 新增user数据(name="张三",age=23,sex="男")
* SQL：insert into demo_user values(xxx,xxx,xxx)
*/
@Test
public void insert(){
User user = new User();
user.setName("张三").setAge(23).setSex("男");
//以对象的方式操作数据！！！
mapper.insert(user);
System.out.println("入库操作成功");
}
/**
* 1.根据Id查询数据库 id= 231
*/
@Test
public void selectById(){
int id = 231;
User user = mapper.selectById(id);//模拟用户参数
System.out.println(user);
System.out.println("查询成功");
}
/**
* 2.查询 name = "小乔" 并且 性别 = "女"
* 思路：如果将来有多个结果，则使用List参数进行接收
* SQL：where name = "xx" and sex = "xx"
* 注意事项：默认的连接符是 and
*/
@Test
public void select01(){
//1.通过对象封装数据
User user = new User();
user.setName("小乔").setSex("女");
//2.构建条件构造器 根据对象中不为null的属性充当where条件！
QueryWrapper<User> queryWrapper = new QueryWrapper(user);
//3.根据条件构造器 实现数据查询
List<User> userList = mapper.selectList(queryWrapper);//Wrapper queryWrapper 条件构造器
System.out.println(userList);
System.out.println("查询成功");
}
/**
* 3.查询 name="小乔" 并且 性别 ="女"
* 逻辑运算符: = eq, > gt, < lt
* >= ge, <= le
* != ne
*/
@Test
public void select02(){
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name","小乔")
.eq("sex","女");
List<User> userList = mapper.selectList(queryWrapper);
System.out.println(userList);
}
/**
* 4.案例: select 查询age < 18岁 性别="女"
* 方式1: 利用mybatis方式实现
* 方式2: 利用MP方式实现
*/
@Test
public void select03(){
//1.mybatis 写法
List<User> userList = mapper.findList(18,"女");
System.out.println(userList);
//2.MP写法
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.lt("age", 18)
.eq("sex", "女");
List<User> userList2 = mapper.selectList(queryWrapper);
System.out.println(userList2);
}
/**
* 5.select 查询 name包含 '君'字的数据
* 关键字： like "%xxx%"
* 以君字开头：likeRight "君%"
* 以君字结尾：likeLeft "%君"
*/
@Test
public void select04(){
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name", "君");
List<User> userList = mapper.selectList(queryWrapper);
System.out.println(userList);
QueryWrapper<User> queryWrapper1 = new QueryWrapper<>();
queryWrapper1.likeRight("name", "君");
List<User> userList2 = mapper.selectList(queryWrapper1);
System.out.println(userList2);
QueryWrapper<User> queryWrapper2 = new QueryWrapper<>();
queryWrapper2.likeLeft("name", "君");
List<User> userList3 = mapper.selectList(queryWrapper2);
System.out.println(userList3);
}
/**
* 6.select 查询 sex = "女" 按照年龄倒序排序
*/
@Test
public void select05(){
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("sex", "女")
.orderByDesc("age");
List<User> userList = mapper.selectList(queryWrapper);
System.out.println(userList);
}
/**
* 7.需求：动态SQL查询:如果有值，则拼接where条件
* 如果数据为null，则不拼接where条件
*
* 语法：condition:true 则拼接条件where条件
* false 则不拼接where条件
*/
@Test
public void select06(){
String name = "貂蝉";
int age = 18;
boolean nameFlag = name == null ? false : true;
boolean ageFlag = age == 0 ? false : true;
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq(nameFlag,"name", name)
.eq(ageFlag, "age", age);
List<User> userList = mapper.selectList(queryWrapper);
System.out.println(userList);
}
/**
* 8.批量查询 查询id = 1,4,5,6...的数据
* 有两种写法
*/
@Test
public void selectIn(){
//1.传统的in方法
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.in("id", 1,4,5,6);
List<User> userList = mapper.selectList(queryWrapper);
System.out.println(userList);
//2.特有的方法
//数组在未来有用户负责传递。
Integer[] array = new Integer[]{1,4,5,6};
//数组转List集合？？
List<Integer> ids = Arrays.asList(array);
List<User> userList1 = mapper.selectBatchIds(ids);
System.out.println(userList1);
}
/**
* 9.查询性别为男的用户ID
* selectObjs(); 只查询第一个字段(主键)
* 实际用途：根据业务只需要主键的查询
*/
@Test
public void selectObjs(){
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("sex", "男");
List<Object> ids = mapper.selectObjs(queryWrapper);
System.out.println(ids);
}
/**
* 10.将ID = 232 的数据 name 改为 "皮皮虾"
* SQL:update demo_user set name = "皮皮虾" where id = 232
*/
@Test
public void update(){
User user = new User();
user.setId(232).setName("皮皮虾");
//buId 表示ID只当作where条件
//其他不为null的属性 当作set条件
mapper.updateById(user);
System.out.println("修改成功");
}
/**
* 11.将name = "泡泡老师" 改为 name = "泡泡" age = 25 sex = "男"
* .update(arg1,arg2)
* arg1:实体对象 set条件的数据
* arg2:updateWrapper 动态拼接where条件
*/
@Test
public void update01(){
User user = new User();
user.setName("泡泡").setAge(25).setSex("男");
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("name", "泡泡老师");
mapper.update(user,updateWrapper);
System.out.println("更新成功");
}
}
- - - 4.6.1 MP中关于查询总结
MP核心：以对象的方式操作数据库
条件构造器：new QueryWrapper<>(); 动态拼接where条件。
拼接规则：根据对象中不为null的属性充当where条件。
特殊转义字符：= --> eq、> --> gt、 < --> lt、 >= --> ge 、<= --> le 、!= --> ne
xml文件中的万能的转义字符：
关键字：like 、order by ...
动态SQL语法：
condition:true 拼接where条件
false 不拼接where条件
- 5.MP操作原理
问题：用户操作对象，如何实现数据库操作！！！
分析问题：对象如何转化为SQL？
- - 5.1 核心理论
例子：mapper.insert(user);
mapper.insert(dog);
SQL：
1.insert into 表名(字段名称...) value(属性的值...);
总结：MP将常规的操作进行抽取，采取公共的接口进行定义，之后只需要按照用户的参数动态的拼接SQL即可
- - 5.2 MP理论流程
重点: 对java反射机制 有一定的了解
- mapper.insert(user); 用户调用接口方法，完成业务。
- 根据用户传递的对象，通过user.getClass() – 获取的是类型。Class userClass = user.getClass();
- 根据class类型，通过反射动态获取User类中指定的@TableName(“demo_user”)注解； TableName tableName = (TableName)
userClass.getAnnotation(TableName.class); - 获取表名 String 表名 = tableName.value();
- 根据User的类型可以获取User类中属性的名称，根据属性名称，可以获取User类属性前的@TableField(“name”)注解，最终获取字段的名称。
- 拼接SQL： insert into demo_user(id,age,name,sex) value (user.getId()…)
- 最终将SQL由MP交给Mybatis执行SQL，最终实现数据的入库操作。
三、前后端交互
- 1.框架之间的关系
1.SpringBoot (工具/框架的框架) 2.Spring(整合第三方)
3.SpringMVC(实现前后端交互) 4.Mybatis/MP(实现持久化操作)
- 2.完成后端层级代码
说明: MVC思想主要的目的实现代码的解耦. 根据MVC思想 演化出层级代码结构 Controller/Service /Dao/Mapper
编码顺序:
1.编辑POJO
2.编辑Mapper接口
3.编辑Service层
4.编辑Controller
- 3.查询案例
- - 1.业务需求
用户浏览器输入地址: http://localhost:8090/findAll,
要求: 利用MP查询数据库,返回集合的JSON数据.
- - 2.编辑UserController
package com.jt.controller;
import com.jt.pojo.User;
import com.jt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
@RestController // 获取请求+响应json数据
//@Controller // 和上面的@RestController注解基本无差别，唯一少了一个@ResponseBody注解
//@ResponseBody // 将服务端数据转换给JSON串返回
public class UserController {
@Autowired
//编码规则：面向接口编程 解耦
private UserService userService;
/**
* 查询所有的数据
* URL: http://localhost:8090/findAll
* 参数：没有参数
* 返回值：List
*/
@RequestMapping("findAll")
public List<User> findAll(){
return userService.findAll();
}
}
- - 3.编辑UserServiceImpl
package com.jt.service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jt.mapper.UserMapper;
import com.jt.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImpl implements UserService{
@Autowired
private UserMapper userMapper;
//查询所有数据，没有where条件的查询全部数据
@Override
public List<User> findAll() {
return userMapper.selectList(null);
}
}
- - 4页面效果展现
