自定义Mybatis自动生成代码规则
前言
大家都清楚mybatis-generate-core 这个工程提供了获取表信息到生成model、dao、xml这三层代码的一个实现，但是这往往有一个痛点，比如需求来了，某个表需要增加字段，肯定需要重新运行mybatis自动生成的脚本，但是会去覆盖之前的代码，如model,dao的java代码，对于xml文件，目前有两种处理方式，一、覆盖，二、追加，本文用的版本是1.3.5版本，默认的是追加方式，本文的目的就是处理xml的一种合并方式，对于java代码的话，我个人认为无论是增加表字段还是其他情况，相对于xml文件都是比较好维护的，这里就不做讨论。
对于方式一的话，直接覆盖，肯定会导致之前自定义的sql，直接没了，还需要事先拷贝一份出来，最蛋疼的就是，可能还会在自动生成的代码文件中，增加了一些属性(如主键返回，flushCache属性)，导致后来人员给忽略了，直到某个时刻才爆发出来。所以本文不采用这种方式，而是采用方式2，对于mybatis自定义的合并规则，看下文介绍。本文会对这个合并规则，进行重写，已达到我们的目标。如下
- 在启用自动生成代码后，原有的自定义sql，一律保留，包括,result|sql|select|delete|update|where|insert等标签，只要不是自动生成的
- 自动生成的标签中，手动添加的一些属性，如主键返回useGeneratedKeys="true" keyColumn="id"，刷新一级缓存,flushCache="true"等属性标签也需要保留。
在重写该规则前，肯定是要摸清它的原有流程，下面分为这几个小节进行叙述
一、合并规则原理
二、重写规则
三、简述适用场景
本文采用的数据库是Mysql
一、合并规则原理
先来一段代码，莫慌，这段代码没什么特别，很常见的自动生成代码
1 package com.qm.mybatis.generate;
2
3 import org.mybatis.generator.api.MyBatisGenerator;
4 import org.mybatis.generator.config.Configuration;
5 import org.mybatis.generator.config.xml.ConfigurationParser;
6 import org.mybatis.generator.internal.DefaultShellCallback;
7
8 import java.io.InputStream;
9 import java.util.ArrayList;
10 import java.util.List;
11
12 public class GenerateTest {
13
14 public static void main(String[] args) {
15 List<String> warnings = new ArrayList<String>();
16 try {
17 boolean overwrite = true;
18 // 读取配置文件
19 InputStream resourceAsStream = GenerateTest.class.getResourceAsStream("/mybatis-generate.xml");
20 ConfigurationParser cp = new ConfigurationParser(warnings);
21 Configuration config = cp.parseConfiguration(resourceAsStream);
22 DefaultShellCallback callback = new DefaultShellCallback(overwrite);
23 MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
24 myBatisGenerator.generate(null);
25 } catch (Exception e) {
26
27 e.printStackTrace();
28 }
29
30 warnings.stream().forEach(warn -> {
31 System.out.println(warn);
32 });
33 System.out.println("生成成功！");
34 }
35 }
可见，最终的生成逻辑在MybatisGenerator#generate方法中，
1 // 最终生成代码的地方
2 public void generate(ProgressCallback callback, Set<String> contextIds,
3 Set<String> fullyQualifiedTableNames, boolean writeFiles) throws SQLException,
4 IOException, InterruptedException {
5
6 if (callback == null) {
7 callback = new NullProgressCallback();
8 }
9
10 generatedJavaFiles.clear();
11 generatedXmlFiles.clear();
12 ObjectFactory.reset();
13 RootClassInfo.reset();
14
15 // calculate the contexts to run
16 List<Context> contextsToRun;
17 if (contextIds == null || contextIds.size() == 0) {
18 contextsToRun = configuration.getContexts();
19 } else {
20 contextsToRun = new ArrayList<Context>();
21 for (Context context : configuration.getContexts()) {
22 if (contextIds.contains(context.getId())) {
23 contextsToRun.add(context);
24 }
25 }
26 }
27
28 // setup custom classloader if required
29 if (configuration.getClassPathEntries().size() > 0) {
30 ClassLoader classLoader = getCustomClassloader(configuration.getClassPathEntries());
31 ObjectFactory.addExternalClassLoader(classLoader);
32 }
33
34 // now run the introspections...
35 int totalSteps = 0;
36 for (Context context : contextsToRun) {
37 totalSteps += context.getIntrospectionSteps();
38 }
39 callback.introspectionStarted(totalSteps);
40
41 for (Context context : contextsToRun) {
42 context.introspectTables(callback, warnings,
43 fullyQualifiedTableNames);
44 }
45
46 // now run the generates
47 totalSteps = 0;
48 for (Context context : contextsToRun) {
49 totalSteps += context.getGenerationSteps();
50 }
51 callback.generationStarted(totalSteps);
52
53 for (Context context : contextsToRun) {
54 context.generateFiles(callback, generatedJavaFiles,
55 generatedXmlFiles, warnings);
56 }
57
58 // 前面各种文件都已经生成完毕，在这里进行保存到具体的文件中
59 if (writeFiles) {
60 callback.saveStarted(generatedXmlFiles.size()
61 + generatedJavaFiles.size());
62
63 // 进行xml文件保存(更新)的地方，也是本文的目标
64 for (GeneratedXmlFile gxf : generatedXmlFiles) {
65 projects.add(gxf.getTargetProject());
66 writeGeneratedXmlFile(gxf, callback);
67 }
68
69 // 保存java文件，如model,example,dao
70 for (GeneratedJavaFile gjf : generatedJavaFiles) {
71 projects.add(gjf.getTargetProject());
72 writeGeneratedJavaFile(gjf, callback);
73 }
74
75 for (String project : projects) {
76 shellCallback.refreshProject(project);
77 }
78 }
79
80 callback.done();
81 }
最终的落实地方就在writeGeneratedXmlFile方法内。
1 private void writeGeneratedXmlFile(GeneratedXmlFile gxf, ProgressCallback callback)
2 throws InterruptedException, IOException {
3 File targetFile;
4 String source;
5 try {
6 File directory = shellCallback.getDirectory(gxf
7 .getTargetProject(), gxf.getTargetPackage());
8 targetFile = new File(directory, gxf.getFileName());
9 // 如果为false，基本上就是第一次生成的时候
10 if (targetFile.exists()) {
11
12 /**
13 * 从这里也可以看出，这个参数决定xml文件的处理方式
14 * 为true时，会执行getMergedSource，透个底，改造也是改造这个方法
15 false，会继续后面两种逻辑。实际生成的内容其实是一样的。这里不做讨论
16 */
17 if (gxf.isMergeable()) {
18 source = XmlFileMergerJaxp.getMergedSource(gxf,
19 targetFile);
20 } else if (shellCallback.isOverwriteEnabled()) {
21 source = gxf.getFormattedContent();
22 warnings.add(getString("Warning.11", //$NON-NLS-1$
23 targetFile.getAbsolutePath()));
24 } else {
25 source = gxf.getFormattedContent();
26 targetFile = getUniqueFileName(directory, gxf
27 .getFileName());
28 warnings.add(getString(
29 "Warning.2", targetFile.getAbsolutePath())); //$NON-NLS-1$
30 }
31 } else {
32 source = gxf.getFormattedContent();
33 }
34
35 callback.checkCancel();
36 callback.startTask(getString(
37 "Progress.15", targetFile.getName())); //$NON-NLS-1$
38 writeFile(targetFile, source, "UTF-8"); //$NON-NLS-1$
39 } catch (ShellException e) {
40 warnings.add(e.getMessage());
41 }
42 }
饶了这么多圈，实际上我们要处理的就是重写XmlFileMergerJaxp#getMergedSource方法，或许有的人会提出疑问了，这个类能让你提供扩展吗？让你去继承？然后去改变这个规则，额(⊙o⊙)…，还真没有，这个类实际上就是一个静态方法，那这搞个毛线啊，你即使重写出来了，那你怎么将他插入进去，别告诉你准备重新编译源码。。。。。莫慌，往下看。
说到这，大家可以去了解一下类加载器和其加载的过程，本文不做过多阐述，直接来结论，你要想覆盖一个jar包里的某个方法，你就直接在你项目中，定义这个类(包名和类名需要完全一致)，然后运行的时候，自然会执行你定义的这个类，千万别去想着同样的方法去覆盖jdk自带的类，没用，因为第三方jar包和jdk自带的类的类加载器不是同一个。有兴趣的可以去网上搜索一下。说了这么多，我们就是要这样做。做之前，先了解下这个merge方法的代码。
1 public static String getMergedSource(InputSource newFile,
2 InputSource existingFile, String existingFileName) throws IOException, SAXException,
3 ParserConfigurationException, ShellException {
4
5 DocumentBuilderFactory factory = DocumentBuilderFactory
6 .newInstance();
7 factory.setExpandEntityReferences(false);
8 DocumentBuilder builder = factory.newDocumentBuilder();
9 builder.setEntityResolver(new NullEntityResolver());
10
11 // 这是xml文件的解析结果，这里就暂且称为旧文件和新文件
12 Document existingDocument = builder.parse(existingFile);
13 Document newDocument = builder.parse(newFile);
14
15 DocumentType newDocType = newDocument.getDoctype();
16 DocumentType existingDocType = existingDocument.getDoctype();
17
18 // 比较两个xml文件是不是同一类型
19 if (!newDocType.getName().equals(existingDocType.getName())) {
20 throw new ShellException(getString("Warning.12", //$NON-NLS-1$
21 existingFileName));
22 }
23
24 // 获取根节点
25 Element existingRootElement = existingDocument.getDocumentElement();
26 Element newRootElement = newDocument.getDocumentElement();
27
28
29 NamedNodeMap attributes = existingRootElement.getAttributes();
30 int attributeCount = attributes.getLength();
31 for (int i = attributeCount - 1; i >= 0; i--) {
32 Node node = attributes.item(i);
33 existingRootElement.removeAttribute(node.getNodeName());
34 }
35
36 // add attributes from the new root node to the old root node
37 attributes = newRootElement.getAttributes();
38 attributeCount = attributes.getLength();
39 for (int i = 0; i < attributeCount; i++) {
40 Node node = attributes.item(i);
41 existingRootElement.setAttribute(node.getNodeName(), node
42 .getNodeValue());
43 }
44
45 // remove the old generated elements and any
46 // white space before the old nodes
47 List<Node> nodesToDelete = new ArrayList<Node>();
48 NodeList children = existingRootElement.getChildNodes();
49 int length = children.getLength();
50 for (int i = 0; i < length; i++) {
51 Node node = children.item(i);
52 if (isGeneratedNode(node)) {
53 nodesToDelete.add(node);
54 } else if (isWhiteSpace(node)
55 && isGeneratedNode(children.item(i + 1))) {
56 nodesToDelete.add(node);
57 }
58 }
59
60 for (Node node : nodesToDelete) {
61 existingRootElement.removeChild(node);
62 }
63
64 // add the new generated elements
65 children = newRootElement.getChildNodes();
66 length = children.getLength();
67 Node firstChild = existingRootElement.getFirstChild();
68 for (int i = 0; i < length; i++) {
69 Node node = children.item(i);
70 // don't add the last node if it is only white space
71 if (i == length - 1 && isWhiteSpace(node)) {
72 break;
73 }
74
75 Node newNode = existingDocument.importNode(node, true);
76 if (firstChild == null) {
77 existingRootElement.appendChild(newNode);
78 } else {
79 existingRootElement.insertBefore(newNode, firstChild);
80 }
81 }
82
83 // pretty print the result
84 return prettyPrint(existingDocument);
85 }
启动的29~43行，的目的是替换mapper节点的namespace，方式重新生成后，namespace有改变
之后的47~62行，就是删除一些节点，其实按照他这意思就是为了删掉特定的节点，具体实现逻辑在isGeneratedNode方法内，由它决定删不删。
65~81行就是将新文件中的所有节点(非空白节点)全部合并至旧文件中。
1 private static boolean isGeneratedNode(Node node) {
2 boolean rc = false;
3
4 if (node != null && node.getNodeType() == Node.ELEMENT_NODE) {
5 Element element = (Element) node;
6 String id = element.getAttribute("id"); //$NON-NLS-1$
7 if (id != null) {
8 for (String prefix : MergeConstants.OLD_XML_ELEMENT_PREFIXES) {
9 if (id.startsWith(prefix)) {
10 rc = true;
11 break;
12 }
13 }
14 }
15
16 if (rc == false) {
17 // check for new node format - if the first non-whitespace node
18 // is an XML comment, and the comment includes
19 // one of the old element tags,
20 // then it is a generated node
21 NodeList children = node.getChildNodes();
22 int length = children.getLength();
23 for (int i = 0; i < length; i++) {
24 Node childNode = children.item(i);
25 if (isWhiteSpace(childNode)) {
26 continue;
27 } else if (childNode.getNodeType() == Node.COMMENT_NODE) {
28 Comment comment = (Comment) childNode;
29 String commentData = comment.getData();
30 for (String tag : MergeConstants.OLD_ELEMENT_TAGS) {
31 if (commentData.contains(tag)) {
32 rc = true;
33 break;
34 }
35 }
36 } else {
37 break;
38 }
39 }
40 }
41 }
42
43 return rc;
44 }
逻辑其实也很简单，4~14行的逻辑就是删除id属性值带有一些特定前缀的节点，如果没找到，这删除commentNode节点，看到这，结果就出来了，按照正常情况下，根本不会把之前的就节点给删除掉。还是完完全全的保留。至此，就是我们常说的追加。
二、重写规则
从上述内容中，熟悉了原有的代码合并规则，接下来就是自定义规则了，本文就不放代码了，那样感觉很啰嗦，就直接简述一下实现思路，具体代码会在文末贴出github链接，可自行查看。
一、遍历新文件的所有非空白节点，遍历同时获取到对应旧文件中的节点，这里不考虑旧文件中有删除自动生成的节点情况，若获取到了，则遍历属性，有无增加，若增加，则移植到新文件中对应节点上，同时对该旧文件中的节点进行标记，等遍历完删掉。
二、第一个步骤完成后，然后再将新文件中的所有节点全部移植到旧文件中，最后视情况，需不需要格式化一下xml文件。
具体规则，就是图中红框处的文件
具体效果，大家可自行尝试，这里不贴效果图了。毕竟眼见为实。
注：不保证该规则适用于所有格式的xml文件，这块需要实地尝试。
三、适用场景
本文这种方式，只适用于代码来生成文件的方式，对于适用maven插件，并不适用，如果需要，这里提供一种无奈方案，就是获取对应源码，替换掉该类，重新编译成jar包，放入到本地仓库里。
代码地址： Mybatis-generate-demo
四、最后
如果还有其它比较好的方案。欢迎交流。
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
转载请注明出处
正文到此结束
- 本文标签： example ACE IO tag update maven sql 需求 Select 参数 删除 一级缓存 stream java node cat 代码 Document mybatis http cache 缓存 mysql tab 数据库 GitHub parse 插件 ask 自动生成 类加载器 源码 tar API 遍历 list core mapper 静态方法 classpath 数据 解析 entity ORM equals 编译 https UI HTML value src constant ArrayList ssl git 配置 App key build message id root shell map CTO XML
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
近期评论
-
文章和留言都翻到11页了 没有OOM
-
-
朋友，翻页到11页，及以后，会出现OOM，无法访问
-
-
搞个gitee的项目
-
-
版本号是多少，你可以下载哪个代码仓库，jdk选1.8 直接跑就行
-
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
