github/SpringBootCodeGenerator
1
0
Fork 0
mirror of https://github.com/moshowgame/SpringBootCodeGenerator.git synced 2025-12-26 05:48:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #92 from gaohanghang/master

Browse Source 
1. 将 mybatis controller 模板里，类上 @RequestMapping 注解里的 url 改为首字母小写 2. 对 java 代码进行格式化，使其看上去更加美观
This commit is contained in:
Moshow郑锴 2020-10-10 17:52:15 +08:00 committed by GitHub
commit 59fae86bc4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 767 additions and 719 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
generator-web/src/main/java/com/softdev/system/generator/GeneratorWebApplication.java
View File

@ -6,7 +6,9 @@ import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication @SpringBootApplication
public class GeneratorWebApplication { public class GeneratorWebApplication {
public static void main(String[] args) {
SpringApplication.run(GeneratorWebApplication.class,args); public static void main(String[] args) {
} SpringApplication.run(GeneratorWebApplication.class, args);
}
} }

40
generator-web/src/main/java/com/softdev/system/generator/config/GlobalDefaultExceptionHandler.java
View File

@ -1,20 +1,20 @@
package com.softdev.system.generator.config; package com.softdev.system.generator.config;
import com.softdev.system.generator.entity.ReturnT; import com.softdev.system.generator.entity.ReturnT;
import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
@ControllerAdvice @ControllerAdvice
public class GlobalDefaultExceptionHandler { public class GlobalDefaultExceptionHandler {
@ExceptionHandler(Exception.class) @ExceptionHandler(Exception.class)
@ResponseBody @ResponseBody
public ReturnT defaultExceptionHandler(HttpServletRequest req,Exception e) { public ReturnT defaultExceptionHandler(HttpServletRequest req, Exception e) {
e.printStackTrace(); e.printStackTrace();
return ReturnT.ERROR(e.getMessage()); return ReturnT.ERROR(e.getMessage());
} }
} }

1
generator-web/src/main/java/com/softdev/system/generator/config/ServerConfig.java
View File

@ -4,6 +4,7 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.web.context.WebServerInitializedEvent; import org.springframework.boot.web.context.WebServerInitializedEvent;
import org.springframework.context.ApplicationListener; import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import java.net.Inet4Address; import java.net.Inet4Address;
import java.net.InetAddress; import java.net.InetAddress;
import java.net.UnknownHostException; import java.net.UnknownHostException;

99
generator-web/src/main/java/com/softdev/system/generator/config/WebMvcConfig.java
View File

@ -1,49 +1,50 @@
package com.softdev.system.generator.config; package com.softdev.system.generator.config;
import com.alibaba.fastjson.support.config.FastJsonConfig; import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter; import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType; import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter; import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.StringHttpMessageConverter; import org.springframework.http.converter.StringHttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
/** /**
* 2019-2-11 liutf WebMvcConfig 整合 cors 和 SpringMvc MessageConverter * 2019-2-11 liutf WebMvcConfig 整合 cors 和 SpringMvc MessageConverter
*/ */
@Configuration @Configuration
public class WebMvcConfig implements WebMvcConfigurer { public class WebMvcConfig implements WebMvcConfigurer {
/* @Override /* @Override
public void addCorsMappings(CorsRegistry registry) { public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**") registry.addMapping("/**")
.allowedOrigins("*") .allowedOrigins("*")
.allowedHeaders("x-requested-with") .allowedHeaders("x-requested-with")
.allowedMethods("GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "TRACE") .allowedMethods("GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS", "TRACE")
.maxAge(3600); .maxAge(3600);
}*/ }*/
@Override @Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) { public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
//FastJsonHttpMessageConverter //FastJsonHttpMessageConverter
FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter(); FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
List<MediaType> fastMediaTypes = new ArrayList<>(); List<MediaType> fastMediaTypes = new ArrayList<>();
fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8); fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
fastConverter.setSupportedMediaTypes(fastMediaTypes); fastConverter.setSupportedMediaTypes(fastMediaTypes);
FastJsonConfig fastJsonConfig = new FastJsonConfig(); FastJsonConfig fastJsonConfig = new FastJsonConfig();
fastJsonConfig.setCharset(StandardCharsets.UTF_8); fastJsonConfig.setCharset(StandardCharsets.UTF_8);
fastConverter.setFastJsonConfig(fastJsonConfig); fastConverter.setFastJsonConfig(fastJsonConfig);
//StringHttpMessageConverter //StringHttpMessageConverter
StringHttpMessageConverter stringConverter = new StringHttpMessageConverter(); StringHttpMessageConverter stringConverter = new StringHttpMessageConverter();
stringConverter.setDefaultCharset(StandardCharsets.UTF_8); stringConverter.setDefaultCharset(StandardCharsets.UTF_8);
stringConverter.setSupportedMediaTypes(fastMediaTypes); stringConverter.setSupportedMediaTypes(fastMediaTypes);
converters.add(stringConverter); converters.add(stringConverter);
converters.add(fastConverter); converters.add(fastConverter);
} }
}
}

25
generator-web/src/main/java/com/softdev/system/generator/controller/IndexController.java
View File

@ -18,6 +18,7 @@ import java.util.Map;
/** /**
* spring boot code generator * spring boot code generator
*
* @author zhengk/moshow * @author zhengk/moshow
*/ */
@Controller @Controller
@ -34,29 +35,37 @@ public class IndexController {
@PostMapping("/genCode") @PostMapping("/genCode")
@ResponseBody @ResponseBody
public ReturnT codeGenerate(@RequestBody ParamInfo paramInfo ) throws Exception { public ReturnT codeGenerate(@RequestBody ParamInfo paramInfo) throws Exception {
if (paramInfo.getTableSql().trim().length()<1) { if (paramInfo.getTableSql().trim().length() < 1) {
return ReturnT.ERROR("表结构信息不可为空"); return ReturnT.ERROR("表结构信息不可为空");
} }
//1.Parse Table Structure 表结构解析 //1.Parse Table Structure 表结构解析
ClassInfo classInfo = null; ClassInfo classInfo = null;
switch (paramInfo.getDataType()){ switch (paramInfo.getDataType()) {
//JSON模式：parse field from json string //JSON模式：parse field from json string
case "json":classInfo = TableParseUtil.processJsonToClassInfo(paramInfo);break; case "json":
classInfo = TableParseUtil.processJsonToClassInfo(paramInfo);
break;
//INSERT SQL模式：parse field from insert sql //INSERT SQL模式：parse field from insert sql
case "insert-sql":classInfo = TableParseUtil.processInsertSqlToClassInfo(paramInfo);break; case "insert-sql":
classInfo = TableParseUtil.processInsertSqlToClassInfo(paramInfo);
break;
//正则表达式模式（非完善版本）：parse sql by regex //正则表达式模式（非完善版本）：parse sql by regex
case "sql-regex":classInfo = TableParseUtil.processTableToClassInfoByRegex(paramInfo);break; case "sql-regex":
classInfo = TableParseUtil.processTableToClassInfoByRegex(paramInfo);
break;
//默认模式：default parse sql by java //默认模式：default parse sql by java
default : classInfo = TableParseUtil.processTableIntoClassInfo(paramInfo);break; default:
classInfo = TableParseUtil.processTableIntoClassInfo(paramInfo);
break;
} }
//2.Set the params 设置表格参数 //2.Set the params 设置表格参数
Map<String, Object> params = new HashMap<String, Object>(8); Map<String, Object> params = new HashMap<String, Object>(8);
params.put("classInfo", classInfo); params.put("classInfo", classInfo);
params.put("tableName", classInfo==null?System.currentTimeMillis():classInfo.getTableName()); params.put("tableName", classInfo == null ? System.currentTimeMillis() : classInfo.getTableName());
params.put("authorName", paramInfo.getAuthorName()); params.put("authorName", paramInfo.getAuthorName());
params.put("packageName", paramInfo.getPackageName()); params.put("packageName", paramInfo.getPackageName());
params.put("returnUtil", paramInfo.getReturnUtil()); params.put("returnUtil", paramInfo.getReturnUtil());

6
generator-web/src/main/java/com/softdev/system/generator/entity/ClassInfo.java
View File

@ -14,7 +14,7 @@ public class ClassInfo {
private String tableName; private String tableName;
private String className; private String className;
private String classComment; private String classComment;
private List<FieldInfo> fieldList; private List<FieldInfo> fieldList;
} }

55
generator-web/src/main/java/com/softdev/system/generator/entity/ParamInfo.java
View File

@ -1,26 +1,29 @@
package com.softdev.system.generator.entity; package com.softdev.system.generator.entity;
import lombok.Data; import lombok.Data;
/** /**
* Post data - ParamInfo * Post data - ParamInfo
* @author zhengkai.blog.csdn.net *
*/ * @author zhengkai.blog.csdn.net
@Data */
public class ParamInfo { @Data
private String tableSql; public class ParamInfo {
private String authorName;
private String packageName; private String tableSql;
private String returnUtil; private String authorName;
private String nameCaseType; private String packageName;
private String tinyintTransType; private String returnUtil;
private String dataType; private String nameCaseType;
private boolean swagger; private String tinyintTransType;
private String dataType;
@Data private boolean swagger;
public static class NAME_CASE_TYPE{
public static String CAMEL_CASE="CamelCase"; @Data
public static String UNDER_SCORE_CASE="UnderScoreCase"; public static class NAME_CASE_TYPE {
public static String UPPER_UNDER_SCORE_CASE="UpperUnderScoreCase"; public static String CAMEL_CASE = "CamelCase";
} public static String UNDER_SCORE_CASE = "UnderScoreCase";
} public static String UPPER_UNDER_SCORE_CASE = "UpperUnderScoreCase";
}
}

111
generator-web/src/main/java/com/softdev/system/generator/entity/ReturnT.java
View File

@ -6,60 +6,73 @@ import java.io.Serializable;
/** /**
* common returnT:公共返回封装类 * common returnT:公共返回封装类
*
* @author zhengkai.blog.csdn.net * @author zhengkai.blog.csdn.net
*/ */
@Data @Data
public class ReturnT implements Serializable { public class ReturnT implements Serializable {
public static final long serialVersionUID = 42L;
public static final int SUCCESS_CODE = 200; public static final long serialVersionUID = 42L;
public static final int FAIL_CODE = 500;
public static final int PAGE_CODE = 0;
public static final String OBJECT_NOT_FOUND = "找不到该对象";
public static final String OPERATION_SUCCESS = "操作成功";
private int code; public static final int SUCCESS_CODE = 200;
private String msg; public static final int FAIL_CODE = 500;
private Object data; public static final int PAGE_CODE = 0;
private int count; public static final String OBJECT_NOT_FOUND = "找不到该对象";
public static final String OPERATION_SUCCESS = "操作成功";
private int code;
private String msg;
private Object data;
private int count;
public ReturnT(int code, String msg) {
this.code = code;
this.msg = msg;
}
public ReturnT(int code, String msg, Object data) {
this.code = code;
this.msg = msg;
this.data = data;
}
public ReturnT(Object data) {
this.code = SUCCESS_CODE;
this.data = data;
}
public ReturnT(Object data, int count) {
this.code = PAGE_CODE;
this.data = data;
this.count = count;
}
public static ReturnT PAGE(Object data, int count) {
return new ReturnT(data, count);
}
public static ReturnT PAGE(Object data, long count) {
return new ReturnT(data, Integer.parseInt(count + ""));
}
public static ReturnT SUCCESS() {
return new ReturnT(SUCCESS_CODE, OPERATION_SUCCESS);
}
public static ReturnT SUCCESS(String msg) {
return new ReturnT(SUCCESS_CODE, msg);
}
public static ReturnT SUCCESS(Object data) {
return new ReturnT(data);
}
public static ReturnT ERROR(String msg) {
return new ReturnT(FAIL_CODE, msg);
}
public static ReturnT ERROR() {
return new ReturnT(FAIL_CODE, OBJECT_NOT_FOUND);
}
public ReturnT(int code, String msg) {
this.code = code;
this.msg = msg;
}
public ReturnT(int code, String msg,Object data) {
this.code = code;
this.msg = msg;
this.data = data;
}
public ReturnT(Object data) {
this.code = SUCCESS_CODE;
this.data = data;
}
public ReturnT( Object data , int count ) {
this.code = PAGE_CODE;
this.data = data;
this.count = count;
}
public static ReturnT PAGE( Object data , int count){
return new ReturnT(data,count);
}
public static ReturnT PAGE( Object data , long count){
return new ReturnT(data,Integer.parseInt(count+""));
}
public static ReturnT SUCCESS(){
return new ReturnT(SUCCESS_CODE,OPERATION_SUCCESS);
}
public static ReturnT SUCCESS(String msg){
return new ReturnT(SUCCESS_CODE,msg);
}
public static ReturnT SUCCESS(Object data){
return new ReturnT(data);
}
public static ReturnT ERROR(String msg){
return new ReturnT(FAIL_CODE,msg);
}
public static ReturnT ERROR(){
return new ReturnT(FAIL_CODE,OBJECT_NOT_FOUND);
}
} }

35
generator-web/src/main/java/com/softdev/system/generator/service/GeneratorService.java
View File

@ -1,17 +1,18 @@
package com.softdev.system.generator.service; package com.softdev.system.generator.service;
import freemarker.template.TemplateException; import freemarker.template.TemplateException;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.io.IOException; import java.io.IOException;
import java.util.Map; import java.util.Map;
/** /**
* GeneratorService * GeneratorService
* @author zhengkai.blog.csdn.net *
*/ * @author zhengkai.blog.csdn.net
public interface GeneratorService { */
public interface GeneratorService {
public Map<String,String> getResultByParams(Map<String, Object> params) throws IOException, TemplateException;
public Map<String, String> getResultByParams(Map<String, Object> params) throws IOException, TemplateException;
}
}

130
generator-web/src/main/java/com/softdev/system/generator/service/GeneratorServiceImpl.java
View File

@ -1,62 +1,68 @@
package com.softdev.system.generator.service; package com.softdev.system.generator.service;
import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSON;
import com.softdev.system.generator.entity.TemplateConfig; import com.softdev.system.generator.entity.TemplateConfig;
import com.softdev.system.generator.util.FreemarkerUtil; import com.softdev.system.generator.util.FreemarkerUtil;
import freemarker.template.TemplateException; import freemarker.template.TemplateException;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.io.BufferedReader; import java.io.BufferedReader;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
import java.io.InputStreamReader; import java.io.InputStreamReader;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.stream.Collectors; import java.util.stream.Collectors;
/** /**
* GeneratorService * GeneratorService
* @author zhengkai.blog.csdn.net *
*/ * @author zhengkai.blog.csdn.net
@Slf4j */
@Service @Slf4j
public class GeneratorServiceImpl implements GeneratorService { @Service
public class GeneratorServiceImpl implements GeneratorService {
@Autowired
private FreemarkerUtil freemarkerTool; @Autowired
private FreemarkerUtil freemarkerTool;
String templateCpnfig=null;
/** String templateCpnfig = null;
* 从项目中的JSON文件读取String
* @author zhengkai.blog.csdn.net /**
*/ * 从项目中的JSON文件读取String
public String getTemplateConfig() throws IOException { *
templateCpnfig=null; * @author zhengkai.blog.csdn.net
if(templateCpnfig!=null){ */
}else{ public String getTemplateConfig() throws IOException {
InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("template.json"); templateCpnfig = null;
templateCpnfig = new BufferedReader(new InputStreamReader(inputStream)) if (templateCpnfig != null) {
.lines().collect(Collectors.joining(System.lineSeparator())); } else {
inputStream.close(); InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("template.json");
} templateCpnfig = new BufferedReader(new InputStreamReader(inputStream))
//log.info(JSON.toJSONString(templateCpnfig)); .lines().collect(Collectors.joining(System.lineSeparator()));
return templateCpnfig; inputStream.close();
} }
/** //log.info(JSON.toJSONString(templateCpnfig));
* 根据配置的Template模板进行遍历解析，得到生成好的String return templateCpnfig;
* @author zhengkai.blog.csdn.net }
*/
@Override /**
public Map<String, String> getResultByParams(Map<String, Object> params) throws IOException, TemplateException { * 根据配置的Template模板进行遍历解析，得到生成好的String
Map<String, String> result = new LinkedHashMap<>(32); *
result.put("tableName",params.get("tableName")+""); * @author zhengkai.blog.csdn.net
List<TemplateConfig> templateConfigList = JSON.parseArray(getTemplateConfig(),TemplateConfig.class); */
for (TemplateConfig item:templateConfigList){ @Override
result.put(item.getName(), freemarkerTool.processString(item.getGroup()+"/"+item.getName()+".ftl", params)); public Map<String, String> getResultByParams(Map<String, Object> params) throws IOException, TemplateException {
} Map<String, String> result = new LinkedHashMap<>(32);
return result; result.put("tableName", params.get("tableName") + "");
} List<TemplateConfig> templateConfigList = JSON.parseArray(getTemplateConfig(), TemplateConfig.class);
} for (TemplateConfig item : templateConfigList) {
result.put(item.getName(), freemarkerTool.processString(item.getGroup() + "/" + item.getName() + ".ftl", params));
}
return result;
}
}

7
generator-web/src/main/java/com/softdev/system/generator/util/CodeGenerateException.java
View File

@ -4,7 +4,9 @@ package com.softdev.system.generator.util;
* @author xuxueli 2018-05-02 21:10:28 * @author xuxueli 2018-05-02 21:10:28
*/ */
public class CodeGenerateException extends RuntimeException { public class CodeGenerateException extends RuntimeException {
private static final long serialVersionUID = 42L; private static final long serialVersionUID = 42L;
public CodeGenerateException() { public CodeGenerateException() {
super(); super();
} }
@ -22,8 +24,9 @@ public class CodeGenerateException extends RuntimeException {
} }
public CodeGenerateException(String message, Throwable cause, public CodeGenerateException(String message, Throwable cause,
boolean enableSuppression, boolean enableSuppression,
boolean writableStackTrace) { boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace); super(message, cause, enableSuppression, writableStackTrace);
} }
} }

11
generator-web/src/main/java/com/softdev/system/generator/util/FreemarkerUtil.java
View File

@ -23,23 +23,23 @@ import java.util.Map;
@Component @Component
public class FreemarkerUtil { public class FreemarkerUtil {
@Autowired @Autowired
private Configuration configuration; private Configuration configuration;
/** /**
* 传入需要转义的字符串进行转义 * 传入需要转义的字符串进行转义
* 20200503 zhengkai.blog.csdn.net * 20200503 zhengkai.blog.csdn.net
* */ */
public static String escapeString(String originStr){ public static String escapeString(String originStr) {
return originStr.replaceAll("井","\\#").replaceAll("￥","\\$"); return originStr.replaceAll("井", "\\#").replaceAll("￥", "\\$");
} }
/** /**
* freemarker config * freemarker config
*/ */
private static Configuration freemarkerConfig = new Configuration(Configuration.DEFAULT_INCOMPATIBLE_IMPROVEMENTS); private static Configuration freemarkerConfig = new Configuration(Configuration.DEFAULT_INCOMPATIBLE_IMPROVEMENTS);
static{
static {
try { try {
//2020-06-21 zhengkai 修复path问题导致jar无法运行而本地项目可以运行的bug //2020-06-21 zhengkai 修复path问题导致jar无法运行而本地项目可以运行的bug
freemarkerConfig.setClassForTemplateLoading(FreemarkerUtil.class, "/templates/code-generator"); freemarkerConfig.setClassForTemplateLoading(FreemarkerUtil.class, "/templates/code-generator");
@ -89,5 +89,4 @@ public class FreemarkerUtil {
return htmlText; return htmlText;
} }
} }

3
generator-web/src/main/java/com/softdev/system/generator/util/StringUtils.java
View File

@ -25,7 +25,7 @@ public class StringUtils {
*/ */
public static String lowerCaseFirst(String str) { public static String lowerCaseFirst(String str) {
//2019-2-10 解决StringUtils.lowerCaseFirst潜在的NPE异常@liutf //2019-2-10 解决StringUtils.lowerCaseFirst潜在的NPE异常@liutf
return (str!=null&&str.length()>1)?str.substring(0, 1).toLowerCase() + str.substring(1):""; return (str != null && str.length() > 1) ? str.substring(0, 1).toLowerCase() + str.substring(1) : "";
} }
/** /**
@ -58,4 +58,5 @@ public class StringUtils {
public static void main(String[] args) { public static void main(String[] args) {
} }
} }

953
generator-web/src/main/java/com/softdev/system/generator/util/TableParseUtil.java
View File

@ -1,472 +1,481 @@
package com.softdev.system.generator.util; package com.softdev.system.generator.util;
import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONObject;
import com.softdev.system.generator.entity.ClassInfo; import com.softdev.system.generator.entity.ClassInfo;
import com.softdev.system.generator.entity.FieldInfo; import com.softdev.system.generator.entity.FieldInfo;
import com.softdev.system.generator.entity.ParamInfo; import com.softdev.system.generator.entity.ParamInfo;
import java.io.IOException; import java.io.IOException;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays; import java.util.Arrays;
import java.util.Date; import java.util.Date;
import java.util.List; import java.util.List;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher; import java.util.regex.Matcher;
import java.util.regex.Pattern; import java.util.regex.Pattern;
/** /**
* 表格解析Util * 表格解析Util
* @author zhengkai.blog.csdn.net *
*/ * @author zhengkai.blog.csdn.net
public class TableParseUtil { */
public class TableParseUtil {
/**
* 解析DDL SQL生成类信息 /**
* @param paramInfo * 解析DDL SQL生成类信息
* @return *
*/ * @param paramInfo
public static ClassInfo processTableIntoClassInfo(ParamInfo paramInfo) * @return
throws IOException { */
//process the param public static ClassInfo processTableIntoClassInfo(ParamInfo paramInfo)
String tableSql=paramInfo.getTableSql(); throws IOException {
String nameCaseType=paramInfo.getNameCaseType(); //process the param
String tinyintTransType=paramInfo.getTinyintTransType(); String tableSql = paramInfo.getTableSql();
String nameCaseType = paramInfo.getNameCaseType();
if (tableSql==null || tableSql.trim().length()==0) { String tinyintTransType = paramInfo.getTinyintTransType();
throw new CodeGenerateException("Table structure can not be empty. 表结构不能为空。");
} if (tableSql == null || tableSql.trim().length() == 0) {
//deal with special character throw new CodeGenerateException("Table structure can not be empty. 表结构不能为空。");
tableSql = tableSql.trim().replaceAll("'","`").replaceAll("\"","`").replaceAll("，",",").toLowerCase(); }
//deal with java string copy \n" //deal with special character
tableSql = tableSql.trim().replaceAll("\\\\n`","").replaceAll("\\+","").replaceAll("``","`").replaceAll("\\\\",""); tableSql = tableSql.trim().replaceAll("'", "`").replaceAll("\"", "`").replaceAll("，", ",").toLowerCase();
// table Name //deal with java string copy \n"
String tableName = null; tableSql = tableSql.trim().replaceAll("\\\\n`", "").replaceAll("\\+", "").replaceAll("``", "`").replaceAll("\\\\", "");
if (tableSql.contains("TABLE") && tableSql.contains("(")) { // table Name
tableName = tableSql.substring(tableSql.indexOf("TABLE")+5, tableSql.indexOf("(")); String tableName = null;
} else if (tableSql.contains("table") && tableSql.contains("(")) { if (tableSql.contains("TABLE") && tableSql.contains("(")) {
tableName = tableSql.substring(tableSql.indexOf("table")+5, tableSql.indexOf("(")); tableName = tableSql.substring(tableSql.indexOf("TABLE") + 5, tableSql.indexOf("("));
} else { } else if (tableSql.contains("table") && tableSql.contains("(")) {
throw new CodeGenerateException("Table structure incorrect.表结构不正确。"); tableName = tableSql.substring(tableSql.indexOf("table") + 5, tableSql.indexOf("("));
} } else {
throw new CodeGenerateException("Table structure incorrect.表结构不正确。");
//新增处理create table if not exists members情况 }
if (tableName.contains("if not exists")) {
tableName=tableName.replaceAll("if not exists",""); //新增处理create table if not exists members情况
} if (tableName.contains("if not exists")) {
tableName = tableName.replaceAll("if not exists", "");
if (tableName.contains("`")) { }
tableName = tableName.substring(tableName.indexOf("`")+1, tableName.lastIndexOf("`"));
}else{ if (tableName.contains("`")) {
//空格开头的，需要替换掉\n\t空格 tableName = tableName.substring(tableName.indexOf("`") + 1, tableName.lastIndexOf("`"));
tableName=tableName.replaceAll(" ","").replaceAll("\n","").replaceAll("\t",""); } else {
} //空格开头的，需要替换掉\n\t空格
//优化对byeas`.`ct_bd_customerdiscount这种命名的支持 tableName = tableName.replaceAll(" ", "").replaceAll("\n", "").replaceAll("\t", "");
if(tableName.contains("`.`")){ }
tableName=tableName.substring(tableName.indexOf("`.`")+3); //优化对byeas`.`ct_bd_customerdiscount这种命名的支持
}else if(tableName.contains(".")){ if (tableName.contains("`.`")) {
//优化对likeu.members这种命名的支持 tableName = tableName.substring(tableName.indexOf("`.`") + 3);
tableName=tableName.substring(tableName.indexOf(".")+1); } else if (tableName.contains(".")) {
} //优化对likeu.members这种命名的支持
// class Name tableName = tableName.substring(tableName.indexOf(".") + 1);
String className = StringUtils.upperCaseFirst(StringUtils.underlineToCamelCase(tableName)); }
if (className.contains("_")) { // class Name
className = className.replaceAll("_", ""); String className = StringUtils.upperCaseFirst(StringUtils.underlineToCamelCase(tableName));
} if (className.contains("_")) {
className = className.replaceAll("_", "");
// class Comment }
String classComment = null;
//mysql是comment=,pgsql/oracle是comment on table, // class Comment
//2020-05-25 优化表备注的获取逻辑 String classComment = null;
if (tableSql.contains("comment=")||tableSql.contains("comment on table")) { //mysql是comment=,pgsql/oracle是comment on table,
String classCommentTmp = (tableSql.contains("comment="))? //2020-05-25 优化表备注的获取逻辑
tableSql.substring(tableSql.lastIndexOf("comment=")+8).trim():tableSql.substring(tableSql.lastIndexOf("comment on table")+17).trim(); if (tableSql.contains("comment=") || tableSql.contains("comment on table")) {
if (classCommentTmp.contains("`")) { String classCommentTmp = (tableSql.contains("comment=")) ?
classCommentTmp = classCommentTmp.substring(classCommentTmp.indexOf("`")+1); tableSql.substring(tableSql.lastIndexOf("comment=") + 8).trim() : tableSql.substring(tableSql.lastIndexOf("comment on table") + 17).trim();
classCommentTmp = classCommentTmp.substring(0,classCommentTmp.indexOf("`")); if (classCommentTmp.contains("`")) {
classComment = classCommentTmp; classCommentTmp = classCommentTmp.substring(classCommentTmp.indexOf("`") + 1);
}else{ classCommentTmp = classCommentTmp.substring(0, classCommentTmp.indexOf("`"));
//非常规的没法分析 classComment = classCommentTmp;
classComment = className; } else {
} //非常规的没法分析
}else{ classComment = className;
//修复表备注为空问题 }
classComment = tableName; } else {
} //修复表备注为空问题
//如果备注跟;混在一起，需要替换掉 classComment = tableName;
classComment=classComment.replaceAll(";",""); }
// field List //如果备注跟;混在一起，需要替换掉
List<FieldInfo> fieldList = new ArrayList<FieldInfo>(); classComment = classComment.replaceAll(";", "");
// field List
// 正常( ) 内的一定是字段相关的定义。 List<FieldInfo> fieldList = new ArrayList<FieldInfo>();
String fieldListTmp = tableSql.substring(tableSql.indexOf("(")+1, tableSql.lastIndexOf(")"));
// 正常( ) 内的一定是字段相关的定义。
// 匹配 comment，替换备注里的小逗号, 防止不小心被当成切割符号切割 String fieldListTmp = tableSql.substring(tableSql.indexOf("(") + 1, tableSql.lastIndexOf(")"));
String commentPattenStr1="comment `(.*?)\\`";
Matcher matcher1 = Pattern.compile(commentPattenStr1).matcher(fieldListTmp); // 匹配 comment，替换备注里的小逗号, 防止不小心被当成切割符号切割
while(matcher1.find()){ String commentPattenStr1 = "comment `(.*?)\\`";
Matcher matcher1 = Pattern.compile(commentPattenStr1).matcher(fieldListTmp);
String commentTmp = matcher1.group(); while (matcher1.find()) {
//2018-9-27 zhengk 不替换，只处理，支持COMMENT评论里面多种注释
//commentTmp = commentTmp.replaceAll("\\ comment `|\\`", " "); // "\\{|\\}" String commentTmp = matcher1.group();
//2018-9-27 zhengk 不替换，只处理，支持COMMENT评论里面多种注释
if (commentTmp.contains(",")) { //commentTmp = commentTmp.replaceAll("\\ comment `|\\`", " "); // "\\{|\\}"
String commentTmpFinal = commentTmp.replaceAll(",", "，");
fieldListTmp = fieldListTmp.replace(matcher1.group(), commentTmpFinal); if (commentTmp.contains(",")) {
} String commentTmpFinal = commentTmp.replaceAll(",", "，");
} fieldListTmp = fieldListTmp.replace(matcher1.group(), commentTmpFinal);
//2018-10-18 zhengkai 新增支持double(10, 2)等类型中有英文逗号的特殊情况 }
String commentPattenStr2="\\`(.*?)\\`"; }
Matcher matcher2 = Pattern.compile(commentPattenStr2).matcher(fieldListTmp); //2018-10-18 zhengkai 新增支持double(10, 2)等类型中有英文逗号的特殊情况
while(matcher2.find()){ String commentPattenStr2 = "\\`(.*?)\\`";
String commentTmp2 = matcher2.group(); Matcher matcher2 = Pattern.compile(commentPattenStr2).matcher(fieldListTmp);
if (commentTmp2.contains(",")) { while (matcher2.find()) {
String commentTmpFinal = commentTmp2.replaceAll(",", "，").replaceAll("\\(", "（").replaceAll("\\)", "）"); String commentTmp2 = matcher2.group();
fieldListTmp = fieldListTmp.replace(matcher2.group(), commentTmpFinal); if (commentTmp2.contains(",")) {
} String commentTmpFinal = commentTmp2.replaceAll(",", "，").replaceAll("\\(", "（").replaceAll("\\)", "）");
} fieldListTmp = fieldListTmp.replace(matcher2.group(), commentTmpFinal);
//2018-10-18 zhengkai 新增支持double(10, 2)等类型中有英文逗号的特殊情况 }
String commentPattenStr3="\\((.*?)\\)"; }
Matcher matcher3 = Pattern.compile(commentPattenStr3).matcher(fieldListTmp); //2018-10-18 zhengkai 新增支持double(10, 2)等类型中有英文逗号的特殊情况
while(matcher3.find()){ String commentPattenStr3 = "\\((.*?)\\)";
String commentTmp3 = matcher3.group(); Matcher matcher3 = Pattern.compile(commentPattenStr3).matcher(fieldListTmp);
if (commentTmp3.contains(",")) { while (matcher3.find()) {
String commentTmpFinal = commentTmp3.replaceAll(",", "，"); String commentTmp3 = matcher3.group();
fieldListTmp = fieldListTmp.replace(matcher3.group(), commentTmpFinal); if (commentTmp3.contains(",")) {
} String commentTmpFinal = commentTmp3.replaceAll(",", "，");
} fieldListTmp = fieldListTmp.replace(matcher3.group(), commentTmpFinal);
String[] fieldLineList = fieldListTmp.split(","); }
if (fieldLineList.length > 0) { }
int i=0; String[] fieldLineList = fieldListTmp.split(",");
//i为了解决primary key关键字出现的地方，出现在前3行，一般和id有关 if (fieldLineList.length > 0) {
for (String columnLine :fieldLineList) { int i = 0;
i++; //i为了解决primary key关键字出现的地方，出现在前3行，一般和id有关
columnLine = columnLine.replaceAll("\n","").replaceAll("\t","").trim(); for (String columnLine : fieldLineList) {
// `userid` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID', i++;
// 2018-9-18 zhengk 修改为contains，提升匹配率和匹配不按照规矩出牌的语句 columnLine = columnLine.replaceAll("\n", "").replaceAll("\t", "").trim();
// 2018-11-8 zhengkai 修复tornadoorz反馈的KEY FK_permission_id (permission_id),KEY FK_role_id (role_id)情况 // `userid` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID',
// 2019-2-22 zhengkai 要在条件中使用复杂的表达式 // 2018-9-18 zhengk 修改为contains，提升匹配率和匹配不按照规矩出牌的语句
// 2019-4-29 zhengkai 优化对普通和特殊storage关键字的判断（感谢@AhHeadFloating的反馈 ） // 2018-11-8 zhengkai 修复tornadoorz反馈的KEY FK_permission_id (permission_id),KEY FK_role_id (role_id)情况
boolean specialFlag=(!columnLine.contains("key ")&&!columnLine.contains("constraint")&&!columnLine.contains("using")&&!columnLine.contains("unique") // 2019-2-22 zhengkai 要在条件中使用复杂的表达式
&&!(columnLine.contains("primary ")&&columnLine.indexOf("storage")+3>columnLine.indexOf("(")) // 2019-4-29 zhengkai 优化对普通和特殊storage关键字的判断（感谢@AhHeadFloating的反馈 ）
&&!columnLine.contains("pctincrease") boolean specialFlag = (!columnLine.contains("key ") && !columnLine.contains("constraint") && !columnLine.contains("using") && !columnLine.contains("unique")
&&!columnLine.contains("buffer_pool")&&!columnLine.contains("tablespace") && !(columnLine.contains("primary ") && columnLine.indexOf("storage") + 3 > columnLine.indexOf("("))
&&!(columnLine.contains("primary ")&&i>3)); && !columnLine.contains("pctincrease")
if (specialFlag){ && !columnLine.contains("buffer_pool") && !columnLine.contains("tablespace")
//如果是oracle的number(x,x)，可能出现最后分割残留的,x)，这里做排除处理 && !(columnLine.contains("primary ") && i > 3));
if(columnLine.length()<5) {continue;} if (specialFlag) {
//2018-9-16 zhengkai 支持'符号以及空格的oracle语句// userid` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID', //如果是oracle的number(x,x)，可能出现最后分割残留的,x)，这里做排除处理
String columnName = ""; if (columnLine.length() < 5) {
columnLine=columnLine.replaceAll("`"," ").replaceAll("\""," ").replaceAll("'","").replaceAll(" "," ").trim(); continue;
//如果遇到username varchar(65) default '' not null,这种情况，判断第一个空格是否比第一个引号前 }
columnName = columnLine.substring(0, columnLine.indexOf(" ")); //2018-9-16 zhengkai 支持'符号以及空格的oracle语句// userid` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID',
// field Name String columnName = "";
// 2019-09-08 yj 添加是否下划线转换为驼峰的判断 columnLine = columnLine.replaceAll("`", " ").replaceAll("\"", " ").replaceAll("'", "").replaceAll(" ", " ").trim();
String fieldName=null; //如果遇到username varchar(65) default '' not null,这种情况，判断第一个空格是否比第一个引号前
if(ParamInfo.NAME_CASE_TYPE.CAMEL_CASE.equals(nameCaseType)){ columnName = columnLine.substring(0, columnLine.indexOf(" "));
fieldName = StringUtils.lowerCaseFirst(StringUtils.underlineToCamelCase(columnName)); // field Name
if (fieldName.contains("_")) { // 2019-09-08 yj 添加是否下划线转换为驼峰的判断
fieldName = fieldName.replaceAll("_", ""); String fieldName = null;
} if (ParamInfo.NAME_CASE_TYPE.CAMEL_CASE.equals(nameCaseType)) {
}else if(ParamInfo.NAME_CASE_TYPE.UNDER_SCORE_CASE.equals(nameCaseType)){ fieldName = StringUtils.lowerCaseFirst(StringUtils.underlineToCamelCase(columnName));
fieldName = StringUtils.lowerCaseFirst(columnName); if (fieldName.contains("_")) {
}else if(ParamInfo.NAME_CASE_TYPE.UPPER_UNDER_SCORE_CASE.equals(nameCaseType)){ fieldName = fieldName.replaceAll("_", "");
fieldName = StringUtils.lowerCaseFirst(columnName.toUpperCase()); }
}else{ } else if (ParamInfo.NAME_CASE_TYPE.UNDER_SCORE_CASE.equals(nameCaseType)) {
fieldName=columnName; fieldName = StringUtils.lowerCaseFirst(columnName);
} } else if (ParamInfo.NAME_CASE_TYPE.UPPER_UNDER_SCORE_CASE.equals(nameCaseType)) {
fieldName = StringUtils.lowerCaseFirst(columnName.toUpperCase());
// field class } else {
columnLine = columnLine.substring(columnLine.indexOf("`")+1).trim(); fieldName = columnName;
// int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID', }
String fieldClass = Object.class.getSimpleName();
//2018-9-16 zhengk 补充char/clob/blob/json等类型，如果类型未知，默认为String // field class
//2018-11-22 lshz0088 处理字段类型的时候，不严谨columnLine.contains(" int") 类似这种的，可在前后适当加一些空格之类的加以区分，否则当我的字段包含这些字符的时候，产生类型判断问题。 columnLine = columnLine.substring(columnLine.indexOf("`") + 1).trim();
//2020-05-03 MOSHOW.K.ZHENG 优化对所有类型的处理 // int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID',
if (columnLine.contains(" tinyint") ) { String fieldClass = Object.class.getSimpleName();
//20191115 MOSHOW.K.ZHENG 支持对tinyint的特殊处理 //2018-9-16 zhengk 补充char/clob/blob/json等类型，如果类型未知，默认为String
fieldClass=tinyintTransType; //2018-11-22 lshz0088 处理字段类型的时候，不严谨columnLine.contains(" int") 类似这种的，可在前后适当加一些空格之类的加以区分，否则当我的字段包含这些字符的时候，产生类型判断问题。
} //2020-05-03 MOSHOW.K.ZHENG 优化对所有类型的处理
else if (columnLine.contains(" int") || columnLine.contains(" smallint")) { if (columnLine.contains(" tinyint")) {
fieldClass = Integer.class.getSimpleName(); //20191115 MOSHOW.K.ZHENG 支持对tinyint的特殊处理
} else if (columnLine.contains(" bigint")) { fieldClass = tinyintTransType;
fieldClass = Long.class.getSimpleName(); } else if (columnLine.contains(" int") || columnLine.contains(" smallint")) {
} else if (columnLine.contains(" float")) { fieldClass = Integer.class.getSimpleName();
fieldClass = Float.class.getSimpleName(); } else if (columnLine.contains(" bigint")) {
} else if (columnLine.contains(" double")) { fieldClass = Long.class.getSimpleName();
fieldClass = Double.class.getSimpleName(); } else if (columnLine.contains(" float")) {
} else if (columnLine.contains(" time") || columnLine.contains(" date") || columnLine.contains(" datetime") || columnLine.contains(" timestamp")) { fieldClass = Float.class.getSimpleName();
fieldClass = Date.class.getSimpleName(); } else if (columnLine.contains(" double")) {
} else if (columnLine.contains(" varchar") || columnLine.contains(" text")|| columnLine.contains(" char") fieldClass = Double.class.getSimpleName();
|| columnLine.contains(" clob")||columnLine.contains(" blob")||columnLine.contains(" json")) { } else if (columnLine.contains(" time") || columnLine.contains(" date") || columnLine.contains(" datetime") || columnLine.contains(" timestamp")) {
fieldClass = String.class.getSimpleName(); fieldClass = Date.class.getSimpleName();
} else if (columnLine.contains(" decimal")||columnLine.contains(" number")) { } else if (columnLine.contains(" varchar") || columnLine.contains(" text") || columnLine.contains(" char")
//2018-11-22 lshz0088 建议对number类型增加int，long，BigDecimal的区分判断 || columnLine.contains(" clob") || columnLine.contains(" blob") || columnLine.contains(" json")) {
//如果startKh大于等于0，则表示有设置取值范围 fieldClass = String.class.getSimpleName();
int startKh=columnLine.indexOf("("); } else if (columnLine.contains(" decimal") || columnLine.contains(" number")) {
if(startKh>=0){ //2018-11-22 lshz0088 建议对number类型增加int，long，BigDecimal的区分判断
int endKh=columnLine.indexOf(")",startKh); //如果startKh大于等于0，则表示有设置取值范围
String[] fanwei=columnLine.substring(startKh+1,endKh).split("，"); int startKh = columnLine.indexOf("(");
//2019-1-5 zhengk 修复@arthaschan反馈的超出范围错误 if (startKh >= 0) {
//System.out.println("fanwei"+ JSON.toJSONString(fanwei)); int endKh = columnLine.indexOf(")", startKh);
// //number(20,6) fanwei["20","6"] String[] fanwei = columnLine.substring(startKh + 1, endKh).split("，");
// //number(0,6) fanwei["0","6"] //2019-1-5 zhengk 修复@arthaschan反馈的超出范围错误
// //number(20,0) fanwei["20","0"] //System.out.println("fanwei"+ JSON.toJSONString(fanwei));
// //number(20) fanwei["20"] // //number(20,6) fanwei["20","6"]
//如果括号里是1位或者2位且第二位为0，则进行特殊处理。只有有小数位，都设置为BigDecimal。 // //number(0,6) fanwei["0","6"]
if((fanwei.length>1&&"0".equals(fanwei[1]))||fanwei.length==1){ // //number(20,0) fanwei["20","0"]
int length=Integer.parseInt(fanwei[0]); // //number(20) fanwei["20"]
if(fanwei.length>1) { //如果括号里是1位或者2位且第二位为0，则进行特殊处理。只有有小数位，都设置为BigDecimal。
length=Integer.valueOf(fanwei[1]); if ((fanwei.length > 1 && "0".equals(fanwei[1])) || fanwei.length == 1) {
} int length = Integer.parseInt(fanwei[0]);
//数字范围9位及一下用Integer，大的用Long if (fanwei.length > 1) {
if(length<=9){ length = Integer.valueOf(fanwei[1]);
fieldClass = Integer.class.getSimpleName(); }
}else{ //数字范围9位及一下用Integer，大的用Long
fieldClass = Long.class.getSimpleName(); if (length <= 9) {
} fieldClass = Integer.class.getSimpleName();
}else{ } else {
//有小数位数一律使用BigDecimal fieldClass = Long.class.getSimpleName();
fieldClass = BigDecimal.class.getSimpleName(); }
} } else {
}else{ //有小数位数一律使用BigDecimal
fieldClass = BigDecimal.class.getSimpleName(); fieldClass = BigDecimal.class.getSimpleName();
} }
} else if (columnLine.contains(" boolean")) { } else {
//20190910 MOSHOW.K.ZHENG 新增对boolean的处理（感谢@violinxsc的反馈）以及修复tinyint类型字段无法生成boolean类型问题（感谢@hahaYhui的反馈） fieldClass = BigDecimal.class.getSimpleName();
fieldClass = Boolean.class.getSimpleName(); }
} else { } else if (columnLine.contains(" boolean")) {
fieldClass = String.class.getSimpleName(); //20190910 MOSHOW.K.ZHENG 新增对boolean的处理（感谢@violinxsc的反馈）以及修复tinyint类型字段无法生成boolean类型问题（感谢@hahaYhui的反馈）
} fieldClass = Boolean.class.getSimpleName();
} else {
// field comment，MySQL的一般位于field行，而pgsql和oralce多位于后面。 fieldClass = String.class.getSimpleName();
String fieldComment = null; }
if(tableSql.contains("comment on column")&&(tableSql.contains("."+columnName+" is ")||tableSql.contains(".`"+columnName+"` is"))){
//新增对pgsql/oracle的字段备注支持 // field comment，MySQL的一般位于field行，而pgsql和oralce多位于后面。
//COMMENT ON COLUMN public.check_info.check_name IS '检查者名称'; String fieldComment = null;
//2018-11-22 lshz0088 正则表达式的点号前面应该加上两个反斜杠，否则会认为是任意字符 if (tableSql.contains("comment on column") && (tableSql.contains("." + columnName + " is ") || tableSql.contains(".`" + columnName + "` is"))) {
//2019-4-29 zhengkai 优化对oracle注释comment on column的支持（@liukex） //新增对pgsql/oracle的字段备注支持
tableSql=tableSql.replaceAll(".`"+columnName+"` is","."+columnName+" is"); //COMMENT ON COLUMN public.check_info.check_name IS '检查者名称';
Matcher columnCommentMatcher = Pattern.compile("\\."+columnName+" is `").matcher(tableSql); //2018-11-22 lshz0088 正则表达式的点号前面应该加上两个反斜杠，否则会认为是任意字符
fieldComment=columnName; //2019-4-29 zhengkai 优化对oracle注释comment on column的支持（@liukex）
while(columnCommentMatcher.find()){ tableSql = tableSql.replaceAll(".`" + columnName + "` is", "." + columnName + " is");
String columnCommentTmp = columnCommentMatcher.group(); Matcher columnCommentMatcher = Pattern.compile("\\." + columnName + " is `").matcher(tableSql);
//System.out.println(columnCommentTmp); fieldComment = columnName;
fieldComment = tableSql.substring(tableSql.indexOf(columnCommentTmp)+columnCommentTmp.length()).trim(); while (columnCommentMatcher.find()) {
fieldComment = fieldComment.substring(0,fieldComment.indexOf("`")).trim(); String columnCommentTmp = columnCommentMatcher.group();
} //System.out.println(columnCommentTmp);
}else if (columnLine.contains(" comment")) { fieldComment = tableSql.substring(tableSql.indexOf(columnCommentTmp) + columnCommentTmp.length()).trim();
//20200518 zhengkai 修复包含comment关键字的问题 fieldComment = fieldComment.substring(0, fieldComment.indexOf("`")).trim();
String commentTmp = columnLine.substring(columnLine.lastIndexOf("comment")+7).trim(); }
// '用户ID', } else if (columnLine.contains(" comment")) {
if (commentTmp.contains("`") || commentTmp.indexOf("`")!=commentTmp.lastIndexOf("`")) { //20200518 zhengkai 修复包含comment关键字的问题
commentTmp = commentTmp.substring(commentTmp.indexOf("`")+1, commentTmp.lastIndexOf("`")); String commentTmp = columnLine.substring(columnLine.lastIndexOf("comment") + 7).trim();
} // '用户ID',
//解决最后一句是评论，无主键且连着)的问题:album_id int(3) default '1' null comment '相册id：0 代表头像 1代表照片墙') if (commentTmp.contains("`") || commentTmp.indexOf("`") != commentTmp.lastIndexOf("`")) {
if(commentTmp.contains(")")){ commentTmp = commentTmp.substring(commentTmp.indexOf("`") + 1, commentTmp.lastIndexOf("`"));
commentTmp = commentTmp.substring(0, commentTmp.lastIndexOf(")")+1); }
} //解决最后一句是评论，无主键且连着)的问题:album_id int(3) default '1' null comment '相册id：0 代表头像 1代表照片墙')
fieldComment = commentTmp; if (commentTmp.contains(")")) {
}else{ commentTmp = commentTmp.substring(0, commentTmp.lastIndexOf(")") + 1);
//修复comment不存在导致报错的问题 }
fieldComment = columnName; fieldComment = commentTmp;
} } else {
//修复comment不存在导致报错的问题
FieldInfo fieldInfo = new FieldInfo(); fieldComment = columnName;
fieldInfo.setColumnName(columnName); }
fieldInfo.setFieldName(fieldName);
fieldInfo.setFieldClass(fieldClass); FieldInfo fieldInfo = new FieldInfo();
fieldInfo.setFieldComment(fieldComment); fieldInfo.setColumnName(columnName);
fieldInfo.setFieldName(fieldName);
fieldList.add(fieldInfo); fieldInfo.setFieldClass(fieldClass);
} fieldInfo.setFieldComment(fieldComment);
}
} fieldList.add(fieldInfo);
}
if (fieldList.size() < 1) { }
throw new CodeGenerateException("表结构分析失败，请检查语句或者提交issue给我"); }
}
if (fieldList.size() < 1) {
ClassInfo codeJavaInfo = new ClassInfo(); throw new CodeGenerateException("表结构分析失败，请检查语句或者提交issue给我");
codeJavaInfo.setTableName(tableName); }
codeJavaInfo.setClassName(className);
codeJavaInfo.setClassComment(classComment); ClassInfo codeJavaInfo = new ClassInfo();
codeJavaInfo.setFieldList(fieldList); codeJavaInfo.setTableName(tableName);
codeJavaInfo.setClassName(className);
return codeJavaInfo; codeJavaInfo.setClassComment(classComment);
} codeJavaInfo.setFieldList(fieldList);
/**
* 解析JSON生成类信息 return codeJavaInfo;
* @param paramInfo }
* @return
*/ /**
public static ClassInfo processJsonToClassInfo(ParamInfo paramInfo){ * 解析JSON生成类信息
ClassInfo codeJavaInfo = new ClassInfo(); *
codeJavaInfo.setTableName("JsonDto"); * @param paramInfo
codeJavaInfo.setClassName("JsonDto"); * @return
codeJavaInfo.setClassComment("JsonDto"); */
public static ClassInfo processJsonToClassInfo(ParamInfo paramInfo) {
//support children json if forget to add '{' in front of json ClassInfo codeJavaInfo = new ClassInfo();
if(paramInfo.getTableSql().trim().startsWith("\"")){ codeJavaInfo.setTableName("JsonDto");
paramInfo.setTableSql("{"+paramInfo.getTableSql()); codeJavaInfo.setClassName("JsonDto");
} codeJavaInfo.setClassComment("JsonDto");
if(JSON.isValid(paramInfo.getTableSql())){
if(paramInfo.getTableSql().trim().startsWith("{")){ //support children json if forget to add '{' in front of json
JSONObject jsonObject = JSONObject.parseObject(paramInfo.getTableSql().trim()); if (paramInfo.getTableSql().trim().startsWith("\"")) {
//parse FieldList by JSONObject paramInfo.setTableSql("{" + paramInfo.getTableSql());
codeJavaInfo.setFieldList(processJsonObjectToFieldList(jsonObject)); }
}else if(paramInfo.getTableSql().trim().startsWith("[")){ if (JSON.isValid(paramInfo.getTableSql())) {
JSONArray jsonArray=JSONArray.parseArray(paramInfo.getTableSql().trim()); if (paramInfo.getTableSql().trim().startsWith("{")) {
//parse FieldList by JSONObject JSONObject jsonObject = JSONObject.parseObject(paramInfo.getTableSql().trim());
codeJavaInfo.setFieldList(processJsonObjectToFieldList(jsonArray.getJSONObject(0))); //parse FieldList by JSONObject
} codeJavaInfo.setFieldList(processJsonObjectToFieldList(jsonObject));
} } else if (paramInfo.getTableSql().trim().startsWith("[")) {
JSONArray jsonArray = JSONArray.parseArray(paramInfo.getTableSql().trim());
return codeJavaInfo; //parse FieldList by JSONObject
} codeJavaInfo.setFieldList(processJsonObjectToFieldList(jsonArray.getJSONObject(0)));
/** }
* parse SQL by regex }
* @author https://github.com/ydq
* @param paramInfo return codeJavaInfo;
* @return }
*/
public static ClassInfo processTableToClassInfoByRegex(ParamInfo paramInfo){ /**
// field List * parse SQL by regex
List<FieldInfo> fieldList = new ArrayList<FieldInfo>(); *
//return classInfo * @param paramInfo
ClassInfo codeJavaInfo = new ClassInfo(); * @return
* @author https://github.com/ydq
//匹配整个ddl，将ddl分为表名，列sql部分，表注释 */
String DDL_PATTEN_STR="\\s*create\\s+table\\s+(?<tableName>\\S+)[^\\(]*\\((?<columnsSQL>[\\s\\S]+)\\)[^\\)]+?(comment\\s*(=|on\\s+table)\\s*'(?<tableComment>.*?)'\\s*;?)?$"; public static ClassInfo processTableToClassInfoByRegex(ParamInfo paramInfo) {
// field List
Pattern DDL_PATTERN = Pattern.compile(DDL_PATTEN_STR, Pattern.CASE_INSENSITIVE); List<FieldInfo> fieldList = new ArrayList<FieldInfo>();
//return classInfo
//匹配列sql部分，分别解析每一列的列名 类型 和列注释 ClassInfo codeJavaInfo = new ClassInfo();
String COL_PATTERN_STR="\\s*(?<fieldName>\\S+)\\s+(?<fieldType>\\w+)\\s*(?:\\([\\s\\d,]+\\))?((?!comment).)*(comment\\s*'(?<fieldComment>.*?)')?\\s*(,|$)";
//匹配整个ddl，将ddl分为表名，列sql部分，表注释
Pattern COL_PATTERN = Pattern.compile(COL_PATTERN_STR, Pattern.CASE_INSENSITIVE); String DDL_PATTEN_STR = "\\s*create\\s+table\\s+(?<tableName>\\S+)[^\\(]*\\((?<columnsSQL>[\\s\\S]+)\\)[^\\)]+?(comment\\s*(=|on\\s+table)\\s*'(?<tableComment>.*?)'\\s*;?)?$";
Matcher matcher = DDL_PATTERN.matcher(paramInfo.getTableSql().trim()); Pattern DDL_PATTERN = Pattern.compile(DDL_PATTEN_STR, Pattern.CASE_INSENSITIVE);
if (matcher.find()){
String tableName = matcher.group("tableName"); //匹配列sql部分，分别解析每一列的列名 类型 和列注释
String tableComment = matcher.group("tableComment"); String COL_PATTERN_STR = "\\s*(?<fieldName>\\S+)\\s+(?<fieldType>\\w+)\\s*(?:\\([\\s\\d,]+\\))?((?!comment).)*(comment\\s*'(?<fieldComment>.*?)')?\\s*(,|$)";
codeJavaInfo.setTableName(tableName.replaceAll("'",""));
codeJavaInfo.setClassName(tableName.replaceAll("'","")); Pattern COL_PATTERN = Pattern.compile(COL_PATTERN_STR, Pattern.CASE_INSENSITIVE);
codeJavaInfo.setClassComment(tableComment.replaceAll("'",""));
String columnsSQL = matcher.group("columnsSQL"); Matcher matcher = DDL_PATTERN.matcher(paramInfo.getTableSql().trim());
if (columnsSQL != null && columnsSQL.length() > 0){ if (matcher.find()) {
Matcher colMatcher = COL_PATTERN.matcher(columnsSQL); String tableName = matcher.group("tableName");
while (colMatcher.find()){ String tableComment = matcher.group("tableComment");
String fieldName = colMatcher.group("fieldName"); codeJavaInfo.setTableName(tableName.replaceAll("'", ""));
String fieldType = colMatcher.group("fieldType"); codeJavaInfo.setClassName(tableName.replaceAll("'", ""));
String fieldComment = colMatcher.group("fieldComment"); codeJavaInfo.setClassComment(tableComment.replaceAll("'", ""));
if (!"key".equalsIgnoreCase(fieldType)){ String columnsSQL = matcher.group("columnsSQL");
FieldInfo fieldInfo = new FieldInfo(); if (columnsSQL != null && columnsSQL.length() > 0) {
fieldInfo.setFieldName(fieldName.replaceAll("'","")); Matcher colMatcher = COL_PATTERN.matcher(columnsSQL);
fieldInfo.setColumnName(fieldName.replaceAll("'","")); while (colMatcher.find()) {
fieldInfo.setFieldClass(fieldType.replaceAll("'","")); String fieldName = colMatcher.group("fieldName");
fieldInfo.setFieldComment(fieldComment.replaceAll("'","")); String fieldType = colMatcher.group("fieldType");
fieldList.add(fieldInfo); String fieldComment = colMatcher.group("fieldComment");
} if (!"key".equalsIgnoreCase(fieldType)) {
} FieldInfo fieldInfo = new FieldInfo();
} fieldInfo.setFieldName(fieldName.replaceAll("'", ""));
codeJavaInfo.setFieldList(fieldList); fieldInfo.setColumnName(fieldName.replaceAll("'", ""));
} fieldInfo.setFieldClass(fieldType.replaceAll("'", ""));
return codeJavaInfo; fieldInfo.setFieldComment(fieldComment.replaceAll("'", ""));
} fieldList.add(fieldInfo);
public static List<FieldInfo> processJsonObjectToFieldList(JSONObject jsonObject){ }
// field List }
List<FieldInfo> fieldList = new ArrayList<FieldInfo>(); }
jsonObject.keySet().stream().forEach(jsonField->{ codeJavaInfo.setFieldList(fieldList);
FieldInfo fieldInfo = new FieldInfo(); }
fieldInfo.setFieldName(jsonField); return codeJavaInfo;
fieldInfo.setColumnName(jsonField); }
fieldInfo.setFieldClass(String.class.getSimpleName());
fieldInfo.setFieldComment("father:"+jsonField); public static List<FieldInfo> processJsonObjectToFieldList(JSONObject jsonObject) {
fieldList.add(fieldInfo); // field List
if(jsonObject.get(jsonField) instanceof JSONArray){ List<FieldInfo> fieldList = new ArrayList<FieldInfo>();
jsonObject.getJSONArray(jsonField).stream().forEach(arrayObject->{ jsonObject.keySet().stream().forEach(jsonField -> {
FieldInfo fieldInfo2 = new FieldInfo(); FieldInfo fieldInfo = new FieldInfo();
fieldInfo2.setFieldName(arrayObject.toString()); fieldInfo.setFieldName(jsonField);
fieldInfo2.setColumnName(arrayObject.toString()); fieldInfo.setColumnName(jsonField);
fieldInfo2.setFieldClass(String.class.getSimpleName()); fieldInfo.setFieldClass(String.class.getSimpleName());
fieldInfo2.setFieldComment("children:"+arrayObject.toString()); fieldInfo.setFieldComment("father:" + jsonField);
fieldList.add(fieldInfo2); fieldList.add(fieldInfo);
}); if (jsonObject.get(jsonField) instanceof JSONArray) {
}else if(jsonObject.get(jsonField) instanceof JSONObject){ jsonObject.getJSONArray(jsonField).stream().forEach(arrayObject -> {
jsonObject.getJSONObject(jsonField).keySet().stream().forEach(arrayObject->{ FieldInfo fieldInfo2 = new FieldInfo();
FieldInfo fieldInfo2 = new FieldInfo(); fieldInfo2.setFieldName(arrayObject.toString());
fieldInfo2.setFieldName(arrayObject.toString()); fieldInfo2.setColumnName(arrayObject.toString());
fieldInfo2.setColumnName(arrayObject.toString()); fieldInfo2.setFieldClass(String.class.getSimpleName());
fieldInfo2.setFieldClass(String.class.getSimpleName()); fieldInfo2.setFieldComment("children:" + arrayObject.toString());
fieldInfo2.setFieldComment("children:"+arrayObject.toString()); fieldList.add(fieldInfo2);
fieldList.add(fieldInfo2); });
}); } else if (jsonObject.get(jsonField) instanceof JSONObject) {
} jsonObject.getJSONObject(jsonField).keySet().stream().forEach(arrayObject -> {
}); FieldInfo fieldInfo2 = new FieldInfo();
if(fieldList.size()<1){ fieldInfo2.setFieldName(arrayObject.toString());
throw new CodeGenerateException("JSON解析失败"); fieldInfo2.setColumnName(arrayObject.toString());
} fieldInfo2.setFieldClass(String.class.getSimpleName());
return fieldList; fieldInfo2.setFieldComment("children:" + arrayObject.toString());
} fieldList.add(fieldInfo2);
});
public static ClassInfo processInsertSqlToClassInfo(ParamInfo paramInfo) { }
// field List });
List<FieldInfo> fieldList = new ArrayList<FieldInfo>(); if (fieldList.size() < 1) {
//return classInfo throw new CodeGenerateException("JSON解析失败");
ClassInfo codeJavaInfo = new ClassInfo(); }
return fieldList;
//get origin sql }
String fieldSqlStr = paramInfo.getTableSql().toLowerCase().trim();
fieldSqlStr=fieldSqlStr.replaceAll(" "," ").replaceAll("\\\\n`","") public static ClassInfo processInsertSqlToClassInfo(ParamInfo paramInfo) {
.replaceAll("\\+","").replaceAll("``","`").replaceAll("\\\\",""); // field List
String valueStr = fieldSqlStr.substring(fieldSqlStr.lastIndexOf("values")+6).replaceAll(" ","").replaceAll("\\(","").replaceAll("\\)",""); List<FieldInfo> fieldList = new ArrayList<FieldInfo>();
//get the string between insert into and values //return classInfo
fieldSqlStr=fieldSqlStr.substring(0,fieldSqlStr.lastIndexOf("values")); ClassInfo codeJavaInfo = new ClassInfo();
System.out.println(fieldSqlStr); //get origin sql
String fieldSqlStr = paramInfo.getTableSql().toLowerCase().trim();
String insertSqlPattenStr = "insert into (?<tableName>.*) \\((?<columnsSQL>.*)\\)"; fieldSqlStr = fieldSqlStr.replaceAll(" ", " ").replaceAll("\\\\n`", "")
//String DDL_PATTEN_STR="\\s*create\\s+table\\s+(?<tableName>\\S+)[^\\(]*\\((?<columnsSQL>[\\s\\S]+)\\)[^\\)]+?(comment\\s*(=|on\\s+table)\\s*'(?<tableComment>.*?)'\\s*;?)?$"; .replaceAll("\\+", "").replaceAll("``", "`").replaceAll("\\\\", "");
String valueStr = fieldSqlStr.substring(fieldSqlStr.lastIndexOf("values") + 6).replaceAll(" ", "").replaceAll("\\(", "").replaceAll("\\)", "");
Matcher matcher1 = Pattern.compile(insertSqlPattenStr).matcher(fieldSqlStr); //get the string between insert into and values
while(matcher1.find()){ fieldSqlStr = fieldSqlStr.substring(0, fieldSqlStr.lastIndexOf("values"));
String tableName = matcher1.group("tableName"); System.out.println(fieldSqlStr);
//System.out.println("tableName:"+tableName);
codeJavaInfo.setClassName(tableName); String insertSqlPattenStr = "insert into (?<tableName>.*) \\((?<columnsSQL>.*)\\)";
codeJavaInfo.setTableName(tableName); //String DDL_PATTEN_STR="\\s*create\\s+table\\s+(?<tableName>\\S+)[^\\(]*\\((?<columnsSQL>[\\s\\S]+)\\)[^\\)]+?(comment\\s*(=|on\\s+table)\\s*'(?<tableComment>.*?)'\\s*;?)?$";
String columnsSQL = matcher1.group("columnsSQL"); Matcher matcher1 = Pattern.compile(insertSqlPattenStr).matcher(fieldSqlStr);
//System.out.println("columnsSQL:"+columnsSQL); while (matcher1.find()) {
List<String> valueList = new ArrayList<>(); String tableName = matcher1.group("tableName");
//add values as comment //System.out.println("tableName:"+tableName);
Arrays.stream(valueStr.split(",")).forEach(column->{ codeJavaInfo.setClassName(tableName);
valueList.add(column); codeJavaInfo.setTableName(tableName);
});
AtomicInteger n= new AtomicInteger(0); String columnsSQL = matcher1.group("columnsSQL");
//add column to fleldList //System.out.println("columnsSQL:"+columnsSQL);
Arrays.stream(columnsSQL.replaceAll(" ", "").split(",")).forEach(column->{
FieldInfo fieldInfo2 = new FieldInfo(); List<String> valueList = new ArrayList<>();
fieldInfo2.setFieldName(column); //add values as comment
fieldInfo2.setColumnName(column); Arrays.stream(valueStr.split(",")).forEach(column -> {
fieldInfo2.setFieldClass(String.class.getSimpleName()); valueList.add(column);
if(n.get()<valueList.size()){ });
fieldInfo2.setFieldComment(column+" , eg."+valueList.get(n.get())); AtomicInteger n = new AtomicInteger(0);
} //add column to fleldList
fieldList.add(fieldInfo2); Arrays.stream(columnsSQL.replaceAll(" ", "").split(",")).forEach(column -> {
n.getAndIncrement(); FieldInfo fieldInfo2 = new FieldInfo();
}); fieldInfo2.setFieldName(column);
fieldInfo2.setColumnName(column);
} fieldInfo2.setFieldClass(String.class.getSimpleName());
if(fieldList.size()<1){ if (n.get() < valueList.size()) {
throw new CodeGenerateException("INSERT SQL解析失败"); fieldInfo2.setFieldComment(column + " , eg." + valueList.get(n.get()));
} }
codeJavaInfo.setFieldList(fieldList); fieldList.add(fieldInfo2);
return codeJavaInfo; n.getAndIncrement();
} });
}
}
if (fieldList.size() < 1) {
throw new CodeGenerateException("INSERT SQL解析失败");
}
codeJavaInfo.setFieldList(fieldList);
return codeJavaInfo;
}
}

2
generator-web/src/main/resources/templates/code-generator/mybatis/controller.ftl
View File

@ -14,7 +14,7 @@ import java.util.Map;
* @date ${.now?string('yyyy-MM-dd')} * @date ${.now?string('yyyy-MM-dd')}
*/ */
@RestController @RestController
@RequestMapping(value = "/${classInfo.className}") @RequestMapping(value = "/${classInfo.className?uncap_first}")
public class ${classInfo.className}Controller { public class ${classInfo.className}Controller {
@Resource @Resource