此博客注意事项
1.SpringBoot 高级用法
为属性赋值操作 YML文件语法说明 为属性赋值操作的优化 环境切换
2 配置LomBok 链式加载
3 SpringBoot整合Mybatis
pom.xml文件:关于数据库驱动的jar包版本号说明
yml关于整合数据库配置说明:数据库驱动高低版本 url参数
yml关于MyBatis配置的说明: 别名包 mapper文件映射路径 驼峰规则映射
Mapper注解优化说明
4.MP介绍 入门案例crud方法测试 设置主键为uuid的方式(MP方式设置的)
配置数据库 日志级别
1.SpringBoot 高级用法
1.1 为属性赋值操（@ResponseBody作用）
1.1.1 业务需求说明
说明: 当程序中出现了频繁变化的数据时,如果采用人为的方式进行修改并且编译打包则导致代码的耦合性较高.不便于维护.所以能否为属性动态赋值?写在配置文件中。.
作用3详解: @ResponseBody是代表业务结束，只有加上这个注解Ajax才能正确返回。（Ajax的结束标识）不加这个注解会执行视图解析器，为页面拼接前缀后缀。加上这个注解是直接返回字符串，不在执行视图解析器。
1.1.2 关于YML文件语法说明
# YML文件语法
# 1. key:(空格) value
# 2. key与key之间有层级的缩进关系.
# 3.注释可以写中文,不能写引号
server:
port: 8090
# 属性赋值操作,编辑属性时注意前缀. 只要springboot启动该数据就会被写入内存中 key-value格式
# 配置redis缓存服务器的ip和端口号。
redis:
host: 192.168.126.130
port: 6379
1.1.3 为属性赋值操作
好处：将来ip地址改了之后，只需要更改配置文件，不需要重新编译和打包。
注意:想要使用这个注解前提是yml文件被spring容器管理,而yml文件在springboot启动是就会自动的被容器管理。如果用的是properties文件则需要多加个注解交给spring容器去管理。
package com.ct.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
//动态获取ip和端口数据
//@ResponseBody 作用1: 将对象转化为JSON 作用2: 如果返回值是String类型,则返回字符串本身
// 作用3: 一般客户端发起ajax请求时,采用该注解返回数据, 将不会执行视图解析器操作
@RestController
public class RedisController {
@Value("${redis.host}") //spring提供的spel表达式(通过key获取value)
private String host; // = "192.168.126.130"; private String host; // = "192.168.126.130";
@Value("${redis.port}")
private Integer port; // = 6379;
@RequestMapping("/getMsg")
public String getMsg(){
return host + ":" + port;
}
}
1.2 为属性赋值操作的优化
需求: YML配置文件是SpringBoot整合第三方配置文件(如:整合的第三方框架mvc redis等),如果将业务配置与YML配置写到一起,则不方便管理.能否在指定的配置文件(pro)中实现属性的赋值.(即:把业务数据的配置内容放在pro文件中—把 整合的第三方配置放在YML文件中.)
1.2.1 编辑properties配置文件
注意:pro只是为了和上面写法的区分，注意如果2种都使用了，则key不能重复，一旦重复以yml文件为准。
1.2.2 编辑RedisController
注意:
1.classpath固定值，路径为properties文件的路径。
2.复制源根目录后是’\‘的形式，在windows系统中没有问题。但是在Linux系统中没有反斜杠的形式，所以不管是windows还是linux统一用’/'的形式
package com.ct.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
//动态获取ip和端口数据
//@ResponseBody 作用1: 将对象转化为JSON 作用2: 如果返回值是String类型,则返回字符串本身
// 作用3: 一般客户端发起ajax请求时,采用该注解返回数据, 将不会执行视图解析器操作
//动态的导入pro配置文件,交给spring容器进行加载.
//prp配置文件默认用的是iso8859-1格式，所以配置文件里面有中文的话，查询会显示乱码。可以进行指定value值，但是多个value ,key不能省。 指定编码格式就可以正确显示了。
//@PropertySource(value="classpath:/application.properties",encoding="UTF-8")
@PropertySource("classpath:/application.properties")
@RestController
public class RedisController {
@Value("${pro.redis.host}")
private String proHost;
@Value("${pro.redis.port}")
private Integer proPort;
@RequestMapping("/getPro")
public String getPro(){
return proHost + ":" + proPort;
}
}
启动项目运行测试
1.3 环境切换
1.3.1 业务场景
一般开发时使用的都是测试环境.当项目上线时需要在生产环境下部署项目.
问题: 在测试环境中的配置与生产环境下的配置可能不一致,经常需要修改IP地址及端口.
想法:能否简化该操作?
策略:指定多个运行环境. 当现在处于测试环境时,让配置文件指向测试. 反之做相同的操作.
1.3.2 编辑YML配置文件
#第一份配置文件,用来指定默认的环境标识
spring:
profiles:
active: prod
---
#指定环境的名称 (1.开发环境)
spring:
profiles: dev
server:
port: 8090
# 属性赋值操作,编辑属性时注意前缀. 只要springboot启动该数据就会被写入内存中 key-value格式
redis:
host: 192.168.126.129
port: 6379
# 需要将环境一分为二 (2.测试环境)
---
spring:
profiles: prod
server:
port: 9000
# 属性赋值操作,编辑属性时注意前缀. 只要springboot启动该数据就会被写入内存中 key-value格式
redis:
host: 111.111.111.111
port: 7000
2 Idea配置LomBok
在设置中添加lombok插件–在pom.xml中添加依赖即可
2.1 添加jar包文件
<!--引入插件lombok 自动的set/get/构造方法插件 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
2.2 测试注解是否能用
package com.jt.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data //set/get/toString方法只会重写自己的属性,不会添加父级的属性(比如这个类继承了父类)
@Accessors(chain = true) //链式加载规则 accessors:访问器 chain:链子
@NoArgsConstructor //无参构造 args:参数
@AllArgsConstructor //全参构造
public class User {
private Integer id;
private String name;
private Integer age;
private String sex;
//accessors底层重写了set方法,然后把自己返回
/* public User setId(Integer id){
this.id = id;
return this;
}*/
}
可以看到set方法,说明lombak可用。
@Accessors(chain = true) //链式加载规则,添加此注解后可以连着点方法,不用写一个对象名点一个方法名。
2.3 面试题
问:项目发布是在Linux中发布的,LomBok的使用一般都需要安装插件.问题:如果在Linux中发布项目,是否需要重写安装LomBok插件.
答案: 不需要
原因: lombok插件在编译器有效. 将.java文件编译为.class文件时lombok会动态的添加get/set/toString…等方法.添加到.class文件中.
Linux上线部署时运行的时.jar文件 .jar包含的文件(.class文件).
3 SpringBoot整合Mybatis
3.1 新建项目(Mybatis入门案例)
说明:暂时只需要勾选web.jar包即可
3.2 导入京淘数据库
略：详情看jt-1
3.3 导入依赖
注意事项:
- 引入mybatis需要引入一个版本号，因为它不是spring家的。
- < !-- < version >5.1.32< /version >–> 注册数据库的版本有时候需要加上，因为工作中力求稳定，新版本连接的驱动可能存在风险。所以用老版本。
但这样也带来了问题:如果用低版本的驱动连接高版本的数据库会报:驱动异常。所以一般去掉不用，即用父标签定义的版本即可。 - 在配置文件中:注册数据库驱动连接低版本数据库写法为:
driver-class-name: com.mysql.jdbc.Driver
高版本为:
driver-class-name: com.mysql.cj.jdbc.Driver
但是驱动配置可以省略不写，会根据你的数据库版本自动判断是否加上cj.
<?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.3.4.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.jt</groupId>
<artifactId>springboot_demo2_mybatis</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>springboot_demo2_mybatis</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
<skipTests>true</skipTests>
</properties>
<dependencies>
<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>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
<!--引入插件lombok 自动的set/get/构造方法插件 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--引入数据库驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
<!--<version>5.1.32</version>-->
</dependency>
<!--springBoot数据库连接 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<!--spring整合mybatis 暂时 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.2</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
3.4 编写 pojo 类
package com.jt.pojo;
import lombok.Data;
import lombok.experimental.Accessors;
import java.io.Serializable;
@Data
@Accessors(chain = true)
public class User implements Serializable {
private Integer Id;
private String name;
private Integer age;
private String sex;
}
3.5 mapper文件(idea中创建接口是在创建类上进行切换)
数据层:mapper或者Dao起名字。
package com.jt.dao;
import com.jt.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import java.util.List;
@Mapper//将接口交给Spring管理
public interface UserDao {
//查询user表的所有的记录
@Select("select * from user")
List<User> findAll();
}
3.6 编辑项目结构代码
resources目录下的资源直接复制课前资料里面的.
测试类也要写在java目录下的主启动类的包以及子包下.
3.7 编辑YML配置文件
server:
port: 8090
servlet:
context-path: /
spring:
datasource:
#driver-class-name: com.mysql.jdbc.Driver 驱动注释,不写采用默认的方式
url: jdbc:mysql://127.0.0.1:3306/jtdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
username: root
password: root
mybatis:
#type-aliases-package: com.jt.demo.pojo
mapper-locations: classpath:/mybatis/mappers/*.xml
#开启驼峰映射
#configuration:
#map-underscore-to-camel-case: true
3.8 编辑测试类
package com.jt;
import com.jt.dao.UserDao;
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
class SpringbootDemo2MybatisApplicationTests {
@Autowired
private UserDao userDao;
@Test
public void test01(){
//双击右键运行即可
List<User> userList = userDao.findAll();
System.out.println(userList);
}
}
运行测试:
3.9 yml关于数据库的配置说明
3.9.1 关于数据库驱动说明
在配置文件中:注册数据库驱动连接低版本数据库写法为:
driver-class-name: com.mysql.jdbc.Driver
高版本为:
driver-class-name: com.mysql.cj.jdbc.Driver
但是可以省略不写，会根据你的数据库版本自动判断是否加上cj.
3.9.2 关于数据库url说明
1.时区设定
serverTimezone=GMT%2B8 %2B= +号
2.编码格式设定
useUnicode=true&characterEncoding=utf8
3.是否自动的重新链接
autoReconnect=true
4.是否允许批量操作，用于一个线程同时执行多个入库操作(例如：一次行执行多个入库操作,用分号隔开。)
allowMultiQueries=true
3.10 yml关于MyBatis配置的说明
3.10.1 别名包定义
简化resultType属性返回值类型的写法，只需要写类名，不需要写全称限定类名。
mybatis:
#定义别名包
type-aliases-package: com.jt.pojo 可以简化mapper映射文件的编辑
#mapper文件的映射路径
mapper-locations: classpath:/mybatis/mappers/*.xml
#开启驼峰映射
configuration:
map-underscore-to-camel-case: true
假如有多个查询语句，每次写包路径太过麻烦，所以进行配置简写，只需要写类名就行。
注意:
当查询结果返回值会自己拼接包路径 com.jt.pojo.User
虽然使用了别名包,但是也可以自己指定包路径.
结论:自己不写 执行别名包.自己写了就执行自己的.
3.10.2 驼峰规则映射
1).配置 configuration:配置
#开启驼峰映射
configuration:
map-underscore-to-camel-case: true
2).具体说明
封装对象要保证:表中的字段和对象的属性保持一致，如果不一致可以通过:1,as指定别名。2,resultMap（一般用于多表，单表太麻烦这样写）3,开启驼峰规则映射。
<!--
前提: Mybatis进行映射时必须满足属性名称一致
业务说明:
表: user_id user_name
对象: userId userName
解决方案: 开启mybatis驼峰规则映射
原理:
去掉下划线:字段名称user_id--->去除"_"线--->userid
首字母大写:userId--->属性userId
只要名称一致,则可以自动映射.
注意事项: 如果开启驼峰规则,则必须满足要求.
问: 对象的属性user_id 与字段user_id能否映射? 不能映射
-->
3.11 关于Mapper注解优化说明
==由于每个接口都需要添加Mapper注解导致代码繁琐.可以采用包扫描的方式动态导入 代码如下 : 用的是相对路径。 ==
@SpringBootApplication
@MapperScan("com.jt.dao") //只要告诉mapper的包路径,会自动的完成包扫描（扫描这个当前包的所有接口）
public class SpringbootDemo2MybatisApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootDemo2MybatisApplication.class, args);
}
}
4 MybatisPlus(MP)
4.1 ORM介绍
对象关系映射（英语：Object Relational Mapping，简称ORM，或O/RM，或O/R mapping），是一种程序设计技术，用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。如今已有很多免费和付费的ORM产品，而有些程序员更倾向于创建自己的ORM工具。
实质: 对象与数据库中表完成映射
分析:
- 对象与表一一映射.
- 对象中的属性与表中的字段一一映射.
实质: 以对象的方式操作数据库.
说明 : Mybatis满足ORM对象映射的要求,但是Mybatis是一种半自动化的ORM映射框架。
案例1: Mybatis进行数据库查询时,是否可以直接转化为对象,供用户使用呢???
true 表与对象完成映射.
案例2: Mybatis在进行数据库更新操作时,能否利用对象直接操作呢???
false 不可以.需要自己手写sql.
4.2 业务场景需求
我是一个开发10年的老鸟.,但是我也有我的困扰.后端开发的实质就是如何"优雅"的书写CURD操作,作为老鸟特别喜欢有难度的业务. 但是某些需求执行单表的CURD操作(特别没有营养).
能否有一种框架可以帮助我们自动的实现单表的CURD操作呢?提高开发的效率???(单表的crud不需要手写)
4.3 MybatisPlus
4.3.1 介绍
官网地址: https://baomidou.com
MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
4.3.2 特性
无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作
mp适合单表
4.4 MP工作原理说明
4.4.1 对象和表实现映射
说明:以对象的方式操作数据库.
需求分析:
1.对象与数据库表如何映射?
利用注解实现对象与表绑定 属性与字段绑定.
2.如何解决众多接口编辑雷同的CRUD操作?
定义一个公共的Mapper接口,定义公共的CRUD操作 利用泛型区分对象.
3.数据库只对Sql感兴趣,对对象没兴趣?(如何将对象转化为sql)
思想:按照特定的语法,将对象转化为sql语句.
例子: 将user对象插入数据库中.
userMapper.insert(user对象); //程序员完成的最后的代码
sql: insert into 表名(字段.....) values (属性值......); //由mp动态拼接之后交由mybatis执行.(即sql语句万年不变可以交给框架实现，底层依然调用的是这个sql语句)
4.4.2 利用接口封装公共的CURD方法
说明:MP主要的目的是实现单表的CRUD操作.所以将公共的方法写到同一个接口中 BaseMapper,以后用户使用时,只需要继承即可.
4.4.3 需要将对象动态转化为SQL
要求:以对象的方式操作数据库. 需要方法动态转化为SQL
userMapper.insert(user对象)
Sql: insert into 表名(字段名称1,字段名称2…) values (属性值1,属性值2…)
personMapper.insert(person对象)
Sql: insert into 表名(字段名称1,字段名称2…) values (属性值1,属性值2…)
底层实现时需要动态的拼接Sql即可.
表名: @TableName注解动态获取
字段名称: @TableField(“name”) 获取
属性值: 动态利用get方法取值即可.
MP将上述的sql结构进行拼接最终形成可执行的Sql.之后利用Mybatis执行sql操作.之后再次封装.
4.5 SpringBoot整合MP入门案例
步骤:
1.引入jar包
2.编辑pojo 添加注解 @tableName @tableId
3.实现接口继承Basemapper
4.编辑YML文件配置信息 将mybatis改为mybatis-plus
4.5.1 导入MP的jar包
注意:spring整合mybatis-plus 只导入MP包,删除原来的mybatis的依赖包 因为mp包含了spring mybatis包,不然jar包冲突。
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.2.0</version>
</dependency>
4.5.2 编辑POJO对象
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.实现表与对象的关联 如果表名和对象名一致(忽略大小写)可以省略表名为:@TableName,对象名默认为类名小写。
@TableName("user")
public class User implements Serializable {
/*2.因为这个属性代表主键，所以需要进行标识主键的信息，设置为自增。注意这个“Tableid”中的id代表主键，而不是字段。
* 还可以设置为UUID的形式：@TableId(type = IdType.UUID)
*/
@TableId(type = IdType.AUTO)
private Integer Id;
//3.设置字段和属性的关联。
//2.2如果字段名称与属性的名称一致(包含驼峰规则) value ="字段名称"
//一般用到的属性为2个,exist=true表示当前属性有需要映射的字段，默认为true可以省略。
@TableField(value = "name",exist =true )
private String name;
@TableField(value = "age")//如果字段名称与属性的名称一致(包含驼峰规则),这个注解可以省略不写。
private Integer age;
private String sex;
}
4.5.3 编辑Mapper接口
注意: 指定泛型对象,操作的是哪个表就把那个表的对象加上.泛型的值为po对象的类名。
使用MP，数据层就不需要在写方法和注解了，这个接口之所以写是为了测试普通方式查询所有值。
4.5.4 修改YML文件配置
只需要改下名字 Mybatis—>mybatis-plus
4.5.5 编辑测试类
package com.jt;
import com.jt.dao.UserDao;
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
class SpringbootDemo2MybatisApplicationTests {
@Autowired
private UserDao userDao;
@Test
public void test02(){
//什么都不传即为null:查询所有。
List<User> userList=userDao.selectList(null);
System.out.println(userList);
}
}
测试类运行方式:
运行结果:
4.6 MP API介绍
4.6.1 开放Sql日志（如果需要看sql的执行只需要配置一下日志就行）
server:
port: 8090
servlet:
context-path: /
spring:
datasource:
#driver-class-name: com.mysql.cj.jdbc.Driver #驱动注释,采用默认的方式
url: jdbc:mysql://127.0.0.1:3306/jtdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
username: root
password: root
#Mybatisplus整合
mybatis-plus:
#定义别名包 将实体对象的包路径进行封装.
type-aliases-package: com.jt.pojo
#添加xml文件的依赖
mapper-locations: classpath:/mybatis/mappers/*.xml
#开启驼峰映射
configuration:
map-underscore-to-camel-case: true
# 配置数据库日志 日志级别：info相比debug更全
logging:
level:
#打印哪个包下的日志信息.
com.jt.mapper: debug
4.5.3 crud操作(不知道的API查MP官网)
package com.jt;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.jt.dao.UserDao;
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.Arrays;
import java.util.List;
@SpringBootTest
class SpringbootDemo2MybatisApplicationTests {
@Autowired
private UserDao userDao;
//普通sql查询
@Test
public void testFind(){
List<User> userList = userDao.findAll();
System.out.println(userList);
}
//mp查询所有
@Test
public void testSelect01(){
List<User> userList = userDao.selectList(null);
System.out.println(userList);
}
/**
* 业务: 查询id=11的用户信息 主键...
*/
@Test
public void testSelect02(){
User user = userDao.selectById(11);
System.out.println(user);
}
/**
* 业务: 查询name属性为"小乔"的数据
* sql: select * from user where name="小乔";
* 对象的方式 > sql方式
*/
@Test
public void testSelect03(){
//条件构造器
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "小乔");
List<User> userList = userDao.selectList(queryWrapper);
System.out.println(userList);
}
/**
* 业务: 查询name属性为"小乔"的数据 并且 age >=18岁
* sql: select * from user where name="小乔" and age>=18;
*
* 大于 > gt| 小于 < lt |
* 大于等于 >= ge | 小于等于 le
*/
@Test
public void testSelect04(){
//条件构造器
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "小乔")
.ge("age", 18);
List<User> userList = userDao.selectList(queryWrapper);
System.out.println(userList);
}
/**
* 业务: 查询name中包含 "精"的用户,并且sex为女
* 业务: 查询name中包含 以精结尾的数据,并且sex为女
* sql: select * from user where name like "%精%" and sex="女";
*/
@Test
public void testSelect05(){
//条件构造器
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.likeLeft("name", "精")
.eq("sex", "女");
List<User> userList = userDao.selectList(queryWrapper);
System.out.println(userList);
}
/**
* 需求: 查询user表中的数据 要求按照年龄降序排列,如果年龄相同按照id降序排列
*/
@Test
public void testSelect06(){
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.orderByDesc("age","id");
List<User> userList = userDao.selectList(queryWrapper);
System.out.println(userList);
}
/**
* 需求: 查询name属性为null的数据.
* where name is null
*/
@Test
public void testSelect07(){
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.isNull("name");
List<User> userList = userDao.selectList(queryWrapper);
System.out.println(userList);
}
/**
* 查询name="小乔" age=17 性别=女的用户
* 如果传递的是对象.会根据对象中不为null的属性充当where条件.
*/
@Test
public void testSelect08(){
User user = new User();
user.setName("小乔").setAge(17).setSex("女");
QueryWrapper<User> queryWrapper = new QueryWrapper<>(user);
List<User> userList = userDao.selectList(queryWrapper);
System.out.println(userList);
}
/**
* 查询id=1,3,5,10数据.
* sql: select * from user where id in (1,3,5,10)
*/
@Test
public void testSelect09(){
//转化时,注意使用对象的类型
Integer[] ids = {
1,3,5,10};
List<Integer> idList = Arrays.asList(ids);
List<User> userList = userDao.selectBatchIds(idList);
System.out.println(userList);
}
@Test
public void testInsert(){
User user = new User();
user.setName("特朗普").setAge(70).setSex("男");
userDao.insert(user);
}
/**
* 删除name=null的数据,或者name="特朗普"
*/
@Test
public void testDelete(){
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.isNull("name")
.or()
.eq("name", "特朗普");
userDao.delete(queryWrapper);
}
/**
* 案例1: 将id=1的数据的年龄改为8000岁.
* sql1: update user set age=8000 where id=1;
* 案例2: 要求将name="黑熊精" age=5500.
* sql2: update user set age=5500 where name="黑熊精";
*/
@Test
public void testUpdate(){
User user = new User();
user.setId(1); //主键充当where条件
user.setAge(8000);
userDao.updateById(user);
//参数说明 1.实体对象 封装set条件的值
// 2.更新条件构造器
User temp = new User();
temp.setAge(5500);
UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("name", "黑熊精");
userDao.update(temp,updateWrapper);
}
}
如果不知道条件构造器的方法可以在官网查看–快速开始–核心功能—条件构造器查找（网址在上面）