-
在 Eclipse 中使用 Lombok 需要手动安装：
1、去 Maven 中央仓库下载 lombok-xxxx.jar 文件
2、打开并安装
3、安装过程中很可能需要手动选择 IDE 的位置，即 eclipse.exe 的位置
4、安装完成后会在 eclipse.exe 同级目录下生成 lombok.jar 包文件
5、打开 eclipse.exe 同目录的 eclipse.ini 文件，在最后一行加上配置信息：-javaagent:D:\\xxxx\lombok.jar
【注】这个 lombok.jar 文件路径可以自由移动，但最好不要包含中文，否则会出错
查看全部 -
自定义SQL的两种方式：
第一种： 使用自定义注解 的方式实现，在 dao 层的方法上使用@Select （“sql 语句”）的方式编写 sql 语句，会自动映射到数据库表中
第二章： 使用创建 mapper.xml 的方式来创建 配置文件，通过在配置文件中 创建 sql 语句，并配置 namespace 名称空间，指向有效的 dao 层，从而实现数据的映射
查看全部 -
JPA的优势：
查看全部 -
/**(年龄小于40或者邮箱不为空)并且名字为王姓
（age< 40 email is not null )and name like '王%'
**/
queryWrapper.nested(wq->wq.lt("age",40).or().isNotNull("email")).likeRight("name","王")；
/**
只返回满足条件的其中一条语句即可
**/
queryWrapper.in("age",Arrays.asList(30,31,34,35)).last("limit 1");
查看全部 -
架构查看全部
-
application.yml配置文件内容
spring: datasource: driver-class-name:com.mysql.cj.jdbc.Driver url:jdbc:mysql://localhost:3306/mp?useSSL=false&serverTimezone=GMT%2B8 username:root password:root
查看全部 -
框架结构
特性
查看全部 -
排除字段
查看全部 -
流程
查看全部 -
排除非表字段的三种方式
使用场景：实体类中的某个属性不对应表中的任何字段，只是用于保存临时数据，或者临时组装的数据。
使用方式：
1、transient修饰实体类属性（修饰的属性不会被序列化）。
缺陷：有些需求需要序列化该字段。
2、static修饰属性（Lombok对静态属性不会提供get、set方法）。
缺陷：每个对象的属性值一致。
3、@TableField(exist=false)，这个注解用来表示数据表中不存在该字段，默认是true。
推荐使用第三种方式
查看全部 -
Mybatis-Plus简介
Mybatis增强工具，只做增强，不作改变，简化开发，提高效率。
官网地址：https://mybatis.plus/
github项目地址：https://github.com/baomidou/mybatis-plus
码云项目地址：https://gitee.com/baomidou/mybatis-plus
Mybatis-Plus特点：
1、无侵入（只做增强，不作改变）、损耗小（程序启动时，进行注入增强的功能）、强大的CRUD操作（通用Service、通用Mapper，通过少量配置可实现单表操作，类似Hibernate）、支持条件构造器，支持各类需求。
2、支持Lambda形式调用、提供了Lambda条件构造器，支持多种数据库（主流的Mysql、Oracle、SQL Server等）
3、支持主键生成策略、支持ActiveRecord模式（实体类只需要继承Model，然后通过实体类完成CRUD操作）。
4、支持自定义全局通用操作（支持全局通用方法注入）、支持关键词自动转义（数据库关键词自动转义）
5、内置代码生成器（实体、Mapper接口、Mapper.xml文件、Service、Controller）、内置分页插件（基于Mybatis的物理分页）、内置性能分析插件
6、内置全局拦截插件（提供了全表的delete、update智能分析阻断，也可以自定义拦截规则，以防误操作）、内置sql注入剥离器（支持sql注入剥离，有效防止注入攻击）
查看全部 -
Mybatis对比JPA
JPA：java持久层API，可以理解为一种规范，Hibernate就是其具体一个实现。（目前比较常用的是SpringDataJpa，它是Spring提供的一套简化开发的框架，按照约定好的方法命名规则，编写dao层接口，就可以在不编写实现情况下执行数据库操作，还提供了除CRUD以外的功能，例如分页、排序、复杂查询等等，SpringDataJpa可以理解为对JPA的再次封装，底层仍旧是Hibernate）
Mybatis优势
1、SQL语句可以自由控制，更灵活、性能较高。
2、SQL与代码分离，易于阅读和维护。
3、提供XML标签，支持编写动态SQL语句。
JPA优势
JPA移植性比较好（Hibernate方言）
提供了很多CRUD方法、开发效率高（不用编写sql语句）
对象化程度更高（面向对象开发思想）
Mybatis劣势
简单CRUD操作需要编写SQL语句（单表仍需要编写Mapper接口方法和xml的sql）
XML中有大量sql需维护
mybatis自身功能有限，但支持plugin
查看全部 -
public class ServiceTest{
@Autowired
private UserService userService;
@Test
public void getOne(){
User one = userService.getOne(Wrappers.<User> lambdaQuery().gt(User::getAge. 25), false);
System.out.println(one);
}
//批量插入
@Test
public void batchInsert(){
User user1 = new User();
user1.setName("青山");
user1.setAge(20);
User user2 = new User();
user2.setName("绿水");
user2.setAge(21);
User user3 = new User();
user3.setName("小桥");
user3.setAge(22);
List<User> userList = Arrays.asList(user1, user2, user3);
boolean saveBatch = userService.saveBatch(userList);
System.out.println(saveBatch);
}
//批量插入
@Test
public void batchInsertOrUpdate(){
//插入
User user1 = new User();
user1.setName("青山1");
user1.setAge(20);
//插入
User user2 = new User();
user2.setName("绿水1");
user2.setAge(21);
//更新
User user3 = new User();
user3.setId(10004);
user3.setName("小桥");
user3.setAge(22);
List<User> userList = Arrays.asList(user1, user2, user3);
boolean saveBatch = userService.saveOrUpdateBatch(userList);
System.out.println(saveBatch);
}
//查询
@Test
public void chain(){
List<User> userList = userService.lambdaQuery().gt(User::getAge, 25).like(User::getName, "雨").list();
userList.forEach(System.out::println);
}
//更新
@Test
public void chain1(){
boolean update = userService.lambdaUpdate().eq(User::getAge, 25).set(User::getAge, 26).update();
System.out.println(update);
}
//删除
@Test
public void chain2(){
boolean remove = userService.lambdaUpdate().eq(User::getAge, 25).remove();
System.out.println(remove);
}
}
查看全部 -
/**
* @date 2020年2月23日
* @author 翁东州
* @所有方法的代码点击查看全文，整理了一整天累死了
*/
package first;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.additional.update.impl.LambdaUpdateChainWrapper;
import com.mp.dao.UserMapper;
import com.mp.entity.User;
import com.mp.service.UserService;
/**
* @date 2020年2月23日
* @author 翁东州
* @方法中文名称:
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class SimpleTest {
@Autowired
private UserMapper userMapper;
//展示所有
@Test
public void select() {
List<User> list = userMapper.selectList(null);
Assert.assertEquals(5, list.size());
list.forEach(System.out::println);
System.out.println();
}
//传统添加
public void insert() {
User user = new User();
user.setName("名字");
user.setAge(31);
user.setManagerId(123L);
user.setCreateTime(LocalDateTime.now());
int rows = userMapper.insert(user);
System.out.println("影响记录数"+rows);
}
//单体展示
public void selectById() {
User user = userMapper.selectById(123L);
System.out.println(user);
}
//多条展示
public void selectByIds() {
List<Long> idList = Arrays.asList(123L,234L,345L);
List<User> users = userMapper.selectBatchIds(idList);
users.forEach(System.out::println);
}
//map形式查询
public void selectByMap() {
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("name", "王天风");
columnMap.put("age", 25);
List<User> users = userMapper.selectByMap(columnMap);
users.forEach(System.out::println);
}
//wrapper 名字包含雨且年龄小于40
public void selectByWrapper() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.eq("name", "雨").lt("age", 40);
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//wrapper 名字包含雨，且年龄在20到40之间,email不为空
public void selectByWrapper2() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.eq("name", "雨").between("age", 20, 40).isNotNull("email");
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//wrapper 名字包含王，年龄大于等于25，按年龄降序排序，而后再按id升序排序
public void selectByWrapper3() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.likeRight("name", "王").or().ge("age", 25).orderByDesc("age").orderByAsc("id");
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//创建日期为2019年2月14日且直属上级名字为王姓
public void selectByWrapper4() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.apply("date_format(create_time,'%Y-%m-%d')={0}", "2019-02-14 or true or true")
.inSql("manager_id", "select id from user where name like '王%'");
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//名字为王姓，并且(年龄小于40或邮箱不为空)
public void selectByWrapper5() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.likeRight("name", "王").and(wq -> wq.lt("age", 40).or().isNotNull("email"));
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//名字为王姓，或者(年龄小于40并且年龄大于20并且邮箱不为空)
public void selectByWrapper6() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.likeRight("name", "王").or(wq -> wq.between("age", 20, 40).isNotNull("email"));
//queryWrapper.likeRight("name", "王").or(wq -> wq.lt("age", 40).gt("age", 20).isNotNull("email"));
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//名字为王姓，并且(年龄小于40或邮箱不为空)
public void selectByWrapper7() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.nested(wq -> wq.lt("age", 40).or().isNotNull("email")).likeRight("name", "王");
//queryWrapper.likeRight("name", "王").and(wq -> wq.lt("age", 40).or().isNotNull("email"));
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//年龄为30，31，34，35
public void selectByWrapper8() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.in("age", Arrays.asList(30,31,34,35));
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//只返回满足条件的其中一条语句即可
public void selectByWrapper9() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.in("age", Arrays.asList(30,31,34,35)).last("limit 1");
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//名字中包含雨并且年龄小于40,只展示id和名字
public void selectByWrapperSupper() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.select("id","name").like("name", "雨").lt("age", 40);
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//名字中包含雨并且年龄小于40,展示不包括创建字段和上级id字段的其他字段
public void selectByWrapperSupper2() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.like("name", "雨").lt("age", 40)
.select(User.class, info -> !info.getColumn().equals("create_time")
&&!info.getColumn().equals("manager_id"));
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//测试condition
@Test
public void testCondition() {
String name = "王";
String email = "";
condition1(name,email);
}
//名字中包含王,当email为空时不查询
public void condition1(String name,String email) {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
//传统方法
//if (StringUtils.isNotColumnName(name)) {
// queryWrapper.like("name", name);
//}
//if (StringUtils.isNotColumnName(email)) {
// queryWrapper.like("email", email);
//}
queryWrapper.like(StringUtils.isNotEmpty(name), "name",name)
.like(StringUtils.isNotEmpty(email), "email",email);
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//查找姓名为刘红雨且年龄32岁的数据
public void selectByWrapperEntity() {
User whereUser = new User();
whereUser.setName("刘红雨");
whereUser.setAge(32);
QueryWrapper<User> queryWrapper = new QueryWrapper<User>(whereUser);
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//allEq
public void selectByWrapperAllEq() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
Map<String, Object> params = new HashMap<String, Object>();
//姓名为王天风,年龄25
//params.put("name", "王天风");
//params.put("age", 25);
//queryWrapper.allEq(params);
//姓名为王天风,年龄为空则忽略
params.put("name", "王天风");
params.put("age", null);
//queryWrapper.allEq(params,false);
//剔除name查询条件
queryWrapper.allEq((k,v)->!k.equals("name"), params);
List<User> userList = userMapper.selectList(queryWrapper);
userList.forEach(System.out::println);
}
//Map格式,查询姓名包含雨，年龄小于40的数据
public void selectByWrapperMaps() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.like("name", "雨").lt("age", 40);
List<Map<String, Object>> userList = userMapper.selectMaps(queryWrapper);
userList.forEach(System.out::println);
}
//Map格式,按照直属上级id分组，查询每组的平均年龄，最大年龄，最小年龄，只去年龄总和小于500的组
public void selectByWrapperMaps2() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.select("avg(age) avg_age","min(age) min_age","max(age) max_age")
.groupBy("manager_id").having("sum(age)<{0}",500);
List<Map<String, Object>> userList = userMapper.selectMaps(queryWrapper);
userList.forEach(System.out::println);
}
//obj格式，查询姓名包含雨，年龄小于40的数据
public void selectByWrapperobjs() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.select("id","name").like("name", "雨").lt("age", 40);
List<Object> userList = userMapper.selectObjs(queryWrapper);
userList.forEach(System.out::println);
}
//查询姓名包含雨，年龄小于40的数据条数的总条数
public void selectByWrapperCount() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.like("name", "雨").lt("age", 40);
Integer count = userMapper.selectCount(queryWrapper);
System.out.println("总记录数"+ count);
}
//查询姓名包含雨，年龄小于40的数据条数的一条数据
public void selectByWrapperOne() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.like("name", "雨").lt("age", 40);
User user = userMapper.selectOne(queryWrapper);
System.out.println(user);
}
//lambda,三种起手
public void selectLambda() {
//LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();
//LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<User>();
LambdaQueryWrapper<User> lambdaQuery = Wrappers.<User>lambdaQuery();
lambdaQuery.like(User::getName, "雨").lt(User::getAge, 40);
List<User> userList = userMapper.selectList(lambdaQuery);
userList.forEach(System.out::println);
}
//lambda,名字为王姓，并且(年龄小于40或邮箱不为空)
public void selectLambda2() {
LambdaQueryWrapper<User> lambdaQuery = Wrappers.<User>lambdaQuery();
lambdaQuery.likeRight(User::getName, "王")
.and(lqw ->lqw.lt(User::getAge, 40).or().isNotNull(User::getEmail));
List<User> userList = userMapper.selectList(lambdaQuery);
userList.forEach(System.out::println);
}
//lambda,名字为王姓，并且(年龄小于40或邮箱不为空)，LambdaQueryChainWrapper一气呵成
public void selectLambda3() {
List<User> userList = new LambdaQueryChainWrapper<User>(userMapper).like(User::getName, "雨").ge(User::getAge, 20).list();
userList.forEach(System.out::println);
}
//分页
public void selectPage() {
QueryWrapper<User> queryWrapper = new QueryWrapper<User>();
queryWrapper.ge("age", 26);
Page<User> page = new Page<User>(1,10);//1为第一页，10为一页10行
IPage<User> iPage = userMapper.selectPage(page, queryWrapper);
System.out.println("总页数"+iPage.getPages());
System.out.println("总记录数"+iPage.getTotal());
List<User> userList = iPage.getRecords();
userList.forEach(System.out::println);
}
//传统根据id更新,根据id更新数据
public void updateById() {
User user = new User();
user.setId(123L);
user.setAge(25);
user.setEmail("wtf2@baomidou.com");
int rows = userMapper.updateById(user);
System.out.println("影响记录数"+ rows);
}
//传统根据Wrapper更新，姓名为李艺伟且年龄为28的数据，更改其id，年龄和邮箱
public void updateByWrapper2() {
UpdateWrapper<User> updateWrapper = new UpdateWrapper<User>();
updateWrapper.eq("name", "李艺伟").eq("age", 28);
User user = new User();
user.setId(123L);
user.setAge(25);
user.setEmail("wtf2@baomidou.com");
int rows = userMapper.update(user,updateWrapper);
System.out.println("影响记录数"+ rows);
}
//Wrapper更新，姓名为李艺伟且年龄为29的数据，更改年龄为30
public void updateByWrapper3() {
UpdateWrapper<User> updateWrapper = new UpdateWrapper<User>();
updateWrapper.eq("name", "李艺伟").eq("age", 29).set("age", 30);
int rows = userMapper.update(null,updateWrapper);
System.out.println("影响记录数"+ rows);
}
//lambda的Wrapper更新，姓名为李艺伟且年龄为29的数据，更改年龄为30
public void updateByWrapperLambda() {
LambdaUpdateWrapper<User> lambdaUpdate = Wrappers.<User>lambdaUpdate();
lambdaUpdate.eq(User::getName, "李艺伟").eq(User::getAge, 30).set(User::getAge, 31);
int rows = userMapper.update(null,lambdaUpdate);
System.out.println("影响记录数"+ rows);
}
//lambda的Wrapper更新，姓名为李艺伟且年龄为29的数据，更改年龄为30,一气呵成
public void updateByWrapperLambdaChain() {
boolean update = new LambdaUpdateChainWrapper<User>(userMapper)
.eq(User::getName, "李艺伟").eq(User::getAge, 29).set(User::getAge, 31).update();
System.out.println(update);
}
//根据id删除数据
public void deleteById() {
int rows = userMapper.deleteById(123L);
System.out.println("删除条数"+rows);
}
//根据map中名称为向后，年龄25删除数据
public void deleteByMap() {
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("name", "向后");
columnMap.put("age",25);
int rows = userMapper.deleteByMap(columnMap);
System.out.println("删除条数"+rows);
}
//根据id删除多条数据
public void deleteByBatchIds() {
int rows = userMapper.deleteBatchIds(Arrays.asList(123L,234L,345L));
System.out.println("删除条数"+rows);
}
//根据wrapper删除数据
public void deleteByWrapper() {
LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.<User>lambdaQuery();
lambdaQueryWrapper.eq(User::getAge, 27).or().gt(User::getAge, 41);
int rows = userMapper.delete(lambdaQueryWrapper);
System.out.println("删除条数"+rows);
}
//AR模式添加
public void insert2() {
User user = new User();
user.setName("刘华");
user.setAge(29);
user.setEmail("lh@baomidou.com");
user.setManagerId(123L);
user.setCreateTime(LocalDateTime.now());
boolean insert = user.insert();//类继承Model
System.out.println(insert);
}
//AR模式查找
public void selectById2() {
User user = new User();
user.setId(123L);
User selectById = user.selectById();
System.out.println(selectById);
}
//AR模式更新
public void updateById2() {
User user = new User();
user.setId(123L);
user.setName("刘华");
user.setAge(29);
user.setEmail("lh@baomidou.com");
user.setManagerId(123L);
user.setCreateTime(LocalDateTime.now());
boolean updateById = user.updateById();//类继承Model
System.out.println(updateById);
}
//AR模式添加或更新
public void insertOrUpdate() {
User user = new User();
user.setName("刘华");
user.setAge(29);
user.setEmail("lh@baomidou.com");
user.setManagerId(123L);
user.setCreateTime(LocalDateTime.now());
boolean insertOrUpdate = user.insertOrUpdate();//类继承Model
System.out.println(insertOrUpdate);
}
@Autowired
private UserService userService;
//使用service，获取一条数据
public void getOne() {
User one = userService.getOne(Wrappers.<User>lambdaQuery().gt(User::getAge, 25));//多条报错
System.out.println(one);
}
//使用service，获取一条数据
public void batch() {
User user1 = new User();
user1.setName("徐丽1");
user1.setAge(28);
User user2 = new User();
user2.setId(123L);
user2.setName("徐丽2");
user2.setAge(29);
List<User> users = Arrays.asList(user1,user2);
boolean saveBatch = userService.saveBatch(users);
//保存或更新
//userService.saveOrUpdateBatch(users);
System.out.println(saveBatch);
}
//使用service，lambda查询年龄大于25且名字包含雨的数据，一气呵成
public void chain1() {
List<User> users = userService.lambdaQuery().gt(User::getAge, 25).like(User::getName, "雨").list();
users.forEach(System.out::println);
}
//使用service，lambda更新年龄为25的数据为26，一气呵成
public void chain2() {
boolean update = userService.lambdaUpdate().eq(User::getAge, 25).set(User::getAge, 26).update();
System.out.println(update);
}
//使用service，lambda删除年龄为25的数据，一气呵成
public void chain3() {
boolean remove = userService.lambdaUpdate().gt(User::getAge, 25).remove();
System.out.println(remove);
}
}
查看全部 -
属性配置
查看全部
举报