java学习day64-JT项目02

SpringBoot程序加强

属性赋值问题

业务需求

​ 说明: 如果将配置信息,通过代码的形式写死到代码中,这样的话程序的耦合性高,不便扩展.
​ 需求: 能否为对象的属性,动态赋值.

@RestController
public class MsgController {
	private String username;//定义一个用户
	private String password;//定义用户密码
	
	@RequestMapping("getMsg")
	public String getMsg() {
		this.username="root";
		this.password="1234";
		return username+"|"+password;
	}

@Value方式赋值

1).编辑YML配置文件

server:
  port: 8090
  servlet:
    context-path: /
#在配置文件种提娜佳属性和属性值,为了防止重名发生,则添加前缀进行区分
jdbc:
  username: root用户名
  password: 1234

2). 编辑MsgController实现属性赋值,spel表达式赋值

@RestController
public class MsgController {
	//需求:利用yml配置文件的信息为属性赋值
	//@Value注解的作用:从spring容器中找到具体的key,为属性赋值
	@Value("${jdbc.username}")//spel表达式,spring提供
	private String username;//定义一个用户
	
	@Value("${jdbc.password}")
	private String password;//定义用户密码	
	@RequestMapping("getMsgValue")
	public String getMsgValue() {
		
		return username+"|"+password;
	}	
}

批量为属性赋值

业务需求

​ 有时某些配置可能需要很多的属性信息.如果这时利用@Value的方式赋值.则必然导致代码冗余.可读性差.
解决方案: 采用批量赋值的方式.

添加jar包文件

<!--添加属性注入依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

编辑MsgController2

@ConfigurationProperties(prefix = "jdbc")注解

@RestController
@ConfigurationProperties(prefix = "jdbc")
public class MsgController2 {
	//利用配置文件为属性赋值,要求配置文件的属性与类中的属性名称必须一致. 自动的赋值.
	private String username;//定义一个用户
	private String password;//定义用户密码
	
	//为属性赋值一定要调用set方法
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	@RequestMapping("/getMsgPrefix")
	public String getMsgValue() {
		return username+"|"+password;
	}
	
}

指定配置文件为属性赋值

业务说明

YML配置文件是SpringBoot程序的核心文件.在其中添加了整合环境的重要的配置.如果有时需要业务数据进行赋值操作时.最好的方式应该采用properties的方式赋值. (通用!!!)

编辑properties配置文件

如果需要中文,需要设置编码格式

步骤:选中文件-->右键-->properties-->选择UTF-8

编辑MsgController

说明:动态引入properties配置文件

@RestController
//properties与spring容器建立关系,指定pro文件之后,进行加载. 默认的加载策略,采用ISO-8859-1编码
//如果其中包含中文,则应该采用utf-8格式编码.
@PropertySource(
    value = "classpath:/properties/jdbc.properties",
    encoding = "UTF-8")
public class MsgController {
    //需求:利用yml配置文件的信息为属性赋值
    //@Value注解的作用:从spring容器中找到具体的key,为属性赋值
    @Value("${jdbc2.username}")//spel表达式,spring提供
    private String username;//定义一个用户

    @Value("${jdbc2.password}")
    private String password;//定义用户密码

    @RequestMapping("getMsgValue")
    public String getMsgValue() {

        return username+"|"+password;
    }	
}

热部署配置

导入依赖即可

<!--支持热部署 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
		</dependency>

环境切换问题

情景需求

测试环境: 要求端口号 8080 用户名为root 密码root. 等.
生产环境: 要求端口号 80 用户名 为admin 密码1234 等
由于工作需要.需要不停的在2个环境中切换.
问题如何简化操作?

解决思路:

我们可以配置多个环境,最好的方式就是将来只需要将对应的环境的名称修改就可以完成环境的切换

编辑YML配置文件(实现环境切换)

#指定默认的环境
spring:
  profiles:
    active: prod #在此位置修改环境即可
---
spring:
  profiles: test

server:
  port: 8090
  servlet:
    context-path: /
#在配置文件种提娜佳属性和属性值,为了防止重名发生,则添加前缀进行区分
jdbc:
  username: root用户名
  password: 1234
---  
spring:
  profiles: prod
  
server:
  port: 8091
  servlet:
    context-path: /
#在配置文件种提娜佳属性和属性值,为了防止重名发生,则添加前缀进行区分
jdbc:
  username: root用户名
  password: root

LOMBOK校验

添加jar包文件

<!--引入插件lombok 自动的set/get/构造方法插件  -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

安装LOMBOK插件

1).找到lombok本地磁盘位置

2).执行jar包文件

3).安装文件

4).校验LOMBOK插件

常用注解

@Data  //动态的生成get和set以及toString方法
@AllArgsConstructor//动态生成全参数构造
@NoArgsConstructor//动态生成无参构造
@Accessors(chain = true)//动态生成链式加载结构
public class User {
	private Integer id;
	private String name;
}

关于链式加载结构就是如下方式:

User user = new User();
user.setId(101).setName("诺手").setAge(23).setSex("男");

关于LOMBOK面试题

问题: 通过lombok可以添加set/get/toString等方法.但是需要运行环境中添加lom插件才行.如果将来程序在Linux系统中发布.问:是否需要提前安装lombok插件?

A.不需要 B 需要 C 不知道/无所谓

解析:

​ lombok在程序编译期有效,当程序由.java文件编译为.class文件时,lombok插件开始工作.动态生成了get/set等方法. 而Linux中运行的项目直接.jar包文件里边包含了.class类型文件.所以不需要lombok插件再次编译即可运行.和lombok是否安装无关.

SpringBoot整合Mybatis

新建项目

1).创建项目

2).添加项目名称

添加POM.xml文件

<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>
    <groupId>com.jt</groupId>
    <artifactId>springboot_demo_2</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <!--利用parent标签,springBoot项目整合了其他框架的包及具体的配置都在parent中进行了定义. 定义了版本包信息. -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <!--当前maven配置信息 -->
    <properties>
        <java.version>1.8</java.version>
        <!-- 指定maven插件版本 -->
        <maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
        <!-- 跳过测试类打包 -->
        <skipTests>true</skipTests>
    </properties>

    <!--项目的依赖信息. Maven: jar包具有依赖性 A ~~~~ B ~~~~~C 导入A时BC都会自动导入. -->

    <dependencies>
        <dependency>
            <!--组ID:一般公司域名倒写 -->
            <groupId>org.springframework.boot</groupId>
            <!--项目名称 -->
            <!--SpringMVC的配置信息 jar 配置文件 开箱即用的效果 定义 -->
            <artifactId>spring-boot-starter-web</artifactId>
            <!--项目版本号 -->
            <!-- <version>父级中进行了定义</version> -->
        </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>

        <!--添加属性注入 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <!--支持热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </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>
        </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>2.1.3</version>
        </dependency>

    </dependencies>

    <!-- maven项目指定的插件配置 该插件主要负责 maven项目相关操作 打包/test/clean/update等相关maven操作 注意事项:但凡是maven项目则必须添加 
  插件.否则将来项目部署必然出错 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

YML配置文件

1).关于数据源配置

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: 1234

说明:

serverTimezone=GMT%2B8 表示东8区
useUnicode=true&characterEncoding=utf8 使用指定的字符集编码
&autoReconnect=true 数据库连接断开之后,是否自动重连
&allowMultiQueries=true 是否允许批量操作sql语句. 一般查询居多 允许

2).关于配置Mybatis整合关系

 mybatis:
  # 定义别名包
  type-aliases-package: com.jt.demo.pojo
  # 批量导入mapper映射文件
  mapper-locations: classpath:/mybatis/mappers/*.xml
  #开启驼峰映射,一旦开启驼峰命名规则,则必须按照规则执行
  configuration:
    map-underscore-to-camel-case: true

3).关于Mybatis 配置介绍

<mapper namespace="com.jt.demo.mapper.UserMapper">
    <!--说明:如果每次数据库操作,都需要写pojo的包路径,则编码比较繁琐. 
  优化策略:可以使用别名包代替.
  问题1: 老师如果使用了别名包,还能不能再使用原路径. 
  答案:  可以正常执行.   有路径则根据路径执行,没有路径则根据别名包执行.
         如果都没有,则报错处理.
  -->
    <select id="findAll" resultType="User">
        select * from user
    </select>

    <!--关于驼峰规则说明
  map-underscore-to-camel-case: true  开启驼峰规则映射.

  表:
    字段:   user_Id,user_age,user_sex

  对象:
    属性:   userId,userAge,userSex

  如果上述的配置,利用restType的方式进行映射时,则不能成功赋值.

  开启驼峰映射:
   user_id ~~~~~去除中间的"_"线userid ~~~~~之后"首字母大写"userId(大小写无关)
   之后将数据映射给对象的属性.

  问题: 
   1.如果开启了驼峰规则映射,则能否违反该约定.
   例如  字段信息~user_id   | 属性~user_id    
   能否映射? 不能映射. 但是程序也不会报错.只不过user_id的属性为null.

  结论: 开启了驼峰映射规则,则必须按照规则定义.
   -->

</mapper>

开启日志

#引入log输出
logging:
  level:
    com.jt.demo.mapper: debug

MybatisPlus介绍

官方地址

MP介绍

​ MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

愿望: 以面向对象的方式操作数据库!

JPA思想

​ JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。 [1]
​ Sun引入新的JPA ORM规范出于两个原因：其一，简化现有Java EE和Java SE应用开发工作；其二，Sun希望整合ORM技术，实现天下归一。

MybatisPlus 原理说明

核心:

1. 表与对象建立关联关系
   对象名称 ---------> 表名
   对象的属性 -------> 数据表中的字段.
2. 采用第三方接口 规范所有的单表操作规则.(封装思想)
3. 将CURD接口方法,必须按照sql的规范转化为指定的sql语句.

思考:

1. 对象与表如何关联? 通过注解实现对象与表映射
2. 如何将curd操作做到统一定义? 将CRUD操作统一封装到Mapper接口中. 其他的Mapper只需要集成即可.
3. 数据库只能识别sql语句. 如何将对象与sql转化???
   将对象的操作动态的转化为sql语句.之后交给Mybatis执行

1. userMapper.insert(user对象);
insert into user  values(#{id},#{name},#{age}....)

2. deptMapper.insert(dept对象);
insert into dept  values(.....)
//不一样的就是表面以及字段,因此可以提供一个规范

导入jar包文件

说明: 导入MP包之后,将原有的Mybatis包删除.

<!--spring整合mybatis-plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.2.0</version>
</dependency>

编辑POJO对象--User

继承公共的Mapper接口

修改YML配置文件

说明:由mybatis的配置切换为mybatis-plus的配置

#切换为mybatis-plus的配置
mybatis-plus:
    #定义别名包
  type-aliases-package: com.jt.demo.pojo
   #批量导入mapper映射文件
  mapper-locations: classpath:/mybatis/mappers/*.xml
    #开启驼峰映射,一旦开启驼峰映射,就必须按照规则执行
  configuration:
    map-underscore-to-camel-case: true

Mybatis入门案例

@SpringBootTest
public class TestMybatis {	
	@Autowired
	private UserMapper userMapper;
	@Test
	public void testFindUser() {
		
		List<User> userList = userMapper.findAll();
		System.out.println(userList);
	}
	//1:利用MP实现查询所有的数据
	@Test
	public void selectList() {	
		List<User> userList = userMapper.selectList(null);
		System.out.println(userList);
	}
}

MP API学习

具体API可以查询这里

查询的相关API演示

定义条件构造器,动态拼接where之后的数据,对其属性的设置其实也就是对where条件的改造

QueryWrapper<User> queryWrapper = new QueryWrapper<>();

Select

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

实例:

package com.jt.demo.test;
@SpringBootTest
public class TestMybatis {
	@Autowired
	private UserMapper userMapper;
	@Test
	public void testFindUser() {		
		List<User> userList = userMapper.findAll();
		System.out.println(userList);
	}
	//利用MP查询所有的数据
	@Test
	public void selectList() {
		
		List<User> selectList = userMapper.selectList(null);
		
		for (User user : selectList) {
			System.out.println(user);
		}
	}
	//用户入库操作,将对象中不为null的对象当作执行要素
	@Test
	public void insert() {
		User user = new User();
		user.setName("诺手");
		user.setAge(23);
		user.setSex("男");
		userMapper.insert(user);
		
	}
	//查询名字等于诺手的用户
	// SELECT id,sex,name,age FROM user WHERE name=? 
	@Test
	public void select01() {
		//定义条件构造器,动态拼接where之后的数据
		User user = new User();
		user.setName("诺手");
		QueryWrapper<User> queryWrapper = new QueryWrapper<>();
		
		List<User> selectList = userMapper.selectList(queryWrapper);
		for (User user2 : selectList) {
			System.out.println(user2);
		}	
	}
	
	//查询性别是女的用户,要求年龄大于200
	//逻辑运算符 = eq，> gt,< lt, >= ge，<= le
	@Test
	public void select02() {
		//定义条件构造器,动态拼接where之后的数据
		QueryWrapper<User> queryWrapper = new QueryWrapper<>();
		queryWrapper.eq("sex", "女");
		queryWrapper.gt("age",18);
		List<User> selectList = userMapper.selectList(queryWrapper);
		for (User user2 : selectList) {
			System.out.println(user2);
		}	
	}
	
	//查询用户中名字包含"精"的用户 like
	//SELECT id,sex,name,age FROM user WHERE (name LIKE ?) 
	// 查询name中以"精"结尾 like %精
	//
	@Test
	public void select03() {
		//定义条件构造器,动态拼接where之后的数据
		QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//		queryWrapper.like("name", "精");
		queryWrapper.likeLeft("name", "精");//
		List<User> selectList = userMapper.selectList(queryWrapper);
		for (User user2 : selectList) {
			System.out.println(user2);
		}	
	}
	/**
	 *  	案例: age between and 操作(年龄在18-30并且性别是男)
	 *  	规则: 查询多条件下默认使用的是and
	 *   Preparing: SELECT id,sex,name,age FROM user WHERE (age BETWEEN ? AND ? AND sex = ?) 
	 */
	@Test
	public void select04() {
		//定义条件构造器,动态拼接where之后的数据
		QueryWrapper<User> queryWrapper = new QueryWrapper<>();
		queryWrapper.between("age", 18, 30).eq("sex", "男");
		List<User> selectList = userMapper.selectList(queryWrapper);
		for (User user2 : selectList) {
			System.out.println(user2);
		}	
	}
	/**
	 * 		查询name不为null的用户信息,
	 * 		 并且根据age降序排列,如果age相同则按照sex排序 
	 *  select * from user where name is not null  order by age desc,sex;
	 */
	@Test
	public void select05() {
		//定义条件构造器,动态拼接where之后的数据
		QueryWrapper<User> queryWrapper = new QueryWrapper<>();
		queryWrapper.isNotNull("name")
					.orderByDesc("age").orderByAsc("sex");
		List<User> selectList = userMapper.selectList(queryWrapper);
		for (User user2 : selectList) {
			System.out.println(user2);
		}	
	}
	/*
	 * 查询单个用户数据
	 */
	@Test
	public void select06() {
		//根据用户的id查询用户的信息
		User user = userMapper.selectById(1);
		System.out.println(user);
		//根据非主键的字段查询单个数据
		QueryWrapper<User> queryWrapper = new QueryWrapper<>();
		queryWrapper.eq("name", "阿狸");
		User selectOne = userMapper.selectOne(queryWrapper);
		System.out.println(selectOne);
		
	}
	//批量查询数据   要求查询id 1 3 5 8 10..
	//单表操作可以使用in/or 但是多表操作不建议使用
	@Test
	public void select07() {
        //采用自己封装list
        List<Integer> idList = new ArrayList<>();
		idList.add(1);
		idList.add(3);
		idList.add(5);
		idList.add(8);
		Integer[] ids = {1,2,3,4,5};
		//将数组类型转化为集合类型
		List<Integer> list = Arrays.asList(ids);
		List<User> list1 = userMapper.selectBatchIds(list);
		for (User user : list1) {
			System.out.println(user);
		}
	}
	/**
	 * 	查询name不为null的记录总数
	 */
	@Test
	public void select08() {
		QueryWrapper<User> queryWrapper = new QueryWrapper<>();
		queryWrapper.isNotNull("name");
		int count = userMapper.selectCount(queryWrapper);
		System.out.println(count);
	}
}

删除的相关API演示

Delete

// 根据 entity 条件，删除记录
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 删除（根据ID 批量删除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 ID 删除
int deleteById(Serializable id);
// 根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

实例:

package com.jt.demo.test;
@SpringBootTest
public class TestDelete {
	@Autowired
	private UserMapper userMapper;
	//根据id删除
	@Test
	public void delete01() {
		int rows = userMapper.deleteById(1);
		System.out.println("影响行数为"+rows);
	}
	//根据 entity 条件，删除记录
	//删除姓名为妲己的用户
	@Test
	public void delete02() {
		UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
		updateWrapper.eq("name", "妲己");
		int rows = userMapper.delete(updateWrapper);
		System.out.println("影响行数"+rows);	
	}
	//删除（根据ID 批量删除）
	@Test
	public void delete03() {
		Integer[] ids = {1,2,3,4,5};
		List<Integer> asList = Arrays.asList(ids);
		int rows = userMapper.deleteBatchIds(asList);
		System.out.println("影响行数"+rows);	
	}

	//根据 columnMap 条件，删除记录
	//删除所有年龄为2000的用户
	@Test
	public void delete04() {
		Map<String,Object> columnMap = new HashMap<>();
//		columnMap.put("name", "八戒");
		//如果put两个默认时and逻辑
		columnMap.put("age", 2000);
		int rows = userMapper.deleteByMap(columnMap);
		System.out.println("影响行数为"+rows);
	}
}

修改的相关API演示

Update

// 根据 whereEntity 条件，更新记录
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

实例

package com.jt.demo.test;

@SpringBootTest
public class TestUpdate {
	@Autowired
	private UserMapper userMapper;	
	//根据id修改信息
	@Test
	public void update01() {
		User user = new User();
		user.setId(6);
		user.setName("寒冰");
		user.setSex("女");
		user.setAge(2000);
		int rows = userMapper.updateById(user);
		System.out.println("影响行数"+rows);
	}
	//将name=null的用户信息 name改为="测试案例" sex="男" age=1;
    //UPDATE user SET sex=?, name=?, age=? WHERE (name IS NULL) 
	@Test
	public void update02() {
		User user = new User();
		user.setName("寒冰").setSex("女").setAge(2000);
		UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
		updateWrapper.isNull("name");
		int rows = userMapper.update(user, updateWrapper);
		System.out.println("影响行数"+rows);
	}
}

新增的相关API演示

Insert

// 插入一条记录
int insert(T entity);

实例:

package com.jt.demo.test;

@SpringBootTest
public class TestInsert {
	@Autowired
	private UserMapper userMapper;
	//新增一个用户
	@Test
	public void insert01() {
		User user = new User();
		user.setName("电耗子").setAge(89).setSex("男");
		int rows = userMapper.insert(user);
		System.out.println("影响行数"+rows);
		
	}	
}