一、MP初体验（插入：insert()）
1.实体类
package com.yh.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
/**
* @Author youHui
**/
@TableName("t_department")//实体类映射数据库表
@Data
public class Department {
@TableId(type= IdType.AUTO)//主键策略，解决类型不匹配问题
private Integer id;
private String name;
private String remark;
}
2.mapper
package com.yh.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.yh.entity.Department;
/**
* @Author youHui
**/
public interface DepartmentMapper extends BaseMapper<Department> {//继承BaseMapper
}
3.yml
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/db_mp?serverTimezone=GMT
username: root
password: root666
#统一处理参数类型不匹配，相当于实体类中的@TableId(type = IdType.AUTO)
mybatis-plus:
global-config:
db-config:
id-type: 0
#@TableName("t_department")//实体类映射数据库表，在这里统一配置
table-prefix: t_4.pom
<!--mybatis-plus-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.3.2</version>
</dependency>
<!---连接池和junit-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>5.测试用例
package com.yh;
import com.yh.entity.Department;
import com.yh.mapper.DepartmentMapper;
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 java.util.List;
/**
* @Author youHui
**/
@RunWith(SpringRunner.class)
@SpringBootTest
public class DepartmentTest {
@Autowired
private DepartmentMapper departmentMapper;
@Test
public void select(){
List<Department> departmentList = departmentMapper.selectList(null);
for(Department department:departmentList){
System.out.println(department);
}
}
/**
* BaseMapper的几个方法
*/
@Test
public void insertTest(){
/**
* insert()
* 返回的是操作的记录条数，如：添加一条数据就返回1
* 可以通过返回值来判断执行的情况
*/
Department department = new Department();
department.setName("吹牛部门2");
department.setRemark("专门吹牛2");
//通过返回值来判断执行的情况
int Num = departmentMapper.insert(department);
if(Num>0){
System.out.println("数据插入成功");
}else {
System.out.println("数据未插入");
}
//可以直接获取主键id
System.out.println("主键ID："+department.getId());
}
}
二、MP驼峰式命名规则配置
1.yml
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/db_mp?serverTimezone=GMT
username: root
password: root666
mybatis-plus:
global-config:
db-config:
id-type: 0
#@TableName("t_department")//实体类映射数据库表，在这里统一配置
table-prefix: t_
#驼峰命名规则配置(表明)
table-underline: false
#驼峰命名规则配置(字段名)
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #打印sql日志
map-underscore-to-camel-case: false虽然这样也能解决java驼峰命名式子规则问题，但对性能有一等的损耗，因此最好的解决方案就是数据库表名和字段名字组合单词用下划线隔开。
2.实体类
package com.yh.entity;
import lombok.Data;
/**
* @Author youHui
**/
@Data
public class SysUser {
private Integer id;
private String userName;
private String passWord;
}
3.测试用例
package com.yh;
import com.yh.entity.SysUser;
import com.yh.mapper.SysUserMapper;
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;
/**
* @Author youHui
**/
@RunWith(SpringRunner.class)
@SpringBootTest
public class SysUserTest {
@Autowired
private SysUserMapper sysUserMapper;
@Test
public void insertTest(){
SysUser sysUser = new SysUser();
sysUser.setUserName("zs");
sysUser.setPassWord("1234");
sysUserMapper.insert(sysUser);
}
}
三、@TableField的value属性和@TableField的exist属性
应用场景：原本设计数据库字段名与java实体属性不一样，如数据库字段是name，而java字段名是userName这时可以用@TableField(value="name")来映射，另外就是java属性不需要隐射到数据库，只是java程序用来记录一些数据，这时可以用可以用@TableField(exist = false)。
package com.yh.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;
/**
* @Author youHui
**/
@Data
public class SysUser {
private Integer id;
@TableField(value="name")
private String userName;
private String passWord;
//这个属性不需要映射数据库字段名，只是java程序跑代码用的
@TableField(exist = false)
private String state;
}
四、MP更新操作-update
@Test
public void updateTest(){
//更新id
Department department = new Department();
department.setId(10);
department.setName("吹牛部门1");
department.setRemark("专门吹牛1");
int Num1 = departmentMapper.updateById(department);
if(Num1>0){
System.out.println("更新成功");
}else{
System.out.println("更新失败");
}
}2.yml
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/db_mp?serverTimezone=GMT
username: root
password: root666
mybatis-plus:
global-config:
db-config:
id-type: 0
table-prefix: t_
table-underline: false
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #打印sql日志
map-underscore-to-camel-case: false五、MP-delete
1.删除id
@Test
public void deleteTest(){
//根据id删除
int Num2 = departmentMapper.deleteById(10);
if(Num2>0){
System.out.println("删除成功");
}else {
System.out.println("删除失败");
}
}2.删除Map集合
@Test
public void deleteTest1(){
Map<String,Object> map = new HashMap<>();
map.put("name","部门");
map.put("remark","xxxx");
int Num3 = departmentMapper.deleteByMap(map);
if(Num3>0){
System.out.println("map集合删除成功");
}else {
System.out.println("map集合删除失败");
}
}3.批量删除
@Test
public void deleteBatchIdsTest(){
List<Integer> idList = new LinkedList<>();
idList.add(8);
idList.add(9);
int Num4 = departmentMapper.deleteBatchIds(idList);
if(Num4>0){
System.out.println("批量删除成功");
}else {
System.out.println("批量删除失败");
}
}
五、MP-select
1.跟据id查询
@Test
public void selectByIdTest(){
Department department = departmentMapper.selectById(2);
System.out.println(department);
}2.根据集合查询（批量查询）
@Test
public void selectBatchIdsTest(){
List<Integer> idList = new ArrayList<>();
idList.add(1);
idList.add(2);
idList.add(3);
List<Department> departments = departmentMapper.selectBatchIds(idList);
System.out.println(departments);
}3.查询同名数据
@Test
public void selectByMapTest(){
Map<String,Object> columnMap = new HashMap<>();
columnMap.put("name","同名数据");
List<Department> departments = departmentMapper.selectByMap(columnMap);
System.out.println(departments);
}六、MP构造器
1.QueryWrapper 条件构造器
package com.yh;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.yh.entity.Department;
import com.yh.entity.Employee;
import com.yh.mapper.DepartmentMapper;
import com.yh.mapper.EmployeeMapper;
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 java.util.*;
/**
* @Author youHui
**/
@RunWith(SpringRunner.class)
@SpringBootTest
public class EmployeeQueryWrapperTest {
@Autowired
private DepartmentMapper departmentMapper;
@Autowired
private EmployeeMapper employeeMapper;
@Test
public void selectQueryWrapper(){
QueryWrapper<Employee> queryWrapper = new QueryWrapper<>();
/**
* 查询工资大于3500且名字含小的数据
*/
queryWrapper.gt("salary",3500).like("name","小");
List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
System.out.println(employeeList);
}
}
@Test
public void selectQueryWrapper1(){
QueryWrapper<Employee> queryWrapper = new QueryWrapper<>();
/**
* 查询工资[3500,5000]名字含小，且email不为空的数据
*/
queryWrapper.between("salary",3500,5000).like("name","小").isNotNull("email");
List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
System.out.println(employeeList);
}2.条件构造器的案例
（1）案例一
@Test
public void selectQueryWrapper2(){
QueryWrapper<Employee> queryWrapper = new QueryWrapper<>();
/**
* 查询姓李的，并且出生日期范围是1993-02-09到1994-04-09的员工
*/
queryWrapper.apply( "DATE_FORMAT(birthday,'%Y-%m-%d')>={0} AND DATE_FORMAT(birthday,'%Y-%m-%d')<= {0}"
,"1993-02-09","1994-04-09").likeRight("name","李%");
List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
System.out.println(employeeList);
}（2）案例二
@Test
public void selectQueryWrapper3(){
QueryWrapper<Employee> queryWrapper = new QueryWrapper<>();
/**
* 查询姓李的或者邮箱不为空并且是女性的员工
*/
queryWrapper.likeRight("name","李%").or(wq->wq.isNotNull("email").eq("gender","女"));
List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
System.out.println(employeeList);
}（3）案例三
@Test
public void selectQueryWrapper4(){
QueryWrapper<Employee> queryWrapper = new QueryWrapper<>();
/**
* 查询姓李的并且邮箱不为空或者是女性的员工
*/
queryWrapper.likeRight("name","李%").and(wq->wq.isNotNull("email").or().eq("gender","女"));
List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
System.out.println(employeeList);
}（4）案例四
@Test
public void selectQueryWrapper5(){
QueryWrapper<Employee> queryWrapper = new QueryWrapper<>();
/**
* 查询属于编号1,2,3部门的并且薪水小于等于3500的员工 根据年龄从大到小排序显示
*/
queryWrapper.le("salary",3500).in("departmentId","1,2,3").orderByAsc("birthday");
List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
System.out.println(employeeList);
}3.条件构造器 UpdateWrappe案例
@Test
public void updateUpdateWrapper(){
UpdateWrapper<Employee> updateWrapper = new UpdateWrapper<>();
/**
* 更新指定员工的邮箱和联系电话
*/
Employee employee = new Employee();
//更新为以下数据
employee.setEmail("11404346@qq.com");
employee.setPhoneNumber("13577516932");
updateWrapper.eq("id",3);
int Num = employeeMapper.update(employee, updateWrapper);
if(Num>0){
System.out.println("更新成功");
}else {
System.out.println("更新失败");
}
}
3.条件构造器 DeleteWrappe案例
@Test
public void deleteDeleteWrapper(){
UpdateWrapper<Employee> updateWrapper = new UpdateWrapper<>();
/**
* 更具条件删除员工
*/
Employee employee = new Employee();
updateWrapper.apply("DATE_FORMAT(birthday,'%Y-%m-%d')<={0}","1990-0101").eq("departmentId",2);
int Num = employeeMapper.delete(updateWrapper);
if(Num>0){
System.out.println("删除成功");
}else {
System.out.println("删除失败");
}
}
4.QueryWrapper构造器的select方法
应用场景：
（1）只需要返回特定的几个数据表字段，可以通过条件构造器的select方法可以指定；
（2）数据库字段很多的时候，需要排除某几个字段，其他字段返回的时候，select方法也支持排除某些字段，查询其他的；
（3）分组聚合函数的时候，可以使用select方法，返回聚合函数执行后的数据字段；
案例一
@Test
public void selectByQueryWrapper1(){
/**
* 查找薪水大于3500 名字里有“小”的 员工 （只显示编号和姓名）
*/
QueryWrapper<Employee> queryWrapper=new QueryWrapper();
queryWrapper.select("id","name").gt("salary",3500).like("name","小");
List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
System.out.println(employeeList);
}案例二
@Test
public void selectByQueryWrapper2(){
/**
* 查找薪水大于3500 名字里有“小”的 员工 （排除出生日期和性别）
*/
QueryWrapper<Employee> queryWrapper=new QueryWrapper();
queryWrapper
.select(Employee.class,fieldInfo->!fieldInfo.getColumn().equals("birthday")&&!fieldInfo.getColumn().equals("gender"))
.gt("salary",3500)
.like("name","小");
List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
System.out.println(employeeList);
}
案例三
实体：
package com.yh.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;
import java.util.Date;
/**
* @Author youHui
**/
@Data
public class Employee {
private Integer id;
private String name;
private Date birthday;
private String gender;
private String email;
private String phoneNumber;
private Integer salary;
@TableField(exist = false)
private Integer departmentId;
@TableField(exist = false)
private Integer avrSalary;
}
@Test
public void selectByQueryWrapper3(){
/**
* 查询每个部门的平均薪资
*/
QueryWrapper<Employee> queryWrapper=new QueryWrapper();
queryWrapper
.select("department_id","AVG(salary) AS avg_salary")
.groupBy("department_id");
List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
System.out.println(employeeList);
}
七、MP条件判断构造器-condition动态判断条件
1.mp框架，在条件构造方法里，都会重载一个condition参数；
这个参数的作用是动态判断条件，假如condition是true，则拼接加条件，false的话，则不拼接加条件；
我们前台传来的动态条件，以前是通过代码判断拼接，现在我们可以直接条件构造方法里写，大大简化代码量；
案例：
@Test
public void selectByQueryWrapperWidthCondition4(){
/*动态判断条件，根据性别和名字查询**/
QueryWrapper<Employee> queryWrapper=new QueryWrapper();
String s_gender="";
String s_name="小";
queryWrapper.eq(StringUtil.isNotEmpty(s_gender),"gender",s_gender).like(StringUtil.isNotEmpty(s_name),"name",s_name);
List<Employee> employeeList = employeeMapper.selectList(queryWrapper);
System.out.println(employeeList);
}2.MP返回Map类型数据
应用场景：
集合List的弊端是会把所有的列属性都封装返回，但是我们有时候，只需要返回几个字段，然后再返回到用户端；
mp框架给我们提供了List<Map<String, Object>>返回类型，String是列名，Object是值，只返回select的字段；
案例：
@Test
public void selectByQueryWrapper10ReturnMap(){
QueryWrapper<Employee> queryWrapper=new QueryWrapper();
queryWrapper
.select("department_id","AVG(salary) AS avg_salary")
.groupBy("department_id");
List<Map<String, Object>> maps = employeeMapper.selectMaps(queryWrapper);
System.out.println(maps);
}八、MP框架提供了lambda表达式条件构造器支持
/**
* 查找薪水大于3500 名字里有“小”的 员工(通过Lambda表达式)
* sql： select * from t_employee where salary>3500 and name like '%小%'
*/
@Test
public void selectByQueryWrapperWidthLambda(){
LambdaQueryWrapper<Employee> lambdaQueryWrapper=new QueryWrapper<Employee>().lambda();
lambdaQueryWrapper
.gt(Employee::getSalary,"3500")
.like(Employee::getName,"小");
List<Employee> employeeList = employeeMapper.selectList(lambdaQueryWrapper);
System.out.println(employeeList);
}
九、MP-物理分页
1.先定义一个bean
package com.yh.config;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @Author youHui
**/
@Configuration
public class MybatisPlusConfig {
@Bean //Spring会把它变成bean
public PaginationInterceptor paginationInterceptor(){
return new PaginationInterceptor();
}
}
2.测试用例
@Test
public void selectQueryWrapper(){
QueryWrapper<Employee> queryWrapper = new QueryWrapper<>();
/**
* 查询工资大于3500且名字含小的数据,以及带分页
*/
queryWrapper.gt("salary",3500).like("name","小");
Page<Employee> page = new Page<>(1,3);
Page<Employee> employeePage = employeeMapper.selectPage(page, queryWrapper);
System.out.println("总条数："+employeePage.getTotal());
System.out.println("总页数："+employeePage.getPages());
System.out.println("当前页数据："+employeePage.getRecords());
}十、MP-ActiveRecord模式（AR）
可以通过实体类对象进行CRUD操作，实体类必须继承Model类，以及加上@EqualsAndHashCode(callSuper = false)注解，不调用父类euqals和hashCode方法；
1.实体类
package com.yh.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* @Author youHui
**/
@Data
@EqualsAndHashCode(callSuper = false)
public class Department extends Model<Department> {
// @TableId(type= IdType.AUTO)//主键策略，解决类型不匹配问题
private Integer id;
private String name;
private String remark;
}
2.测试用例
package com.yh;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.yh.entity.Department;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
/**
* @Author youHui
**/
@RunWith(SpringRunner.class)
@SpringBootTest
public class ArTest {
/**
* 添加
*/
@Test
public void insertTest(){
Department department = new Department();
department.setName("xx部门");
department.setRemark("xxx");
boolean insert = department.insert();
System.out.println("插入结果："+insert);
}
/**
* 修改
*/
@Test
public void updateTest(){
Department department = new Department();
department.setId(11);//根据id修改
department.setName("xxx部门1");
department.setRemark("xxx1");
boolean b = department.updateById();
System.out.println("修改结果："+b);
}
/**
* 有id就添加
* 无id就更新
*/
@Test
public void insertOrUpdateTest(){
Department department = new Department();
department.setId(11);
department.setName("xxx部门2");
department.setRemark("xxx2");
boolean b = department.insertOrUpdate();
System.out.println("执行结果："+b);
}
/**
* 删除
*/
@Test
public void deleteTest(){
Department department = new Department();
boolean b = department.deleteById(8);
System.out.println(b);
}
/**
* 查询
*/
@Test
public void selectTest(){
Department department = new Department();
Department d = department.selectById(11);
System.out.println(d);
}
@Test
public void selectAllTest(){
Department department = new Department();
List<Department> d = department.selectAll();
System.out.println(d);
}
@Test
public void selectByQueryWrapperTest(){
Department department = new Department();
QueryWrapper<Department> queryWrapper = new QueryWrapper<>();
queryWrapper.like("name","xx");
List<Department> departmentList = department.selectList(queryWrapper);
System.out.println(departmentList);
}
}
十一、MP-Service操作
Servie
1.DepartmentServie
package com.yh.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.yh.entity.Department;
/**
* @Author youHui
**/
public interface DepartmentService extends IService<Department> {
}
2.Impl实现类
DepartmentServieImpl
package com.yh.service.imp;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yh.entity.Department;
import com.yh.mapper.DepartmentMapper;
import com.yh.service.DepartmentService;
import org.springframework.stereotype.Service;
/**
* @Author youHui
**/
@Service("departmentService")
public class DepartmentServiceImpl extends ServiceImpl<DepartmentMapper, Department> implements DepartmentService {
}
3.测试用例
package com.yh;
import com.yh.entity.Department;
import com.yh.mapper.DepartmentMapper;
import com.yh.service.DepartmentService;
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 java.util.*;
/**
* @Author youHui
**/
@RunWith(SpringRunner.class)
@SpringBootTest
public class DepartmentServiceTest {
@Autowired
private DepartmentService departmentService;
/**
* 添加
*/
@Test
public void saveTest(){
Department department = new Department();
department.setName("xxx牛");
department.setRemark("xxx描述");
boolean save = departmentService.save(department);
System.out.println("执行结果"+save);
}
/**
* 修改
*/
@Test
public void updateByIdTest(){
Department department = new Department();
department.setId(12);
department.setName("xxx牛1");
department.setRemark("xxx描述1");
boolean save = departmentService.updateById(department);
System.out.println("执行结果"+save);
}
/**
* 删除
*/
@Test
public void removeByIdTest(){
Department department = new Department();
boolean save = departmentService.removeById(12);
System.out.println("执行结果"+save);
}
/**
* 查询
*/
@Test
public void listTest(){
Department department = new Department();
List<Department> list = departmentService.list();
System.out.println("执行结果"+list);
}
/**
* 批量添加
*/
@Test
public void saveMoreTest(){
Department department1 = new Department();
department1.setName("xxx牛1");
department1.setRemark("xxx描述1");
Department department2 = new Department();
department2.setName("xxx牛2");
department2.setRemark("xxx描述2");
Department department3 = new Department();
department3.setName("xxx牛3");
department3.setRemark("xxx描述3");
boolean b = departmentService.saveBatch(Arrays.asList(department1, department2, department3));
System.out.println("执行结果"+b);
}
/**
* 批量添加之添加或更新
*/
@Test
public void saveOrUpdateMoreTest1(){
Department department1 = new Department();
department1.setName("xxx牛4");
department1.setRemark("xxx描述4");
Department department2 = new Department();
department2.setName("xxx牛5");
department2.setRemark("xxx描述5");
Department department3 = new Department();
department3.setId(15);
department3.setName("xxx牛6");
department3.setRemark("xxx描述6");
boolean b = departmentService.saveOrUpdateBatch(Arrays.asList(department1, department2, department3));
System.out.println("执行结果"+b);
}
}
十二、MP-代码生成器
AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
1.添加 代码生成器 依赖
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.5.0</version>
</dependency>
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity</artifactId>
<version>1.7</version>
</dependency>
2.代码生成类
package com.yh;
import com.baomidou.mybatisplus.core.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.TemplateConfig;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import org.junit.Test;
/**
* @Author youHui
**/
public class Mptest2ApplicationTest {
@Test
public void contextLoads(){
// 代码生成器
AutoGenerator mpg = new AutoGenerator();
// 全局配置
GlobalConfig gc = new GlobalConfig();
String projectPath = System.getProperty("user.dir");
gc.setOutputDir(projectPath + "/src/main/java");
gc.setAuthor("yh");
gc.setOpen(false);
// gc.setSwagger2(true); 实体属性 Swagger2 注解
mpg.setGlobalConfig(gc);
// 数据源配置
DataSourceConfig dsc = new DataSourceConfig();
dsc.setUrl("jdbc:mysql://localhost:3306/db_mp?useUnicode=true&useSSL=false&characterEncoding=utf8");
// dsc.setSchemaName("public");
dsc.setDriverName("com.mysql.cj.jdbc.Driver");
dsc.setUsername("root");
dsc.setPassword("密码");
mpg.setDataSource(dsc);
// 包配置
PackageConfig pc = new PackageConfig();
//pc.setModuleName(scanner("模块名"));
pc.setParent("com.yh");
pc.setEntity("entity");//实体类包
pc.setMapper("mapper");//mapper
pc.setService("service");//servie
pc.serController("controller");//controller
mpg.setPackageInfo(pc);
// 策略配置
StrategyConfig strategy = new StrategyConfig();
strategy.setNaming(NamingStrategy.underline_to_camel);
strategy.setColumnNaming(NamingStrategy.underline_to_camel);
//strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
//strategy.setEntityLombokModel(true);
strategy.setRestControllerStyle(true);
// 公共父类
//strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!");
// 写于父类中的公共字段
strategy.setSuperEntityColumns("id");
//strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
strategy.setControllerMappingHyphenStyle(true);
strategy.setTablePrefix(pc.getModuleName() + "_");
mpg.setStrategy(strategy);
//mpg.setTemplateEngine(new FreemarkerTemplateEngine());
mpg.execute();
}
}
}
补充：以官网为准，其他配置需要自己手动配置。
本文含有隐藏内容，请 开通VIP 后查看