自制一个restful的java代码生成工具

最新推荐文章于 2024-04-19 17:12:36 发布
最新推荐文章于 2024-04-19 17:12:36 发布
阅读量310 收藏
点赞数 2
文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44649291/article/details/119571247
版权

注意： 文本有些类得需要自己定义哦

前言

很多朋友在使用mybatis-plus开发spring的项目时候，经常会使用带代码生成的工具，目前我用过的就mybatis-plus官方提供的一个代码，但是该代码无法生成controller的代码，而且使用也需要引入好多包，还有就是idea的插件MybtaisCodeHelperPro（还是很好用），但是这个插件居然要收费，博主用的是最新的idea，还没找到该插件的破解版，所以只能在用的时候冲上一元。

上面的都算我用过的，除此之外，经常看到用写开源的平台上面有写代码生成的功能，所以为了方便和更便捷的生成代码，我就自己开发一个适合自己代码风格的工具。

设计思路

在这里插入图片描述
由于代码比较多，本文中模板中有些许项目中定义的类，大家可自行定义，如有需要可以私信我哦

废话不多说，我们上代码。。。

模型类

模型类比较多，可直接引入。

public class AutoCodeConfig {
    /**
     * 获取配置信息
     */
    public static Configuration getConfig() {
        try {
            final PropertiesConfiguration proCfing = new PropertiesConfiguration();
            proCfing.setEncoding("UTF-8");
            proCfing.load("auto_code/auto_code_config.properties");
            return proCfing;
        } catch (ConfigurationException e) {
            System.out.println("获取配置文件失败");
            e.printStackTrace();
            return null;
        }
    }
   
    /**
     * 获取配置文件value
     *
     * @param key
     * @return
     * @author fuce
     * @Date 2019年8月17日 上午12:29:40
     */
    public String getConfigkey(String key) {
        return Objects.requireNonNull(getConfig()).getString(key);
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class AutoConfigModel {
    /**
     * 表名称
     **/
    private String tableName;
    /**
     * 表描述
     **/
    private String tableComment;
    /**
     * 作者
     **/
    private String author;
    /**
     * 父菜单
     **/
    private String pid;
    /**
     * 自定义路径
     **/
    private String parentPath;

    private List<BeanColumn> beanColumns;
}


@Data
public class BeanColumn {

    /**
     * 空字符串
     */
    private static final String NULLSTR = "";

    /**
     * 表\目录
     **/
    private String table_catalog;
    /**
     * 是否为null
     **/
    private String is_nullable;
    /**
     * 表名
     **/
    private String table_name;
    /**
     * 数据库
     **/
    private String table_schema;
    /**
     * 额外的 EXTRA": "auto_increment  自增id
     **/
    private String extra;
    /**
     * 列名
     **/
    private String column_name;
    /**
     * 主键 PRI
     **/
    private String column_key;
    /**
     * 数字精度
     **/
    private String numeric_precision;
    /**
     * 权限
     **/
    private String privileges;
    /**
     * 列注释
     **/
    private String column_comment;
    /**
     * 数字刻度
     **/
    private String numeric_scale;
    /**
     * 列/类型
     **/
    private String column_type;
    /**
     * 生成表达式
     **/
    private String generation_expression;
    /**
     * 序数位置
     **/
    private String ordinal_position;
    /**
     * 数据类型
     **/
    private String data_type;
    /**
     * 默认值
     **/
    private String column_default;
    /**
     * 字符最大长度
     **/
    private String character_maximum_length;
    /**
     * 字符\八位字节\长度
     **/
    private String character_octet_length;
    /**
     * 日期时间精度
     **/
    private String datetime_precision;
    /**
     * 字符集名称
     **/
    private String character_set_name;
    /**
     * 排序规则名称
     **/
    private String collation_name;

    /**
     * 实体类型 java.lang.String
     **/
    private String beanType;

    /**
     * 实体bean列名 例如:nameVc
     **/
    private String beanName;
    /**
     * mapperxml需要类型 例如:jdbcType="VARCHAR"
     **/
    private String jdbcType;

    /**
     * java类型
     **/
    private String javaType;
    /**
     * java 首字母大写
     **/
    private String javaName;

    public String getData_type() {
        return data_type;
    }

    public void setData_type(String data_type) {
        this.data_type = data_type;
    }


    public String getJavaType() {
        String beanType = this.getBeanType();
        String returnStr = "String";
        if (beanType == null) {
            return returnStr;
        } else {
            returnStr = beanType.substring(beanType.lastIndexOf(".") + 1, beanType.length());
        }
        javaType = returnStr;
        return javaType;
    }

    public void setJavaType(String javaType) {
        this.javaType = javaType;
    }

    public String getBeanType() {
        String type = this.getData_type();
        String returnStr = "java.lang.String";
        if (type == null) {
            return returnStr;
        }
        switch (type) {
            case "tinyint":
                returnStr = "java.lang.Integer";
                break;
            case "smallint":
                returnStr = "java.lang.Integer";
                break;
            case "int":
                returnStr = "java.lang.Integer";
                break;
            case "bigint":
                returnStr = "java.lang.Long";
                break;
            case "mediumint":
                returnStr = "java.lang.Integer";
                break;
            case "integer":
                returnStr = "java.lang.Integer";
                break;
            case "float":
                returnStr = "java.lang.Float";
                break;
            case "double":
                returnStr = "java.lang.Double";
                break;
            case "decimal":
                returnStr = "java.math.BigDecimal";
                break;
            case "bit":
                returnStr = "java.lang.Byte";
                break;
            case "char":
                returnStr = "java.lang.Character";
                break;
            case "varchar":
                returnStr = "java.lang.String";
                break;
            case "tinytext":
                returnStr = "java.lang.String";
                break;
            case "text":
                returnStr = "java.lang.String";
                break;
            case "mediumtext":
                returnStr = "java.lang.String";
                break;
            case "longtext":
                returnStr = "java.lang.String";
                break;
            case "date":
                returnStr = "java.util.Date";
                break;
            case "datetime":
                returnStr = "java.util.Date";
                break;
            case "timestamp":
                returnStr = "java.util.Date";
                break;
            default:
                break;
        }
        beanType = returnStr;
        return beanType;
    }

    public String getBeanName() {
        if (getColumn_name() != null) {
            return upperCase_(this.column_name, false);
        }
        return beanName;
    }

    public String getJavaName() {
        javaName = firstUpperCase(getBeanName());
        return javaName;
    }


    /**
     * 首字母大写
     *
     * @param name
     * @return
     */
    public static String firstUpperCase(String name) {
        name = name.substring(0, 1).toUpperCase() + name.substring(1);
        return name;
    }

    /**
     * 将下划线转化为大写
     *
     * @param name
     * @param firstCase 首字母是否大写 true:大写 false;小写
     * @return
     */
    public static String upperCase_(String name, boolean firstCase) {
        if (isEmpty(name)) {
            return "";
        }
        String[] s = name.split("_");
        StringBuffer stringBuffer = new StringBuffer();
        for (String s1 : s) {
            stringBuffer.append(s1.substring(0, 1).toUpperCase() + s1.substring(1));
        }
        if (!firstCase) {
            return firstLowerCase(stringBuffer.toString());
        }
        return stringBuffer.toString();
    }


    public static String firstLowerCase(String name) {
        name = name.substring(0, 1).toLowerCase() + name.substring(1);
        return name;

    }

    /**
     * * 判断一个字符串是否为空串
     *
     * @param str String
     * @return true：为空 false：非空
     */
    public static boolean isEmpty(String str) {
        return isNull(str) || NULLSTR.equals(str.trim());
    }

    /**
     * * 判断一个对象是否为空
     *
     * @param object Object
     * @return true：为空 false：非空
     */
    public static boolean isNull(Object object) {
        return object == null;
    }

    public String getJdbcType() {
        String datetype = getData_type();
        String returnStr = "VARCHAR";
        if (datetype == null) {
            return returnStr;
        }
        switch (datetype) {
            case "tinyint":
                returnStr = "TINYINT";
                break;
            case "smallint":
                returnStr = "SMALLINT";
                break;
            case "int":
                returnStr = "INTEGER";
                break;
            case "bigint":
                returnStr = "BIGINT";
                break;
            case "mediumint":
                returnStr = "INTEGER";
                break;
            case "integer":
                returnStr = "INTEGER";
                break;
            case "float":
                returnStr = "REAL";
                break;
            case "double":
                returnStr = "DOUBLE";
                break;
            case "decimal":
                returnStr = "DECIMAL";
                break;
            case "bit":
                returnStr = "OTHER";
                break;
            case "char":
                returnStr = "CHAR";
                break;
            case "varchar":
                returnStr = "VARCHAR";
                break;
            case "tinytext":
                returnStr = "VARCHAR";
                break;
            case "text":
                returnStr = "VARCHAR";
                break;
            case "mediumtext":
                returnStr = "VARCHAR";
                break;
            case "longtext":
                returnStr = "VARCHAR";
                break;
            case "date":
                returnStr = "TIMESTAMP";
                break;
            case "datetime":
                returnStr = "TIMESTAMP";
                break;
            case "timestamp":
                returnStr = "TIMESTAMP";
                break;
            default:
                break;
        }
        jdbcType = returnStr;
        return jdbcType;
    }

}



@Data
public class TableInfo {
    //数据库表名字 t_fifle
    private String tableName;
    //java表名字例如    SysOperLog
    private String javaTableName;
    //数据表注释 例如文件管理系统
    private String tableComment;
    //java表名字例如    sysOperLog
    private String javaTableName_a;

    //字段集合
    List<BeanColumn> beanColumns;


    public TableInfo(String tableName, List<BeanColumn> beanColumns, String tableComment) {
        super();
        this.tableName = tableName;
        this.javaTableName = tableToJava(tableName);
        this.beanColumns = beanColumns;
        this.tableComment = tableComment;
        this.javaTableName_a = tableToJava_a(tableName);
    }

    public TableInfo() {
        super();
    }

    /**
     * 列名转换成Java属性名
     * 例如 xxx_xx_aa > XxxXxAa
     */
    public String columnToJava(String columnName) {
        return WordUtils.capitalizeFully(columnName, new char[]{'_'}).replace("_", "");
    }

    /**
     * 表名转换成Java类名
     * 例如t_user > User
     */
    public String tableToJava(String tableName) {
        String tablePrefix = AutoCodeConfig.getConfig().getString("tablePrefix");
        if (StringUtils.isNotBlank(tablePrefix)) {
            tableName = tableName.replaceFirst(tablePrefix, "");
        }
        return columnToJava(tableName);
    }

    /**
     * 首字母小写
     *
     * @param tableName
     * @return
     * @author fuce
     * @Date 2021年1月15日 下午6:22:58
     */
    public String tableToJava_a(String tableName) {
        String str = tableToJava(tableName);
        return firstLowerCase(str);
    }

    public static String firstLowerCase(String name) {
        name = name.substring(0, 1).toLowerCase() + name.substring(1);
        return name;

    }


}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class TsysTables implements Serializable {
    private static final long serialVersionUID = 1L;
    private String tableName;//表名
    private String engine;//表引擎
    private String tableComment;//表注释
    private String tableModel;//表实体名字
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date createTime;
}

工具类


/**
 * 自动生成 通用类
 */
public class AutoCodeUtil {
    
    public static List<String> getTemplates() {
        List<String> templates = new ArrayList<String>();

        //java代码模板
        templates.add("auto_code/model/Entity.java.vm");
        templates.add("auto_code/mapperxml/EntityMapper.xml.vm");
        templates.add("auto_code/service/EntityService.java.vm");
        templates.add("auto_code/mapper/EntityMapper.java.vm");
        templates.add("auto_code/controller/EntityController.java.vm");
        templates.add("auto_code/request/EntityRequest.java.vm");
        templates.add("auto_code/service/impl/EntityServiceImpl.java.vm");
        templates.add("auto_code/vo/EntityVo.java.vm");
        templates.add("auto_code/wrapper/EntityWrapper.java.vm");
        return templates;
    }


    /**
     * 创建单表
     */
    public static void autoCodeOneModel(TableInfo tableInfo, AutoConfigModel autoConfigModel) {
        AutoCodeConfig autoCodeConfig = new AutoCodeConfig();
        //设置velocity资源加载器
        Properties prop = new Properties();
        prop.put("file.resource.loader.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
        Velocity.init(prop);
        Map<String, Object> map = new HashMap<>();
        //数据库表数据
        map.put("tableInfo", tableInfo);
        //字段集合
        map.put("beanColumns", tableInfo.getBeanColumns());
        //配置文件
        map.put("SnowflakeIdWorker", SnowflakeIdWorker.class);
        //class类路径
        map.put("parentPack", autoCodeConfig.getConfigkey("parentPack"));
        //作者
        map.put("author", autoConfigModel.getAuthor());
        //时间
        map.put("datetime", new DateTime());
        //sql需要的权限父级pid
        map.put("pid", autoConfigModel.getPid());

        VelocityContext context = new VelocityContext(map);

        //获取模板列表
        List<String> templates = getTemplates();
       
        for (String template : templates) {
            try {
                String targetPath = autoConfigModel.getParentPath();
                String filepath = getCoverFileName(template, tableInfo, autoCodeConfig.getConfigkey("parentPack"), targetPath);
                Template tpl = Velocity.getTemplate(template, "UTF-8");
                File file = new File(filepath);
                if (!file.getParentFile().exists())
                    file.getParentFile().mkdirs();
                if (!file.exists())
                    file.createNewFile();
                try (FileOutputStream outStream = new FileOutputStream(file);
                     OutputStreamWriter writer = new OutputStreamWriter(outStream, StandardCharsets.UTF_8);
                     BufferedWriter sw = new BufferedWriter(writer)) {
                    tpl.merge(context, sw);
                    sw.flush();
                    System.out.println("成功生成Java文件:" + filepath);
                }
            } catch (IOException e) {
                try {
                    throw new Exception("渲染模板失败，表名：" + "c" + "\n" + e.getMessage());
                } catch (Exception e1) {
                    e1.printStackTrace();
                }
            }
        }
    }

    public static String getCoverFileName(String template, TableInfo tableInfo, String packageName, String targetPath) {

        String separator = File.separator;
        String packagePath = targetPath + separator + "src" + separator + "main" + separator + "java" + separator;
        String resourcesPath = targetPath + separator + "src" + separator + "main" + separator + "resources" + separator;
        if (StringUtils.isNotBlank(packageName)) {
            packagePath += packageName.replace(".", separator) + separator;
        }

        if (template.contains("Entity.java.vm")) {//model.java
            return packagePath + "entity" + separator + tableInfo.getJavaTableName() + ".java";
        }
        if (template.contains("EntityExample.java.vm")) {//modelExample.java
            return packagePath + "entity" + separator + tableInfo.getJavaTableName() + "Example.java";
        }

        if (template.contains("EntityMapper.java.vm")) {//daomapper.java
            return packagePath + "mapper" + separator + tableInfo.getJavaTableName() + "Mapper.java";
        }
        if (template.contains("EntityMapper.xml.vm")) {//daomapper.xml
            return resourcesPath + "mapper" + separator + tableInfo.getJavaTableName() + "Mapper.xml";
        }

        if (template.contains("EntityService.java.vm")) {
            return packagePath + "service" + separator + tableInfo.getJavaTableName() + "Service.java";
        }
        if (template.contains("EntityController.java.vm")) {
            return packagePath + "controller" + separator + tableInfo.getJavaTableName() + "Controller.java";
        }
        if (template.contains("EntityServiceImpl.java.vm")) {
            return packagePath + "service" + separator + "impl" + separator + tableInfo.getJavaTableName() + "ServiceImpl.java";
        }
        if (template.contains("EntityVo.java.vm")) {
            return packagePath + "vo" + separator + tableInfo.getJavaTableName() + "Vo.java";
        }
        if (template.contains("EntityRequest.java.vm")) {
            return packagePath + "request" + separator + tableInfo.getJavaTableName() + "Request.java";
        }
        if (template.contains("EntityWrapper.java.vm")) {
            return packagePath + "wrapper" + separator + tableInfo.getJavaTableName() + "Wrapper.java";
        }

        return "";
    }
}


public class SnowflakeIdWorker {

    // ==============================Fields===========================================
    /**
     * 开始时间截 (2015-01-01)
     */
    private final long twepoch = 1489111610226L;

    /**
     * 机器id所占的位数
     */
    private final long workerIdBits = 5L;

    /**
     * 数据标识id所占的位数
     */
    private final long dataCenterIdBits = 5L;

    /**
     * 支持的最大机器id，结果是31 (这个移位算法可以很快的计算出几位二进制数所能表示的最大十进制数)
     */
    private final long maxWorkerId = -1L ^ (-1L << workerIdBits);

    /**
     * 支持的最大数据标识id，结果是31
     */
    private final long maxDataCenterId = -1L ^ (-1L << dataCenterIdBits);

    /**
     * 序列在id中占的位数
     */
    private final long sequenceBits = 12L;

    /**
     * 机器ID向左移12位
     */
    private final long workerIdShift = sequenceBits;

    /**
     * 数据标识id向左移17位(12+5)
     */
    private final long dataCenterIdShift = sequenceBits + workerIdBits;

    /**
     * 时间截向左移22位(5+5+12)
     */
    private final long timestampLeftShift = sequenceBits + workerIdBits + dataCenterIdBits;

    /**
     * 生成序列的掩码，这里为4095 (0b111111111111=0xfff=4095)
     */
    private final long sequenceMask = -1L ^ (-1L << sequenceBits);

    /**
     * 工作机器ID(0~31)
     */
    private long workerId;

    /**
     * 数据中心ID(0~31)
     */
    private long dataCenterId;

    /**
     * 毫秒内序列(0~4095)
     */
    private long sequence = 0L;

    /**
     * 上次生成ID的时间截
     */
    private long lastTimestamp = -1L;


    static SnowflakeIdWorker idWorker = new SnowflakeIdWorker(1, 1);
    //==============================Constructors=====================================

    /**
     * 构造函数
     *
     * @param workerId     工作ID (0~31)
     * @param dataCenterId 数据中心ID (0~31)
     */
    public SnowflakeIdWorker(long workerId, long dataCenterId) {
        if (workerId > maxWorkerId || workerId < 0) {
            throw new IllegalArgumentException(String.format("workerId can't be greater than %d or less than 0", maxWorkerId));
        }
        if (dataCenterId > maxDataCenterId || dataCenterId < 0) {
            throw new IllegalArgumentException(String.format("dataCenterId can't be greater than %d or less than 0", maxDataCenterId));
        }
        this.workerId = workerId;
        this.dataCenterId = dataCenterId;
    }

    // ==============================Methods==========================================

    /**
     * 获得下一个ID (该方法是线程安全的)
     *
     * @return SnowflakeId
     */
    public synchronized long nextId() {
        long timestamp = timeGen();

        //如果当前时间小于上一次ID生成的时间戳，说明系统时钟回退过这个时候应当抛出异常
        if (timestamp < lastTimestamp) {
            throw new RuntimeException(
                    String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
        }

        //如果是同一时间生成的，则进行毫秒内序列
        if (lastTimestamp == timestamp) {
            sequence = (sequence + 1) & sequenceMask;
            //毫秒内序列溢出
            if (sequence == 0) {
                //阻塞到下一个毫秒,获得新的时间戳
                timestamp = tilNextMillis(lastTimestamp);
            }
        }
        //时间戳改变，毫秒内序列重置
        else {
            sequence = 0L;
        }

        //上次生成ID的时间截
        lastTimestamp = timestamp;

        //移位并通过或运算拼到一起组成64位的ID
        return ((timestamp - twepoch) << timestampLeftShift) //
                | (dataCenterId << dataCenterIdShift) //
                | (workerId << workerIdShift) //
                | sequence;
    }

    /**
     * 阻塞到下一个毫秒，直到获得新的时间戳
     *
     * @param lastTimestamp 上次生成ID的时间截
     * @return 当前时间戳
     */
    protected long tilNextMillis(long lastTimestamp) {
        long timestamp = timeGen();
        while (timestamp <= lastTimestamp) {
            timestamp = timeGen();
        }
        return timestamp;
    }

    /**
     * 返回以毫秒为单位的当前时间
     *
     * @return 当前时间(毫秒)
     */
    protected long timeGen() {
        return System.currentTimeMillis();
    }
}

模板文件

目录结构

----resources
||||----auto_code
||||||||----controller
			EntityController.java.vm
||||||||----mapper
			EntityMapper.java.vm
||||||||----mapperxml
			EntityMapper.xml.vm
||||||||----model
			Entity.java.vm
||||||||----request
			EntityRequest.java.vm
||||||||----service
			EntityService.java.vm
||||||||||||----impl
				EntityServiceImpl.java.vm
||||||||----vo
			EntityVo.java.vm
||||||||----wrapper
			EntityWrapper.java.vm

package ${parentPack}.controller;

import ${parentPack}.api.R;
import ${parentPack}.dto.${tableInfo.javaTableName}Dto;
import ${parentPack}.entity.${tableInfo.javaTableName};
import ${parentPack}.request.${tableInfo.javaTableName}Request;
import ${parentPack}.service.${tableInfo.javaTableName}Service;
import ${parentPack}.utils.BeanUtil;
import ${parentPack}.utils.ParamUtil;
import ${parentPack}.vo.${tableInfo.javaTableName}Vo;
import ${parentPack}.wrapper.${tableInfo.javaTableName}Wrapper;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;
import springfox.documentation.annotations.ApiIgnore;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.exceptions.ApiException;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

import java.util.List;

/**
 * ${tableInfo.tableComment}Controller
 * @ClassName: ${tableInfo.javaTableName}Controller
 * @author ${author}
 * @date ${datetime}
 */
@Api(value = "${tableInfo.tableComment}")
@RestController
@RequestMapping("/${tableInfo.javaTableName}")
public class ${tableInfo.javaTableName}Controller{

	
	@Autowired
	private ${tableInfo.javaTableName}Service ${tableInfo.javaTableName_a}Service;
	
	
	/**
	 * ${tableInfo.tableComment}页面展示
	 * @param page
	 * @return String
	 * @author ${author}
	 */
	@ApiOperation(value = "分页查询", notes = "分页查询")
	@ApiImplicitParams({
			@ApiImplicitParam(name = "current", value = "当前页数", paramType = "query", dataType = "int", example = "1"),
			@ApiImplicitParam(name = "size", value = "每页条数", paramType = "query", dataType = "int", example = "10")
	})
	@GetMapping("/page")
    public R<IPage<${tableInfo.javaTableName}Vo>> page(@ApiIgnore Page<${tableInfo.javaTableName}> page)
    {
		Page<${tableInfo.javaTableName}> pageList = ${tableInfo.javaTableName_a}Service.page(page, new LambdaQueryWrapper<${tableInfo.javaTableName}>()
				.orderByDesc(${tableInfo.javaTableName}::getCreateTime)
		);
		return R.data(${tableInfo.javaTableName}Wrapper.build().pageVO(pageList));
    }

	@GetMapping("/{id}")
	@ApiOperation(value = "根据id获取", notes = "id")
	public R<${tableInfo.javaTableName}> getOne(@PathVariable(value = "id") Long id) {
		return R.data(${tableInfo.javaTableName_a}Service.getById(id));
	}

	@PostMapping
	@ApiOperation(value = "新增", notes = "实体")
	public R save(@RequestBody ${tableInfo.javaTableName}Request request) {
		return R.status(${tableInfo.javaTableName_a}Service.save(${tableInfo.javaTableName}Wrapper.build().requestEntity(request)));
	}

	@PutMapping
	@ApiOperation(value = "修改", notes = "实体")
	public R update(@RequestBody ${tableInfo.javaTableName}Request request) {
		return R.status(${tableInfo.javaTableName_a}Service.updateById(${tableInfo.javaTableName}Wrapper.build().requestEntity(request)));
	}

	@DeleteMapping
	@ApiImplicitParam(name = "ids", value = "ids", paramType = "query", dataType = "Long")
	@ApiOperation(value = "删除", notes = "ids")
	public R delete(@ApiIgnore @RequestBody List<Long> ids) {
		ParamUtil.checkNull(ids,"id不能为空");
		return R.status(${tableInfo.javaTableName_a}Service.removeByIds(ids));
	}
}


package ${parentPack}.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import ${parentPack}.entity.${tableInfo.javaTableName};


/**
 * ${tableInfo.tableComment} ${tableInfo.javaTableName}Mapper
 * @author ${author}_自动生成
 * @email ${email}
 * @date ${datetime}
 */
public interface ${tableInfo.javaTableName}Mapper extends BaseMapper<${tableInfo.javaTableName}>{

  	
}

<?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="${parentPack}.mapper.${tableInfo.javaTableName}Mapper">

  <resultMap id="BaseResultMap" type="${parentPack}.entity.${tableInfo.javaTableName}">
    #foreach($column in $beanColumns)
      <result column="${column.column_name}" jdbcType="${column.jdbcType}" property="${column.beanName}" />
    #end
  </resultMap>

  <sql id="Base_Column_List">
#set( $lag = 0)
#foreach ($column in $beanColumns)
  #if(($lag+1) >= (${beanColumns.size()}))
    ${column.column_name}
  #else
    ${column.column_name},
  #end
  #set( $lag = ($lag + 1) )
#end
  </sql>
   
</mapper>

package ${parentPack}.entity;

import java.io.Serializable;

import com.baomidou.mybatisplus.annotation.*;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName(value = "${tableInfo.tableName}")
@ApiModel(value="${tableInfo.tableComment}")
public class ${tableInfo.javaTableName} implements Serializable {
    private static final long serialVersionUID = 1L;

#set($isdate = false)
#foreach ($column in $beanColumns)
#if(${column.beanType} == "java.util.Date")
	#set($isdate =true)
	@ApiModelProperty(value = "$column.column_comment")
##	@TableId(value = "${column.column_name}",type = IdType.ASSIGN_ID)
	private ${column.javaType} ${column.beanName};
#else
	#if(${column.beanType} == "java.util.Date")
@TableId(value = "${column.column_name}",type = IdType.ASSIGN_ID)
	@ApiModelProperty(value = "$column.column_comment")
	private ${column.javaType} ${column.beanName};

	#else

@TableField(value = "`${column.column_name}`")
	@ApiModelProperty(value = "$column.column_comment")
	private ${column.javaType} ${column.beanName};
#end
#end	
#end

}

package ${parentPack}.request;

import ${parentPack}.entity.${tableInfo.javaTableName};
import lombok.Data;

import java.io.Serializable;

@Data
public class ${tableInfo.javaTableName}Request extends ${tableInfo.javaTableName} implements Serializable  {

    private static final long serialVersionUID = 1L;


}

package ${parentPack}.service;

import ${parentPack}.entity.${tableInfo.javaTableName};
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * ${tableInfo.tableComment} ${tableInfo.javaTableName}Service
 * @Title: ${tableInfo.javaTableName}Service.java 
 * @Package ${parentPack}.service 
 * @author ${author}_自动生成
 * @email ${email}
 * @date ${datetime}  
 **/
public interface ${tableInfo.javaTableName}Service extends IService<${tableInfo.javaTableName}>{

}


package ${parentPack}.service;

import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import ${parentPack}.mapper.${tableInfo.javaTableName}Mapper;
import ${parentPack}.entity.${tableInfo.javaTableName};
import ${parentPack}.service.${tableInfo.javaTableName}Service;
/**
 * ${tableInfo.tableComment} ${tableInfo.javaTableName}Service
 * @Title: ${tableInfo.javaTableName}Service.java 
 * @Package ${parentPack}.service 
 * @author ${author}_自动生成
 * @email ${email}
 * @date ${datetime}  
 **/
@Service
public class ${tableInfo.javaTableName}Service extends ServiceImpl<${tableInfo.javaTableName}Mapper, ${tableInfo.javaTableName}> implements ${tableInfo.javaTableName}Service{

}


package ${parentPack}.vo;

import ${parentPack}.entity.${tableInfo.javaTableName};
import lombok.Data;

import java.io.Serializable;

@Data
public class ${tableInfo.javaTableName}Vo extends ${tableInfo.javaTableName} implements Serializable  {

    private static final long serialVersionUID = 1L;


}

package ${parentPack}.wrapper;

import cn.hutool.core.bean.BeanUtil;
import ${parentPack}.entity.${tableInfo.javaTableName};
import ${parentPack}.request.${tableInfo.javaTableName}Request;
import ${parentPack}.support.BaseEntityWrapper;
import ${parentPack}.vo.${tableInfo.javaTableName}Vo;

public class ${tableInfo.javaTableName}Wrapper extends BaseEntityWrapper<${tableInfo.javaTableName}, ${tableInfo.javaTableName}Vo> {

	private static final long serialVersionUID = 1L;

	public static ${tableInfo.javaTableName}Wrapper build(){
		return new ${tableInfo.javaTableName}Wrapper();
	}

	@Override
	public ${tableInfo.javaTableName}Vo entityVO(${tableInfo.javaTableName} entity) {
			${tableInfo.javaTableName}Vo vo = new ${tableInfo.javaTableName}Vo();
		BeanUtil.copyProperties(entity,vo);
		return vo;
	}

	public ${tableInfo.javaTableName} requestEntity(${tableInfo.javaTableName}Request request) {
		${tableInfo.javaTableName} entity = new ${tableInfo.javaTableName}();
		BeanUtil.copyProperties(request,entity);
		return entity;
	}
}

配置文件

auto_code_config.properties

globalConfig:
    #生成代码的父包
    parentPack: com.xxx
    #作者
    author: CHENYU
    #电子邮箱
    email: jchen_px@126.com
    #java在项目中的classpath位置
    javaSource: src/main/java
    #resource位置
    resources: src/main/resources
    #表前缀
    tablePrefix: xxx_

使用例子

@RestController
@Api(tags = "代码生成器")
@RequestMapping("/auto")
public class AutoController {

    private static final String author = "CHENYU";
    private static final String pid = BigDecimal.ZERO.toString();
    private static final String parentPath = System.getProperty("user.dir");

    @Autowired
    private AutoService autoService;

    @ApiOperation(value = "自动生成代码")
    @GetMapping
    @ApiImplicitParams({
            @ApiImplicitParam(value = "表名",name = "tableName"),
            @ApiImplicitParam(value = "模型名",name = "modelName")
    })
    public R auto(String tableName, String modelName) {
        if(StringUtils.isBlank(tableName)){
            throw new ApiException("请先输入表名");
        }
        //获取表信息
        TsysTables tsysTables = autoService.tableNameDesc(tableName);
        if(tsysTables == null){
            throw new ApiException("没有查询到"+tableName+"表");
        }
        //获取表的字段信息
        List<BeanColumn> beanColumnList = autoService.tableColumnsDesc(tableName);
        //构建对象
        TableInfo tableInfo = new TableInfo(tsysTables.getTableName(), beanColumnList, tsysTables.getTableComment());
        AutoConfigModel autoConfigModel = new AutoConfigModel(tsysTables.getTableName(), tsysTables.getTableComment(), author, pid, parentPath + modelName, beanColumnList);
        AutoCodeUtil.autoCodeOneModel(tableInfo, autoConfigModel);

        return R.status(true);
    }
}

这个xml文件是mybatis查询数据库的文件，这里就没粘贴上上面service中的东西了，就是单纯的查了一下数据库

<?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.sensemobile.mapper.AutoMapper">
    <resultMap id="BaseResultMap" type="com.sensemobile.model.autocode.TsysTables">
        <result column="table_name" property="tableName" jdbcType="VARCHAR"/>
        <result column="engine" property="engine" jdbcType="VARCHAR"/>
        <result column="table_comment" property="tableComment" jdbcType="VARCHAR"/>
        <result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
    </resultMap>

    <resultMap id="BaseResultMap2" type="com.sensemobile.model.autocode.BeanColumn">
        <result column="table_catalog" property="table_catalog" jdbcType="VARCHAR"/>
        <result column="table_schema" property="table_schema" jdbcType="VARCHAR"/>
        <result column="table_name" property="table_name" jdbcType="VARCHAR"/>
        <result column="column_name" property="column_name" jdbcType="VARCHAR"/>
        <result column="ordinal_position" property="ordinal_position" jdbcType="VARCHAR"/>
        <result column="column_default" property="column_default" jdbcType="VARCHAR"/>
        <result column="is_nullable" property="is_nullable" jdbcType="VARCHAR"/>
        <result column="data_type" property="data_type" jdbcType="VARCHAR"/>
        <result column="character_maximum_length" property="character_maximum_length" jdbcType="VARCHAR"/>
        <result column="character_octet_length" property="character_octet_length" jdbcType="VARCHAR"/>
        <result column="numeric_precision" property="numeric_precision" jdbcType="VARCHAR"/>
        <result column="numeric_scale" property="numeric_scale" jdbcType="VARCHAR"/>
        <result column="datetime_precision" property="datetime_precision" jdbcType="VARCHAR"/>
        <result column="character_set_name" property="character_set_name" jdbcType="VARCHAR"/>
        <result column="collation_name" property="collation_name" jdbcType="VARCHAR"/>
        <result column="column_type" property="column_type" jdbcType="VARCHAR"/>
        <result column="column_key" property="column_key" jdbcType="VARCHAR"/>
        <result column="extra" property="extra" jdbcType="VARCHAR"/>
        <result column="privileges" property="privileges" jdbcType="VARCHAR"/>
        <result column="column_comment" property="column_comment" jdbcType="VARCHAR"/>
        <result column="generation_expression" property="generation_expression" jdbcType="VARCHAR"/>
    </resultMap>

    <!-- 查询表 -->
    <select id="queryTable" resultMap="BaseResultMap" parameterType="String">
        select table_name, engine, table_comment, create_time
        from information_schema.tables
        where table_schema = (select database())
          and table_name = #{tableName}
    </select>

    <!-- 表字段详情  -->
    <select id="queryColumns" resultMap="BaseResultMap2" parameterType="String">
        select
        TABLE_CATALOG as table_catalog
        ,TABLE_SCHEMA as table_schema
        ,TABLE_NAME as table_name
        ,COLUMN_NAME as column_name
        ,ORDINAL_POSITION as ordinal_position
        ,COLUMN_DEFAULT as column_default
        ,IS_NULLABLE as is_nullable
        ,DATA_TYPE as data_type
        ,CHARACTER_MAXIMUM_LENGTH as character_maximum_length
        ,COLUMN_TYPE as column_type
        ,COLUMN_KEY as column_key
        ,EXTRA as extra
        ,COLUMN_COMMENT as column_comment
        from information_schema.columns
        where table_name = #{tableName} and table_schema = (select database()) order by ordinal_position
    </select>
</mapper>

总结：

终于可以自定义一份代码生成工具了，代码里都算自己平时写代码的风格，如有什么大神需要纠正我的可以私信我了，我也是在探索的路上。

不是Guava是瓜娃
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java Restful Web 源代码，Java Restful Web 源代码
10-14
Java Restful Web 源代码Java Restful Web 源代码Java Restful Web 源代码Java Restful Web 源代码Java Restful Web 源代码Java Restful Web 源代码Java Restful Web 源代码Java Restful Web 源代码Java Restful Web...
codegen:Java代码生成器
05-11
使用生成器的步骤： 该项目基于maven，codegen模块包含Velocity模板，这些模板生成Spring代码1-访问codegen项目文件夹并执行命令： mvn install 2-访问maven插件文件夹，该文件夹将基于在调用Archetype之后生成的...
JAVA开发（基于Restful的微服务第三方简易接口设计）
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
05-30 2146
java后端需要提供接口服务，其中接口服务分为对内网的后台管理系统的接口，对外网的用户接口和对第三方系统的接口。这里主要讲对第三方的接口。
Spring Boot如何实现接口文档自动生成
it_xushixiong的博客
05-31 3036
Swagger是一种RESTful API文档生成工具，可以自动生成接口文档、API测试和客户端代码等。它通过注解方式标记API的信息，然后根据这些信息生成API的文档和测试页面。Swagger支持多种语言和框架，包括Java和Spring Boot。在本文中，我们将介绍如何使用Swagger实现Spring Boot接口文档自动生成。本文介绍了如何使用Swagger实现Spring Boot接口文档自动生成。我们首先添加了Swagger的依赖项，并在配置类中启用了Swagger。
Java Spring Boot框架如何快速构建RESTful API？
最新发布
Lindaoland的博客
04-19 736
在UserController中，我们可以定义处理各种HTTP请求的方法，如GET、POST、PUT、DELETE等。通过创建Spring Boot项目、定义数据模型、创建Repository接口和Controller类，我们可以轻松地构建出功能完善的RESTful API。例如，我们可以创建一个User实体类，包含id、name、age等属性，并使用@Entity、@Id等注解进行配置。在构建RESTful API的过程中，我们还可以进行一些优化和扩展操作，以提高API的性能和可维护性。
java实战2：利用Spring boot开发Restful 接口
热门推荐
weixin_43930865的博客
05-11 1万+
利用Spring boot开发Restful 接口 1：Spring boot 1.1：SpringBoot框架 SpringBoot框架一般分为View层、Controller层、Service层、Mapper层、pojo层。 View层：视图层，根据接到的数据展示页面给用户 Controller层：响应用户需求，决定用什么视图，需要准备什么数据来显示。Controller层负责前后端交互，接收前端请求，调用Service层，接收Service层返回的数据，最后返回具体的数据和页面到客户端 Service
mybatis一对多关联映射
zjg
10-07 227
一个学生信息对应多个成绩信息；
Java代码一键生成神器，支持Jpa/Mybatis/plus多种ORM框架，亲测好用
欢迎光临
02-15 5672
基于模板引擎实现，具有非常高的自由度，可随意修改为适合你的代码风格
基于Java的智能文档生成工具设计源码
04-06
这些文件详细展示了如何使用Java、HTML、CSS和JavaScript构建一个智能文档生成工具，该工具支持Java RESTful API和Apache Dubbo RPC接口文档的生成，完全基于注释生成文档，做到零侵入。这些文件非常适合用于学习和...
Spring Boot 代码生成器
04-17
自己写的非常好用的Java代码生成器，用于生成 RESTful 风格的 Controller、Service、Dao、Entity 层代码。 提供的源码简单明了，可以直接使用，方便快捷生成你的项目代码，避免繁琐的基础代码设计；也可以快速修改...
java代码springboot+Swagger+redis+mybatis+restful代码案例(有文档)
07-06
mapper和dto结合的方式，这代码一般可以用来交个java的课程作业，或者自己学习swagger等相关的都能用得上，您正在寻找一个使用Java编写的具有Spring Boot、Swagger、Redis、MyBatis和Restful的代码示例，并且包含...
AutoCode代码生成器 V2.0 JAVA版 下载
05-03
AutoCode代码生成器 V2.0 JAVA版 下载
[JAVA]代码生成工具-MyBatisPlus
duanduanxiao的博客
01-30 444
JAVA代码生成工具-MyBatisPlus
Java进阶篇--生成器
m0_74293254的博客
08-18 929
流实现中，通过 Stream.generate() 方法和一个供给型函数生成无限流，并使用 limit() 方法限制生成的元素数量。生成器可以用于处理无限序列或大型数据集。flatMap(Function mapper)：对流中的每个元素应用指定的映射函数并将结果扁平化为一个新的流。filter(Predicate predicate)：过滤流中的元素，只保留满足指定条件的元素。limit(long maxSize)：截取流中的前N个元素，返回一个包含最多N个元素的新流。
MapStruct：代码生成工具，让Java对象映射更轻松
gitblog_00068的博客
03-17 408
MapStruct：代码生成工具，让Java对象映射更轻松 MapStruct是一个简单的代码生成器，它可以帮助您在Java对象之间进行自动映射。它通过提供自动生成的转换器，使您的代码变得更加简洁、可读性强且易于维护。 项目简介 MapStruct 是一个开源 Java 框架，用于自动将一个 Java 对象（源对象）转换为另一个 Java 对象（目标对象）。它基于注解，并使用 Java 编译器 A...
Java快速开发之代码生成器
weixin_64051447的博客
06-21 3641
观察我们之前写的代码，会发现其中也会有很多重复内容，比如:那我们就想，如果我想做一个Book模块的开发，是不是只需要将红色部分的内容全部更换成Book即可，如：所以我们会发现，做任何模块的开发，对于这段代码，基本上都是对红色部分的调整，，以后只需要传入不同的参数，就可以根据模板创建出不同模块的dao代码。除了Dao可以抽取模块，其实我们常见的类都可以进行抽取，只要他们有公共部分即可。所以只要我们知道是对哪张表进行代码生成，这些内容我们都可以进行填充。
Java开源工具库使用之java源代码生成库JavaPoet
十十办文武的博客
10-17 1322
JavaPoet是一个用于生成 .java 源代码文件的 Java API。截止博客发表为止，整个项目核心源码就17个类文件，github上却有 9.9k stars，可谓短小精悍。javapoet 实现了自动导包和语句分号添加，代码流程控制，代码格式化等功能，很方便开发者生成一些模板代码
自定义流水号的autocode
weixin_34075551的博客
03-22 142
package cn.com.do1.component.yopin.util;import cn.com.do1.common.dac.QuickDAC;import cn.com.do1.common.exception.BaseException;import cn.com.do1.common.util.AssertUtil;import cn.com.do1.dqdp.core.Dqdp...
Spring Boot系列之四 自动生成RESTful文档
AndyLizh的专栏
04-12 4455
简介 标题不让写那么长,嗨嗨,原文主题应该为 Spring Boot系列之四 使用Swagger2构建RESTful API文档 不知道会不会影响阅读量... 推荐越来越少了... 本来系列4和系列5的文章不打算发了的,一方面是应用机会很少,另一方面也是自己当时用的时候对Spring Boot的了解还不够透彻,有点小错误.不过有粉丝评论说直接从3到了6,中间少了两篇,不成系列
写一个java restful 接口
04-12
好的，我可以帮你写一个 Java Restful 接口。首先，你需要使用 Spring Boot 框架，因为它可以方便地创建 Restful 服务。然后，你需要定义一个 Controller 类，这个类需要使用注解 `@RestController` 来表明这是一个 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值