# generator

**Repository Path**: mhb0409/generator

## Basic Information

- **Project Name**: generator
- **Description**: 超容易上手代码生成器，只需几秒自动生成（entity、mapper、xml、controller、service、view），支持多表生成，高度自由选择，容易扩展，注释详细.....
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 22
- **Forks**: 1
- **Created**: 2020-04-29
- **Last Updated**: 2023-07-21

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 代码生成器介绍
本项目是为了公司快速开发新模块所编写的代码生成器，参照了mybatis plus的代码生成器规格，可以生成 （Myabtis plus、mybatis）代码，不需要额外部署，只需要引入jar包，复制下方的代码，修改为自己的就可以了。
## 生成类型选择
本代码生成器可以选择生成除entity外其他模块

 0.全局设置
```java
  GlobalConfig globalConfig = new GlobalConfig();
        globalConfig
                .setAuthor("博博") // 设置 作者
                .setGenerateMapper(true) // 是否生成mapper
                .setGenerateService(true) // 是否生成service impl
                .setGenerateBaseCRUD(true) // 是否生出基础curd语句
                .setGenerateBaseResultMap(true) // 是否生成基础resultMap
                .setGenerateTemplate(true) // 是否生成视图模板
                .setGenerateBaseColumnList(true) // 是否生成基础查询字段
                .setGenerateController(true) // 是否生成controller
                .setFilePath("E:\\IdeaProjects\\Generator\\src\\main\\java\\")// 生成路径
                .setMybatisPlus(true) // 是否生成mybatis plus代码
                .setPageMethod(true); // 是否生成分页方法 service 和 controller 方法

```


1. 策略设置
```java
  	// 生成策略
        StrategyConfig strategyConfig = new StrategyConfig();
        strategyConfig
                // 生成模块 名称 %s 则是系统根据表生成的名称
                .setServiceName("%sService")
                .setServiceImplName("%sServiceImpl")
                .setMapperName("%sMapper")
                .setControllerName("%sController")
                // 字段输出方式，underline_to_camel 下划线转换驼峰，no_change 不做转换
                .setNamingStrategy(NamingStrategy.underline_to_camel)
                // 去除表前缀，生成的时候 如果指定了表前缀，例如：table ; we_user 生成的模块名就是 user，去除we_
                .setTablePrefix("we_")
                // 生成的表数组，
                .setTables(tables)
                // 是否使用lombok插件
                .setEntityLomBokModel(true)
                // 是否使用构建者模式
                .setEntityBuilderModel(true);
```
2.视图设置
```java
	// 视图配置
        ViewConfig viewConfig = new ViewConfig();
        viewConfig
                /*
                   是否懒生成 视图
                  （如果设置了懒 为 false 则生成controller 基础方法，但是不生成视图，需要手动再执行手动生成）
                  （如果设置了懒 为 true 生成controller 基础方法，但是生成视图，但是生成的视图则为全部参数都有的）
                 */
                .setLazyGenerate(true)
                // 使用生成的视图模板，目前只支持 ftl，如果有需要可以自己扩展
                .setUseViewType(UseViewType.FTL)
                // 模板文件是否把驼峰转换为下划线
                .setTemplateCamel(true)
                // 生成视图 名称 %s 则是系统根据表生成的名称
                .setSelectViewName("%s_select")
                .setUpdateViewName("%s_update")
                .setDetailViewName("%s_detail")
                .setSaveViewName("%s_save")
                // 生成模板类型，目前只支持jsp，如果有需要可以自己扩展。扩展容易，可以参考源码中的 view_detail_jsp.ftl....
                .setTemplateType(TemplateType.JSP)
                // 生成文件的路径
                .setTemplatePath("E:\\IdeaProjects\\Generator\\src\\main\\resources\\jsp\\")
                // controller return 返回的视图前缀
                .setPathPrefix("/sys/tester/");
```
3.包配置
```java
   // 包配置
        PackageConfig packageConfig = new PackageConfig();
        packageConfig
                // 设置父包 设置父包后，子包路径就是 com.mhb.generator.tester.pojo .....
                .setParent("com.mhb.generator.tester")
                // 实体包名
                .setEntity("pojo")
                // mapper
                .setMapper("mapper")
                // controller
                .setController("controller")
                // service
                .setService("service");

```
4.数据库连接配置
```java
        // 数据库连接配置
        DataSourceConfig dataSourceConfig = new DataSourceConfig();
        dataSourceConfig
                // 数据库类型 目前支持MySQL，如有其它需要可以自己扩展。参考 com.mhb.generator.config.query.MySqlQuery
                .setDbType(DbType.MYSQL)
                // 驱动
                .setDriverName("com.mysql.jdbc.Driver")
                // url
                .setUrl("jdbc:mysql://localhost:3306/zhdj_wx")
                // 用户名
                .setUsername("root")
                // 密码
                .setPassword("root");
```
5.生成执行
```java
    AutoGenerator autoGenerator = new AutoGenerator();
        autoGenerator.setDataSourceConfig(dataSourceConfig)
                .setGlobalConfig(globalConfig)
                .setPackageConfig(packageConfig)
                .setStrategyConfig(strategyConfig)
                .setViewConfig(viewConfig);
	// 执行
        autoGenerator.execution();
```

## 生成代码
```java
   public static void main(String[] args) {
        GlobalConfig globalConfig = new GlobalConfig();
        globalConfig
                .setAuthor("博博") // 设置 作者
                .setGenerateMapper(true) // 是否生成mapper
                .setGenerateService(true) // 是否生成service impl
                .setGenerateBaseCRUD(true) // 是否生出基础curd语句
                .setGenerateBaseResultMap(true) // 是否生成基础resultMap
                .setGenerateTemplate(true) // 是否生成视图模板
                .setGenerateBaseColumnList(true) // 是否生成基础查询字段
                .setGenerateController(true) // 是否生成controller
                .setFilePath("E:\\IdeaProjects\\Generator\\src\\main\\java\\")// 生成路径
                .setMybatisPlus(true) // 是否生成mybatis plus代码
                .setPageMethod(true); // 是否生成分页方法 service 和 controller 方法


        // 数据库连接配置
        DataSourceConfig dataSourceConfig = new DataSourceConfig();
        dataSourceConfig
                // 数据库类型 目前支持MySQL，如有其它需要可以自己扩展。参考 com.mhb.generator.config.query.MySqlQuery
                .setDbType(DbType.MYSQL)
                // 驱动
                .setDriverName("com.mysql.jdbc.Driver")
                // url
                .setUrl("jdbc:mysql://localhost:3306/zhdj_wx")
                // 用户名
                .setUsername("root")
                // 密码
                .setPassword("root");

        // 包配置
        PackageConfig packageConfig = new PackageConfig();
        packageConfig
                // 设置父包 设置父包后，子包路径就是 com.mhb.generator.tester.pojo .....
                .setParent("com.mhb.generator.tester")
                // 实体包名
                .setEntity("pojo")
                // mapper
                .setMapper("mapper")
                // controller
                .setController("controller")
                // service
                .setService("service");

        String[] tables = {"t_role_user"};
        // 生成策略
        StrategyConfig strategyConfig = new StrategyConfig();
        strategyConfig
                // 生成模块 名称 %s 则是系统根据表生成的名称
                .setServiceName("%sService")
                .setServiceImplName("%sServiceImpl")
                .setMapperName("%sMapper")
                .setControllerName("%sController")
                // 字段输出方式，underline_to_camel 下划线转换驼峰，no_change 不做转换
                .setNamingStrategy(NamingStrategy.underline_to_camel)
                // 去除表前缀，生成的时候 如果指定了表前缀，例如：table ; we_user 生成的模块名就是 user，去除we_
                .setTablePrefix("t_")
                // 生成的表数组，
                .setTables(tables)
                // 是否使用lombok插件
                .setEntityLomBokModel(true)
                // 是否使用构建者模式
                .setEntityBuilderModel(true);

        // 视图配置
        ViewConfig viewConfig = new ViewConfig();
        viewConfig
                /*
                   是否懒生成 视图
                  （如果设置了懒 为 false 则生成controller 基础方法，但是不生成视图，需要手动再执行手动生成）
                  （如果设置了懒 为 true 生成controller 基础方法，但是生成视图，但是生成的视图则为全部参数都有的）
                 */
                .setLazyGenerate(true)
                // 使用生成的视图模板，目前只支持 ftl，如果有需要可以自己扩展
                .setUseViewType(UseViewType.FTL)
                // 模板文件是否把驼峰转换为下划线
                .setTemplateCamel(true)
                // 生成视图 名称 %s 则是系统根据表生成的名称
                .setSelectViewName("%s_select")
                .setUpdateViewName("%s_update")
                .setDetailViewName("%s_detail")
                .setSaveViewName("%s_save")
                // 生成模板类型，目前只支持jsp，如果有需要可以自己扩展。扩展容易，可以参考源码中的 view_detail_jsp.ftl....
                .setTemplateType(TemplateType.JSP)
                // 生成文件的路径
                .setTemplatePath("E:\\IdeaProjects\\Generator\\src\\main\\resources\\jsp\\")
                // controller return 返回的视图前缀
                .setPathPrefix("/sys/tester/");

        AutoGenerator autoGenerator = new AutoGenerator();
        autoGenerator.setDataSourceConfig(dataSourceConfig)
                .setGlobalConfig(globalConfig)
                .setPackageConfig(packageConfig)
                .setStrategyConfig(strategyConfig)
                .setViewConfig(viewConfig);
        autoGenerator.execution();
    }
```


## 控制台输出
![image.png](https://images.gitee.com/uploads/images/2020/0429/102038_2e220a6b_2333340.png)

## java 文件
### 1.entity
```java
package com.mhb.generator.tester.pojo;

import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import lombok.AllArgsConstructor;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.NoArgsConstructor;
import java.io.Serializable;

/**
 * <p>
 * 
 * </p>
 *
 * @author 博博
 * @since 2020-04-29
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
@TableName("t_role_user")
public class RoleUser implements Serializable {

    private static final long serialVersionUID = 1L;

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

    /**
     * 外联权限表id
     */
    @TableField("role_id")
    private Integer roleId;

    /**
     * 用户id
     */
    @TableField("user_id")
    private Integer userId;

    /**
     * 用户类型 （1.前台用户 2.后台用户）
     */
    @TableField("type")
    private Integer type;


}

```
### 2.mapper
```java
package com.mhb.generator.tester.mapper;

import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mhb.generator.tester.pojo.RoleUser;
import java.io.Serializable;

/**
 * <p>
 * Mapper 接口
 * </p>
 *
 * @author 博博
 * @since 2020-04-29
 */
public interface RoleUserMapper extends BaseMapper<RoleUser> {
    /**
     * 批量添加
     *
     * @param list 实体对象集合
     * @return 影响行数
     */
    int saveBatch(List<RoleUser> list);

    /**
     * 添加一条数据
     *
     * @param roleUser 实体对象
     * @return 影响行数
     */
    int save(RoleUser roleUser);

     /**
      * 添加对象中不为空的数据
      *
      * @param roleUser 实体对象
      * @return 影响行数
      */
    int saveNotEmpty(RoleUser roleUser);

    /**
     * 根据id删除
     *
     * @param id id
     * @return 影响行数
     */
    int deleteById(@Param("id")Serializable id);

    /**
     * 根据id修改
     *
     * @param roleUser 实体对象
     * @return 影响行数
     */
    int updateById(RoleUser roleUser);

     /**
      * 根据id修改 对象中不为空的数据
      *
      * @param roleUser 实体对象
      * @return 影响行数
      */
    int updateNotEmptyById(RoleUser roleUser);

    /**
     * 根据 实体不为空的数据查询
     *
     * @param roleUser 实体对象
     * @return 检索后的集合
     */
    List<RoleUser> findListByEntity(RoleUser roleUser);

    /**
     * 根据 实体不为空的数据查询
     *
     * @param roleUser 实体对象
     * @return 检索后的对象
     */
    RoleUser getRoleUserByEntity(RoleUser roleUser);

     /**
      * 根据id查询对象
      *
      * @param id id
      * @return 查询后的对象
      */
    RoleUser getRoleUserById(@Param("id")Serializable id);
}

```
### 3.mapper xml
```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.mhb.generator.tester.mapper.RoleUserMapper">

    <!-- 通用查询映射结果 -->
    <resultMap id="BaseResultMap" type="com.mhb.generator.tester.pojo.RoleUser">
        <id column="id" property="id" />
        <result column="role_id" property="roleId" />
        <result column="user_id" property="userId" />
        <result column="type" property="type" />
    </resultMap>

    <!-- 通用查询结果列 -->
    <sql id="Base_Column_List">
        `id`,`role_id`,`user_id`,`type`
    </sql>
    <!--批量添加-->
    <insert id="saveBatch" keyColumn="id" useGeneratedKeys="true"  keyProperty="id">
        INSERT INTO `t_role_user` (`id`,`role_id`,`user_id`,`type`)
        VALUES
        <foreach collection="list" item="item" separator=",">
                (#{item.id},#{item.roleId},#{item.userId},#{item.type})
        </foreach>
    </insert>
    <!--添加一条数据-->
    <insert id="save"   keyColumn="id" useGeneratedKeys="true"  keyProperty="id">
        insert into `t_role_user`(`id`,`role_id`,`user_id`,`type`)
        values(#{id},#{roleId},#{userId},#{type})
    </insert>
    <!--添加对象中不为空的数据-->
    <insert id="saveNotEmpty"  keyColumn="id" useGeneratedKeys="true"  keyProperty="id">
        insert into `t_role_user`
        <trim prefix="(" suffix=")" suffixOverrides=",">
             <if test="id != null ">id,</if>
             <if test="roleId != null ">role_id,</if>
             <if test="userId != null ">user_id,</if>
             <if test="type != null ">type,</if>
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
             <if test="id != null ">#{id},</if>
             <if test="roleId != null ">#{roleId},</if>
             <if test="userId != null ">#{userId},</if>
             <if test="type != null ">#{type},</if>
        </trim>
    </insert>
    <!--根据id修改-->
    <update id="updateById">
        update `t_role_user` set
        role_id=#{roleId},user_id=#{userId},type=#{type}
        where `id`=#{id}
    </update>
    <!--根据id修改 对象中不为空的数据-->
    <update id="updateNotEmptyById">
        update `t_role_user`
        <set>
            <if test="id != null ">
                id=#{id},
            </if>
            <if test="roleId != null ">
                role_id=#{roleId},
            </if>
            <if test="userId != null ">
                user_id=#{userId},
            </if>
            <if test="type != null ">
                type=#{type},
            </if>
        </set>
        where `id`=#{id}
    </update>
    <!--根据id删除-->
    <delete id="deleteById">
        delete from `t_role_user`
        where `id`=#{id}
    </delete>
    <!--根据 实体不为空的数据查询-->
    <select id="findListByEntity" resultMap="BaseResultMap">
        SELECT
        <include refid="Base_Column_List"/>
        FROM `t_role_user`
        <where>
            <if test="id != null ">and id=#{id}</if>
            <if test="roleId != null ">and role_id=#{roleId}</if>
            <if test="userId != null ">and user_id=#{userId}</if>
            <if test="type != null ">and type=#{type}</if>
        </where>
    </select>
    <!--根据 实体不为空的数据查询-->
    <select id="getRoleUserByEntity" resultMap="BaseResultMap">
        SELECT
        <include refid="Base_Column_List"/>
        FROM `t_role_user`
        <where>
                    <if test="id != null ">and id=#{id}</if>
                    <if test="roleId != null ">and role_id=#{roleId}</if>
                    <if test="userId != null ">and user_id=#{userId}</if>
                    <if test="type != null ">and type=#{type}</if>
        </where>
        limit 1
    </select>
    <!--根据id查询对象-->
    <select id="getRoleUserById" resultMap="BaseResultMap">
        SELECT
        <include refid="Base_Column_List"/>
        FROM `t_role_user`
        WHERE `id`=#{id}
    </select>
</mapper>

```
### 4.service
```java
package com.mhb.generator.tester.service;

import java.util.List;
import com.mhb.generator.tester.pojo.RoleUser;
import com.baomidou.mybatisplus.extension.service.IService;
import com.github.pagehelper.PageInfo;
import com.mhb.generator.tester.mapper.RoleUserMapper;
import java.io.Serializable;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author 博博
 * @since 2020-04-29
 */
public interface RoleUserService extends IService<RoleUser> {
    /**
     * 批量添加
     *
     * @param list 实体对象集合
     * @return 是否执行成功
     */
    boolean saveBatch(List<RoleUser> list);

    /**
     * 添加一条数据
     *
     * @param roleUser 实体对象
     * @return 是否执行成功
     */
    boolean save(RoleUser roleUser);

     /**
      * 添加对象中不为空的数据
      *
      * @param roleUser 实体对象
      * @return 是否执行成功
      */
    boolean saveNotEmpty(RoleUser roleUser);

    /**
     * 根据id删除
     *
     * @param id id
     * @return 是否执行成功
     */
    boolean deleteById(Serializable id);

    /**
     * 根据id修改
     *
     * @param roleUser 实体对象
     * @return 是否执行成功
     */
    boolean updateById(RoleUser roleUser);

     /**
      * 根据id修改 对象中不为空的数据
      *
      * @param roleUser 实体对象
      * @return 是否执行成功
      */
    boolean updateNotEmptyById(RoleUser roleUser);

    /**
     * 根据 实体不为空的数据查询
     *
     * @param roleUser 实体对象
     * @return 检索后的集合
     */
    List<RoleUser> findListByEntity(RoleUser roleUser);

    /**
     * 根据 实体不为空的数据查询
     *
     * @param roleUser 实体对象
     * @return 检索后的对象
     */
    RoleUser getRoleUserByEntity(RoleUser roleUser);

     /**
      * 根据id查询对象
      *
      * @param id id
      * @return 查询后的对象
      */
    RoleUser getRoleUserById(Serializable id);

    /**
     * 根据传入的实体内容作为检索条件 进行分页查询
     *
     * @param roleUser 实体对象
     * @param pageIndex   起始页
     * @param pageSize    每页页数
     * @return 分页结果
     */
    PageInfo<RoleUser> queryTableData(RoleUser roleUser,Integer pageIndex, Integer pageSize);
}

```
### 5. service impl
```java
package com.mhb.generator.tester.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import java.util.List;
import com.mhb.generator.tester.service.RoleUserService;
import org.springframework.stereotype.Service;
import com.mhb.generator.tester.pojo.RoleUser;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mhb.generator.tester.mapper.RoleUserMapper;
import java.io.Serializable;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 博博
 * @since 2020-04-29
 */
@Service
public class RoleUserServiceImpl extends ServiceImpl<RoleUserMapper, RoleUser> implements RoleUserService {


    @Override
    public boolean saveBatch(List<RoleUser> list){
        return isSuccess(this.baseMapper.saveBatch(list));
    }

    @Override
    public boolean save(RoleUser roleUser){
        return isSuccess(this.baseMapper.save(roleUser));
    }

    @Override
    public boolean saveNotEmpty(RoleUser roleUser){
        return isSuccess(this.baseMapper.saveNotEmpty(roleUser));
    }

    @Override
    public boolean deleteById(Serializable id){
        return isSuccess(this.baseMapper.deleteById(id));
    }

    @Override
    public boolean updateById(RoleUser roleUser){
        return isSuccess(this.baseMapper.updateById(roleUser));
    }

    @Override
    public boolean updateNotEmptyById(RoleUser roleUser){
        return isSuccess(this.baseMapper.updateNotEmptyById(roleUser));
    }

    @Override
    public List<RoleUser> findListByEntity(RoleUser roleUser){
        return this.baseMapper.findListByEntity(roleUser);
    }

    @Override
    public RoleUser getRoleUserByEntity(RoleUser roleUser){
        return this.baseMapper.getRoleUserByEntity(roleUser);
    }

    @Override
    public RoleUser getRoleUserById(Serializable id){
        return this.baseMapper.getRoleUserById(id);
    }

    @Override
    public PageInfo<RoleUser> queryTableData(RoleUser roleUser, Integer pageIndex, Integer pageSize){
        PageHelper.startPage(pageIndex, pageSize);
        List<RoleUser> list = this.baseMapper.findListByEntity(roleUser);
        PageInfo<RoleUser> info = new PageInfo<>(list);
        return info;
    }


    /**
     * 是否成功 如果传入的num大于0则是true
     * @param num 数值
     * @return 是否成功
     */
    private boolean isSuccess(int num){
        return num > 0;
    }

}

```
### 6.controller
```java 
package com.mhb.generator.tester.controller;

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PathVariable;
import com.mhb.generator.tester.service.RoleUserService;
import javax.annotation.Resource;
import org.springframework.web.bind.annotation.RequestMapping;
import com.github.pagehelper.PageInfo;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ResponseBody;
import java.io.Serializable;
import java.util.List;
import org.springframework.ui.Model;
import com.mhb.generator.tester.pojo.RoleUser;
import lombok.Data;
import org.springframework.web.bind.annotation.GetMapping;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author 博博
 * @since 2020-04-29
 */
@Controller
@RequestMapping(value = "/roleUser")
public class RoleUserController {

    private String prefixView = "/sys/tester/";
    @Resource
    private RoleUserService roleUserService;

    /**
     * 获取JSON 数据的list集合
     *
     * @param roleUser 对象参数
     * @return JSON格式的 对象
     */
    @GetMapping(value = "/getRoleUserList")
    @ResponseBody
    public ReturnResult getRoleUserList(RoleUser roleUser) {
        List<RoleUser> list = roleUserService.findListByEntity(roleUser);
        return ReturnResult.ok(list);
    }

    /**
     * 添加数据
     *
     * @param roleUser 对象
     * @return JSON格式的 对象
     */
    @PostMapping(value = "/addRoleUser")
    @ResponseBody
    public ReturnResult addRoleUser(RoleUser roleUser) {
        // 添加成功则返回true
        if (roleUserService.saveNotEmpty(roleUser)) {
            return ReturnResult.ok();
        }
        return ReturnResult.error("添加失败.");
    }


    /**
     * 修改数据
     *
     * @param roleUser 对象
     * @return JSON格式的 对象
     */
    @PostMapping(value = "/updateRoleUser")
    @ResponseBody
    public ReturnResult updateRoleUser(RoleUser roleUser) {
        // 根据id修改，修改成功则返回true
        if (roleUserService.updateNotEmptyById(roleUser)) {
            return ReturnResult.ok();
        }
        return ReturnResult.error("修改失败.");
    }

    /**
     * 根据id删除
     *
     * @param id id
     * @return JSON格式的 对象
     */
    @PostMapping(value = "/deleteRoleUserById/{id}")
    @ResponseBody
    public ReturnResult deleteRoleUserById(@PathVariable Integer id) {
        // 如果id为null 为了安全考虑，则不执行，返回提示
        if (id == null) {
            return ReturnResult.error("Id不能为空!");
        } else {
            // 根据id删除，删除成功则返回true
            if (roleUserService.deleteById(id)) {
                return ReturnResult.ok("删除成功.");
            }
        }
        return ReturnResult.error("删除失败.");
    }

    /**
     * 根据传入id获取单个对象
     *
     * @param id id
     * @return JSON格式的 对象
     */
    @PostMapping(value = "/getRoleUserById/{id}")
    @ResponseBody
    public ReturnResult getRoleUserById(@PathVariable Integer id) {
        // 如果id为null 为了安全考虑，则不执行，返回提示
        if (id == null) {
            return ReturnResult.error("Id不能为空!");
        } else {
            return ReturnResult.ok(roleUserService.getRoleUserById(id));
        }
    }
    /**
     * 分页查询
     *
     * @param roleUser 实体对象
     * @param pageIndex            起始页
     * @param pageSize             每页页数
     * @return 返回layui table格式数据
     */
    @GetMapping(value = "/queryTableData")
    @ResponseBody
    public ReturnResult queryTableData(RoleUser roleUser, Integer pageIndex, Integer pageSize) {
        // 查询分页数据
        PageInfo<RoleUser> pageInfo = roleUserService.queryTableData(roleUser, pageIndex, pageSize);
        return new ReturnResult(ReturnResult.SUCCESS, pageInfo.getList(), "成功.", pageInfo.getTotal());
    }

    /**
     * 跳转到查询页面
     *
     * @return 逻辑视图
     */
    @GetMapping(value = "/goSelectView")
    public String goSelectView() {
        return prefixView + "role_user_select";
    }

    /**
     * 跳转到添加页面
     *
     * @return 逻辑视图
     */
    @GetMapping(value = "/goSaveView")
    public String goSaveView() {
        return prefixView + "role_user_save";
    }

    /**
     * 跳转到修改页面
     *
     * @param id    id
     * @param model 模型传输对象
     * @return 逻辑视图
     */
    @GetMapping(value = "/goUpdateView")
    public String goUpdateView(Integer id, Model model) {
        RoleUser roleUser =  roleUserService.getRoleUserById(id);
        model.addAttribute("roleUser", roleUser);
        return prefixView + "role_user_update";
    }

    // 该类为示例返回格式，如没有特殊要求可以把该类单独创建一个类
    @Data
    static class ReturnResult implements Serializable {
        // 成功
        private static final Integer SUCCESS = 200;
        // 失败
        private static final Integer ERROR = 500;

        private Integer status;
        private Object data;
        private String msg;
        private Long count;

        public ReturnResult(Integer status, String msg) {
            this.status = status;
            this.msg = msg;
        }

        public ReturnResult(Integer status) {
            this.status = status;
        }

        public ReturnResult(Integer status, Object msg) {
            this.status = status;
            this.data = msg;
        }

        public ReturnResult(Integer status, Object obj, String msg) {
            this.status = status;
            this.data = obj;
            this.msg = msg;
        }

        public ReturnResult(Integer status, Object data, String msg, Long count) {
            this.status = status;
            this.data = data;
            this.msg = msg;
            this.count = count;
        }

        /**
         * 返回成功状态
         *
         * @param obj 需要传送的值
         * @return ReturnResult 对象
         */
        public static ReturnResult ok(Object obj) {
            return new ReturnResult(SUCCESS, obj);
        }

        /**
         * 返回成功状态
         *
         * @return ReturnResult 对象
         */
        public static ReturnResult ok() {
            return new ReturnResult(SUCCESS);
        }

        /**
         * 返回失败状态
         *
         * @param msg 失败消息
         * @return ReturnResult 对象
         */
        public static ReturnResult error(String msg) {
            return new ReturnResult(ERROR, msg);
        }

    }

}

```

视图就不截图了，开箱即用，增删改查，全都可以直接用。

作者不易，如果喜欢就请给个start。