58-mybatis_plus

目录

• MybatisPlus
• 今日内容介绍
• 学习目标
• 1. Mybatis Plus入门
  • 1.1. Mybatis Plus简介
  • 1.2. 快速入门
• 2. Mybatis Plus CRUD-通用Mapper
  • 2.1. 添加
  • 2.2. 删除
  • 2.3. 更新
  • 2.4. 查询
• 3.LambdaQueryWrapper
  • 3.1. 条件 查询
  • 3.2. 条件 删除
  • 3.3. 条件 update
• 4. service 封装-通用service
• 5. 逆向工程-代码生成器
  • 5.1. 引入依赖
  • 5.2. 执行main 方法
• 6. dubbo工程改造
  • 6.1. dubbo_parent
  • 6.2. dubbo_domain
  • 6.3. dubbo_provider
  • 6.4. dubbo_consumer
• 总结

 

---

回到顶部

MybatisPlus

回到顶部

今日内容介绍

回到顶部

学习目标

• 了解mybatisplus的特点
• 能够掌握mybatisplus快速入门
• 能够掌握mybatisplus常用注解
• 能够掌握mybatisplus常用的增删改查
• 能够掌握mybatisplus自动代码生成

回到顶部

1. Mybatis Plus入门

【目标】

掌握mybatisplus

【路径】

1：了解MyBatis Plus

2： 掌握Mybatis Plus入门

【讲解】

1.1. Mybatis Plus简介

​ MyBatis-Plus（简称 MP）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

​ 官网：https://mybatis.plus/ 或 https://mp.baomidou.com/

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.1.1</version>
</dependency>

1.2. 快速入门

SpringBoot 整合 MyBatis-Plus，并实现根据Id查询功能。

数据库环境准备
创建SpringBoot工程，引入MyBatis-Plus起步依赖
编写DataSource相关配置
编写mapper
测试

1.2.1. 数据库环境准备

-- 创建数据库
CREATE DATABASE itcast_mp;
USE itcast_mp;

-- 创建测试表
CREATE TABLE `tb_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
  `user_name` varchar(20) NOT NULL COMMENT '用户名',
  `password` varchar(20) NOT NULL COMMENT '密码',
  `name` varchar(30) DEFAULT NULL COMMENT '姓名',
  `age` int(11) DEFAULT NULL COMMENT '年龄',
  `email` varchar(50) DEFAULT NULL COMMENT '邮箱',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

-- 插入测试数据
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('1', 'zhangsan', '123456', '张三', '18', 'test1@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('2', 'lisi', '123456', '李四', '20', 'test2@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('3', 'wangwu', '123456', '王五', '28', 'test3@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('4', 'zhaoliu', '123456', '赵六', '21', 'test4@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES ('5', 'sunqi', '123456', '孙七', '24', 'test5@itcast.cn');

1.2.2. 创建工程

创建SpringBoot工程，引入MyBatis-Plus起步依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>my-springboot-mybaitsplus</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- mysql  驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!-- lombok  ,自动生成get,Set 方法-->
        <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>
        <!--mybatisplus起步依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency>
    </dependencies>
</project>

1.2.3. 创建application.yml

# datasource
spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/itcast_mp
    username: root
    password: admin
    driver-class-name: com.mysql.jdbc.Driver

1.2.4. 创建实体对象

package com.itheima.pojo;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@TableName("tb_user") // 指定表名
@Data
public class User {
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

1.2.5. 创建UserMapper

package com.itheima.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itheima.pojo.User;

/**
 * 使用mp定义Mapper，需要让Mapper接口继承 BaseMapper接口。
 */
public interface UserMapper extends BaseMapper<User> {
}

1.2.6. 创建启动类

启动类加上@MapperScan 注解

package com.itheima;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan("com.itheima.dao")
@SpringBootApplication
public class MybatisPlusSpringbootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusSpringbootApplication.class, args);
    }
}

1.2.7. 测试

package com.itheima;

import com.itheima.dao.UserMapper;
import com.itheima.pojo.User;
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;

@SpringBootTest
@RunWith(SpringRunner.class)
public class UserMapperTest {
    @Autowired
    private UserMapper userMapper;
    /**
     * 根据id查询
     */
    @Test
    public void testSelectById() {
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }
}

【小结】

1：了解MyBatis Plus

2：掌握MyBatis Plus入门

​ 创建工程 引入MybatisPlus依赖等

​ 创建实体对象 @TableName("tb_user") 建立数据库表 跟 实体对象 映射关系，操作实体对象 就等同于操作表

​ 创建持久层接口 extends BaseMapper 单表操作CRUD

​ 创建启动类 与 测试类

​ 创建application.yml

回到顶部

2. Mybatis Plus CRUD-通用Mapper

【目标】

使用Mybatis Plus 掌握CRUD

【路径】

1：新增

2：删除

3：更新

4：查询

【讲解】

2.1. 添加

2.1.1. 添加

@Test
public void testInsert() {
    User user = new User();
    //user.setId(6L);
    user.setUserName("itcast");
    user.setPassword("itheima");
    int count = userMapper.insert(user);
    System.out.println(count);
}

2.1.2. 实体类注解分析

1)  @TableName("user_name") 指定映射关系
实体类的属性名和数据库的字段名自动映射：
	 *  名称一样
	 *  数据库字段使用_分割，实体类属性名使用驼峰名称
   否则需要使用 @TableField("user_name") 指定映射关系
2)  忽略某个字段的查询和 插入
	  @TableField(exist = false) 
3)  设置id生成策略:AUTO 数据库自增
    @TableId(type = IdType.AUTO)

2.1.3. 配置分析

mybatis-plus:
  global-config:
    db-config:
      # 表名前缀
      table-prefix: tb_
      # id生成策略 数据库自增
      id-type: auto
  configuration:
    # 日志
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

2.1.4. 具体使用如下

/**
 * 实体类的属性名和数据库的字段名自动映射：
 *  1. 名称一样
 *  2. 数据库字段使用_分割，实体类属性名使用驼峰名称
 */

@TableName("tb_user")
@Data
public class User {
    //设置id生成策略:AUTO 数据库自增
    @TableId(type = IdType.AUTO)
    private Long id;
    //@TableField("user_name")
    private String userName;

    private String password;
    private String name;
    private Integer age;
    private String email;

    //不希望该值存入数据库
   // @TableField(exist = false)
   // private String info;
}

2.2. 删除

2.2.1. 根据id删除

@Test
public void testDeleteById() {
    int count = userMapper.deleteById(1350820615237488643L);
    System.out.println(count);
}

2.2.2. 根据id集合批量删除

@Test
public void testDeleteBatchIds(){
    List ids = new ArrayList();
    ids.add(1350820615237488641L);
    ids.add(1350820615237488642L);
    userMapper.deleteBatchIds(ids);
}

2.2.3. 根据map构造条件，删除

@Test
public void testDeleteByMap(){
    Map<String, Object> map = new HashMap<>();
    //delete from tb_user where user_name = ? and age = ?
    map.put("user_name","sunqi");
    map.put("age","24");
    userMapper.deleteByMap(map);
}

2.3. 更新

@Test
public void testUpdateById() {
    User user = new User();
    user.setId(2L);
    user.setPassword("1111111");
    int count = userMapper.updateById(user);
}

2.4. 查询

2.4.1. 不带条件分页查询

配置 拦截器

package com.itheima.config;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class PageConfig {

    /**
     * 3.4.0之前的版本用这个
     * @return
     */
    @Bean
    public PaginationInterceptor paginationInterceptor(){
        return  new PaginationInterceptor();
    }

    /**
     * 3.4.0之后提供的拦截器的配置方式
     * @return
     */
   /*@Bean
   public MybatisPlusInterceptor mybatisPlusInterceptor(){
       MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
       mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
       return mybatisPlusInterceptor;
   }*/
}

查询

/**
  * 分页查询：
  *  1. 当前页码：currentPage
  *  2. 每页显示条数：size
  *  注意：使用mp的分页要设置一个拦截器！！！
*/
@Test
public void testSelectPage() {
    int current = 1;//当前页码
    int size = 2;//每页显示条数
    IPage<User> page = new Page(current,size);
    userMapper.selectPage(page,null);

    List<User> records = page.getRecords();//当前页的数据
    long pages = page.getPages();//总页数 2
    long total = page.getTotal();//总记录数 4
    System.out.println(records);
    System.out.println(pages);
    System.out.println(total);
}

2.4.2. 条件构造器查询

/**
 * 基础比较查询
 *
 * Wrapper:
 *  1.QueryWrapper 查询 删除
 *      LambdaQueryWrapper
 *  2.UpdateWrapper 更新
 *      LambdaUpdateWrapper
 *
 */

2.4.2.1. 基础查询

通过 QueryWrapper 指定查询条件

eq( ) :  等于 =
ne( ) :  不等于 <>
gt( ) :  大于 >
ge( ) :  大于等于  >=
lt( ) :  小于 <
le( ) :  小于等于 <=
between ( ) :  BETWEEN 值1 AND 值2 
notBetween ( ) :  NOT BETWEEN 值1 AND 值2 
in( ) :  in
notIn( ) ：not in

@Test
public void testWrapper1(){
    //1.创建查询条件构建器
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //2.设置条件
    wrapper.eq("user_name","lisi")
        .lt("age",23)
        .in("name","李四","王五");
    //select * from tb_user where user_name = ? and age < ? and name in (?,?)
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

2.4.2.2. 逻辑查询 or

or( ) ：让紧接着下一个方法用or连接 

@Test
public void testWrapper2(){
    //1.创建查询条件构建器
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //2.设置条件
    wrapper.eq("user_name","lisi")
        .or()
        .lt("age",23)
        .in("name","李四","王五");
    /*
      select * from tb_user where user_name = ? or age < ? and name in (?,?)
    */
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

2.4.2.3. 模糊查询 like

like
notLike
likeLeft
likeRight

/**
  * 模糊查询
  */
@Test
public void testWrapper3(){
    //1.创建查询条件构建器
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //2.设置条件
    wrapper.likeLeft("user_name","zhang");
    /*
       SELECT id,user_name,password,name,age,email
       from tb_user
       where user_name like ?
       %zhang
    */
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

2.4.2.4. 排序查询

orderBy
orderByAsc
orderByDesc

@Test
public void testWrapper4(){
    //1.创建查询条件构建器
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //2.设置条件
    wrapper.eq("user_name","lisi")
        .or()
        .lt("age",23)
        .in("name","李四","王五")
        //.orderBy(true,true,"age")
        .orderByDesc("age");
    /*
            select * from tb_user where user_name = ? or age < ? and name in (?,?) order by age asc
         */
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

2.4.2.5. select指定需要查询的字段

@Test
public void testWrapper5(){
    //1.创建查询条件构建器
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    //2.设置条件
    wrapper.eq("user_name","lisi")
        .or()
        .lt("age",23)
        .in("name","李四","王五")
        //.orderBy(true,true,"age")
        .orderByDesc("age")
        .select("id","user_name");
    /*
            select id,user_name from tb_user where user_name = ? or age < ? and name in (?,?) order by age asc
         */
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

2.4.2.6. 分页条件查询

@Test
public void testWrapper6(){
    int current = 1;//当前页码
    int size = 2;//每页显示条数
    //1. 构建分页对象
    Page<User> page = new Page<>(current,size);
    //2. 构建条件对象
    QueryWrapper<User> wrapper = new QueryWrapper();
    wrapper.lt("age",23);
    userMapper.selectPage(page,wrapper);
    List<User> records = page.getRecords();
    long total = page.getTotal();
    long pages = page.getPages();
    System.out.println(records);
    System.out.println(total);//2
    System.out.println(pages);//1
}

【小结】

掌握Mybatis Plus CRUD

回到顶部

3.LambdaQueryWrapper

LambdaQueryWrapper条件构造

【目标】

掌握LambdaQueryWrapper使用

【路径】

1：条件 查询

2：条件 删除

2：条件 update

【讲解】

3.1. 条件 查询

消除代码中的硬编码

@Test
public void testWrapper7(){
    LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
    wrapper.eq(User::getUserName,"zhangsan");
    List<User> users = userMapper.selectList(wrapper);
    System.out.println(users);
}

3.2. 条件 删除

@Test
public void testDeleteByUserName(){
    //QueryWrapper<User> wrapper = new QueryWrapper<>();
    //wrapper.eq("user_name","bbb");
    //userMapper.delete(wrapper);

    LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(User::getUserName,"bbb");
    userMapper.delete(queryWrapper);
}

3.3. 条件 update

 
@Test
public void testWrapper9(){
    //UpdateWrapper<User> wrapper = new UpdateWrapper<>();
    //条件
    //wrapper.eq("user_name","zhangsan")
    //.set("password","22222");
    //update tb_user set password = ? where user_name = ?
    //userMapper.update(null,wrapper);


    LambdaUpdateWrapper<User> wrapper = new LambdaUpdateWrapper<>();
    //条件
    wrapper.eq(User::getUserName,"zhangsan")
        .set(User::getPassword,"33333");
    //update tb_user set password = ? where user_name = ?
    userMapper.update(null,wrapper);
}

@Test
public void testWrapper10(){
    UpdateWrapper<User> wrapper = new UpdateWrapper<>();
    //条件
    wrapper.eq("user_name","lisi");
    //update tb_user set password = ?,age = ? where user_name = ?
    User user = new User();
    user.setPassword("3333");
    user.setAge(33);
    userMapper.update(user,wrapper);
}

【小结】

回到顶部

4. service 封装-通用service

Mybatis-Plus 为了开发更加快捷，对业务层也进行了封装，直接提供了相关的接口和实现类。我们在进行业务层开发时，可以继承它提供的接口和实现类，使得编码更加高效

- 1. 定义接口继承IService
- 2. 定义实现类继承ServiceImpl<Mapper，Entity> 实现定义的接口

接口

public interface _UserService extends IService<User> {
}

实现类封装

@Service
public class _UserServiceImpl extends ServiceImpl<UserMapper, User> implements _UserService {}

回到顶部

5. 逆向工程-代码生成器

【目标】

会使用代码生成器

【路径】

1：代码生成器生成各个模块代码

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

【讲解】

5.1. 引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>my-springboot-autogenerator</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
            <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>
        <!--mybatis plus 起步依赖-->

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency>

        <!--mp 代码生成器-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.1.1</version>
        </dependency>

        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.30</version>
        </dependency>
    </dependencies>
</project>

5.2. 执行main 方法

package com.itheima;

import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

// 演示例子，执行 main 方法控制台输入模块表名回车自动生成对应项目目录中
public class CodeGenerator {

    /**
     * <p>
     * 读取控制台内容
     * </p>
     */
    public static String scanner(String tip) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder help = new StringBuilder();
        help.append("请输入" + tip + "：");
        System.out.println(help.toString());
        if (scanner.hasNext()) {
            String ipt = scanner.next();
            if (StringUtils.isNotEmpty(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }

    public static void main(String[] args) {
        // 代码生成器
        AutoGenerator mpg = new AutoGenerator();

        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");
        System.out.println(projectPath);
        gc.setOutputDir(projectPath + "/src/main/java");
        gc.setAuthor("itheima");
        gc.setOpen(false);
        // gc.setSwagger2(true); 实体属性 Swagger2 注解
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://localhost:3306/itcast_mp");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("admin");
        mpg.setDataSource(dsc);

        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName(scanner("模块名"));
        pc.setParent("com.itheima");
        mpg.setPackageInfo(pc);

        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                // to do nothing
            }
        };

        // 如果模板引擎是 freemarker
        String templatePath = "/templates/mapper.xml.ftl";
        // 如果模板引擎是 velocity
        // String templatePath = "/templates/mapper.xml.vm";

        // 自定义输出配置
        List<FileOutConfig> focList = new ArrayList<>();
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 ， 如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                return projectPath + "/src/main/resources/mapper/" + pc.getModuleName()
                        + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });
        /*
        cfg.setFileCreate(new IFileCreate() {
            @Override
            public boolean isCreate(ConfigBuilder configBuilder, FileType fileType, String filePath) {
                // 判断自定义文件夹是否需要创建
                checkDir("调用默认方法创建的目录，自定义目录用");
                if (fileType == FileType.MAPPER) {
                    // 已经生成 mapper 文件判断存在，不想重新生成返回 false
                    return !new File(filePath).exists();
                }
                // 允许生成模板文件
                return true;
            }
        });
        */
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);

        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();

        // 配置自定义输出模板
        //指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
        // templateConfig.setEntity("templates/entity2.java");
        // templateConfig.setService();
        // templateConfig.setController();

        templateConfig.setXml(null);
        mpg.setTemplate(templateConfig);

        // 策略配置
        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();
    }
}

【小结】

会使用代码生成器

回到顶部

6. dubbo工程改造

【分析】

方式一：

1.将mybatis依赖改为mybatis plus起步依赖

2.服务提供者持久层接口 UserDao 基础 BaseMapper 并将接口中方法映射文件删除

3.服务提供者业务层方法中api方法需要修改

4.暂不考虑改实体对象：在application.yml配置文件中配置表名的前缀t_ 主键策略 日志

方式二：实体对象加 @TableName("t_user")

1.将服务提供者中起步依赖 移动到 实体对象工程中

2.在实体对象上加上@TableName("t_user") 配置文件需要去掉前缀配置

3.可以在消费者启动类上排除DataSourceAutoConfiguration

方式三：消费者启动类不排除DataSourceAutoConfiguration（探花项目中使用的方式）

1.实体对象pom改造起步依赖 改为普通依赖（需要能用上注解）

2.服务提供者pom还需要加上mybatis plus起步依赖

【目标】

将mybatis改造成mybatis-plus

【路径】

1：改造服务提供者

2：改造服务消费者

3：测试

【讲解】

6.1. dubbo_parent

6.1.1. 删除mybaits依赖

<mybatis-spring.version>2.0.1</mybatis-spring.version>

<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.1.1</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>${mybatis-spring.version}</version>
</dependency>

6.1.2. 添加mybatis-plus依赖

<dependencyManagement>
    <!--mybatisplus起步依赖-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.1.1</version>
    </dependency>
    ......
</dependencyManagement>    

6.2. dubbo_domain

6.2.1. 引入mybatis-plus依赖

因为实体对象要用到mybatis-plus注解

<dependencies>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
    </dependency>
</dependencies>

6.2.2. 修改实体对象

package com.itheima.pojo;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**'
 * 用户实体对象
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("t_user")
public class User implements Serializable {
    private Integer id;
    private String username;
    private Integer age;
}

6.3. dubbo_provider

6.3.1. 删除mybatis依赖

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>

6.3.2. UserDao接口

package com.itheima.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itheima.pojo.User;
/**
 * 用户持久层接口
 */
public interface UserDao extends BaseMapper<User> {
}

删除resources目录下UserDao映射文件

6.3.3. UserServiceImpl

package com.itheima.service;
import com.itheima.dao.UserDao;
import com.itheima.pojo.User;
import org.apache.dubbo.config.annotation.Service;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * 服务提供者实现类
 */
@Service
public class UserServiceImpl implements UserService  {
    @Autowired
    private UserDao userDao;

    @Override
    public User findById(Integer id) {
        System.out.println("dubbo_provider...");
        return userDao.selectById(id);
    }
}

6.3.4. application.yml

mybatis-plus:
  global-config:
    db-config:
      # 表名前缀
      table-prefix: t_
      # id生成策略 数据库自增
      id-type: auto
  configuration:
    # 日志
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

6.4. dubbo_consumer

修改启动不加载DataSourceAutoConfiguration

package com.itheima;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
/**
 * 消费者启动类
 */
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class DubboConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(DubboConsumerApplication.class,args);
    }
}

【小结】

掌握dubbo工程改造

回到顶部

总结

1.Mybatis PLUS-通过Mapper CRUD-重点掌握

2.dubbo工程改造-重点掌握