进阶项目 03 使用mybatis-plus（不需要写sql语句了）

01.导入依赖

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

02.修改yml文件

server:
	port: 8080
	servlet:
		context-path: /
spring:
	datasource:
		driver-class-name: com.mysql.jdbc.Driver
		url: jdbc:mysql:///jtdb?
		serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8
		username: root
		password: root
#mybatis-plus的配置
mybatis-plus:
	#resultType="User"可以映射结果对象时可以省略包路径
	type-aliases-package: com.jt.pojo
	#加载mapper的映射文件路径
	mapper-locations: classpath:/mybatis/mappers/*.xml
	#数据表中的user_id的值userId item_id--->itemId
	#开启驼峰规则
	configuration:
		map-underscore-to-camel-case: true
#动态的展示sql
logging:
	level:
		com.jt.mapper: debug

03.需要修饰的pojo实体类需要的几个注解
01.@TableName(value=“xxx”)

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain=true)
@TableName(value="user")
public class user implements Serializable {
	@TableId(type = IdType.AUTO  )
 private Integer id;
 private String name;
 private Integer age;
 private String sex;
}

表示的是这个被注解@TableName(value=“xxx”)修饰的类，与数据库中的表（表名是xxx）一一对应，也就是说这个在项目中的user类的属性，与数据库中的表user的列名一一对应。

@TableId(type = IdType.AUTO )表示修饰的类的属性，是数据库中的相关表的主键（AUTO表示主键自增）

假如有属性与数据库中的表的列名不一致，但是又想要一一对应的话，可以使用@TableField（“数据库中的列名”）

03.dao接口的修改

mybatis-plus也是需要dao接口的

package com.jt.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.pojo.user;

@Mapper
public interface userMapper extends BaseMapper<user> {
    public List<user> findall();
}

extends BaseMapper 项目中的dao接口需要去扩张抽象类BaseMapper，其中的泛型T是项目中被修饰的实体类的类名，这里的实体类是user，所以T就改写成user。

依赖的版本过高，会导致空指针异常。

04.测试mp的方法。

package com.jt;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jt.mapper.userMapper;
import com.jt.pojo.user;

@SpringBootTest
public class testUserMapper {
	@Autowired
	userMapper usermapper;
	@Test
	public void testusermp() {
	List<user> list=usermapper.selectList(null);
	for (user user : list) {
		System.out.println(user);
	}
	}

	@Test
	public void testselectbyid()
	{
		/**
		* 需求:可以一次性根据多个id查询数据库
		* sql：select * from user where id in（xxx,xxx,xxx）
		*/
		List<Integer> list=new ArrayList<>();
		list.add(1);
		list.add(3);
		list.add(5);
	    List<user> userlist=usermapper.selectBatchIds(list);
		System.out.println(userlist);
	}
	
	@Test
	public void testselectbywheremap()
	{
		/**
		* 需求：根据指定的字段，然后实现查询
		* sql:select * from user where name=? and age=?;
		*/
		Map<String,Object> map=new HashMap<>();
		map.put("name", "金角大王");
		map.put("age", "3000");
	    List<user> userlist=usermapper.selectByMap(map);
		System.out.println(userlist);
	}
	
	/**
	* 需求：模糊查询
	* 1.name属性包含"精"的数据，并且为女性
	* sql:where name like %精% and sex=“女”;
	* > gt =eq <lt
	* >=ge <=le
	* SELECT id,sex,name,age FROM user WHERE (name LIKE ? AND sex = ?)
	*/
	
	@Test
	public void testselectbywherelike()
	{
		/**
		* 需求：模糊查询
		* 1.name属性包含"精"的数据，并且为女性
		* sql:where name like %精% and sex=“女”;
		* > gt =eq <lt
		* >=ge <=le
		* SELECT id,sex,name,age FROM user WHERE (name LIKE ? AND sex = ?)
		*/
		//条件构造器的作用：拼接where条件，多个条件时，使用and连接
		
		QueryWrapper<user> queryWrapper=new QueryWrapper<>();
		queryWrapper.like("name", "精").eq("sex", "女");
		List<user> list=usermapper.selectList(queryWrapper);
		System.out.println(list);
	}
	
	/**
	* 需求：查询年龄在18~35之间的女性用户
	* where age between 18 and 35 and sex=女
	*/
	
	@Test
	public void testselectbywhereagebetween()
	{
		/**
		* 需求：查询年龄在18~35之间的女性用户
		* where age between 18 and 35 and sex=女
		*/
		//条件构造器的作用：拼接where条件，多个条件时，使用and连接
		
		QueryWrapper<user> queryWrapper=new QueryWrapper<>();
		queryWrapper.ge("age", 18).le("age", 35);
		List<user> list=usermapper.selectList(queryWrapper);
		System.out.println(list);
	}
	
	/**
	* 需求：查询年龄大于100岁的，并且按照年龄降序排序，如果年龄相同的再按照id排序
	* order by 字段 asc/desc
	* SELECT id,sex,name,age FROM user WHERE (age > ?) ORDER BY age DESC , id
	DESC
	*/
	
	@Test
	public void testselectbywhereageorderby()
	{
		/**
		* 需求：查询年龄大于100岁的，并且按照年龄降序排序，如果年龄相同的再按照id排序
		* order by 字段 asc/desc
		* SELECT id,sex,name,age FROM user WHERE (age > ?) ORDER BY age DESC , id
		DESC
		*/
		//条件构造器的作用：拼接where条件，多个条件时，使用and连接
		
		QueryWrapper<user> queryWrapper=new QueryWrapper<>();
		queryWrapper.gt("age", 100).orderByDesc("age","id");
		List<user> list=usermapper.selectList(queryWrapper);
		System.out.println(list);
	}
		/**
	* 需求：查询以“乔”字（%乔）结尾的，并且性别为女，并且age小于30，按照年龄降序排序
	* SELECT id,sex,name,age FROM user WHERE (name LIKE ? AND sex = ? AND age <
	?) ORDER BY age DESC
	*/
	@Test
	public void testselectbywherenamesexageorderby()
	{
		/**
		* 需求：查询以“乔”字（%乔）结尾的，并且性别为女，并且age小于30，按照年龄降序排序
		* SELECT id,sex,name,age FROM user WHERE (name LIKE ? AND sex = ? AND age <
		?) ORDER BY age DESC
		*/
		//条件构造器的作用：拼接where条件，多个条件时，使用and连接
		
		QueryWrapper<user> queryWrapper=new QueryWrapper<>();
		queryWrapper.likeLeft("name", "乔").eq("sex", "女").lt("age",30).orderByDesc("age") ;
		List<user> list=usermapper.selectList(queryWrapper);
		System.out.println(list);
	}
	/**
	* 需求：嵌套查询
	* 条件：查询age<100岁的用户，并且性别与name=孙尚香的性别相同的用户数据
	*/
	@Test
	public void testSelect07() {
		/**
		* 需求：嵌套查询
		* 条件：查询age<100岁的用户，并且性别与name=孙尚香的性别相同的用户数据
		*/
	//条件构造器的作用：拼接where条件，多个条件时，使用and连接
	QueryWrapper<user> queryWrapper=new QueryWrapper<>();
	queryWrapper.lt("age", 100).inSql("sex", "select sex from user where name='孙尚香'");
	List<user> userList = usermapper.selectList(queryWrapper);
	System.out.println(userList);
	}
	/**
	* 需求：查询年龄=18岁的用户的记录数
	* sql：select count(*) from user where age=18
	*/
	@Test
	public void testSelectcount() {
		/**
		* 需求：查询年龄=18岁的用户的记录数
		* sql：select count(*) from user where age=18
		*/
	//条件构造器的作用：拼接where条件，多个条件时，使用and连接
	QueryWrapper<user> queryWrapper=new QueryWrapper<>();
	queryWrapper.eq("age", 18);
	int num = usermapper.selectCount(queryWrapper);
	System.out.println(num);
	}


	/**
	* 需求：查询name为金角大王的用户的信息
	* 注意：用selectone()必须保证查询的记录只有一条
	*/
	@Test
	public void testSelectbyname() {
	QueryWrapper<user> queryWrapper=new QueryWrapper<>();
	queryWrapper.eq("name", "金角大王");
	user user=usermapper.selectOne(queryWrapper);
	System.out.println(user);
	}
	/**
	* 新增用户信息
	* sql：insert into user(sex,name,age) values(?,?,?)
	*/
	@Test
	public void testisnert() {
	user user=new user();
	user.setAge(18).setName("小小").setSex("男");
	int num=usermapper.insert(user);
	System.out.println(num);
	}
	
		/**
	* 修改：基于id修改用户信息
	*/
	@Test
	public void testupdatebyid() {
	user user=new user();
	user.setAge(18).setName("小小").setSex("男").setId(20);
	int num=usermapper.updateById(user);
	System.out.println(num);
	}
	
		/**
		* 需求：将name=null的数据进行修改
		*/
	@Test
	public void testupdatewherenamenotnull() {
	
	user user=new user();
	user.setAge(18).setName("小小").setSex("男").setId(9);
	
	//UpdateWrapper是封装where条件，user是封装数据对象
	UpdateWrapper<user> updateWrapper=new UpdateWrapper<>();
	updateWrapper.isNull("name");
	int num=usermapper.update(user, updateWrapper);
	System.out.println(num);
	}
	/**
    * 删除id=49的用户
	*/
	@Test
	public void testdeletebyid() {
	int rows = userMapper.deleteById(49);
	System.out.println(rows);
	}
	/**
	* 基于多个id进行批量删除
	*/
	@Test
	public void testdeleteinids() {
	List<Integer> idList=new ArrayList<>();
	idList.add(46);
	idList.add(50);
	int rows=userMapper.deleteBatchIds(idList);
	System.out.println(rows);
	}

/**
	* 基于条件删除
	*/
	
	//UpdateWrapper是封装where条件
	//user是封装数据对象
	@Test
	public void testdeleteupdatewhere() {
    QueryWrapper<user> Wrapper=new QueryWrapper<>();
	Wrapper.isNull("name");
	int num=usermapper.delete(Wrapper);
	System.out.println(num);
	}
	/**
	* 基于所指定的字段然后进行删除
	*/
	@Test
	public void testdeletewheresomething() {
    Map<String,Object> map=new HashMap();
	map.put("name", "1");
	int num=usermapper.deleteByMap(map);
	System.out.println(num);
	}