<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.2</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

CREATE TABLE employee(
emp_id BIGINT(20) NOT NULL,
name VARCHAR(30),
emp_gender VARCHAR(6),
age INT,
email VARCHAR(50),
PRIMARY KEY(emp_id)
);
INSERT INTO employee(emp_id,name,emp_gender,age,email)
VALUES(1367686308726788098,'劉曉娟','女',20,'liuxianjuan@qq.com');
INSERT INTO employee(emp_id,name,emp_gender,age,email)
VALUES(1367709299695099906,'張春雨','男',28,'zhangchunyu@sina.com');
INSERT INTO employee(emp_id,name,emp_gender,age,email)
VALUES(1367717669156028418,'何雨柱','男',23,'heyuzhu@126.com');

public class Employee {
    private Long empId;
    private String name;
    private String empGender;
    private Integer age;
    private String email;
    public Long getEmpId() {
        return empId;
    }
    public void setEmpId(Long empId) {
        this.empId = empId;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEmpGender() {
        return empGender;
    }
    public void setEmpGender(String empGender) {
        this.empGender = empGender;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    @Override
    public String toString() {
        return "Employee{" +
        "empId=" + empId +
        ", name='" + name + '\'' +
        ", empGender='" + empGender + '\'' +
        ", age=" + age +
        ", email='" + email + '\'' +
        '}';
    }
}

spring:
datasource:
 driver-class-name: com.mysql.jdbc.Driver
 url: jdbc:mysql:///mybatis_plus
 username: root
 password: root
logging:
level:
 com:
   offcn:
      mapper: debug

@SpringBootApplication
@MapperScan("com.offcn.mapper")
public class MybatisPlus01Application {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlus01Application.class, args);
    }
}

public interface EmployeeMapper extends BaseMapper<Employee> {}

@RunWith(SpringRunner.class)
@SpringBootTest
public class MybatisPlus01ApplicationTests {
    @Autowired
    private EmployeeMapper employeeMapper;
    @Test
    public void testSelect(){
        List<Employee> employeeList = employeeMapper.selectList(null);
        employeeList.forEach( System.out::println);
    }
}

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.4</version>
    <scope>provided</scope>
</dependency>

public class Employee {
    private Long empId;
    private String name;
    private String empGender;
    private Integer age;
    private String email;
}

@NoArgsConstructor
@AllArgsConstructor
@Data
@ToString
public class Employee {
    private Long empId;
    private String name;
    private String empGender;
    private Integer age;
    private String email;
}

// 插入一條記錄
int insert(T entity);
// 根據(jù) entity 條件，刪除記錄
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 刪除（根據(jù)ID 批量刪除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根據(jù) ID 刪除
int deleteById(Serializable id);
// 根據(jù) columnMap 條件，刪除記錄
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根據(jù) whereEntity 條件，更新記錄
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
// 根據(jù) ID 修改
int updateById(@Param(Constants.ENTITY) T entity);
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查詢(xún)（根據(jù) columnMap 條件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根據(jù) Wrapper 條件，查詢(xún)?nèi)坑涗?
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根據(jù) Wrapper 條件，查詢(xún)?nèi)坑涗洝Ｗ⒁猓?只返回第一個(gè)字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根據(jù) entity 條件，查詢(xún)?nèi)坑涗洠ú⒎?yè)）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根據(jù) Wrapper 條件，查詢(xún)?nèi)坑涗洠ú⒎?yè)）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page,
@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根據(jù) Wrapper 條件，查詢(xún)總記錄數(shù)
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

@Test
public void testInsert() {
    Employee employee=new Employee();
    //employee.setEmpId(100000);
    employee.setName("劉龍");
    employee.setEmpGender("男");
    employee.setAge(25);
    employee.setEmail("liulong@163.com");
    employeeMapper.insert(employee);
}

@NoArgsConstructor
@AllArgsConstructor
@Data
@ToString
public class Employee {
    //使用數(shù)據(jù)庫(kù)自增策略
    //@TableId(type=IdType.AUTO)
    //默認(rèn)使用雪花算法生成數(shù)字
    @TableId
    private Long empId;
    private String empName;
    private String empGender;
    private Integer age;
    private String email;
}

@NoArgsConstructor
@AllArgsConstructor
@Data
@ToString
@TableName(value = "tb_employee")
public class Employee {
    //使用數(shù)據(jù)庫(kù)自增策略
    //@TableId(type=IdType.AUTO)
    //默認(rèn)使用雪花算法生成數(shù)字
    @TableId
    private Long empId;
    private String empName;
    private String empGender;
    private Integer age;
    private String email;
}

@NoArgsConstructor
@AllArgsConstructor
@Data
@ToString
@TableName(value = "tb_employee")
public class Employee {
    @TableId
    private Long empId;
    //當(dāng)表中的列與實(shí)體類(lèi)屬性不一致時(shí)，使用TableField指定數(shù)據(jù)庫(kù)中的列名
    @TableField(value = "emp_name")
    private String name;
    private String empGender;
    private Integer age;
    private String email;
    //當(dāng)表中沒(méi)有remark時(shí)，使用TableField的exist=false屬性忽略該字段
    @TableField(exist = false)
    private String remark;
}

@TableId(type=IdType.AUTO)
private Long empId;

public void testInsert() {
    Employee employee=new Employee();
    employee.setName("劉龍200");
    employee.setEmpGender("男");
    employee.setAge(25);
    employee.setEmail("liulong@163.com");
    employee.setRemark("該員工是一個(gè)好員工");
    employeeMapper.insert(employee);
    System.out.println(employee.getEmpId());
}

public void testUpdateById() {
    Employee employee=new Employee();
    employee.setEmpId(10)
    employee.setName("劉龍");
    employee.setEmpGender("女");
    employee.setAge(23);
    employee.setEmail("liulong@163.com");
    employeeMapper.updateById(employee);
}

public void testdateById(){
    //根據(jù)員工的名字,更新
    Employee employee2=new Employee();
    employee2.setEmpGender("男");
    employee2.setAge(18);
    employee2.setEmail("liulong@126.com");
    employeeMapper.update(employee2,new UpdateWrapper<Employee>().eq("name","劉龍"));
}

@Test
public void testSelectById() {
    Employee employee=employeeMapper.selectById(1);
    System.out.println(employee);
}

@Test
public void testSelectBatchIds() {
    List list= Arrays.asList(1,2,3);
    List<Employee> employeeList = employeeMapper.selectBatchIds(list);
    employeeList.forEach(System.out::println);
}

@Test
public void testSelectByMap() {
    Map<String,Object> map=new HashMap<>();
    map.put("emp_gender","男");
    map.put("age",29);
    List<Employee> employeeList = employeeMapper.selectByMap(map);
    employeeList.forEach(System.out::println);
}

@Test
public void testDeleteById(){
    int rows=employeeMapper.deleteById(1);
    System.out.println("受影響的行數(shù):"+rows);
}

@Test
public void testDeleteByMap(){
    Map<String,Object> map=new HashMap<>();
    map.put("emp_gender","男");
    map.put("emp_name","劉輝");
    int rows=employeeMapper.deleteByMap(map);
    System.out.println("受影響的行數(shù):"+rows);
}

@Test
public void testDeleteBatchIds(){
    List list= Arrays.asList(4,7,1);
    int rows=employeeMapper.deleteBatchIds(list);
    System.out.println("受影響的行數(shù):"+rows);
}

//查詢(xún)姓名為劉輝軍并且性別為男的員工
@Test
public void testSelectOne(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.eq("name","劉輝軍");
    queryWrapper.eq("emp_gender","男");
    Employee employee = employeeMapper.selectOne(queryWrapper);
    System.out.println(employee);
}

//查詢(xún)姓名中帶有"磊"的并且年齡小于30的員工
@Test
public void testSelectList(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.like("name","磊").lt("age",30);
    List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
    employeeList.forEach(System.out::println);
}
//查詢(xún)姓劉的或者性別為男，按年齡的除序排序
@Test
public void testSelectList2(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.like("name","王")
        .or().eq("emp_gender","男")
        .orderByDesc("age");
    List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
    employeeList.forEach(System.out::println);
}
//查詢(xún)姓劉的并且（年齡小于35或者郵箱不為空）
@Test
public void testSelectList3(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.likeRight("name","劉")
        .and(wq->wq.lt("age",35).or().isNotNull("email"));
    List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
    employeeList.forEach(System.out::println);
}

@Configuration
public class MybatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

@Test
public void testSelectPage(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.lt("age",50);
    Page<Employee> page=new Page<>(1,2);
    Page<Employee> employeePage = employeeMapper.selectPage(page, queryWrapper);
    System.out.println("當(dāng)前頁(yè):"+ employeePage.getCurrent());
    System.out.println("每頁(yè)記錄數(shù):"+employeePage.getSize());
    System.out.println("總記錄數(shù):"+employeePage.getTotal());
    System.out.println("總頁(yè)數(shù):"+employeePage.getPages());
    List<Employee> employeeList = employeePage.getRecords();
    employeeList.forEach(System.out::println);
}

//根據(jù)姓名和年齡修改記錄
@Test
public void testUpdate(){
    QueryWrapper<Employee> updateWrapper=new QueryWrapper<>();
    updateWrapper.eq("name","劉龍")
        .eq("age",25);
    Employee employee=new Employee();
    employee.setEmpId(1367720249630318593L);
    employee.setName("劉龍");
    employee.setEmail("lilong111@.qq.com");
    employee.setAge(26);
    employee.setEmpGender("女");
    int rows=employeeMapper.update(employee,updateWrapper);
    System.out.println("受影響的行數(shù):"+rows);
}

//根據(jù)姓名和年齡刪除記錄
@Test
public void testDelete(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.eq("name","劉龍")
        .eq("age",26);
    int rows=employeeMapper.delete(queryWrapper);
    System.out.println("受影響的行數(shù):"+rows);
}

/**
* 插入一條記錄（選擇字段，策略插入）
*
* @param entity 實(shí)體對(duì)象
*/
default boolean save(T entity) {
    return SqlHelper.retBool(getBaseMapper().insert(entity));
}
/**
* 根據(jù) ID 選擇修改
*
* @param entity 實(shí)體對(duì)象
*/
default boolean updateById(T entity) {
    return SqlHelper.retBool(getBaseMapper().updateById(entity));
}
/**
* TableId 注解存在更新記錄，否插入一條記錄
*
* @param entity 實(shí)體對(duì)象
*/
boolean saveOrUpdate(T entity);
/**
* 根據(jù) Wrapper，查詢(xún)一條記錄 <br/>
* <p>結(jié)果集，如果是多個(gè)會(huì)拋出異常，隨機(jī)取一條加上限制條件 wrapper.last("LIMIT
1")</p>
*
* @param queryWrapper 實(shí)體對(duì)象封裝操作類(lèi) {@link
com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
*/
default T getOne(Wrapper<T> queryWrapper) {
    return getOne(queryWrapper, true);
}
/**
* 根據(jù) Wrapper，查詢(xún)一條記錄
*
* @param queryWrapper 實(shí)體對(duì)象封裝操作類(lèi) {@link
com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
* @param throwEx 有多個(gè) result 是否拋出異常
*/
T getOne(Wrapper<T> queryWrapper, boolean throwEx);

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.2</version>
</dependency>

public interface EmloyeeService extends IService<Employee> {
}

@Service
public class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper,Employee> implements EmloyeeService {
}

@Test
public void testSave(){
    Employee employee=new Employee();
    employee.setName("孫寶來(lái)");
    employee.setEmpGender("男");
    employee.setAge(30);
    employee.setEmail("sunbaolai@qq.com");
    employeeService.save(employee);
}
@Test
public void testSaveOrUpdate(){
    Employee employee=new Employee();
    employee.setEmpId(1367720249630318594L);
    employee.setName("孫寶來(lái)");
    employee.setEmpGender("女");
    employee.setAge(33);
    employee.setEmail("sunbaolai@qq.com");
    employeeService.saveOrUpdate(employee);
}
@Test
public void testGetOne(){
    QueryWrapper<Employee> queryWrapper=new QueryWrapper<>();
    queryWrapper.gt("age",24);
    Employee employee = employeeService.getOne(queryWrapper,false);
    System.out.println(employee);
}

<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>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
    <version>3.2.0</version>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.2.0</version>
</dependency>
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.3</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

// 代碼生成器
AutoGenerator mpg = new AutoGenerator();
// 全局配置
GlobalConfig gc = new GlobalConfig();
//獲取工程路徑
String projectPath = System.getProperty("user.dir");
gc.setOutputDir(projectPath + "/src/main/java");
gc.setAuthor("zs");//設(shè)置作者
gc.setOpen(false);//生成是后是否打開(kāi)資源管理器
gc.setFileOverride(false);//重新生成文件時(shí)是否覆蓋
gc.setServiceName("%sService");
// gc.setSwagger2(true); 實(shí)體屬性 Swagger2 注解
mpg.setGlobalConfig(gc);

// 數(shù)據(jù)源配置
DataSourceConfig dsc = new DataSourceConfig();
dsc.setUrl("jdbc:mysql://localhost:3306/mybatis_plus?
useUnicode=true&useSSL=false&characterEncoding=utf8");
// dsc.setSchemaName("public");
dsc.setDriverName("com.mysql.jdbc.Driver");
dsc.setUsername("root");
dsc.setPassword("root");
dsc.setDbType(DbType.MYSQL);
mpg.setDataSource(dsc);

// 包配置
PackageConfig pc = new PackageConfig();
pc.setModuleName(null);
pc.setParent("com.offcn.ssm");
pc.setController("controller");
pc.setEntity("entity");
pc.setService("service");
pc.setMapper("mapper");
mpg.setPackageInfo(pc);

//策略配置
StrategyConfig strategy = new StrategyConfig();
strategy.setInclude("tb_employee");//對(duì)那一張表生成代碼
strategy.setNaming(NamingStrategy.underline_to_camel);//數(shù)據(jù)庫(kù)表映射到實(shí)體的命名策略
strategy.setTablePrefix(pc.getModuleName() + "_"); //生成實(shí)體時(shí)去掉表前綴
strategy.setColumnNaming(NamingStrategy.underline_to_camel);//數(shù)據(jù)庫(kù)表字段映射到實(shí)體的命名策略
strategy.setEntityLombokModel(true); // lombok 模型 @Accessors(chain = true) setter鏈?zhǔn)讲僮?
strategy.setRestControllerStyle(true); //restful api風(fēng)格控制器
strategy.setControllerMappingHyphenStyle(true); //url中駝峰轉(zhuǎn)連字符
mpg.setStrategy(strategy);

//執(zhí)行
mpg.execute();

@MapperScan("com.offcn.ssm.mapper")

spring:
 datasource:
  driver-class-name: com.mysql.jdbc.Driver
  url: jdbc:mysql:///mybatis_plus
  username: root
  password: root
logging:
level:
 com:
  offcn:
   mybatis:
    dao: debug

@RequestMapping("/tb-employee")
public class TbEmployeeController {
    @Autowired
    private TbEmployeeService tbEmployeeService;
    @RequestMapping("/emps")
    public List<TbEmployee> getEmployees(){
        List<TbEmployee> list = tbEmployeeService.list();
        return list;
    }
}