public interface UserMapper extends BaseMapper<User>{
    /*
    原來Mybatis中：我們需要在mapper中自定義方法，然后在mapper.xml中使用sql實現(xiàn)方法
    但是使用了Mybatis-plus之后，我們直接繼承 “BaseMapper<>”：它里面有單表的增刪改查各種方法以及實現(xiàn)
    我們繼承它以后就擁有了這些方法，就不用寫mapper.xml文件了;
     */
}

@SpringBootTest  //這個注解：就會自動完成ioc容器初始化，我們想要誰直接拿即可?。。。。。。。。。。。。。。。?！
public class SpringBootMybatisPlusTest {
    @Autowired
    private UserMapper userMapper; //拿到對象?。?！
    public void test(){
        List<User> users = userMapper.selectList(null); //不傳參數(shù)：直接寫null：代表查詢?nèi)繑?shù)據(jù);
                           直接調(diào)用baseMapper接口中相應的方法即可
    }
}

（1）mapper接口
		如果我們想要對User表的數(shù)據(jù)進行單表CRUD：
		  我們使用Mybatis-plus之后：我們只需要：
		   1.創(chuàng)建mapper接口
		   2.繼承 BaseMapper<User> （要操作的表/實體類）：我們就會擁有CRUD方法+CURD的sql語句
		 */
		public interface Use rMapper extends BaseMapper<User> {
			//繼承之后：下面就相當于有了方法
		}
（2）測試類：
	@SpringBootTest
public class MybatisPlusTest {
	@Autowired
	private UserMapper userMapper;
	//（1）insert：
	@Test
	public void test(){
	   User user=new User();
	   user.setName("kun");
	   user.setAge(88);
	   user.setEmail("xxx");
	   //baseMapper提供的數(shù)據(jù)庫insert方法
		int row = userMapper.insert(user);
	}
	//(2)delete:
	@Test
	public void test_delete(){
		//1.根據(jù)id刪除：（）內(nèi)裝值
		int rows = userMapper.deleteById(1687124323556002889L);
		//2.根據(jù)id刪除：age=20  name=jack; ()內(nèi)裝條件： -->拼接條件
		Map param=new HashMap();
		param.put("age",20);     //-->刪除age=20 + name=jack
		param.put("name","jack");
		int i = userMapper.deleteByMap(param);
		System.out.println("i = " + i);
		//wrapper 條件封裝對象，無限封裝條件;
		//userMapper.delete(wrapper)
	}
	//(3)Update()
	@Test
	public void test_update(){
		//1.將主鍵userId為1的age改為30:  ()內(nèi)裝值
		  //update user set age=30 where id=1:就等同于下方
		User user=new User();
		user.setId(1L);
		user.setAge(30);
		int i = userMapper.updateById(user);
		//2.將所有人age改為20
		User user1=new User();
		user1.setAge(20); //
		int update = userMapper.update(user1, null);// null:代表沒條件，該所有
		System.out.println("update = " + update);
		/*
		TODO:update：當屬性為null時：代表不修改
			 updateById():實體類的id必須有值
			 update() :實體類可以沒有id值
		 */
	}
	//(4)select a:根據(jù)主鍵查詢  b：根據(jù)主鍵集合查詢
	public void test_select(){
		//a:根據(jù)id查詢
		User user = userMapper.selectById(1);
		//b：根據(jù)集合查詢：eg：根據(jù)ids查詢
		List<Long> ids=new ArrayList<>();
		ids.add(1L);
		ids.add(2L);
		List<User> users = userMapper.selectBatchIds(ids); //selectBatchIds：批量ids
		System.out.println("users = " + users);
	}
}

-04
@SpringBootApplication
@MapperScan("com.atguigu.mapper")
/*
啟動類也是配置類：所以我們可以聲明帶@Bean的方法
1.配置一個分頁的插件：Mybatis-plus提供的，我們直接加進來使用就行了;
  在配置類/啟動類：中使用@Bean返回
 */
public class Main {
	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
		@Bean
		//1.將Mybatis-plus插件加到ioc容器
		public MybatisPlusInterceptor plusInterceptor(){
			//a:是所有Mybatis-plus的插件集合:我們想要使用任何插件都可以加到這個集合中去;eg:我們可以將分頁插件加到里面;
			MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
			//b:加入分頁插件：
			mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
																						//指定數(shù)據(jù)庫
			return mybatisPlusInterceptor;
		}
}
/*
測試類：
2.之后就可以使用分頁插件了：
 */
@SpringBootTest
public class MybatisPlusTest {
	@Autowired
	private UserMapper userMapper; //注入UserMapper對象：進行數(shù)據(jù)庫操作
	@Test
	public void testPage(){
		//a：創(chuàng)建Page對象: 參數(shù)解釋：(參數(shù)1：頁碼， 參數(shù)2：頁容量)
		Page<User> page=new Page<>(1,3);
		userMapper.selectPage(page,null); //需要放入Page對象
		//最后分頁的結(jié)果也會被封裝到page里面:-->所以直接通過page對象獲取結(jié)果即可
		long pages = page.getPages();
		long current = page.getCurrent(); //獲取當前頁碼、
		List<User> records = page.getRecords(); //獲取當前頁數(shù)據(jù)
		long total = page.getTotal();//獲取總條數(shù)
	}
}

public interface UserMapper extends BaseMapper<User> {
	//繼承BaseMapper接口:里面有單表的方法
	/*
	演示：自定義mapper方法實現(xiàn)分頁：
	  eg:查詢
	 */
	//1.在mapper接口中定義抽象方法：但是：方法的第一個參數(shù)：要傳一個IPage，返回值要是IPage，里面寫查詢集合的泛型即可
   IPage<User> queryByAge(IPage<User>page, @Param("age") Integer age);
}
2.
	<!--2.使用sql語句實現(xiàn)UserMapper接口的方法：不用在最后加limit，！-->
	<select id="queryByAge" resultType="com.atguigu.pojo.User"> <!--resultType:泛型-->
		select * from user where age>#{age}
	</select>
 3.
		 /*
	 3.測試自定義方法分頁
	  */
	public void test_MyPage(){
		//a:傳一個分頁插件的值：
		Page<User> page=new Page<>(1,3);
		//b.
		userMapper.queryByAge(page,1);
		//c:
		//最后分頁的結(jié)果也會被封裝到page里面:-->所以直接通過page對象獲取結(jié)果即可
		long pages = page.getPages();
		long current = page.getCurrent(); //獲取當前頁碼、
		List<User> records = page.getRecords(); //獲取當前頁數(shù)據(jù)
		long total = page.getTotal();//獲取總條數(shù)
		System.out.println("total:"+total);
	}
}

使用方法：
     1.在mapper接口中定義方法，并繼承base接口（提供了各種方法的實現(xiàn)）
     2.直接使用java代碼實現(xiàn)：不需要在mapper.xml文件中實現(xiàn)了
     //a:創(chuàng)建QueryWrapper
  	QueryWrapper<實體類>queryWrapper=new QueryWrapper<>();
  	//b：條件拼接：調(diào)用queryWrapper方法
  	//c：使用mappper對象：調(diào)用CRUD方法，傳入對象即可

1.mapper接口：
public interface UserMapper extends BaseMapper<User> {
	//繼承BaseMapper接口:里面有單表的方法
	/*
	演示：自定義mapper方法實現(xiàn)分頁：
	  eg:查詢
	 */
	//1.在mapper接口中定義抽象方法：但是：方法的第一個參數(shù)：要傳一個IPage，返回值要是IPage，里面寫查詢集合的泛型即可
   IPage<User> queryByAge(IPage<User>page, @Param("age") Integer age);
}
2.
/*
演示條件構(gòu)造器使用：進行條件的動態(tài)拼接：
（1）QueryWrapper測試：
 */
@SpringBootTest
public class MybatisPlusQueryWrapper {
	@Autowired
	private UserMapper userMapper; //拿到對象：操作數(shù)據(jù)庫
	@Test
	public void test_01(){
		//查詢用戶名包含 a，age在20到30之間的，且郵箱不為空的用戶;
		 //分析：查詢：返回的是集合List-->selectList
		//a：創(chuàng)建一個QueryWrapper集合：相當于容器來裝條件
		QueryWrapper<User> queryWrapper=new QueryWrapper<>();
		//b：之后sql語句的條件：直接使用queryWrapper動態(tài)調(diào)用wrapper的方法來完成動態(tài)拼接;
		queryWrapper.like("name","a"); //條件1：name種包含a的
		queryWrapper.between("age",20,30); //條件2：age在20-30之間
		queryWrapper.isNotNull("email"); //第三個條件：email不為null
		List<User> users = userMapper.selectList(queryWrapper);  ----->:因為繼承了base接口，所以單表直接調(diào)用方法即可！
		//queryWrapper就是sql條件，將它·傳進去！?。?
		//之后這個就會變成sql語句； ?。。。。。。。。。。?
		//就相當于：select  * from user where name(like %a% and age>=20 and age<=30 and email is not null)
		/*
		!!!一個個調(diào)用麻煩，可以使用鏈式調(diào)用：?。。?！
		 queryWrapper.like("name","a").between("age",20,30).isNotNull("email");
		 */
	}
}

@SpringBootTest
	public class MybatisPlusQueryWrapper {
		@Autowired
		private UserMapper userMapper; //拿到對象：操作數(shù)據(jù)庫按照年齡降序查詢用戶，如果年齡age相同則按id升序排列
		 //(2)queryWrapper:按年齡降序查詢用戶，如果年齡相同則按id升序排列
		@Test
		public void test_02(){
			//a:創(chuàng)建QueryMapper集合：裝條件
			QueryWrapper<User> queryWrapper=new QueryWrapper<>();
			//b:使用條件構(gòu)造器進行條件的拼接：
			queryWrapper.orderByDesc("age").orderByAsc("id");
								//a:條件1：age降序排列; b:條件2：id增序
			//c：放到queryWrapper中，進行條件拼接; ==order by age desc,id asc
			List<User> users = userMapper.selectList(queryWrapper);
		}
		//(3)刪除email為null的用戶
		@Test
		public void test_03(){
			//a:
			QueryWrapper<User> queryWrapper=new QueryWrapper<>();
			//b:
			queryWrapper.isNotNull("email");
			//c:
			int delete = userMapper.delete(queryWrapper);
		}
		//(4):將age>20且用戶名中包含a或email為null的用戶信息修改：
		  //分析：修改：--update：所以usermapper調(diào)用update方法
				：相應的條件：age>20... 使用queryWrapper封裝，然后作為條件放入update方法形參中;!!!!!
		@Test
		public void test_04(){
			//a:
			QueryWrapper<User> queryWrapper=new QueryWrapper<>();
			//b：添加條件：
			queryWrapper.gt("age",20).like("name","a")                ---------->B:相當于：where .......
					.or().isNotNull("email");
			   //1.條件：age>20 name包含a，--->:條件直接調(diào)用時：默認自動使用and進行拼接;?。。。?！
				  //queryWrapper.gt("age",20).like("name","a") == where age>20 and ..      
			   //2.如果想要在條件之后追加or關(guān)鍵字：可以使用： “or().條件”；
			//c：創(chuàng)建User對象，進行update修改
			User user=new User();
			user.setAge(88);                ----->A:相當于update user  set name="" age= 
			user.setEmail("hehe");
			//d:如果要修改：第一位傳入要修改的對象
			 userMapper.update(user, queryWrapper); //放入對象 + queryWrapper
		}
		//(5)：查詢用戶信息的name和age字段;  --->指定列查詢?。?！
		  //select name,age from t_user where id>1;
		public void test_05() {
			//a:
			QueryWrapper<User> queryWrapper = new QueryWrapper<>();
			//b:條件拼接：
			queryWrapper.gt("age",1);
			//!!!查詢時：默認是查詢?nèi)???！?。。?！，但可以使用select指定
			queryWrapper.select("name","age");
			userMapper.selectList(queryWrapper);
		}
		//(6)前端傳入兩個參數(shù),name，age:---->:動態(tài)條件組織判斷?。。?！
		// 只要name不為null，就作為條件 來查詢符合的
		//只要age>18作為條件，就作為條件 來查詢符合的
		@Test
		public void test_06(){
			String name="xx";
			Integer age=19;
			//a:
			QueryWrapper<User>queryWrapper=new QueryWrapper<>();
			//b:進行條件拼接：
			  //b.1：如果name！=null,就使用queryWrapper進行條件拼接
			if(StringUtils.isNotBlank(name)){  //調(diào)用isNotBlank進行判斷
				//動態(tài)條件判斷：如果name不為null，就進行條件的拼接
				queryWrapper.eq("name",name); //使用queryWrapper進行拼接
			}
			  //b.2:如果age>18 進行動態(tài)拼接：
			if (age>18 && age!=null){
				queryWrapper.eq("age",age);
			}
			userMapper.selectList(queryWrapper);
			 /*
		注意：!!!!!!!!!!!!!!!!
		  Wrapper每個方法都有：一個boolean類型的condition，允許我們第一個參數(shù)放一個比較表達式，
		  ：如果condition為true-->整個條件為true，就執(zhí)行下面代碼
		  ：如果condition為false-->整個條件為false，就失效，不執(zhí)行下面代碼
		  -->condition里面有動態(tài)判斷，就不用我們在外部寫判斷了
		  eg：
		 */
			queryWrapper.eq(StringUtils.isNotBlank(name),"name",name);
			queryWrapper.eq(age>18 && age!=null,"age",age);
		}

@SpringBootTest
	public class MybatisPlusQueryWrapper {
		@Autowired
		private UserMapper userMapper; //拿到對象：操作數(shù)據(jù)庫按照年齡降序查詢用戶，如果年齡age相同則按id升序排列
		 //(2)queryWrapper:按年齡降序查詢用戶，如果年齡相同則按id升序排列
		@Test
		public void test_02(){
			//a:創(chuàng)建QueryMapper集合：裝條件
			QueryWrapper<User> queryWrapper=new QueryWrapper<>();
			//b:使用條件構(gòu)造器進行條件的拼接：
			queryWrapper.orderByDesc("age").orderByAsc("id");
								//a:條件1：age降序排列; b:條件2：id增序
			//c：放到queryWrapper中，進行條件拼接; ==order by age desc,id asc
			List<User> users = userMapper.selectList(queryWrapper);
		}
		//(3)刪除email為null的用戶
		@Test
		public void test_03(){
			//a:
			QueryWrapper<User> queryWrapper=new QueryWrapper<>();
			//b:
			queryWrapper.isNotNull("email");
			//c:
			int delete = userMapper.delete(queryWrapper);
		}
		//(4):將age>20且用戶名中包含a或email為null的用戶信息修改：
		  //分析：修改：--update：所以usermapper調(diào)用update方法
				：相應的條件：age>20... 使用queryWrapper封裝，然后作為條件放入update方法形參中;!!!!!
		@Test
		public void test_04(){
			//a:
			QueryWrapper<User> queryWrapper=new QueryWrapper<>();
			//b：添加條件：
			queryWrapper.gt("age",20).like("name","a")                ---------->B:相當于：where .......
					.or().isNotNull("email");
			   //1.條件：age>20 name包含a，--->:條件直接調(diào)用時：默認自動使用and進行拼接;！?。。?！
				  //queryWrapper.gt("age",20).like("name","a") == where age>20 and ..      
			   //2.如果想要在條件之后追加or關(guān)鍵字：可以使用： “or().條件”；
			//c：創(chuàng)建User對象，進行update修改
			User user=new User();
			user.setAge(88);                ----->A:相當于update user  set name="" age= 
			user.setEmail("hehe");
			//d:如果要修改：第一位傳入要修改的對象
			 userMapper.update(user, queryWrapper); //放入對象 + queryWrapper
		}
		//(5)：查詢用戶信息的name和age字段;  --->指定列查詢?。?！
		  //select name,age from t_user where id>1;
		public void test_05() {
			//a:
			QueryWrapper<User> queryWrapper = new QueryWrapper<>();
			//b:條件拼接：
			queryWrapper.gt("age",1);
			//!!!查詢時：默認是查詢?nèi)????。。。?！，但可以使用select指定
			queryWrapper.select("name","age");
			userMapper.selectList(queryWrapper);
		}
		//(6)前端傳入兩個參數(shù),name，age:---->:動態(tài)條件組織判斷?。。?！
		// 只要name不為null，就作為條件 來查詢符合的
		//只要age>18作為條件，就作為條件 來查詢符合的
		@Test
		public void test_06(){
			String name="xx";
			Integer age=19;
			//a:
			QueryWrapper<User>queryWrapper=new QueryWrapper<>();
			//b:進行條件拼接：
			  //b.1：如果name！=null,就使用queryWrapper進行條件拼接
			if(StringUtils.isNotBlank(name)){  //調(diào)用isNotBlank進行判斷
				//動態(tài)條件判斷：如果name不為null，就進行條件的拼接
				queryWrapper.eq("name",name); //使用queryWrapper進行拼接
			}
			  //b.2:如果age>18 進行動態(tài)拼接：
			if (age>18 && age!=null){
				queryWrapper.eq("age",age);
			}
			userMapper.selectList(queryWrapper);
			 /*
		注意：!!!!!!!!!!!!!!!!
		  Wrapper每個方法都有：一個boolean類型的condition，允許我們第一個參數(shù)放一個比較表達式，
		  ：如果condition為true-->整個條件為true，就執(zhí)行下面代碼
		  ：如果condition為false-->整個條件為false，就失效，不執(zhí)行下面代碼
		  -->condition里面有動態(tài)判斷，就不用我們在外部寫判斷了
		  eg：
		 */
			queryWrapper.eq(StringUtils.isNotBlank(name),"name",name);
			queryWrapper.eq(age>18 && age!=null,"age",age);
		}

     //a:
    UpdateWrapper<User> queryWrapper=new UpdateWrapper<>();
     //b：
    queryWrapper.gt("age",20).like("name","a").isNotNull("email")
            .set("email",null).set("age",100);
     //c：
   userMapper.update(null,queryWrapper);

（參數(shù)1：條件； 參數(shù)2：修改的數(shù)據(jù)）
queryWrapper修改：參數(shù)1只能放條件，且列名不能為null
updateWrapper修改：參數(shù)1可以放條件， 且列名可以設(shè)置為null;
				   且可以直接調(diào)用set方法進行修改

  和第一種用法一樣，只是對第一種的增強
   eg:
    Lambda：避免列寫錯的機制：傳入的列名可以是” 方法引用的表達式 “：類名::getName -->相當于找方法對應的列名

eg:
查詢用戶名包含 a like，年齡在20-30之間，并且郵箱不為null的用戶信息;
		LambdaQueryWrapper<User>lambdaQueryWrapper=new LambdaQueryWrapper<>();
		 //即只要將原來的列名，變?yōu)長ambda方法引用即可，其余不變?。。。。。。。。?！
		 lambdaQueryWrapper.like(User::getName,"a").between(User::getAge,20,30).isNotNull(User::getEmail);
		userMapper.selectList(queryWrapper);

eg：
		LambdaUpdateWrapper<User>lambdaUpdateWrapper=new LambdaUpdateWrapper<>();
		//即只要將原來的列名，變?yōu)長ambda方法引用即可，其余不變?。。。。。。。。?！
		lambdaUpdateWrapper.gt(User::getAge,20).like(User::getName,"a").isNotNull(User::getEmail)
				.set(User::getEmail,null).set(User::getAge,100);
		userMapper.update(null,lambdaUpdateWrapper);

@SpringBootTest
public class MybatisPlusTableIdTest {
	@Autowired
	private UserMapper userMapper;
	@Test
	public  void test_01(){
		//以插入數(shù)據(jù)舉例：
		User user=new User();
		user.setName("坤坤");
		user.setAge(20);
		user.setEmail("xxx@qq.com");
		//插入的時候：主鍵id不要賦值; 主鍵自增長 或者 type策略 進行賦值?。。。。。。。。。。?！
		/*
		1.默認主鍵的type（策略）是：雪花算法;--->:它會生成一個不重復的long類型的數(shù)字; eg：123456789
			雪花算法：
			  a：要求數(shù)據(jù)庫主鍵是 bigint / varchar(64) 類型;         -->:eg:varchar(64)/bigint money;!!!
			  b：要求實體類相應屬性：使用Long/String接值（int接不到）  -->:eg:Long/String  money;!!!
			  c：隨機生成一個數(shù)字，給予主鍵值（不重復）
		2.但我們想要把主鍵type（策略）變成auto自增長，
		   方式1：直接在實體類的主鍵上方加：@TableId(type= IdType.AUTO); 前提是mysql數(shù)據(jù)庫必須設(shè)置了主鍵自增長(auto_increment)
			auto：
			  a：要求mysql數(shù)據(jù)庫的 表主鍵 必須設(shè)置了 自增長
			  b：插入數(shù)據(jù)就是自增長了
		   方式2：全局設(shè)置主鍵自增長策略：如果每個表都設(shè)置為自增長（auto）,在配置文件(application.yml)中配置
		 */
		userMapper.insert(user); //之間調(diào)用BaseMapper中的insert方法;
	}
}
User視圖類：
 public class User(){
	@TableId(type = IdType.AUTO)
	private Long id;   
 }

以單個表實現(xiàn)邏輯刪除為例：
 @TableLogic
 private Integer deleted;
@SpringBootTest
public class MybatisPlusTableLogicTest {
	@Autowired
	private UserMapper userMapper;
	public void test_01(){
		//a:之前是物理刪除：delete from user where id=5;
		//b:現(xiàn)在：邏輯刪除：相當于：update user set deleted=1 where id=5
		userMapper.deleteById(5);
		//eg：
		userMapper.selectList(null); -->之后在查詢時：就只會查詢deleted=0的了：?。。。。。ㄗ詣釉跅l件位置加上where deleted=0）
	}

1.樂觀鎖 和悲觀鎖 都是在 并發(fā)編程 中用于處理并發(fā)訪問和資源競爭的兩種不同機制;
2.(1)悲觀鎖：
	同步鎖/互斥鎖：線程在訪問共享資源之前會獲取到鎖，在數(shù)據(jù)訪問時只允許一個線程訪問資源，只有當前線程訪問完成只后，才會釋放鎖，讓其它線程繼續(xù)操作資源;
  (2)樂觀鎖：不需要提前加鎖，而是在數(shù)據(jù)更新階段進行檢測
   樂觀鎖和悲觀鎖是兩種解決并發(fā)數(shù)據(jù)問題的思路，不是技術(shù)?。?
3.具體的技術(shù)和方案：
	  1.樂觀鎖實現(xiàn)方案和技術(shù)
		版本號/時間戳
		CAS
		無鎖數(shù)據(jù)結(jié)構(gòu)
	  2.悲觀鎖的實現(xiàn)方案和技術(shù)
		 鎖機制
		 數(shù)據(jù)庫鎖
		 信號量
4. 現(xiàn)在主要學習如何使用樂觀鎖(版本號)解決并發(fā)問題?。。。。?!
	  (1)版本號：解決數(shù)據(jù)并發(fā)更新出現(xiàn)錯誤數(shù)據(jù)的問題;--->保證數(shù)據(jù)一致性;
	  (2)樂觀鎖技術(shù)的實現(xiàn)流程：
		  a：每條數(shù)據(jù)添加一個版本號字段version
		  b：取出記錄時，獲取當前version
		  c：更新時，檢查獲取版本號是不是數(shù)據(jù)庫當前最新版本號
		  d：如果是(代表沒人修改過數(shù)據(jù))，執(zhí)行更新：set數(shù)據(jù)更新，version=version+1
		  e：如果不是（證明已經(jīng)修改過了），更新失敗
5.使用mybatis-plus數(shù)據(jù)使用樂觀鎖
	   步驟： 
		  1.數(shù)據(jù)庫插入一個version字段：alert table user add version int default 1  （int類型 樂觀鎖字段）
		  2 實體類創(chuàng)建相應的屬性： private Integer version;  + 在屬性上方使用@Version注解
		  3.添加攔截器（添加版本號更新插件）
		   之后在更新的時候就會檢查版本，檢查數(shù)據(jù)錯誤的問題;

1.
 alter  table user add version int default 1;  #int 類型 樂觀鎖字段
2.
public class User {
	@Version
	private Integer version; //版本號字段
}
//注意：之后在數(shù)據(jù)修改時都會檢查樂觀鎖;
3.在配置類/Main類中加入攔截器
public class Main {
	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
		@Bean
		public MybatisPlusInterceptor plusInterceptor(){
			//攔截器2：樂觀鎖【版本號插件】 mybatis-plus在每次更新時候，每次幫我們對比版本號字段和增加版本號+1
			   mybatisPlusInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
			return mybatisPlusInterceptor;
		}
4.
/*
測試樂觀鎖實現(xiàn)
 */
@SpringBootTest
public class MybatisPlusVersionTest {
	private UserMapper userMapper;
	@Test
	public void testById(){
		//步驟1：先查詢，再更新 獲取version數(shù)據(jù)
		//同時查詢兩條，但是version唯一，最后更新的失敗、
		User user=new User();  //user 版本號為：1
		User user1=new User(); //user1 版本號為：1
		user.setAge(20);
		user.setAge(30);
		userMapper.updateById(user); //20-->:此時數(shù)據(jù)庫的version ->2
		//樂觀鎖生效：失敗
		userMapper.updateById(user1);
		//因為user1的版本號為1，但是數(shù)據(jù)庫的版本號為2，證明不是最新數(shù)據(jù) -->1!=2,樂觀鎖生效，更新失敗
		  //所以最終age為：20
	}
}

1.加入攔截器/插件：
public class Main {
	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
		@Bean
		public MybatisPlusInterceptor plusInterceptor(){
		  //攔截器3：防止全表刪除和更新的攔截器
			mybatisPlusInterceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
			return mybatisPlusInterceptor;
		}
 2.測試類中：
	 public void test(){
	 @Au..
	 private UserMapper userMapper; //拿到mapper對象，進行數(shù)據(jù)庫操作?。?！;
	 //a：全表刪除！
	 mapper.delete(null); ----->：null,代表沒有寫條件，代表：全表刪除;
	 //b：全表更新：
	 mapper.update(null); ------>: null,代表沒有條件，代表全表更新！
	 ----------->:之后就會拋出異常：不允許全表delete/update?。。。。。?！
 }