Mybatis-Plus学习

不知道是使用了何种姿势，导入的包总是有问题，一直缺点什么？学习过程中有些类总是使用不了，一堆堆的问题
SpringBoot2
Maven ==> 阿里仓库
        后面再仔细修改…

pom.xml

<!-- pom 部分 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</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.0-gamma</version>
</dependency>

<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.0</version>
</dependency>

代码生成器

/**
 * 代码生成器
 */
@Test
public void generatorTest() {
    //----------------- 全局配置
    GlobalConfig config = new GlobalConfig();
    config.setActiveRecord(true)    //----------------- 是否支持 AR
            .setAuthor("fjigww")    //----------------- 作者
            .setOutputDir("D:\\IdeaProjects\\Lecent\\Research\\demo\\src\\main\\java")  //----------------- 生成路径
            .setFileOverride(true)  //----------------- 文件覆盖(全新文件)
            .setIdType(IdType.AUTO) //----------------- 主键策略
            .setServiceName("%sService")    //----------------- 设置生成的 service 接口的名字首字母是否有I（IEmployeeService）
                                            //----------------- 当前为没有I，默认有I
            .setBaseResultMap(true) //----------------- SQL 映射文件
            .setBaseColumnList(true); //----------------- SQL 片段

    //----------------- 数据源配置
    DataSourceConfig dataSourceConfig = new DataSourceConfig();
    dataSourceConfig.setDbType(DbType.MYSQL)
                    .setDriverName("com.mysql.jdbc.Driver")
                    .setUrl("jdbc:mysql://localhost:3306/mp")
                    .setUsername("root")
                    .setPassword("root");

    //----------------- 策略配置
    StrategyConfig strategyConfig = new StrategyConfig();
    strategyConfig.setCapitalMode(true) //----------------- 全局大写命名
                    .setDbColumnUnderline(true) //----------------- 下划线命名
                    .setNaming(NamingStrategy.underline_to_camel)   //----------------- 数据库表映射到实体的命名策略(下划线驼峰命名法)
                    .setTablePrefix("tbl_") //----------------- 数据库表的前缀
                    .setInclude("tbl_employee");

    //----------------- 包名策略配置(自动生成包)
    PackageConfig packageConfig = new PackageConfig();
    packageConfig.setParent("com.fjigww.demo")
                    .setMapper("mapper")
                    .setEntity("entity")
                    .setService("service")
                    .setController("controller");
                    //.setServiceImpl("service.impl"); 会自动生成 impl，可以不设定

    //----------------- 整合配置(所有配置包含进来)
    AutoGenerator autoGenerator = new AutoGenerator();
    autoGenerator.setGlobalConfig(config)
                    .setDataSource(dataSourceConfig)
                    .setStrategy(strategyConfig)
                    .setPackageInfo(packageConfig);

    //----------------- 执行代码生成
    autoGenerator.execute();

}

生成 - Entity

@TableName("tbl_employee")
public class Employee extends Model<Employee> {

    /**
     *  继承 Model，使用 AR 模式
     */

    private static final long serialVersionUID = 1L;

    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;
    private String lastName;
    private String email;

    //----------------- 公共字段填充注解
    //      ==> DEFAULT         默认不处理
    //      ==> INSERT          插入填充字段
    //      ==> UPDATE          更新填充字段
    //      ==> INSERT_UPDATE   插入/更新填充字段
    @TableField(fill = FieldFill.INSERT)
    private String gender;
    private Integer age;

    //----------------- 乐观锁
    @Version
    private Integer version;

    //----------------- 逻辑删除
    @TableLogic
    private Integer deleteFlag;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDate updateData;
    private String updateUser;

    @Override
    protected Serializable pkVal() {
        return this.id;
    }
    //get
    //set
    //toString
}

生成 - Mapper

public interface EmployeeMapper extends BaseMapper<Employee> {
}

生成 - Mapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fjigww.demo.mapper.EmployeeMapper">

    <!-- 通用查询映射结果 -->
    <resultMap id="BaseResultMap" type="com.fjigww.demo.entity.Employee">
        <id column="id" property="id" />
        <result column="last_name" property="lastName" />
        <result column="email" property="email" />
        <result column="gender" property="gender" />
        <result column="age" property="age" />
        <result column="version" property="version" />
        <result column="delete_flag" property="deleteFlag" />
        <result column="update_data" property="updateData" />
        <result column="update_user" property="updateUser" />
    </resultMap>

    <!-- 通用查询结果列 -->
    <sql id="Base_Column_List">
        id, last_name, email, gender, age, version, delete_flag, update_data, update_user
    </sql>

</mapper>

生成 - Service

public interface EmployeeService extends IService<Employee> {
}

生成 - ServiceImpl

@Service
public class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper, Employee> implements EmployeeService {
    /**
     *  继承了 ServiceImpl
     *      已经具有基本的 CRUD 方法，可直接 Service 使用
     */
}

生成 - Controller

@Controller
@RequestMapping("/employee")
public class EmployeeController {
    /**
     *  Service 已经具有基本的 CRUD 方法
     */
    @Resource
    EmployeeService employeeService;

    public void insert(Employee employee) {
        employeeService.insert(employee);
    }

    public void delete() {
        employeeService.delete();
        employeeService.deleteById();
        employeeService.deleteByMap();
        employeeService.deleteBatchIds();
    }

    public void select() {
        employeeService.selectById();
        employeeService.selectList();
        employeeService.selectPage();
        employeeService.selectOne();
        employeeService.selectBatchIds();
        //----------------- .......
    }

    public void update() {
        employeeService.update();
        employeeService.updateById();
        employeeService.updateBatchById();
    }
}

Config

@Configuration
@MapperScan("com.fjigww.demo.mapper*")
public class MybatisPlusConfig {

    /**
     * 分页插件
     */
    /*@Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }*/

    /**
     * SQL执行效率插件
     * 开发环境使用，用于输出 SQL 语句及起执行时间
     */
    /*@Bean
    public PerformanceInterceptor performanceInterceptor() {
        return new PerformanceInterceptor();
    }*/

    /**
     * 乐观锁插件
     * 作用：当要更新一条记录时，希望这条记录没有被别人更新
     * 实现方式：
     *      取出记录时，获取当前version
     *      更新时，使用此version
     *      执行更新时，set version = myVersion + 1 where version = myversion
     *      若version不对，更新失败
     * 使用：
     *      需要两步：
     *          1.配置开启锁
     *          2.实体中添加
     *          @Version
     *          private Integer version;
     */
    /*@Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }*/

    /**
     * 集成配置
     */
    @Bean("mybatisSqlSession")
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource, ResourceLoader resourceLoader/*, GlobalConfiguration globalConfiguration*/) throws Exception {
        MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();
        sqlSessionFactory.setDataSource(dataSource);
//        sqlSessionFactory.setTypeAliasesPackage("com.fjigww.demo.mapper*");
        MybatisConfiguration configuration = new MybatisConfiguration();
        configuration.setDefaultScriptingLanguage(MybatisXMLLanguageDriver.class);
        configuration.setJdbcTypeForNull(JdbcType.NULL);
        sqlSessionFactory.setConfiguration(configuration);
        sqlSessionFactory.setPlugins(new Interceptor[]{
                new PaginationInterceptor(),        //----------------- 分页插件
                new PerformanceInterceptor(),       //----------------- 性能分析插件
                new OptimisticLockerInterceptor()   //----------------- 乐观锁插件
        });
        /*sqlSessionFactory.setGlobalConfig(globalConfiguration);*/ //----------------- 包有问题，无法找到 GlobalConfiguration
        return sqlSessionFactory.getObject();
    }

    /**
     *  逻辑删除配置 ==> GlobalConfiguration这个鬼东西一直找不到，后面看看
     *      *      1.全局注入LogicSqlInjector
     *      *      2.逻辑删除的字段需要注解 @TableLogic
     *      *      application.yml 中配置
     */
    /*@Bean
    public GlobalConfiguration globalConfiguration() {
        GlobalConfiguration conf = new GlobalConfiguration(new LogicSqlInjector());
        conf.setLogicDeleteValue("1");
        conf.setLogicNotDeleteValue("0");
        conf.setIdType(2);
        return conf;
    }*/
}

通用CRUD

Insert

@Resource
EmployeeMapper employeeMapper;

@Test
public void insertTest() {
    Employee employee = new Employee();
    employee.setLastName("fjigww2");
    employee.setEmail("[email protected]");
    employee.setGender("1");
    employee.setAge(5);
    employee.setVersion(0);
    employee.setDeleteFlag(0);

    //-----------------  插入数据，未填字段不插入
    employeeMapper.insert(employee);

    //-----------------  获取当前插入数据的主键值
    Integer key = employee.getId();

}

Update

/**
 * 更新
 */
@Test
public void updateTest() {
    Employee employee = new Employee();
    employee.setId(10);
    employee.setLastName("11111111");

    //-----------------  根据 ID 修改
    employeeMapper.updateById(employee);

    //-----------------  条件更改
    Employee employeeUpdate = new Employee();
    employeeUpdate.setLastName("fjigww24");
    employeeUpdate.setGender("5");
    employeeMapper.update(employeeUpdate, new UpdateWrapper<Employee>()
            .eq("last_name", "fjigww"));
}

Select

/**
 * 查询
 */
@Test
public void selectTest() {
    //-----------------  根据 ID 查询
    Employee selectById = employeeMapper.selectById(4);
    System.out.println("selectById ==> " + selectById);

    //-----------------  多条件查询
    Employee selectOne = employeeMapper.selectOne(new QueryWrapper<Employee>()
            .like("last_name", "11111")
            .eq("gender", 5)
    );
    System.out.println("selectOne ==> " + selectOne);

    //-----------------  ID 批量查询
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(4);
    list.add(10);
    List<Employee> selectBatchIds = employeeMapper.selectBatchIds(list);
    System.out.println("selectBatchIds ==> " + selectBatchIds);

    //-----------------  Map 封装条件查询 ==> key 必须是数据表列名
    Map<String, Object> columnMap = new HashMap<>();
    columnMap.put("last_name", "11111111");
    columnMap.put("id", 10);
    List<Employee> selectByMap = employeeMapper.selectByMap(columnMap);
    System.out.println("selectByMap ==> " + selectByMap);

    // IPage ==> mybatis自带的分页查询条件
    // wrapper ==> 实体对象封装操作类（条件构造器）
    //-----------------  分页查询
    IPage<Employee> selectPag = employeeMapper.selectPage(new Page<Employee>(1, 3),
            new QueryWrapper<Employee>()
                    .between("age", 24, 25)
                    .eq("gender", 0)
    );
    System.out.println("selectPage ==> " + selectPag.getRecords());

    //-----------------  查询总条数
    employeeMapper.selectCount(new QueryWrapper<Employee>()
            .eq("gender", 1));

    //-----------------  条件查询
    List<Employee> selectList = employeeMapper.selectList(new QueryWrapper<Employee>()
            .eq("gender", 0)
            .like("last_name", "w")
    );
    System.out.println("selectList ==> " + selectList);

    //-----------------  查询数据返回 Map集合
    List<Map<String, Object>> selectMaps = employeeMapper.selectMaps(new QueryWrapper<Employee>()
            .eq("gender", 0)
            .like("last_name", "ww1")
    );
    System.out.println("selectMaps ==> " + selectMaps);

    //-----------------  返回分页的 Map集合
    IPage<Map<String, Object>> selectMapsPage = employeeMapper.selectMapsPage(new Page<Employee>(1,2),
            new QueryWrapper<Employee>()
                    .between("age", 2, 25)
                    .in("gender", 0, 1)
                    .orderByDesc("age")
    );
    System.out.println("selectMapsPage ==> " + selectMapsPage.getRecords());

    //-----------------  返回查询结果的第一个字段   (数据表的第一个字段)
    List<Object> selectObjs = employeeMapper.selectObjs(new QueryWrapper<Employee>()
            .like("last_name", "fj")
            .eq("gender", 0)
    );
    System.out.println("selectObjs ==> " + selectObjs);
}

Delete

/**
 * 删除
 */
@Test
public void deleteTest() {
    //-----------------  根据 ID 删除
    employeeMapper.deleteById(11);

    //-----------------  Map 封装条件删除 ==> key 必须为数据表列名
    Map<String, Object> deleteMap = new HashMap<>();
    deleteMap.put("last_name", "fjigww");
    employeeMapper.deleteByMap(deleteMap);


    //-----------------  多 ID 删除
    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(5);
    list.add(10);
    employeeMapper.deleteBatchIds(list);

    //-----------------  条件删除
    employeeMapper.delete(new QueryWrapper<Employee>().like("last_name", "111"));
}

AR(ActiveRecord)

Entity extends Model<\Entity>

/**
 *  AR 插入
 */
@Test
public void ARInsert() {
    Employee employee = new Employee();
    employee.setLastName("vander");
    employee.setEmail("[email protected]");
    employee.setGender("1");
    employee.setAge(24);

    //-----------------  字段不为空插入
    employee.insert();

    //-----------------  ID为空插入，否则为更新
    employee.insertOrUpdate();
}

/**
 *  AR 修改
 */
@Test
public void ARUpdate() {
    Employee employee = new Employee();
    employee.setLastName("vander");
    employee.setEmail("[email protected]");
    employee.setGender("0");
    employee.setAge(24);
    employee.setId(20);

    //-----------------  ID 修改
    employee.updateById();

    //-----------------  条件修改
    /**
     * UPDATE tbl_employee SET last_name='vander',email='[email protected]',gender=0,age=24 WHERE gender = '5'
     */
    employee.update(new UpdateWrapper<Employee>().eq("gender","5"));
}

/**
 *  AR 查询
 */
@Test
public void ARSelect() {
    Employee employee = new Employee();
    employee.setId(24);

    //-----------------  setId
    employee.selectById();

    //-----------------  直接键入 Id
    employee.selectById(24);

    //-----------------  条件
    employee.selectCount(new QueryWrapper<>().eq("gender", "0"));

    //-----------------  查询所有
    employee.selectAll();

    //-----------------  查询总记录数
    employee.selectList((Wrapper) new QueryWrapper().eq("gender", 0));

    //-----------------
    employee.selectOne(new QueryWrapper());

    //-----------------
    employee.selectPage(new Page<>(1,2), new QueryWrapper<>());

}

/**
 *  AR 删除
 */
@Test
public void ARDelete() {
    /**
     *  删除不存在的数据 在逻辑上也是成功的，返回结果 true
     */
    Employee employee = new Employee();
    employee.setId(30);

    //-----------------
    employee.deleteById();

    //-----------------
    employee.deleteById(31);

    //-----------------
    employee.delete((Wrapper) new QueryWrapper().eq("Id", 32));
}

插件扩展

逻辑删除

@RunWith(SpringRunner.class)
@SpringBootTest
public class LogicDeleteTest {
    @Resource
    EmployeeMapper employeeMapper;

    /**
     *  逻辑删除 ==> 测试失败，没有找到GlobalConfiguration并配置成功，姿势不对0_0
     */
    @Test
    public void logicDeleteTest() {
        employeeMapper.deleteById(29);
    }
}

分页插件

/**
 *  分页插件
 */
@Test
public void pagingTest() {
    Page<Employee> page = new Page<>(1,5);
    IPage<Employee> employeeIPage = employeeMapper.selectPage(page, null);
    System.out.println("返回数据：" + employeeIPage.getRecords());

    System.out.println("总条数：" + page.getTotal());
    System.out.println("当前页码：" + page.getCurrent());
    System.out.println("总页码：" + page.getPages());
    System.out.println("每页显示条数：" + page.getSize());
    System.out.println("是否有上一页：" + page.hasPrevious());
    System.out.println("是否有下一页：" + page.hasNext());
    System.out.println("返回的数据：" + page.getRecords());
}

乐观锁

/**
 * 乐观锁插件
 */
@Test
public void optimisticLockerTest() {
    Employee employee = new Employee();
    employee.setId(20);
    employee.setAge(11);
    employee.setGender("1");
    employee.setLastName("hhhh111hhhhh");
    employee.setVersion(1);

    //----------------- AR 模式没有乐观锁形式
//        employee.updateById();

    //----------------- MP 模式才具有乐观锁模式，version修改
    employeeMapper.updateById(employee);

}

性能分析

/**
 *  性能分析插件  ==> 开发环境使用
 */
@Test
public void performanceTest() {
    Employee employee = new Employee();
    employee.selectById(1);
    /**
     *  Time：13 ms - ID：com.fjigww.demo.mapper.EmployeeMapper.selectById        ==> 13 ms
     *  Execute SQL：SELECT id AS id,last_name AS lastName,email AS email,gender AS gender,age AS age FROM tbl_employee WHERE id=1       ==> 执行 SQL
     */
}

自定义填充公共自动

public class MyMetaObjectHandler extends MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        Object fieldValue = getFieldValByName("updateData", metaObject);
        if(fieldValue == null) {
            setFieldValByName("updateData", new Date(), metaObject);
        }
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        Object fieldValue = getFieldValByName("updateData", metaObject);
        setFieldValByName("updateData", new Date(), metaObject);
    }
}

---

---

---

学习知识源：*尚**Mybatis-Plus视频*