[maven-release-plugin] prepare release V1.0.7

# Conflicts:
#	README.md

README.md

@@ -4,14 +4,16 @@
   
 ---------------------------------------
 插件列表：  
-* 查询单条数据插件（SelectOneByExamplePlugin）
-* MySQL分页插件（LimitPlugin）
-* 数据Model链式构建插件（ModelBuilderPlugin）
-* Example Criteria 增强插件（ExampleEnhancedPlugin（CriteriaBuilderPlugin这个是老版本叫法，已经弃用））
-* Example 目标包修改插件（ExampleTargetPlugin）
-* 批量插入插件（BatchInsertPlugin）
-* 逻辑删除插件（LogicalDeletePlugin）
-* 数据Model属性对应Column获取插件（ModelColumnPlugin）
+* [查询单条数据插件（SelectOneByExamplePlugin）](#1-查询单条数据插件)
+* [MySQL分页插件（LimitPlugin）](#2-mysql分页插件)
+* [数据Model链式构建插件（ModelBuilderPlugin）](#3-数据model链式构建插件)
+* [Example Criteria 增强插件（ExampleEnhancedPlugin）](#4-example-增强插件exampleandiforderby)
+* [Example 目标包修改插件（ExampleTargetPlugin）](#5-example-目标包修改插件)
+* [批量插入插件（BatchInsertPlugin）](#6-批量插入插件)
+* [逻辑删除插件（LogicalDeletePlugin）](#7-逻辑删除插件)
+* [数据Model属性对应Column获取插件（ModelColumnPlugin）](#8-数据model属性对应column获取插件)
+* [存在即更新插件（UpsertPlugin）](#9-存在即更新插件)
+* [Selective选择插入更新增强插件（SelectiveEnhancedPlugin）](#10-selective选择插入更新增强插件)
   
 ---------------------------------------
 Maven引用：  
@@ -19,7 +21,7 @@ Maven引用：
 <dependency>
   <groupId>com.itfsw</groupId>
   <artifactId>mybatis-generator-plugin</artifactId>
-  <version>1.0.5</version>
+  <version>1.0.7</version>
 </dependency>
 ```
 ---------------------------------------
@@ -252,8 +254,10 @@ Mybatis Generator 插件默认把Model类和Example类都生成到一个包下
 </plugin>
 ```
 ### 6. 批量插入插件
-提供了一个批量插入batchInsert方法，因为方法使用了使用了JDBC的getGenereatedKeys方法返回插入主键，所以只能在MYSQL和SQLServer下使用。
-建议配合数据Model属性对应Column获取插件（ModelColumnPlugin）插件使用，会把批量插入方法从batchInsert(@Param("list") List<Tb> list)增强为batchInsert(@Param("list") List<Tb> list, @Param("insertColumns") Tb.Column ... insertColumns)，实现类似于insertSelective插入列！  
+提供了批量插入batchInsert和batchInsertSelective方法，因为方法使用了使用了JDBC的getGenereatedKeys方法返回插入主键，所以只能在MYSQL和SQLServer下使用。
+需配合数据Model属性对应Column获取插件（ModelColumnPlugin）插件使用，实现类似于insertSelective插入列！  
+PS:为了和Mybatis官方代码风格保持一致，1.0.5+版本把批量插入方法分开了，基于老版本1.0.5-版本生成的代码请继续使用“com.itfsw.mybatis.generator.plugins.BatchInsertOldPlugin”不影响使用  
+PS:继续PS，本来想继续保留老版本代码，不影响老版本已经生成代码使用的，但是始终没有绕过BindingException，只能把代码移入BatchInsertOldPlugin类~~~~~  
 插件：
 ```xml
 <!-- 批量插入插件 -->
@@ -284,12 +288,16 @@ public class Test {
         // 普通插入，插入所有列
         this.tbMapper.batchInsert(list);
         // !!!下面按需插入指定列（类似于insertSelective），需要数据Model属性对应Column获取插件（ModelColumnPlugin）插件
-        this.tbMapper.batchInsert(list, Tb.Column.field1, Tb.Column.field2, Tb.Column.field3, Tb.Column.createTime);
+        this.tbMapper.batchInsertSelective(list, Tb.Column.field1, Tb.Column.field2, Tb.Column.field3, Tb.Column.createTime);
     }
 }
 ```
 ### 7. 逻辑删除插件
 因为很多实际项目数据都不允许物理删除，多采用逻辑删除，所以单独为逻辑删除做了一个插件，方便使用。  
+- 增加logicalDeleteByExample和logicalDeleteByPrimaryKey方法；  
+- 查询构造工具中增加逻辑删除条件andDeleted(boolean)； 
+- 增加逻辑删除常量DEL_FLAG_OFF（已删除）、DEL_FLAG_ON（未删除）；
+ 
 插件：
 ```xml
 <xml>
@@ -298,14 +306,17 @@ public class Test {
         <!-- 这里配置的是全局逻辑删除列和逻辑删除值，当然在table中配置的值会覆盖该全局配置 -->
         <!-- 逻辑删除列类型只能为数字、字符串或者布尔类型 -->
         <property name="logicalDeleteColumn" value="del_flag"/>
-        <!-- 未设置该属性或者该属性的值为null或者NULL,逻辑删除时会把该字段置为NULL。 -->
+        <!-- 逻辑删除-已删除值 -->
         <property name="logicalDeleteValue" value="9"/>
+        <!-- 逻辑删除-未删除值 -->
+        <property name="logicalUnDeleteValue" value="0"/>
     </plugin>
     
     <table tableName="tb">
         <!-- 这里可以单独表配置逻辑删除列和删除值，覆盖全局配置 -->
         <property name="logicalDeleteColumn" value="del_flag"/>
         <property name="logicalDeleteValue" value="1"/>
+        <property name="logicalUnDeleteValue" value="-1"/>
     </table>
 </xml>
 ```
@@ -335,13 +346,19 @@ public class Test {
                 .andDelFlagEqualTo(Tb.DEL_FLAG)
                 .example()
         );
+        
+        // 4. 逻辑删除和未删除常量
+        Tb tb = new Tb.Builder()
+                .delFlag(Tb.DEL_FLAG_OFF)   // 删除
+                .delFlag(Tb.DEL_FLAG_ON)    // 未删除
+                .build();
     }
 }
 ```
 ### 8. 数据Model属性对应Column获取插件
 项目中我们有时需要获取数据Model对应数据库字段的名称，一般直接根据数据Model的属性就可以猜出数据库对应column的名字，可是有的时候当column使用了columnOverride或者columnRenamingRule时就需要去看数据库设计了，所以提供了这个插件获取model对应的数据库Column。  
 * 配合Example Criteria 增强插件（ExampleEnhancedPlugin）使用，这个插件还提供了asc()和desc()方法配合Example的orderBy方法效果更佳。
-* 配合批量插入插件（BatchInsertPlugin）使用，批量插入会被增强成batchInsert(@Param("list") List<XXX> list, @Param("insertColumns") XXX.Column ... insertColumns)。  
+* 配合批量插入插件（BatchInsertPlugin）使用，batchInsertSelective(@Param("list") List<XXX> list, @Param("selective") XXX.Column ... insertColumns)。  
 
 插件：
 ```xml
@@ -395,7 +412,122 @@ public class Test {
         // 这个会插入表所有列
         this.tbMapper.batchInsert(list);
         // 下面按需插入指定列（类似于insertSelective）
-        this.tbMapper.batchInsert(list, Tb.Column.field1, Tb.Column.field2, Tb.Column.field3, Tb.Column.createTime);
+        this.tbMapper.batchInsertSelective(list, Tb.Column.field1, Tb.Column.field2, Tb.Column.field3, Tb.Column.createTime);
+    }
+}
+```
+### 9. 存在即更新插件
+1. 使用MySQL的[“insert ... on duplicate key update”](https://dev.mysql.com/doc/refman/5.7/en/insert-on-duplicate.html)实现存在即更新操作，简化数据入库操作（[[issues#2]](https://github.com/itfsw/mybatis-generator-plugin/issues/2)）。  
+2. 在开启allowMultiQueries=true（默认不会开启）情况下支持upsertByExample，upsertByExampleSelective操作，但强力建议不要使用（需保证团队没有使用statement提交sql,否则会存在sql注入风险）（[[issues#2]](https://github.com/itfsw/mybatis-generator-plugin/issues/2)）。
+
+插件：
+```xml
+<!-- 存在即更新插件 -->
+<plugin type="com.itfsw.mybatis.generator.plugins.UpsertPlugin">
+    <!-- 
+    支持upsertByExample，upsertByExampleSelective操作
+    ！需开启allowMultiQueries=true多条sql提交操作，所以不建议使用！
+    -->
+    <property name="allowMultiQueries" value="true"/>
+</plugin>
+```
+使用：  
+```java
+public class Test {
+    public static void main(String[] args) {
+        // 1. 未入库数据入库，执行insert
+        Tb tb = new Tb.Builder()
+                .field1(1)
+                .field2("xx0")
+                .delFlag(Tb.DEL_FLAG_ON)
+                .build();
+        int k0 = this.tbMapper.upsert(tb);
+        // 2. 已入库数据再次入库,执行update（！！需要注意如触发update其返回的受影响行数为2）
+        tb.setField2("xx1");
+        int k1 = this.tbMapper.upsert(tb);
+
+        // 3. 类似insertSelective实现选择入库
+        Tb tb1 = new Tb.Builder()
+                .field1(1)
+                .field2("xx0")
+                .build();
+        int k2 = this.tbMapper.upsertSelective(tb1);
+        tb1.setField2("xx1");
+        int k3 = this.tbMapper.upsertSelective(tb1);
+
+        // 4. 开启allowMultiQueries后增加upsertByExample，upsertByExampleSelective但强力建议不要使用（需保证团队没有使用statement提交sql,否则会存在sql注入风险）
+        Tb tb2 = new Tb.Builder()
+                .field1(1)
+                .field2("xx0")
+                .field3(1003)
+                .delFlag(Tb.DEL_FLAG_ON)
+                .build();
+        int k4 = this.tbMapper.upsertByExample(tb2,
+                new TbExample()
+                        .createCriteria()
+                        .andField3EqualTo(1003)
+                        .example()
+        );
+        tb2.setField2("xx1");
+        // !!! upsertByExample,upsertByExampleSelective触发更新时，更新条数返回是有问题的，这里只会返回0
+        // 这是mybatis自身问题，也是不怎么建议开启allowMultiQueries功能原因之一
+        int k5 = this.tbMapper.upsertByExample(tb2,
+                new TbExample()
+                        .createCriteria()
+                        .andField3EqualTo(1003)
+                        .example()
+        );
+        // upsertByExampleSelective 用法类似
+    }
+}
+```
+### 10. Selective选择插入更新增强插件
+项目中往往需要指定某些字段进行插入或者更新，或者把某些字段进行设置null处理，这种情况下原生xxxSelective方法往往不能达到需求，因为它的判断条件是对象字段是否为null，这种情况下可使用该插件对xxxSelective方法进行增强。  
+WAREN:配置插件时请把插件配置在所有插件末尾最后执行，这样才能把上面提供的某些插件的Selective方法也同时增强！
+
+插件：
+```xml
+<!-- Selective选择插入更新增强插件！请配在所有插件末尾以便最后执行 -->
+<plugin type="com.itfsw.mybatis.generator.plugins.SelectiveEnhancedPlugin"/>
+```
+使用：  
+```java
+public class Test {
+    public static void main(String[] args) {
+        // 1. 指定插入或更新字段
+        Tb tb = new Tb.Builder()
+                .field1(1)
+                .field2("xx2")
+                .field3(1)
+                .field4(new Date())
+                .createTime(new Date())
+                .delFlag(Tb.DEL_FLAG_ON)
+                .build();
+        // 只插入或者更新field1,field2字段
+        this.tbMapper.insertSelective(tb.selective(Tb.Column.field1, Tb.Column.field2));
+        this.tbMapper.updateByExampleSelective(tb.selective(Tb.Column.field1, Tb.Column.field2),
+                new TbExample()
+                        .createCriteria()
+                        .andIdEqualTo(1l)
+                        .example()
+        );
+        this.tbMapper.updateByPrimaryKeySelective(tb.selective(Tb.Column.field1, Tb.Column.field2));
+        this.tbMapper.upsertSelective(tb.selective(Tb.Column.field1, Tb.Column.field2));
+        this.tbMapper.upsertByExampleSelective(tb.selective(Tb.Column.field1, Tb.Column.field2),
+                new TbExample()
+                        .createCriteria()
+                        .andField3EqualTo(1)
+                        .example()
+        );
+
+        // 2. 更新某些字段为null
+        this.tbMapper.updateByPrimaryKeySelective(
+                new Tb.Builder()
+                .id(1l)
+                .field1(null)   // 方便展示，不用设也可以
+                .build()
+                .selective(Tb.Column.field1)
+        );
     }
 }
 ```

pom.xml

@@ -3,7 +3,7 @@
 
     <groupId>com.itfsw</groupId>
     <artifactId>mybatis-generator-plugin</artifactId>
-    <version>1.0.5</version>
+    <version>1.0.7</version>
     <packaging>jar</packaging>
 
     <name>${project.groupId}:${project.artifactId}</name>
@@ -175,7 +175,7 @@
         <connection>scm:git:https://github.com/itfsw/mybatis-generator-plugin.git</connection>
         <developerConnection>scm:git:https://github.com/itfsw/mybatis-generator-plugin.git</developerConnection>
         <url>https://github.com/itfsw/mybatis-generator-plugin</url>
-      <tag>v1.0.5</tag>
+      <tag>V1.0.7</tag>
   </scm>
 
     <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++distribution++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->

src/main/java/com/itfsw/mybatis/generator/plugins/BatchInsertOldPlugin.java

@@ -0,0 +1,302 @@
+/*
+ * Copyright (c) 2017.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.itfsw.mybatis.generator.plugins;
+
+import com.itfsw.mybatis.generator.plugins.utils.BasePlugin;
+import com.itfsw.mybatis.generator.plugins.utils.XmlElementGeneratorTools;
+import org.mybatis.generator.api.IntrospectedColumn;
+import org.mybatis.generator.api.IntrospectedTable;
+import org.mybatis.generator.api.dom.java.*;
+import org.mybatis.generator.api.dom.xml.Attribute;
+import org.mybatis.generator.api.dom.xml.Document;
+import org.mybatis.generator.api.dom.xml.TextElement;
+import org.mybatis.generator.api.dom.xml.XmlElement;
+import org.mybatis.generator.codegen.mybatis3.ListUtilities;
+import org.mybatis.generator.codegen.mybatis3.MyBatis3FormattingUtilities;
+import org.mybatis.generator.config.Context;
+import org.mybatis.generator.config.PluginConfiguration;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * ---------------------------------------------------------------------------
+ * 批量插入插件
+ * ---------------------------------------------------------------------------
+ * @author: hewei
+ * @time:2017/1/13 9:33
+ * ---------------------------------------------------------------------------
+ */
+@Deprecated
+public class BatchInsertOldPlugin extends BasePlugin {
+    public static final String METHOD_BATCH_INSERT = "batchInsert";  // 方法名
+    private boolean hasModelBuilderPlugin;  // 是否配置了ModelBuilderPlugin插件
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean validate(List<String> warnings) {
+        // 插件使用前提是数据库为MySQL或者SQLserver，因为返回主键使用了JDBC的getGenereatedKeys方法获取主键
+        if ("com.mysql.jdbc.Driver".equalsIgnoreCase(this.getContext().getJdbcConnectionConfiguration().getDriverClass()) == false
+                && "com.microsoft.jdbc.sqlserver.SQLServer".equalsIgnoreCase(this.getContext().getJdbcConnectionConfiguration().getDriverClass()) == false
+                && "com.microsoft.sqlserver.jdbc.SQLServerDriver".equalsIgnoreCase(this.getContext().getJdbcConnectionConfiguration().getDriverClass()) == false){
+            logger.warn("itfsw:插件" + this.getClass().getTypeName() + "插件使用前提是数据库为MySQL或者SQLserver，因为返回主键使用了JDBC的getGenereatedKeys方法获取主键！");
+            return false;
+        }
+
+        logger.warn("itfsw:插件" + this.getClass().getTypeName() + "插件已过期，不再维护请使用com.itfsw.mybatis.generator.plugins.BatchInsertPlugin区分batchInsert和batchInsertSelective！");
+
+        return super.validate(warnings);
+    }
+
+    /**
+     * 初始化
+     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
+     *
+     * @param introspectedTable
+     * @return
+     */
+    @Override
+    public void initialized(IntrospectedTable introspectedTable) {
+        // 插件使用前提是使用了ModelColumnPlugin插件
+        Context ctx = getContext();
+        // 利用反射获取pluginConfigurations属性
+        try {
+            java.lang.reflect.Field field = Context.class.getDeclaredField("pluginConfigurations");
+            field.setAccessible(true);
+            List<PluginConfiguration> list = (List<PluginConfiguration>) field.get(ctx);
+            // 检查是否配置了ModelColumnPlugin插件
+            for (PluginConfiguration config: list) {
+                if (ModelColumnPlugin.class.getName().equals(config.getConfigurationType())){
+                    this.hasModelBuilderPlugin = true;
+                }
+            }
+        } catch (Exception e) {
+            logger.error(e.getLocalizedMessage());
+        }
+    }
+
+    /**
+     * Java Client Methods 生成
+     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
+     *
+     * @param interfaze
+     * @param topLevelClass
+     * @param introspectedTable
+     * @return
+     */
+    @Override
+    public boolean clientGenerated(Interface interfaze, TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
+        if (hasModelBuilderPlugin){
+            // 方法生成
+            Method method = new Method(METHOD_BATCH_INSERT);
+            // 返回值类型
+            method.setReturnType(FullyQualifiedJavaType.getIntInstance());
+            // 添加参数
+            FullyQualifiedJavaType type = FullyQualifiedJavaType.getNewListInstance();
+            type.addTypeArgument(introspectedTable.getRules().calculateAllFieldsClass());
+            method.addParameter(new Parameter(type, "list", "@Param(\"list\")"));
+            FullyQualifiedJavaType type1 = new FullyQualifiedJavaType(introspectedTable.getRules().calculateAllFieldsClass().getShortName()+"."+ModelColumnPlugin.ENUM_NAME);
+            method.addParameter(new Parameter(type1, "insertColumns", "@Param(\"insertColumns\")", true));
+            // 添加方法说明
+            commentGenerator.addGeneralMethodComment(method, introspectedTable);
+
+            // interface 增加方法
+            interfaze.addMethod(method);
+            logger.debug("itfsw(批量插入插件):" + interfaze.getType().getShortName() + "增加batchInsert方法。");
+        } else {
+            // 方法生成
+            Method method = new Method(METHOD_BATCH_INSERT);
+            // 方法可见性 interface会忽略
+            // method.setVisibility(JavaVisibility.PUBLIC);
+            // 返回值类型
+            method.setReturnType(FullyQualifiedJavaType.getIntInstance());
+            // 添加参数
+            FullyQualifiedJavaType type = FullyQualifiedJavaType.getNewListInstance();
+            type.addTypeArgument(introspectedTable.getRules().calculateAllFieldsClass());
+            method.addParameter(new Parameter(type, "list", "@Param(\"list\")"));
+            // 添加方法说明
+            commentGenerator.addGeneralMethodComment(method, introspectedTable);
+
+            // interface 增加方法
+            interfaze.addMethod(method);
+            logger.debug("itfsw(批量插入插件):" + interfaze.getType().getShortName() + "增加batchInsert方法。");
+        }
+
+        return true;
+    }
+
+    /**
+     * SQL Map Methods 生成
+     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
+     *
+     * @param document
+     * @param introspectedTable
+     * @return
+     */
+    @Override
+    public boolean sqlMapDocumentGenerated(Document document, IntrospectedTable introspectedTable) {
+        if (hasModelBuilderPlugin){
+            XmlElement element = new XmlElement("insert");
+            element.addAttribute(new Attribute("id", METHOD_BATCH_INSERT));
+            // 参数类型
+            element.addAttribute(new Attribute("parameterType", "map"));
+            // 添加注释(!!!必须添加注释，overwrite覆盖生成时，@see XmlFileMergerJaxp.isGeneratedNode会去判断注释中是否存在OLD_ELEMENT_TAGS中的一点，例子：@mbg.generated)
+            commentGenerator.addComment(element);
+
+            // 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
+            XmlElementGeneratorTools.useGeneratedKeys(element, introspectedTable);
+
+            // choose 节点
+            XmlElement choose = new XmlElement("choose");
+            // when 节点
+            XmlElement when = new XmlElement("when");
+            when.addAttribute(new Attribute("test", "insertColumns.length != 0"));
+            when.addElement(new TextElement("insert into "+introspectedTable.getFullyQualifiedTableNameAtRuntime()+" ("));
+
+            XmlElement foreachInsertColumns = new XmlElement("foreach");
+            foreachInsertColumns.addAttribute(new Attribute("collection", "insertColumns"));
+            foreachInsertColumns.addAttribute(new Attribute("item", "column"));
+            foreachInsertColumns.addAttribute(new Attribute("separator", ","));
+            foreachInsertColumns.addElement(new TextElement("${column.value}"));
+
+            when.addElement(foreachInsertColumns);
+
+            when.addElement(new TextElement(")"));
+
+            // values
+            when.addElement(new TextElement("values"));
+
+            // foreach values
+            XmlElement foreachValues = new XmlElement("foreach");
+            foreachValues.addAttribute(new Attribute("collection", "list"));
+            foreachValues.addAttribute(new Attribute("item", "item"));
+            foreachValues.addAttribute(new Attribute("separator", ","));
+
+            foreachValues.addElement(new TextElement("("));
+
+            // foreach 所有插入的列，比较是否存在
+            XmlElement foreachInsertColumnsCheck = new XmlElement("foreach");
+            foreachInsertColumnsCheck.addAttribute(new Attribute("collection", "insertColumns"));
+            foreachInsertColumnsCheck.addAttribute(new Attribute("item", "column"));
+            foreachInsertColumnsCheck.addAttribute(new Attribute("separator", ","));
+
+            // 所有表字段
+            List<IntrospectedColumn> columns = ListUtilities.removeIdentityAndGeneratedAlwaysColumns(introspectedTable.getAllColumns());
+            for (int i = 0; i < columns.size(); i++) {
+                IntrospectedColumn introspectedColumn = columns.get(i);
+                XmlElement check = new XmlElement("if");
+                check.addAttribute(new Attribute("test", "'"+introspectedColumn.getActualColumnName()+"' == column.value"));
+                check.addElement(new TextElement(MyBatis3FormattingUtilities.getParameterClause(introspectedColumn, "item.")));
+
+                foreachInsertColumnsCheck.addElement(check);
+            }
+            foreachValues.addElement(foreachInsertColumnsCheck);
+
+            foreachValues.addElement(new TextElement(")"));
+
+            when.addElement(foreachValues);
+            choose.addElement(when);
+
+            // 普通不带insertColumns参数实现
+            XmlElement otherwise = new XmlElement("otherwise");
+            this.addNormalBatchInsertXml(otherwise, introspectedTable);
+            choose.addElement(otherwise);
+
+            element.addElement(choose);
+            if (context.getPlugins().sqlMapInsertElementGenerated(element, introspectedTable)) {
+                document.getRootElement().addElement(element);
+                logger.debug("itfsw(批量插入插件):" + introspectedTable.getMyBatis3XmlMapperFileName() + "增加batchInsert实现方法。");
+            }
+        } else {
+            XmlElement element = new XmlElement("insert"); //$NON-NLS-1$
+
+            element.addAttribute(new Attribute("id", METHOD_BATCH_INSERT)); //$NON-NLS-1$
+
+            // 参数类型
+            element.addAttribute(new Attribute("parameterType", FullyQualifiedJavaType.getNewListInstance().getFullyQualifiedName()));
+
+            // 添加注释(!!!必须添加注释，overwrite覆盖生成时，@see XmlFileMergerJaxp.isGeneratedNode会去判断注释中是否存在OLD_ELEMENT_TAGS中的一点，例子：@mbg.generated)
+            commentGenerator.addComment(element);
+
+            // 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
+            XmlElementGeneratorTools.useGeneratedKeys(element, introspectedTable);
+
+            // 普通插入语句
+            this.addNormalBatchInsertXml(element, introspectedTable);
+
+            document.getRootElement().addElement(element);
+            logger.debug("itfsw(批量插入插件):" + introspectedTable.getMyBatis3XmlMapperFileName() + "增加batchInsert实现方法。");
+        }
+        return true;
+    }
+
+    /**
+     * 普通不带insertColumns的插入语句Xml实现
+     *
+     * @param element
+     * @param introspectedTable
+     */
+    private void addNormalBatchInsertXml(XmlElement element, IntrospectedTable introspectedTable) {
+
+        StringBuilder insertClause = new StringBuilder();
+        StringBuilder valuesClause = new StringBuilder();
+
+        insertClause.append("insert into "); //$NON-NLS-1$
+        insertClause.append(introspectedTable.getFullyQualifiedTableNameAtRuntime());
+        insertClause.append(" ("); //$NON-NLS-1$
+
+        valuesClause.append(" ("); //$NON-NLS-1$
+
+        List<String> valuesClauses = new ArrayList<String>();
+        List<IntrospectedColumn> columns = ListUtilities.removeIdentityAndGeneratedAlwaysColumns(introspectedTable.getAllColumns());
+        for (int i = 0; i < columns.size(); i++) {
+            IntrospectedColumn introspectedColumn = columns.get(i);
+
+            insertClause.append(MyBatis3FormattingUtilities.getEscapedColumnName(introspectedColumn));
+
+            // 生成foreach下插入values
+            valuesClause.append(MyBatis3FormattingUtilities.getParameterClause(introspectedColumn, "item."));
+            if (i + 1 < columns.size()) {
+                insertClause.append(", "); //$NON-NLS-1$
+                valuesClause.append(", "); //$NON-NLS-1$
+            }
+        }
+
+        insertClause.append(')');
+        element.addElement(new TextElement(insertClause.toString()));
+
+        valuesClause.append(')');
+        valuesClauses.add(valuesClause.toString());
+
+
+        // 添加foreach节点
+        XmlElement foreachElement = new XmlElement("foreach");
+        foreachElement.addAttribute(new Attribute("collection", "list"));
+        foreachElement.addAttribute(new Attribute("item", "item"));
+        foreachElement.addAttribute(new Attribute("separator", ","));
+
+        for (String clause : valuesClauses) {
+            foreachElement.addElement(new TextElement(clause));
+        }
+
+        // values 构建
+        element.addElement(new TextElement("values"));
+        element.addElement(foreachElement);
+    }
+}

src/main/java/com/itfsw/mybatis/generator/plugins/BatchInsertPlugin.java

@@ -16,10 +16,12 @@
 
 package com.itfsw.mybatis.generator.plugins;
 
-import com.itfsw.mybatis.generator.plugins.utils.CommentTools;
+import com.itfsw.mybatis.generator.plugins.utils.BasePlugin;
+import com.itfsw.mybatis.generator.plugins.utils.JavaElementGeneratorTools;
+import com.itfsw.mybatis.generator.plugins.utils.PluginTools;
+import com.itfsw.mybatis.generator.plugins.utils.XmlElementGeneratorTools;
 import org.mybatis.generator.api.IntrospectedColumn;
 import org.mybatis.generator.api.IntrospectedTable;
-import org.mybatis.generator.api.PluginAdapter;
 import org.mybatis.generator.api.dom.java.*;
 import org.mybatis.generator.api.dom.xml.Attribute;
 import org.mybatis.generator.api.dom.xml.Document;
@@ -27,14 +29,7 @@ import org.mybatis.generator.api.dom.xml.TextElement;
 import org.mybatis.generator.api.dom.xml.XmlElement;
 import org.mybatis.generator.codegen.mybatis3.ListUtilities;
 import org.mybatis.generator.codegen.mybatis3.MyBatis3FormattingUtilities;
-import org.mybatis.generator.config.Context;
-import org.mybatis.generator.config.GeneratedKey;
-import org.mybatis.generator.config.PluginConfiguration;
-import org.mybatis.generator.internal.util.StringUtility;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -45,21 +40,15 @@ import java.util.List;
  * @time:2017/1/13 9:33
  * ---------------------------------------------------------------------------
  */
-public class BatchInsertPlugin extends PluginAdapter {
-    private static final Logger logger = LoggerFactory.getLogger(BatchInsertPlugin.class);
+public class BatchInsertPlugin extends BasePlugin {
     public static final String METHOD_BATCH_INSERT = "batchInsert";  // 方法名
-    private boolean hasModelBuilderPlugin;  // 是否配置了ModelBuilderPlugin插件
+    public static final String METHOD_BATCH_INSERT_SELECTIVE = "batchInsertSelective";  // 方法名
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean validate(List<String> warnings) {
-        // 插件使用前提是targetRuntime为MyBatis3
-        if (StringUtility.stringHasValue(getContext().getTargetRuntime()) && "MyBatis3".equalsIgnoreCase(getContext().getTargetRuntime()) == false) {
-            logger.warn("itfsw:插件" + this.getClass().getTypeName() + "要求运行targetRuntime必须为MyBatis3！");
-            return false;
-        }
 
         // 插件使用前提是数据库为MySQL或者SQLserver，因为返回主键使用了JDBC的getGenereatedKeys方法获取主键
         if ("com.mysql.jdbc.Driver".equalsIgnoreCase(this.getContext().getJdbcConnectionConfiguration().getDriverClass()) == false
@@ -68,35 +57,21 @@ public class BatchInsertPlugin extends PluginAdapter {
             logger.warn("itfsw:插件" + this.getClass().getTypeName() + "插件使用前提是数据库为MySQL或者SQLserver，因为返回主键使用了JDBC的getGenereatedKeys方法获取主键！");
             return false;
         }
-        return true;
+
+
+        // 插件使用前提是使用了ModelColumnPlugin插件
+        if (!PluginTools.checkDependencyPlugin(ModelColumnPlugin.class, getContext())) {
+            logger.warn("itfsw:插件" + this.getClass().getTypeName() + "插件需配合com.itfsw.mybatis.generator.plugins.ModelColumnPlugin插件使用！");
+            return false;
+        }
+
+        // TODO
+        logger.warn("itfsw:插件" + this.getClass().getTypeName() + "插件如之前使用1.0.5-的插件可继续使用com.itfsw.mybatis.generator.plugins.BatchInsertOldPlugin或者修改batchInsert(@Param(\"list\") List<Tb> list, @Param(\"insertColumns\") Tb.Column ... selective)调用为batchInsertSelective！");
+
+        return super.validate(warnings);
     }
 
-    /**
-     * 初始化
-     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
-     *
-     * @param introspectedTable
-     * @return
-     */
-    @Override
-    public void initialized(IntrospectedTable introspectedTable) {
-        // 插件使用前提是使用了ModelColumnPlugin插件
-        Context ctx = getContext();
-        // 利用反射获取pluginConfigurations属性
-        try {
-            java.lang.reflect.Field field = Context.class.getDeclaredField("pluginConfigurations");
-            field.setAccessible(true);
-            List<PluginConfiguration> list = (List<PluginConfiguration>) field.get(ctx);
-            // 检查是否配置了ModelColumnPlugin插件
-            for (PluginConfiguration config: list) {
-                if (ModelColumnPlugin.class.getName().equals(config.getConfigurationType())){
-                    this.hasModelBuilderPlugin = true;
-                }
-            }
-        } catch (Exception e) {
-            logger.error(e.getLocalizedMessage());
-        }
-    }
+
 
     /**
      * Java Client Methods 生成
@@ -109,41 +84,34 @@ public class BatchInsertPlugin extends PluginAdapter {
      */
     @Override
     public boolean clientGenerated(Interface interfaze, TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
-        if (hasModelBuilderPlugin){
-            // 方法生成
-            Method method = new Method(METHOD_BATCH_INSERT);
-            // 返回值类型
-            method.setReturnType(FullyQualifiedJavaType.getIntInstance());
-            // 添加参数
-            FullyQualifiedJavaType type = FullyQualifiedJavaType.getNewListInstance();
-            type.addTypeArgument(introspectedTable.getRules().calculateAllFieldsClass());
-            method.addParameter(new Parameter(type, "list", "@Param(\"list\")"));
-            FullyQualifiedJavaType type1 = new FullyQualifiedJavaType(introspectedTable.getRules().calculateAllFieldsClass().getShortName()+"."+ModelColumnPlugin.ENUM_NAME);
-            method.addParameter(new Parameter(type1, "insertColumns", "@Param(\"insertColumns\")", true));
-            // 添加方法说明
-            CommentTools.addGeneralMethodComment(method, introspectedTable);
+        // 1. batchInsert
+        FullyQualifiedJavaType listType = FullyQualifiedJavaType.getNewListInstance();
+        listType.addTypeArgument(introspectedTable.getRules().calculateAllFieldsClass());
+        Method mBatchInsert = JavaElementGeneratorTools.generateMethod(
+                METHOD_BATCH_INSERT,
+                JavaVisibility.DEFAULT,
+                FullyQualifiedJavaType.getIntInstance(),
+                new Parameter(listType, "list", "@Param(\"list\")")
 
-            // interface 增加方法
-            interfaze.addMethod(method);
-            logger.debug("itfsw(批量插入插件):" + interfaze.getType().getShortName() + "增加batchInsert方法。");
-        } else {
-            // 方法生成
-            Method method = new Method(METHOD_BATCH_INSERT);
-            // 方法可见性 interface会忽略
-            // method.setVisibility(JavaVisibility.PUBLIC);
-            // 返回值类型
-            method.setReturnType(FullyQualifiedJavaType.getIntInstance());
-            // 添加参数
-            FullyQualifiedJavaType type = FullyQualifiedJavaType.getNewListInstance();
-            type.addTypeArgument(introspectedTable.getRules().calculateAllFieldsClass());
-            method.addParameter(new Parameter(type, "list", "@Param(\"list\")"));
-            // 添加方法说明
-            CommentTools.addGeneralMethodComment(method, introspectedTable);
+        );
+        commentGenerator.addGeneralMethodComment(mBatchInsert, introspectedTable);
+        // interface 增加方法
+        interfaze.addMethod(mBatchInsert);
+        logger.debug("itfsw(批量插入插件):" + interfaze.getType().getShortName() + "增加batchInsert方法。");
 
-            // interface 增加方法
-            interfaze.addMethod(method);
-            logger.debug("itfsw(批量插入插件):" + interfaze.getType().getShortName() + "增加batchInsert方法。");
-        }
+        // 2. batchInsertSelective
+        FullyQualifiedJavaType selectiveType = new FullyQualifiedJavaType(introspectedTable.getRules().calculateAllFieldsClass().getShortName()+"."+ModelColumnPlugin.ENUM_NAME);
+        Method mBatchInsertSelective = JavaElementGeneratorTools.generateMethod(
+                METHOD_BATCH_INSERT_SELECTIVE,
+                JavaVisibility.DEFAULT,
+                FullyQualifiedJavaType.getIntInstance(),
+                new Parameter(listType, "list", "@Param(\"list\")"),
+                new Parameter(selectiveType, "selective", "@Param(\"selective\")", true)
+        );
+        commentGenerator.addGeneralMethodComment(mBatchInsertSelective, introspectedTable);
+        // interface 增加方法
+        interfaze.addMethod(mBatchInsertSelective);
+        logger.debug("itfsw(批量插入插件):" + interfaze.getType().getShortName() + "增加batchInsertSelective方法。");
 
         return true;
     }
@@ -158,159 +126,19 @@ public class BatchInsertPlugin extends PluginAdapter {
      */
     @Override
     public boolean sqlMapDocumentGenerated(Document document, IntrospectedTable introspectedTable) {
-        if (hasModelBuilderPlugin){
-            XmlElement element = new XmlElement("insert");
-            element.addAttribute(new Attribute("id", METHOD_BATCH_INSERT));
-            // 参数类型
-            element.addAttribute(new Attribute("parameterType", "map"));
-            // 添加注释(!!!必须添加注释，overwrite覆盖生成时，@see XmlFileMergerJaxp.isGeneratedNode会去判断注释中是否存在OLD_ELEMENT_TAGS中的一点，例子：@mbg.generated)
-            CommentTools.addComment(element);
+        // 1. batchInsert
+        XmlElement batchInsertEle = new XmlElement("insert");
+        batchInsertEle.addAttribute(new Attribute("id", METHOD_BATCH_INSERT));
+        // 参数类型
+        batchInsertEle.addAttribute(new Attribute("parameterType", "map"));
+        // 添加注释(!!!必须添加注释，overwrite覆盖生成时，@see XmlFileMergerJaxp.isGeneratedNode会去判断注释中是否存在OLD_ELEMENT_TAGS中的一点，例子：@mbg.generated)
+        commentGenerator.addComment(batchInsertEle);
 
-            GeneratedKey gk = introspectedTable.getGeneratedKey();
-            if (gk != null) {
-                IntrospectedColumn introspectedColumn = introspectedTable.getColumn(gk.getColumn());
-                // if the column is null, then it's a configuration error. The
-                // warning has already been reported
-                if (introspectedColumn != null) {
-                    // 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
-                    element.addAttribute(new Attribute("useGeneratedKeys", "true")); //$NON-NLS-1$ //$NON-NLS-2$
-                    element.addAttribute(new Attribute("keyProperty", introspectedColumn.getJavaProperty())); //$NON-NLS-1$
-                    element.addAttribute(new Attribute("keyColumn", introspectedColumn.getActualColumnName())); //$NON-NLS-1$
-                }
-            }
-
-            // choose 节点
-            XmlElement choose = new XmlElement("choose");
-            // when 节点
-            XmlElement when = new XmlElement("when");
-            when.addAttribute(new Attribute("test", "insertColumns.length != 0"));
-            when.addElement(new TextElement("insert into "+introspectedTable.getFullyQualifiedTableNameAtRuntime()+" ("));
-
-            XmlElement foreachInsertColumns = new XmlElement("foreach");
-            foreachInsertColumns.addAttribute(new Attribute("collection", "insertColumns"));
-            foreachInsertColumns.addAttribute(new Attribute("item", "column"));
-            foreachInsertColumns.addAttribute(new Attribute("separator", ","));
-            foreachInsertColumns.addElement(new TextElement("${column.value}"));
-
-            when.addElement(foreachInsertColumns);
-
-            when.addElement(new TextElement(")"));
-
-            // values
-            when.addElement(new TextElement("values"));
-
-            // foreach values
-            XmlElement foreachValues = new XmlElement("foreach");
-            foreachValues.addAttribute(new Attribute("collection", "list"));
-            foreachValues.addAttribute(new Attribute("item", "item"));
-            foreachValues.addAttribute(new Attribute("separator", ","));
-
-            foreachValues.addElement(new TextElement("("));
-
-            // foreach 所有插入的列，比较是否存在
-            XmlElement foreachInsertColumnsCheck = new XmlElement("foreach");
-            foreachInsertColumnsCheck.addAttribute(new Attribute("collection", "insertColumns"));
-            foreachInsertColumnsCheck.addAttribute(new Attribute("item", "column"));
-            foreachInsertColumnsCheck.addAttribute(new Attribute("separator", ","));
-
-            // 所有表字段
-            List<IntrospectedColumn> columns = ListUtilities.removeIdentityAndGeneratedAlwaysColumns(introspectedTable.getAllColumns());
-            for (int i = 0; i < columns.size(); i++) {
-                IntrospectedColumn introspectedColumn = columns.get(i);
-                XmlElement check = new XmlElement("if");
-                check.addAttribute(new Attribute("test", "'"+introspectedColumn.getActualColumnName()+"' == column.value"));
-                check.addElement(new TextElement(MyBatis3FormattingUtilities.getParameterClause(introspectedColumn, "item.")));
-
-                foreachInsertColumnsCheck.addElement(check);
-            }
-            foreachValues.addElement(foreachInsertColumnsCheck);
-
-            foreachValues.addElement(new TextElement(")"));
-
-            when.addElement(foreachValues);
-            choose.addElement(when);
-
-            // 普通不带insertColumns参数实现
-            XmlElement otherwise = new XmlElement("otherwise");
-            this.addNormalBatchInsertXml(otherwise, introspectedTable);
-            choose.addElement(otherwise);
-
-            element.addElement(choose);
-            if (context.getPlugins().sqlMapInsertElementGenerated(element, introspectedTable)) {
-                document.getRootElement().addElement(element);
-                logger.debug("itfsw(批量插入插件):" + introspectedTable.getMyBatis3XmlMapperFileName() + "增加batchInsert实现方法。");
-            }
-        } else {
-            XmlElement element = new XmlElement("insert"); //$NON-NLS-1$
-
-            element.addAttribute(new Attribute("id", METHOD_BATCH_INSERT)); //$NON-NLS-1$
-
-            // 参数类型
-            element.addAttribute(new Attribute("parameterType", FullyQualifiedJavaType.getNewListInstance().getFullyQualifiedName()));
-
-            // 添加注释(!!!必须添加注释，overwrite覆盖生成时，@see XmlFileMergerJaxp.isGeneratedNode会去判断注释中是否存在OLD_ELEMENT_TAGS中的一点，例子：@mbg.generated)
-            CommentTools.addComment(element);
-
-            GeneratedKey gk = introspectedTable.getGeneratedKey();
-            if (gk != null) {
-                IntrospectedColumn introspectedColumn = introspectedTable.getColumn(gk.getColumn());
-                // if the column is null, then it's a configuration error. The
-                // warning has already been reported
-                if (introspectedColumn != null) {
-                    // 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
-                    element.addAttribute(new Attribute("useGeneratedKeys", "true")); //$NON-NLS-1$ //$NON-NLS-2$
-                    element.addAttribute(new Attribute("keyProperty", introspectedColumn.getJavaProperty())); //$NON-NLS-1$
-                    element.addAttribute(new Attribute("keyColumn", introspectedColumn.getActualColumnName())); //$NON-NLS-1$
-                }
-            }
-
-            // 普通插入语句
-            this.addNormalBatchInsertXml(element, introspectedTable);
-
-            document.getRootElement().addElement(element);
-            logger.debug("itfsw(批量插入插件):" + introspectedTable.getMyBatis3XmlMapperFileName() + "增加batchInsert实现方法。");
-        }
-        return true;
-    }
-
-    /**
-     * 普通不带insertColumns的插入语句Xml实现
-     *
-     * @param element
-     * @param introspectedTable
-     */
-    private void addNormalBatchInsertXml(XmlElement element, IntrospectedTable introspectedTable) {
-
-        StringBuilder insertClause = new StringBuilder();
-        StringBuilder valuesClause = new StringBuilder();
-
-        insertClause.append("insert into "); //$NON-NLS-1$
-        insertClause.append(introspectedTable.getFullyQualifiedTableNameAtRuntime());
-        insertClause.append(" ("); //$NON-NLS-1$
-
-        valuesClause.append(" ("); //$NON-NLS-1$
-
-        List<String> valuesClauses = new ArrayList<String>();
-        List<IntrospectedColumn> columns = ListUtilities.removeIdentityAndGeneratedAlwaysColumns(introspectedTable.getAllColumns());
-        for (int i = 0; i < columns.size(); i++) {
-            IntrospectedColumn introspectedColumn = columns.get(i);
-
-            insertClause.append(MyBatis3FormattingUtilities.getEscapedColumnName(introspectedColumn));
-
-            // 生成foreach下插入values
-            valuesClause.append(MyBatis3FormattingUtilities.getParameterClause(introspectedColumn, "item."));
-            if (i + 1 < columns.size()) {
-                insertClause.append(", "); //$NON-NLS-1$
-                valuesClause.append(", "); //$NON-NLS-1$
-            }
-        }
-
-        insertClause.append(')');
-        element.addElement(new TextElement(insertClause.toString()));
-
-        valuesClause.append(')');
-        valuesClauses.add(valuesClause.toString());
+        // 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
+        XmlElementGeneratorTools.useGeneratedKeys(batchInsertEle, introspectedTable);
 
+        batchInsertEle.addElement(new TextElement("insert into " + introspectedTable.getFullyQualifiedTableNameAtRuntime()));
+        batchInsertEle.addElement(XmlElementGeneratorTools.generateKeys(ListUtilities.removeIdentityAndGeneratedAlwaysColumns(introspectedTable.getAllColumns())));
 
         // 添加foreach节点
         XmlElement foreachElement = new XmlElement("foreach");
@@ -318,12 +146,80 @@ public class BatchInsertPlugin extends PluginAdapter {
         foreachElement.addAttribute(new Attribute("item", "item"));
         foreachElement.addAttribute(new Attribute("separator", ","));
 
-        for (String clause : valuesClauses) {
-            foreachElement.addElement(new TextElement(clause));
-        }
+        foreachElement.addElement(XmlElementGeneratorTools.generateValues(ListUtilities.removeIdentityAndGeneratedAlwaysColumns(introspectedTable.getAllColumns()), "item."));
+
 
         // values 构建
+        batchInsertEle.addElement(new TextElement("values"));
+        batchInsertEle.addElement(foreachElement);
+        if (context.getPlugins().sqlMapInsertElementGenerated(batchInsertEle, introspectedTable)) {
+            document.getRootElement().addElement(batchInsertEle);
+            logger.debug("itfsw(批量插入插件):" + introspectedTable.getMyBatis3XmlMapperFileName() + "增加batchInsert实现方法。");
+        }
+
+        // 2. batchInsertSelective
+        XmlElement element = new XmlElement("insert");
+        element.addAttribute(new Attribute("id", METHOD_BATCH_INSERT_SELECTIVE));
+        // 参数类型
+        element.addAttribute(new Attribute("parameterType", "map"));
+        // 添加注释(!!!必须添加注释，overwrite覆盖生成时，@see XmlFileMergerJaxp.isGeneratedNode会去判断注释中是否存在OLD_ELEMENT_TAGS中的一点，例子：@mbg.generated)
+        commentGenerator.addComment(element);
+
+        // 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
+        XmlElementGeneratorTools.useGeneratedKeys(element, introspectedTable);
+
+        element.addElement(new TextElement("insert into "+introspectedTable.getFullyQualifiedTableNameAtRuntime()+" ("));
+
+        XmlElement foreachInsertColumns = new XmlElement("foreach");
+        foreachInsertColumns.addAttribute(new Attribute("collection", "selective"));
+        foreachInsertColumns.addAttribute(new Attribute("item", "column"));
+        foreachInsertColumns.addAttribute(new Attribute("separator", ","));
+        foreachInsertColumns.addElement(new TextElement("${column.value}"));
+
+        element.addElement(foreachInsertColumns);
+
+        element.addElement(new TextElement(")"));
+
+        // values
         element.addElement(new TextElement("values"));
-        element.addElement(foreachElement);
+
+        // foreach values
+        XmlElement foreachValues = new XmlElement("foreach");
+        foreachValues.addAttribute(new Attribute("collection", "list"));
+        foreachValues.addAttribute(new Attribute("item", "item"));
+        foreachValues.addAttribute(new Attribute("separator", ","));
+
+        foreachValues.addElement(new TextElement("("));
+
+        // foreach 所有插入的列，比较是否存在
+        XmlElement foreachInsertColumnsCheck = new XmlElement("foreach");
+        foreachInsertColumnsCheck.addAttribute(new Attribute("collection", "selective"));
+        foreachInsertColumnsCheck.addAttribute(new Attribute("item", "column"));
+        foreachInsertColumnsCheck.addAttribute(new Attribute("separator", ","));
+
+        // 所有表字段
+        List<IntrospectedColumn> columns = ListUtilities.removeIdentityAndGeneratedAlwaysColumns(introspectedTable.getAllColumns());
+        List<IntrospectedColumn> columns1 = ListUtilities.removeIdentityAndGeneratedAlwaysColumns(introspectedTable.getAllColumns());
+        for (int i = 0; i < columns1.size(); i++) {
+            IntrospectedColumn introspectedColumn = columns.get(i);
+            XmlElement check = new XmlElement("if");
+            check.addAttribute(new Attribute("test", "'"+introspectedColumn.getActualColumnName()+"' == column.value"));
+            check.addElement(new TextElement(MyBatis3FormattingUtilities.getParameterClause(introspectedColumn, "item.")));
+
+            foreachInsertColumnsCheck.addElement(check);
+        }
+        foreachValues.addElement(foreachInsertColumnsCheck);
+
+        foreachValues.addElement(new TextElement(")"));
+
+        element.addElement(foreachValues);
+
+        if (context.getPlugins().sqlMapInsertElementGenerated(element, introspectedTable)) {
+            document.getRootElement().addElement(element);
+            logger.debug("itfsw(批量插入插件):" + introspectedTable.getMyBatis3XmlMapperFileName() + "增加batchInsertSelective实现方法。");
+        }
+
+        return true;
     }
-}
+
+}

src/main/java/com/itfsw/mybatis/generator/plugins/CriteriaBuilderPlugin.java

@@ -16,9 +16,6 @@
 
 package com.itfsw.mybatis.generator.plugins;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.util.List;
 
 /**
@@ -31,8 +28,6 @@ import java.util.List;
  */
 @Deprecated
 public class CriteriaBuilderPlugin extends ExampleEnhancedPlugin{
-    private static final Logger logger = LoggerFactory.getLogger(CriteriaBuilderPlugin.class);
-
     /**
      * {@inheritDoc}
      */

src/main/java/com/itfsw/mybatis/generator/plugins/ExampleEnhancedPlugin.java

@@ -1,14 +1,11 @@
 package com.itfsw.mybatis.generator.plugins;
 
-import com.itfsw.mybatis.generator.plugins.utils.CommentTools;
-import com.itfsw.mybatis.generator.plugins.utils.InnerInterface;
-import com.itfsw.mybatis.generator.plugins.utils.InnerInterfaceWrapperToInnerClass;
+import com.itfsw.mybatis.generator.plugins.utils.BasePlugin;
+import com.itfsw.mybatis.generator.plugins.utils.JavaElementGeneratorTools;
+import com.itfsw.mybatis.generator.plugins.utils.enhanced.InnerInterface;
+import com.itfsw.mybatis.generator.plugins.utils.enhanced.InnerInterfaceWrapperToInnerClass;
 import org.mybatis.generator.api.IntrospectedTable;
-import org.mybatis.generator.api.PluginAdapter;
 import org.mybatis.generator.api.dom.java.*;
-import org.mybatis.generator.internal.util.StringUtility;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.List;
 
@@ -20,25 +17,11 @@ import java.util.List;
  * @time:2017/1/16 16:28
  * ---------------------------------------------------------------------------
  */
-public class ExampleEnhancedPlugin  extends PluginAdapter {
-    private static final Logger logger = LoggerFactory.getLogger(ExampleEnhancedPlugin.class);
-    /**
-     * {@inheritDoc}
-     */
-    @Override
-    public boolean validate(List<String> warnings) {
-        // 插件使用前提是targetRuntime为MyBatis3
-        if (StringUtility.stringHasValue(getContext().getTargetRuntime()) && "MyBatis3".equalsIgnoreCase(getContext().getTargetRuntime()) == false ){
-            logger.warn("itfsw:插件"+this.getClass().getTypeName()+"要求运行targetRuntime必须为MyBatis3！");
-            return false;
-        }
-        return true;
-    }
+public class ExampleEnhancedPlugin extends BasePlugin {
 
     /**
      * ModelExample Methods 生成
      * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
-     *
      * @param topLevelClass
      * @param introspectedTable
      * @return
@@ -60,7 +43,7 @@ public class ExampleEnhancedPlugin  extends PluginAdapter {
             if (!"createCriteriaInternal".equals(method.getName()))
                 continue;
             method.getBodyLines().set(0, "Criteria criteria = new Criteria(this);");
-            logger.debug("itfsw(Example增强插件):"+topLevelClass.getType().getShortName()+"修改createCriteriaInternal方法，修改构造Criteria时传入Example对象");
+            logger.debug("itfsw(Example增强插件):" + topLevelClass.getType().getShortName() + "修改createCriteriaInternal方法，修改构造Criteria时传入Example对象");
         }
 
         // orderBy方法
@@ -71,15 +54,20 @@ public class ExampleEnhancedPlugin  extends PluginAdapter {
 
     /**
      * 添加工厂方法
-     *
      * @param topLevelClass
      * @param innerClass
      * @param introspectedTable
      */
     private void addFactoryMethodToCriteria(TopLevelClass topLevelClass, InnerClass innerClass, IntrospectedTable introspectedTable) {
-        Field f = new Field("example", topLevelClass.getType());
-        f.setVisibility(JavaVisibility.PRIVATE);
-        innerClass.addField(f);
+        // example field
+        Field exampleField = JavaElementGeneratorTools.generateField(
+                "example",
+                JavaVisibility.PRIVATE,
+                topLevelClass.getType(),
+                null
+        );
+        commentGenerator.addFieldComment(exampleField, introspectedTable);
+        innerClass.addField(exampleField);
 
         // overwrite constructor
         List<Method> methods = innerClass.getMethods();
@@ -87,100 +75,118 @@ public class ExampleEnhancedPlugin  extends PluginAdapter {
             if (method.isConstructor()) {
                 method.addParameter(new Parameter(topLevelClass.getType(), "example"));
                 method.addBodyLine("this.example = example;");
-                logger.debug("itfsw(Example增强插件):"+topLevelClass.getType().getShortName()+"修改构造方法，增加example参数");
+                commentGenerator.addGeneralMethodComment(method, introspectedTable);
+                logger.debug("itfsw(Example增强插件):" + topLevelClass.getType().getShortName() + "修改构造方法，增加example参数");
             }
         }
 
-        // add factory method "example"
-        Method method = new Method("example");
-        method.setVisibility(JavaVisibility.PUBLIC);
-        method.setReturnType(topLevelClass.getType());
-        method.addBodyLine("return this.example;");
-        CommentTools.addGeneralMethodComment(method, introspectedTable);
-        innerClass.addMethod(method);
-        logger.debug("itfsw(Example增强插件):"+topLevelClass.getType().getShortName()+"."+innerClass.getType().getShortName()+"增加工厂方法example");
+        // 添加example工厂方法
+        Method exampleMethod = JavaElementGeneratorTools.generateMethod(
+                "example",
+                JavaVisibility.PUBLIC,
+                topLevelClass.getType()
+        );
+        commentGenerator.addGeneralMethodComment(exampleMethod, introspectedTable);
+        exampleMethod = JavaElementGeneratorTools.generateMethodBody(
+                exampleMethod,
+                "return this.example;"
+        );
+        innerClass.addMethod(exampleMethod);
+        logger.debug("itfsw(Example增强插件):" + topLevelClass.getType().getShortName() + "." + innerClass.getType().getShortName() + "增加工厂方法example");
     }
 
 
     /**
      * 增强Criteria的链式调用，添加andIf(boolean addIf, CriteriaAdd add)方法，实现链式调用中按条件增加查询语句
-     *
      * @param topLevelClass
      * @param innerClass
      * @param introspectedTable
      */
-    private void addAndIfMethodToCriteria(TopLevelClass topLevelClass, InnerClass innerClass, IntrospectedTable introspectedTable){
+    private void addAndIfMethodToCriteria(TopLevelClass topLevelClass, InnerClass innerClass, IntrospectedTable introspectedTable) {
         // 添加接口CriteriaAdd
         InnerInterface criteriaAddInterface = new InnerInterface("ICriteriaAdd");
         criteriaAddInterface.setVisibility(JavaVisibility.PUBLIC);
-        CommentTools.addInterfaceComment(criteriaAddInterface, introspectedTable);
-        logger.debug("itfsw(Example增强插件):"+topLevelClass.getType().getShortName()+"."+innerClass.getType().getShortName()+"增加接口ICriteriaAdd");
+        commentGenerator.addInterfaceComment(criteriaAddInterface, introspectedTable);
+        logger.debug("itfsw(Example增强插件):" + topLevelClass.getType().getShortName() + "." + innerClass.getType().getShortName() + "增加接口ICriteriaAdd");
 
         // ICriteriaAdd增加接口add
-        Method addMethod = new Method("add");
-        addMethod.setReturnType(innerClass.getType());
-        addMethod.addParameter(new Parameter(innerClass.getType(), "add"));
-        CommentTools.addGeneralMethodComment(addMethod, introspectedTable);
+        Method addMethod = JavaElementGeneratorTools.generateMethod(
+                "add",
+                JavaVisibility.DEFAULT,
+                innerClass.getType(),
+                new Parameter(innerClass.getType(), "add")
+        );
+        commentGenerator.addGeneralMethodComment(addMethod, introspectedTable);
         criteriaAddInterface.addMethod(addMethod);
-        logger.debug("itfsw(Example增强插件):"+topLevelClass.getType().getShortName()+"."+innerClass.getType().getShortName()+"."+criteriaAddInterface.getType().getShortName()+"增加方法add");
+        logger.debug("itfsw(Example增强插件):" + topLevelClass.getType().getShortName() + "." + innerClass.getType().getShortName() + "." + criteriaAddInterface.getType().getShortName() + "增加方法add");
 
         InnerClass innerClassWrapper = new InnerInterfaceWrapperToInnerClass(criteriaAddInterface);
         innerClass.addInnerClass(innerClassWrapper);
 
         // 添加andIf方法
-        Method method = new Method("andIf");
-        method.setVisibility(JavaVisibility.PUBLIC);
-        method.setReturnType(innerClass.getType());
-        method.addParameter(new Parameter(FullyQualifiedJavaType.getBooleanPrimitiveInstance(), "ifAdd"));
-        method.addParameter(new Parameter(criteriaAddInterface.getType(), "add"));
-
-        method.addBodyLine("if (ifAdd) {");
-        method.addBodyLine("add.add(this);");
-        method.addBodyLine("}");
-        method.addBodyLine("return this;");
-        CommentTools.addGeneralMethodComment(method, introspectedTable);
-        innerClass.addMethod(method);
-        logger.debug("itfsw(Example增强插件):"+topLevelClass.getType().getShortName()+"."+innerClass.getType().getShortName()+"增加方法andIf");
+        Method andIfMethod = JavaElementGeneratorTools.generateMethod(
+                "andIf",
+                JavaVisibility.PUBLIC,
+                innerClass.getType(),
+                new Parameter(FullyQualifiedJavaType.getBooleanPrimitiveInstance(), "ifAdd"),
+                new Parameter(criteriaAddInterface.getType(), "add")
+        );
+        commentGenerator.addGeneralMethodComment(andIfMethod, introspectedTable);
+        andIfMethod = JavaElementGeneratorTools.generateMethodBody(
+                andIfMethod,
+                "if (ifAdd) {",
+                "add.add(this);",
+                "}",
+                "return this;"
+        );
+        innerClass.addMethod(andIfMethod);
+        logger.debug("itfsw(Example增强插件):" + topLevelClass.getType().getShortName() + "." + innerClass.getType().getShortName() + "增加方法andIf");
     }
 
     /**
      * Example增强了setOrderByClause方法，新增orderBy(String orderByClause)方法直接返回example，增强链式调用，可以一路.下去了。
-     *
      * @param topLevelClass
      * @param introspectedTable
      */
-    private void addOrderByMethodToExample(TopLevelClass topLevelClass, IntrospectedTable introspectedTable){
+    private void addOrderByMethodToExample(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
         // 添加orderBy
-        Method method = new Method("orderBy");
-        method.setVisibility(JavaVisibility.PUBLIC);
-        method.setReturnType(topLevelClass.getType());
-        method.addParameter(new Parameter(FullyQualifiedJavaType.getStringInstance(), "orderByClause"));
-
-        method.addBodyLine("this.setOrderByClause(orderByClause);");
-        method.addBodyLine("return this;");
-
-        CommentTools.addGeneralMethodComment(method, introspectedTable);
-        topLevelClass.addMethod(method);
-        logger.debug("itfsw(Example增强插件):"+topLevelClass.getType().getShortName()+"增加方法orderBy");
+        Method orderByMethod = JavaElementGeneratorTools.generateMethod(
+                "orderBy",
+                JavaVisibility.PUBLIC,
+                topLevelClass.getType(),
+                new Parameter(FullyQualifiedJavaType.getStringInstance(), "orderByClause")
+        );
+        commentGenerator.addGeneralMethodComment(orderByMethod, introspectedTable);
+        orderByMethod = JavaElementGeneratorTools.generateMethodBody(
+                orderByMethod,
+                "this.setOrderByClause(orderByClause);",
+                "return this;"
+        );
+        topLevelClass.addMethod(orderByMethod);
+        logger.debug("itfsw(Example增强插件):" + topLevelClass.getType().getShortName() + "增加方法orderBy");
 
         // 添加orderBy
-        Method mOrderByMore = new Method("orderBy");
-        mOrderByMore.setVisibility(JavaVisibility.PUBLIC);
-        mOrderByMore.setReturnType(topLevelClass.getType());
-        mOrderByMore.addParameter(new Parameter(FullyQualifiedJavaType.getStringInstance(), "orderByClauses", true));
+        Method orderByMethod1 = JavaElementGeneratorTools.generateMethod(
+                "orderBy",
+                JavaVisibility.PUBLIC,
+                topLevelClass.getType(),
+                new Parameter(FullyQualifiedJavaType.getStringInstance(), "orderByClauses", true)
+        );
+        commentGenerator.addGeneralMethodComment(orderByMethod1, introspectedTable);
+        orderByMethod1 = JavaElementGeneratorTools.generateMethodBody(
+                orderByMethod1,
+                "StringBuffer sb = new StringBuffer();",
+                "for (int i = 0; i < orderByClauses.length; i++) {",
+                "sb.append(orderByClauses[i]);",
+                "if (i < orderByClauses.length - 1) {",
+                "sb.append(\" , \");",
+                "}",
+                "}",
+                "this.setOrderByClause(sb.toString());",
+                "return this;"
+        );
 
-        mOrderByMore.addBodyLine("StringBuffer sb = new StringBuffer();");
-        mOrderByMore.addBodyLine("for (int i = 0; i < orderByClauses.length; i++) {");
-        mOrderByMore.addBodyLine("sb.append(orderByClauses[i]);");
-        mOrderByMore.addBodyLine("if (i < orderByClauses.length - 1) {");
-        mOrderByMore.addBodyLine("sb.append(\" , \");");
-        mOrderByMore.addBodyLine("}");
-        mOrderByMore.addBodyLine("}");
-        mOrderByMore.addBodyLine("this.setOrderByClause(sb.toString());");
-        mOrderByMore.addBodyLine("return this;");
-
-        CommentTools.addGeneralMethodComment(mOrderByMore, introspectedTable);
-        topLevelClass.addMethod(mOrderByMore);
-        logger.debug("itfsw(Example增强插件):"+topLevelClass.getType().getShortName()+"增加方法orderBy(String ... orderByClauses)");
+        topLevelClass.addMethod(orderByMethod1);
+        logger.debug("itfsw(Example增强插件):" + topLevelClass.getType().getShortName() + "增加方法orderBy(String ... orderByClauses)");
     }
 }

src/main/java/com/itfsw/mybatis/generator/plugins/ExampleTargetPlugin.java

@@ -18,13 +18,10 @@
 
 package com.itfsw.mybatis.generator.plugins;
 
+import com.itfsw.mybatis.generator.plugins.utils.BasePlugin;
 import org.mybatis.generator.api.IntrospectedTable;
-import org.mybatis.generator.api.PluginAdapter;
 import org.mybatis.generator.config.Context;
 import org.mybatis.generator.config.JavaModelGeneratorConfiguration;
-import org.mybatis.generator.internal.util.StringUtility;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.List;
 import java.util.Properties;
@@ -37,10 +34,8 @@ import java.util.Properties;
  * @time:2017/1/12 12:36
  * ---------------------------------------------------------------------------
  */
-public class ExampleTargetPlugin extends PluginAdapter {
+public class ExampleTargetPlugin extends BasePlugin {
     public static final String TARGET_PACKAGE_KEY = "targetPackage";  // 配置targetPackage名
-    private static final Logger logger = LoggerFactory.getLogger(ExampleTargetPlugin.class);
-
     private static String targetPackage;   // 目标包
 
     /**
@@ -48,11 +43,6 @@ public class ExampleTargetPlugin extends PluginAdapter {
      */
     @Override
     public boolean validate(List<String> warnings) {
-        // 插件使用前提是targetRuntime为MyBatis3
-        if (StringUtility.stringHasValue(getContext().getTargetRuntime()) && "MyBatis3".equalsIgnoreCase(getContext().getTargetRuntime()) == false ){
-            logger.warn("itfsw:插件"+this.getClass().getTypeName()+"要求运行targetRuntime必须为MyBatis3！");
-            return false;
-        }
         // 获取配置的目标package
         Properties properties = getProperties();
         this.targetPackage = properties.getProperty(TARGET_PACKAGE_KEY);
@@ -60,7 +50,7 @@ public class ExampleTargetPlugin extends PluginAdapter {
             logger.warn("请配置com.itfsw.mybatis.generator.plugins.ExampleTargetPlugin插件的目标包名(targetPackage)！");
             return false;
         }
-        return true;
+        return super.validate(warnings);
     }
 
     /**

src/main/java/com/itfsw/mybatis/generator/plugins/LimitPlugin.java

@@ -16,16 +16,13 @@
 
 package com.itfsw.mybatis.generator.plugins;
 
-import com.itfsw.mybatis.generator.plugins.utils.CommentTools;
+import com.itfsw.mybatis.generator.plugins.utils.BasePlugin;
+import com.itfsw.mybatis.generator.plugins.utils.JavaElementGeneratorTools;
 import org.mybatis.generator.api.IntrospectedTable;
-import org.mybatis.generator.api.PluginAdapter;
 import org.mybatis.generator.api.dom.java.*;
 import org.mybatis.generator.api.dom.xml.Attribute;
 import org.mybatis.generator.api.dom.xml.TextElement;
 import org.mybatis.generator.api.dom.xml.XmlElement;
-import org.mybatis.generator.internal.util.StringUtility;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.List;
 
@@ -37,24 +34,18 @@ import java.util.List;
  * @time:2016/12/29 18:14
  * ---------------------------------------------------------------------------
  */
-public class LimitPlugin extends PluginAdapter {
-    private static final Logger logger = LoggerFactory.getLogger(LimitPlugin.class);
+public class LimitPlugin extends BasePlugin {
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean validate(List<String> warnings) {
-        // 插件使用前提是targetRuntime为MyBatis3
-        if (StringUtility.stringHasValue(getContext().getTargetRuntime()) && "MyBatis3".equalsIgnoreCase(getContext().getTargetRuntime()) == false ){
-            logger.warn("itfsw:插件"+this.getClass().getTypeName()+"要求运行targetRuntime必须为MyBatis3！");
-            return false;
-        }
         // 该插件只支持MYSQL
         if ("com.mysql.jdbc.Driver".equalsIgnoreCase(this.getContext().getJdbcConnectionConfiguration().getDriverClass()) == false){
             logger.warn("itfsw:插件"+this.getClass().getTypeName()+"只支持MySQL数据库！");
             return false;
         }
-        return true;
+        return super.validate(warnings);
     }
 
     /**
@@ -69,89 +60,89 @@ public class LimitPlugin extends PluginAdapter {
     public boolean modelExampleClassGenerated(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
         PrimitiveTypeWrapper integerWrapper = FullyQualifiedJavaType.getIntInstance().getPrimitiveTypeWrapper();
         // 添加offset和rows字段
-        Field offset = new Field();
-        offset.setName("offset");
-        offset.setVisibility(JavaVisibility.PROTECTED);
-        offset.setType(integerWrapper);
-        CommentTools.addFieldComment(offset, introspectedTable);
-        topLevelClass.addField(offset);
+        Field offsetField = JavaElementGeneratorTools.generateField(
+                "offset",
+                JavaVisibility.PROTECTED,
+                integerWrapper,
+                null
+        );
+        commentGenerator.addFieldComment(offsetField, introspectedTable);
+        topLevelClass.addField(offsetField);
 
-        Field rows = new Field();
-        rows.setName("rows");
-        rows.setVisibility(JavaVisibility.PROTECTED);
-        rows.setType(integerWrapper);
-        CommentTools.addFieldComment(rows, introspectedTable);
-        topLevelClass.addField(rows);
+        Field rowsField = JavaElementGeneratorTools.generateField(
+                "rows",
+                JavaVisibility.PROTECTED,
+                integerWrapper,
+                null
+        );
+        commentGenerator.addFieldComment(rowsField, introspectedTable);
+        topLevelClass.addField(rowsField);
         logger.debug("itfsw(MySQL分页插件):"+topLevelClass.getType().getShortName()+"增加offset和rows字段");
 
         // 增加getter && setter 方法
-        Method setOffset = new Method();
-        setOffset.setVisibility(JavaVisibility.PUBLIC);
-        setOffset.setName("setOffset");
-        setOffset.addParameter(new Parameter(integerWrapper, "offset"));
-        setOffset.addBodyLine("this.offset = offset;");
-        CommentTools.addGeneralMethodComment(setOffset, introspectedTable);
-        topLevelClass.addMethod(setOffset);
+        Method mSetOffset = JavaElementGeneratorTools.generateSetterMethod(offsetField);
+        commentGenerator.addGeneralMethodComment(mSetOffset, introspectedTable);
+        topLevelClass.addMethod(mSetOffset);
 
-        Method getOffset = new Method();
-        getOffset.setVisibility(JavaVisibility.PUBLIC);
-        getOffset.setReturnType(integerWrapper);
-        getOffset.setName("getOffset");
-        getOffset.addBodyLine("return offset;");
-        CommentTools.addGeneralMethodComment(getOffset, introspectedTable);
-        topLevelClass.addMethod(getOffset);
+        Method mGetOffset = JavaElementGeneratorTools.generateGetterMethod(offsetField);
+        commentGenerator.addGeneralMethodComment(mGetOffset, introspectedTable);
+        topLevelClass.addMethod(mGetOffset);
 
-        Method setRows = new Method();
-        setRows.setVisibility(JavaVisibility.PUBLIC);
-        setRows.setName("setRows");
-        setRows.addParameter(new Parameter(integerWrapper, "rows"));
-        setRows.addBodyLine("this.rows = rows;");
-        CommentTools.addGeneralMethodComment(setRows, introspectedTable);
-        topLevelClass.addMethod(setRows);
+        Method mSetRows = JavaElementGeneratorTools.generateSetterMethod(rowsField);
+        commentGenerator.addGeneralMethodComment(mSetRows, introspectedTable);
+        topLevelClass.addMethod(mSetRows);
 
-        Method getRows = new Method();
-        getRows.setVisibility(JavaVisibility.PUBLIC);
-        getRows.setReturnType(integerWrapper);
-        getRows.setName("getRows");
-        getRows.addBodyLine("return rows;");
-        CommentTools.addGeneralMethodComment(getRows, introspectedTable);
-        topLevelClass.addMethod(getRows);
+        Method mGetRows = JavaElementGeneratorTools.generateGetterMethod(rowsField);
+        commentGenerator.addGeneralMethodComment(mGetRows, introspectedTable);
+        topLevelClass.addMethod(mGetRows);
         logger.debug("itfsw(MySQL分页插件):"+topLevelClass.getType().getShortName()+"增加offset和rows的getter和setter实现。");
 
         // 提供几个快捷方法
-        Method setLimit = new Method();
-        setLimit.setVisibility(JavaVisibility.PUBLIC);
-        setLimit.setReturnType(topLevelClass.getType());
-        setLimit.setName("limit");
-        setLimit.addParameter(new Parameter(integerWrapper, "rows"));
-        setLimit.addBodyLine("this.rows = rows;");
-        setLimit.addBodyLine("return this;");
-        CommentTools.addGeneralMethodComment(setLimit, introspectedTable);
+        Method setLimit = JavaElementGeneratorTools.generateMethod(
+                "limit",
+                JavaVisibility.PUBLIC,
+                topLevelClass.getType(),
+                new Parameter(integerWrapper, "rows")
+        );
+        commentGenerator.addGeneralMethodComment(setLimit, introspectedTable);
+        setLimit = JavaElementGeneratorTools.generateMethodBody(
+                setLimit,
+                "this.rows = rows;",
+                "return this;"
+        );
         topLevelClass.addMethod(setLimit);
 
-        Method setLimit2 = new Method();
-        setLimit2.setVisibility(JavaVisibility.PUBLIC);
-        setLimit2.setReturnType(topLevelClass.getType());
-        setLimit2.setName("limit");
-        setLimit2.addParameter(new Parameter(integerWrapper, "offset"));
-        setLimit2.addParameter(new Parameter(integerWrapper, "rows"));
-        setLimit2.addBodyLine("this.offset = offset;");
-        setLimit2.addBodyLine("this.rows = rows;");
-        setLimit2.addBodyLine("return this;");
-        CommentTools.addGeneralMethodComment(setLimit2, introspectedTable);
+        Method setLimit2 = JavaElementGeneratorTools.generateMethod(
+                "limit",
+                JavaVisibility.PUBLIC,
+                topLevelClass.getType(),
+                new Parameter(integerWrapper, "offset"),
+                new Parameter(integerWrapper, "rows")
+        );
+        commentGenerator.addGeneralMethodComment(setLimit2, introspectedTable);
+        setLimit2 = JavaElementGeneratorTools.generateMethodBody(
+                setLimit2,
+                "this.offset = offset;",
+                "this.rows = rows;",
+                "return this;"
+        );
         topLevelClass.addMethod(setLimit2);
         logger.debug("itfsw(MySQL分页插件):"+topLevelClass.getType().getShortName()+"增加limit方法。");
 
-        Method setPage = new Method();
-        setPage.setVisibility(JavaVisibility.PUBLIC);
-        setPage.setReturnType(topLevelClass.getType());
-        setPage.setName("page");
-        setPage.addParameter(new Parameter(integerWrapper, "page"));
-        setPage.addParameter(new Parameter(integerWrapper, "pageSize"));
-        setPage.addBodyLine("this.offset = page * pageSize;");
-        setPage.addBodyLine("this.rows = pageSize;");
-        setPage.addBodyLine("return this;");
-        CommentTools.addGeneralMethodComment(setPage, introspectedTable);
+        Method setPage = JavaElementGeneratorTools.generateMethod(
+                "page",
+                JavaVisibility.PUBLIC,
+                topLevelClass.getType(),
+                new Parameter(integerWrapper, "page"),
+                new Parameter(integerWrapper, "pageSize")
+        );
+        commentGenerator.addGeneralMethodComment(setPage, introspectedTable);
+        setPage = JavaElementGeneratorTools.generateMethodBody(
+                setPage,
+                "this.offset = page * pageSize;",
+                "this.rows = pageSize;",
+                "return this;"
+        );
         topLevelClass.addMethod(setPage);
         logger.debug("itfsw(MySQL分页插件):"+topLevelClass.getType().getShortName()+"增加page方法");
 

src/main/java/com/itfsw/mybatis/generator/plugins/LogicalDeletePlugin.java

@@ -16,20 +16,17 @@
 
 package com.itfsw.mybatis.generator.plugins;
 
-import com.itfsw.mybatis.generator.plugins.utils.CommentTools;
+import com.itfsw.mybatis.generator.plugins.utils.BasePlugin;
+import com.itfsw.mybatis.generator.plugins.utils.JavaElementGeneratorTools;
 import com.itfsw.mybatis.generator.plugins.utils.XmlElementGeneratorTools;
 import org.mybatis.generator.api.IntrospectedColumn;
 import org.mybatis.generator.api.IntrospectedTable;
-import org.mybatis.generator.api.PluginAdapter;
 import org.mybatis.generator.api.dom.java.*;
 import org.mybatis.generator.api.dom.xml.Attribute;
 import org.mybatis.generator.api.dom.xml.Document;
 import org.mybatis.generator.api.dom.xml.TextElement;
 import org.mybatis.generator.api.dom.xml.XmlElement;
 import org.mybatis.generator.codegen.mybatis3.MyBatis3FormattingUtilities;
-import org.mybatis.generator.internal.util.StringUtility;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.sql.JDBCType;
 import java.util.*;
@@ -42,34 +39,22 @@ import java.util.*;
  * @time:2017/1/13 14:08
  * ---------------------------------------------------------------------------
  */
-public class LogicalDeletePlugin extends PluginAdapter {
-    private static final Logger logger = LoggerFactory.getLogger(LogicalDeletePlugin.class);
-
+public class LogicalDeletePlugin extends BasePlugin {
     public static final String METHOD_LOGICAL_DELETE_BY_EXAMPLE = "logicalDeleteByExample";  // 方法名
     public static final String METHOD_LOGICAL_DELETE_BY_PRIMARY_KEY = "logicalDeleteByPrimaryKey";  // 方法名
 
     public static final String LOGICAL_DELETE_COLUMN_KEY = "logicalDeleteColumn";  // 逻辑删除列-Key
     public static final String LOGICAL_DELETE_VALUE_KEY = "logicalDeleteValue";  // 逻辑删除值-Key
+    public static final String LOGICAL_UN_DELETE_VALUE_KEY = "logicalUnDeleteValue";  // 逻辑删除未删除值-Key
 
-    public static final String DEL_FLAG_NAME = "DEL_FLAG";  // 逻辑删除标志位常量名称
+    public static final String DEL_FLAG_NAME = "DEL_FLAG_OFF";  // 逻辑删除标志位常量名称
+    public static final String UN_DEL_FLAG_NAME = "DEL_FLAG_ON";  // 逻辑删除标志位常量名称(未删除)
 
     public static final String METHOD_LOGICAL_DELETE = "andDeleted"; // 逻辑删除查询方法
 
     private IntrospectedColumn logicalDeleteColumn; // 逻辑删除列
     private String logicalDeleteValue;  // 逻辑删除值
-
-    /**
-     * {@inheritDoc}
-     */
-    @Override
-    public boolean validate(List<String> warnings) {
-        // 插件使用前提是targetRuntime为MyBatis3
-        if (StringUtility.stringHasValue(getContext().getTargetRuntime()) && "MyBatis3".equalsIgnoreCase(getContext().getTargetRuntime()) == false ){
-            logger.warn("itfsw:插件"+this.getClass().getTypeName()+"要求运行targetRuntime必须为MyBatis3！");
-            return false;
-        }
-        return true;
-    }
+    private String logicalUnDeleteValue;    // 逻辑删除值（未删除）
 
     /**
      * 初始化阶段
@@ -84,6 +69,7 @@ public class LogicalDeletePlugin extends PluginAdapter {
         Properties properties = getProperties();
         String logicalDeleteColumn = properties.getProperty(LOGICAL_DELETE_COLUMN_KEY);
         this.logicalDeleteValue = properties.getProperty(LOGICAL_DELETE_VALUE_KEY);
+        this.logicalUnDeleteValue = properties.getProperty(LOGICAL_UN_DELETE_VALUE_KEY);
         // 2. 获取表单独配置，如果有则覆盖全局配置
         if (introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_COLUMN_KEY) != null){
             logicalDeleteColumn = introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_COLUMN_KEY);
@@ -91,6 +77,9 @@ public class LogicalDeletePlugin extends PluginAdapter {
         if (introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_VALUE_KEY) != null){
             this.logicalDeleteValue = introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_VALUE_KEY);
         }
+        if (introspectedTable.getTableConfigurationProperty(LOGICAL_UN_DELETE_VALUE_KEY) != null){
+            this.logicalUnDeleteValue = introspectedTable.getTableConfigurationProperty(LOGICAL_UN_DELETE_VALUE_KEY);
+        }
         // 3. 判断该表是否存在逻辑删除列
         this.logicalDeleteColumn = null;
         List<IntrospectedColumn> columns = introspectedTable.getAllColumns();
@@ -124,6 +113,11 @@ public class LogicalDeletePlugin extends PluginAdapter {
         if (introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_COLUMN_KEY) != null && this.logicalDeleteColumn == null){
             logger.warn("itfsw(逻辑删除插件):"+introspectedTable.getFullyQualifiedTable()+"没有找到您配置的逻辑删除列("+introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_COLUMN_KEY)+")！");
         }
+
+        // 4. 判断逻辑删除值是否配置了
+        if (this.logicalDeleteColumn != null && (this.logicalDeleteValue == null || this.logicalUnDeleteValue == null)){
+            logger.warn("itfsw(逻辑删除插件):"+introspectedTable.getFullyQualifiedTable()+"没有找到您配置的逻辑删除值，请全局或者局部配置logicalDeleteValue和logicalUnDeleteValue值！");
+        }
     }
 
     /**
@@ -146,7 +140,7 @@ public class LogicalDeletePlugin extends PluginAdapter {
             FullyQualifiedJavaType type = new FullyQualifiedJavaType(introspectedTable.getExampleType());
             mLogicalDeleteByExample.addParameter(new Parameter(type, "example"));
             // 添加方法说明
-            CommentTools.addGeneralMethodComment(mLogicalDeleteByExample, introspectedTable);
+            commentGenerator.addGeneralMethodComment(mLogicalDeleteByExample, introspectedTable);
             // interface 增加方法
             interfaze.addMethod(mLogicalDeleteByExample);
             logger.debug("itfsw(逻辑删除插件):"+interfaze.getType().getShortName()+"增加方法logicalDeleteByExample。");
@@ -191,7 +185,7 @@ public class LogicalDeletePlugin extends PluginAdapter {
                 }
 
                 // 添加方法说明
-                CommentTools.addGeneralMethodComment(mLogicalDeleteByPrimaryKey, introspectedTable);
+                commentGenerator.addGeneralMethodComment(mLogicalDeleteByPrimaryKey, introspectedTable);
                 // interface 增加方法
                 interfaze.addImportedTypes(importedTypes);
                 interfaze.addMethod(mLogicalDeleteByPrimaryKey);
@@ -216,7 +210,7 @@ public class LogicalDeletePlugin extends PluginAdapter {
             XmlElement logicalDeleteByExample = new XmlElement("update"); //$NON-NLS-1$
             logicalDeleteByExample.addAttribute(new Attribute("id", METHOD_LOGICAL_DELETE_BY_EXAMPLE));
             logicalDeleteByExample.addAttribute(new Attribute("parameterType", "map")); //$NON-NLS-1$ //$NON-NLS-2$
-            CommentTools.addComment(logicalDeleteByExample);
+            commentGenerator.addComment(logicalDeleteByExample);
 
             StringBuilder sb = new StringBuilder();
             sb.append("update "); //$NON-NLS-1$
@@ -267,7 +261,7 @@ public class LogicalDeletePlugin extends PluginAdapter {
                     }
                 }
                 logicalDeleteByPrimaryKey.addAttribute(new Attribute("parameterType", parameterClass));
-                CommentTools.addComment(logicalDeleteByPrimaryKey);
+                commentGenerator.addComment(logicalDeleteByPrimaryKey);
 
                 StringBuilder sb1 = new StringBuilder();
                 sb1.append("update "); //$NON-NLS-1$
@@ -330,27 +324,50 @@ public class LogicalDeletePlugin extends PluginAdapter {
     @Override
     public boolean modelBaseRecordClassGenerated(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
         if (this.logicalDeleteColumn != null){
-            // 添加删除标志位常量
-            Field field = new Field(DEL_FLAG_NAME, this.logicalDeleteColumn.getFullyQualifiedJavaType());
-            field.setVisibility(JavaVisibility.PUBLIC);
-            field.setStatic(true);
-            field.setFinal(true);
 
-            if (this.logicalDeleteValue == null || "NULL".equalsIgnoreCase(this.logicalDeleteValue)){
-                field.setInitializationString("null");
-            } else if (this.logicalDeleteColumn.getFullyQualifiedJavaType().getShortNameWithoutTypeArguments().equalsIgnoreCase("String")){
-                field.setInitializationString("\"" + this.logicalDeleteValue + "\"");
-            } else if (this.logicalDeleteColumn.getFullyQualifiedJavaType().getShortNameWithoutTypeArguments().equalsIgnoreCase("Boolean")){
-                field.setInitializationString((this.logicalDeleteValue.equals("1") || this.logicalDeleteValue.equalsIgnoreCase("true")) ? "true" : "false");
-            } else {
-                field.setInitializationString(this.logicalDeleteValue);
-            }
-            CommentTools.addFieldComment(field, introspectedTable);
-
-            // 常量插入到第一位
             ArrayList<Field> fields = (ArrayList<Field>) topLevelClass.getFields();
-            fields.add(0, field);
+
+            // TODO 过期的
+            Field field2 = JavaElementGeneratorTools.generateStaticFinalField("DEL_FLAG", this.logicalDeleteColumn.getFullyQualifiedJavaType(), DEL_FLAG_NAME);
+            commentGenerator.addFieldComment(field2, introspectedTable);
+            field2.addAnnotation("@Deprecated");
+            // 常量插入到第一位
+            fields.add(0, field2);
             logger.debug("itfsw(逻辑删除插件):"+topLevelClass.getType().getShortName()+"增加方法DEL_FLAG的常量。");
+
+            // 添加删除标志位常量 DEL_FLAG_OFF
+            String delFlagOnValue;
+            if (this.logicalDeleteValue == null || "NULL".equalsIgnoreCase(this.logicalDeleteValue)){
+                delFlagOnValue = "null";
+            } else if (this.logicalDeleteColumn.getFullyQualifiedJavaType().getShortNameWithoutTypeArguments().equalsIgnoreCase("String")){
+                delFlagOnValue = "\"" + this.logicalDeleteValue + "\"";
+            } else if (this.logicalDeleteColumn.getFullyQualifiedJavaType().getShortNameWithoutTypeArguments().equalsIgnoreCase("Boolean")){
+                delFlagOnValue = (this.logicalDeleteValue.equals("1") || this.logicalDeleteValue.equalsIgnoreCase("true")) ? "true" : "false";
+            } else {
+                delFlagOnValue = this.logicalDeleteValue;
+            }
+            Field field = JavaElementGeneratorTools.generateStaticFinalField(DEL_FLAG_NAME, this.logicalDeleteColumn.getFullyQualifiedJavaType(), delFlagOnValue);
+            commentGenerator.addFieldComment(field, introspectedTable);
+            // 常量插入到第一位
+            fields.add(0, field);
+            logger.debug("itfsw(逻辑删除插件):"+topLevelClass.getType().getShortName()+"增加方法DEL_FLAG_OFF的常量。");
+
+            // 添加删除标志位常量 DEL_FLAG_ON
+            String unDelFlagOnValue;
+            if (this.logicalUnDeleteValue == null || "NULL".equalsIgnoreCase(this.logicalUnDeleteValue)){
+                unDelFlagOnValue = "null";
+            } else if (this.logicalDeleteColumn.getFullyQualifiedJavaType().getShortNameWithoutTypeArguments().equalsIgnoreCase("String")){
+                unDelFlagOnValue = "\"" + this.logicalUnDeleteValue + "\"";
+            } else if (this.logicalDeleteColumn.getFullyQualifiedJavaType().getShortNameWithoutTypeArguments().equalsIgnoreCase("Boolean")){
+                unDelFlagOnValue = (this.logicalUnDeleteValue.equals("1") || this.logicalUnDeleteValue.equalsIgnoreCase("true")) ? "true" : "false";
+            } else {
+                unDelFlagOnValue = this.logicalUnDeleteValue;
+            }
+            Field field1 = JavaElementGeneratorTools.generateStaticFinalField(UN_DEL_FLAG_NAME, this.logicalDeleteColumn.getFullyQualifiedJavaType(), unDelFlagOnValue);
+            commentGenerator.addFieldComment(field1, introspectedTable);
+            // 常量插入到第一位
+            fields.add(0, field1);
+            logger.debug("itfsw(逻辑删除插件):"+topLevelClass.getType().getShortName()+"增加方法DEL_FLAG_ON的常量。");
         }
         return true;
     }
@@ -375,7 +392,7 @@ public class LogicalDeletePlugin extends PluginAdapter {
                 if ("Criteria".equals(innerClass.getType().getShortName())) {
                     // 增加逻辑删除条件
                     Method method = new Method(METHOD_LOGICAL_DELETE);
-                    CommentTools.addGeneralMethodComment(method, introspectedTable);
+                    commentGenerator.addGeneralMethodComment(method, introspectedTable);
                     method.setVisibility(JavaVisibility.PUBLIC);
                     method.setReturnType(innerClass.getType());
                     method.addParameter(new Parameter(FullyQualifiedJavaType.getBooleanPrimitiveInstance(), "deleted"));

src/main/java/com/itfsw/mybatis/generator/plugins/ModelBuilderPlugin.java

@@ -16,15 +16,12 @@
 
 package com.itfsw.mybatis.generator.plugins;
 
-import com.itfsw.mybatis.generator.plugins.utils.CommentTools;
+import com.itfsw.mybatis.generator.plugins.utils.BasePlugin;
+import com.itfsw.mybatis.generator.plugins.utils.JavaElementGeneratorTools;
 import org.mybatis.generator.api.IntrospectedColumn;
 import org.mybatis.generator.api.IntrospectedTable;
-import org.mybatis.generator.api.PluginAdapter;
 import org.mybatis.generator.api.dom.java.*;
 import org.mybatis.generator.internal.util.JavaBeansUtil;
-import org.mybatis.generator.internal.util.StringUtility;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.List;
 
@@ -36,27 +33,12 @@ import java.util.List;
  * @time:2016/12/28 14:56
  * ---------------------------------------------------------------------------
  */
-public class ModelBuilderPlugin extends PluginAdapter {
+public class ModelBuilderPlugin extends BasePlugin {
     public static final String BUILDER_CLASS_NAME = "Builder";  // Builder 类名
-    private static final Logger logger = LoggerFactory.getLogger(ModelBuilderPlugin.class);
-
-    /**
-     * {@inheritDoc}
-     */
-    @Override
-    public boolean validate(List<String> warnings) {
-        // 插件使用前提是targetRuntime为MyBatis3
-        if (StringUtility.stringHasValue(getContext().getTargetRuntime()) && "MyBatis3".equalsIgnoreCase(getContext().getTargetRuntime()) == false ){
-            logger.warn("itfsw:插件"+this.getClass().getTypeName()+"要求运行targetRuntime必须为MyBatis3！");
-            return false;
-        }
-        return true;
-    }
 
     /**
      * Model Methods 生成
      * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
-     *
      * @param topLevelClass
      * @param introspectedTable
      * @return
@@ -69,13 +51,12 @@ public class ModelBuilderPlugin extends PluginAdapter {
         InnerClass innerClass = new InnerClass(BUILDER_CLASS_NAME);
         innerClass.setVisibility(JavaVisibility.PUBLIC);
         innerClass.setStatic(true);
-        CommentTools.addInnerClassComment(innerClass, introspectedTable);
-        logger.debug("itfsw(数据Model链式构建插件):"+topLevelClass.getType().getShortName()+"增加内部Builder类。");
+        commentGenerator.addClassComment(innerClass, introspectedTable);
+        logger.debug("itfsw(数据Model链式构建插件):" + topLevelClass.getType().getShortName() + "增加内部Builder类。");
 
         // 构建内部obj变量
-        Field f = new Field("obj", topLevelClass.getType());
-        f.setVisibility(JavaVisibility.PRIVATE);
-        CommentTools.addFieldComment(f, introspectedTable);
+        Field f = JavaElementGeneratorTools.generateField("obj", JavaVisibility.PRIVATE, topLevelClass.getType(), null);
+        commentGenerator.addFieldComment(f, introspectedTable);
         innerClass.addField(f);
 
         // 构造构造方法
@@ -83,53 +64,40 @@ public class ModelBuilderPlugin extends PluginAdapter {
         constructor.setVisibility(JavaVisibility.PUBLIC);
         constructor.setConstructor(true);
         constructor.addBodyLine(new StringBuilder("this.obj = new ").append(topLevelClass.getType().getShortName()).append("();").toString());
-        CommentTools.addGeneralMethodComment(constructor, introspectedTable);
+        commentGenerator.addGeneralMethodComment(constructor, introspectedTable);
         innerClass.addMethod(constructor);
-        logger.debug("itfsw(数据Model链式构建插件):"+topLevelClass.getType().getShortName()+".Builder增加的构造方法。");
+        logger.debug("itfsw(数据Model链式构建插件):" + topLevelClass.getType().getShortName() + ".Builder增加的构造方法。");
 
-        // ！！可能Model存在复合主键情况，字段要加上这些
-        if (topLevelClass.getSuperClass() != null && topLevelClass.getSuperClass().compareTo(new FullyQualifiedJavaType(introspectedTable.getPrimaryKeyType())) == 0){
-            for (IntrospectedColumn introspectedColumn : introspectedTable.getPrimaryKeyColumns()) {
-                Field field = JavaBeansUtil.getJavaBeansField(introspectedColumn, context, introspectedTable);
-                Method setterMethod = JavaBeansUtil.getJavaBeansSetter(introspectedColumn, context, introspectedTable);
 
-                Method method = new Method(field.getName());
-                method.setVisibility(JavaVisibility.PUBLIC);
-                method.setReturnType(innerClass.getType());
-                method.addParameter(new Parameter(field.getType(), field.getName()));
-                method.addBodyLine(new StringBuilder().append("obj.").append(setterMethod.getName())
-                        .append("(").append(field.getName()).append(");").toString());
-                method.addBodyLine(new StringBuilder().append("return this;").toString());
-                CommentTools.addGeneralMethodComment(method, introspectedTable);
-                innerClass.addMethod(method);
-                logger.debug("itfsw(数据Model链式构建插件):"+topLevelClass.getType().getShortName()+".Builder增加"+method.getName()+"方法(复合主键)。");
-            }
-        }
+        for (IntrospectedColumn introspectedColumn : introspectedTable.getAllColumns()) {
+            Field field = JavaBeansUtil.getJavaBeansField(introspectedColumn, context, introspectedTable);
+            Method setterMethod = JavaBeansUtil.getJavaBeansSetter(introspectedColumn, context, introspectedTable);
 
-        // 根据Model属性生成链式赋值方法
-        for (Field field : fields) {
-            if (field.isStatic())
-                continue;
-
-            Method method = new Method(field.getName());
-            method.setVisibility(JavaVisibility.PUBLIC);
-            method.setReturnType(innerClass.getType());
-            method.addParameter(new Parameter(field.getType(), field.getName()));
-            method.addBodyLine(new StringBuilder().append("obj.").append(field.getName())
-                    .append(" = ").append(field.getName()).append(";").toString());
-            method.addBodyLine(new StringBuilder().append("return this;").toString());
-            CommentTools.addGeneralMethodComment(method, introspectedTable);
+            Method method = JavaElementGeneratorTools.generateMethod(
+                    field.getName(),
+                    JavaVisibility.PUBLIC,
+                    innerClass.getType(),
+                    new Parameter(field.getType(), field.getName())
+            );
+            commentGenerator.addSetterComment(method, introspectedTable, introspectedColumn);
+            method = JavaElementGeneratorTools.generateMethodBody(
+                    method,
+                    "obj." + setterMethod.getName() + "(" + field.getName() + ");",
+                    "return this;"
+            );
             innerClass.addMethod(method);
-            logger.debug("itfsw(数据Model链式构建插件):"+topLevelClass.getType().getShortName()+".Builder增加"+method.getName()+"方法。");
+            logger.debug("itfsw(数据Model链式构建插件):" + topLevelClass.getType().getShortName() + ".Builder增加" + method.getName() + "方法(复合主键)。");
         }
 
-        Method build = new Method("build");
-        build.setReturnType(topLevelClass.getType());
-        build.setVisibility(JavaVisibility.PUBLIC);
+        Method build = JavaElementGeneratorTools.generateMethod(
+                "build",
+                JavaVisibility.PUBLIC,
+                topLevelClass.getType()
+        );
         build.addBodyLine("return this.obj;");
-        CommentTools.addGeneralMethodComment(build, introspectedTable);
+        commentGenerator.addGeneralMethodComment(build, introspectedTable);
         innerClass.addMethod(build);
-        logger.debug("itfsw(数据Model链式构建插件):"+topLevelClass.getType().getShortName()+".Builder增加build方法。");
+        logger.debug("itfsw(数据Model链式构建插件):" + topLevelClass.getType().getShortName() + ".Builder增加build方法。");
 
         topLevelClass.addInnerClass(innerClass);
         return true;

src/main/java/com/itfsw/mybatis/generator/plugins/ModelColumnPlugin.java

@@ -16,15 +16,11 @@
 
 package com.itfsw.mybatis.generator.plugins;
 
-import com.itfsw.mybatis.generator.plugins.utils.CommentTools;
+import com.itfsw.mybatis.generator.plugins.utils.BasePlugin;
 import org.mybatis.generator.api.IntrospectedColumn;
 import org.mybatis.generator.api.IntrospectedTable;
-import org.mybatis.generator.api.PluginAdapter;
 import org.mybatis.generator.api.dom.java.*;
 import org.mybatis.generator.internal.util.JavaBeansUtil;
-import org.mybatis.generator.internal.util.StringUtility;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.List;
 
@@ -36,27 +32,12 @@ import java.util.List;
  * @time:2017/1/17 11:20
  * ---------------------------------------------------------------------------
  */
-public class ModelColumnPlugin  extends PluginAdapter {
+public class ModelColumnPlugin extends BasePlugin {
     public static final String ENUM_NAME = "Column";  // 内部Enum名
-    private static final Logger logger = LoggerFactory.getLogger(ModelColumnPlugin.class);
-
-    /**
-     * {@inheritDoc}
-     */
-    @Override
-    public boolean validate(List<String> warnings) {
-        // 插件使用前提是targetRuntime为MyBatis3
-        if (StringUtility.stringHasValue(getContext().getTargetRuntime()) && "MyBatis3".equalsIgnoreCase(getContext().getTargetRuntime()) == false ){
-            logger.warn("itfsw:插件"+this.getClass().getTypeName()+"要求运行targetRuntime必须为MyBatis3！");
-            return false;
-        }
-        return true;
-    }
 
     /**
      * Model Methods 生成
      * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
-     *
      * @param topLevelClass
      * @param introspectedTable
      * @return
@@ -69,37 +50,37 @@ public class ModelColumnPlugin  extends PluginAdapter {
         InnerEnum innerEnum = new InnerEnum(new FullyQualifiedJavaType(ENUM_NAME));
         innerEnum.setVisibility(JavaVisibility.PUBLIC);
         innerEnum.setStatic(true);
-        CommentTools.addInnerEnumComment(innerEnum, introspectedTable);
-        logger.debug("itfsw(数据Model属性对应Column获取插件):"+topLevelClass.getType().getShortName()+"增加内部Builder类。");
+        commentGenerator.addEnumComment(innerEnum, introspectedTable);
+        logger.debug("itfsw(数据Model属性对应Column获取插件):" + topLevelClass.getType().getShortName() + "增加内部Builder类。");
 
         // 生成属性和构造函数
         Field columnField = new Field("column", FullyQualifiedJavaType.getStringInstance());
         columnField.setVisibility(JavaVisibility.PRIVATE);
         columnField.setFinal(true);
-        CommentTools.addFieldComment(columnField, introspectedTable);
+        commentGenerator.addFieldComment(columnField, introspectedTable);
         innerEnum.addField(columnField);
 
         Method mValue = new Method("value");
         mValue.setVisibility(JavaVisibility.PUBLIC);
         mValue.setReturnType(FullyQualifiedJavaType.getStringInstance());
         mValue.addBodyLine("return this.column;");
-        CommentTools.addGeneralMethodComment(mValue, introspectedTable);
+        commentGenerator.addGeneralMethodComment(mValue, introspectedTable);
         innerEnum.addMethod(mValue);
 
         Method mGetValue = new Method("getValue");
         mGetValue.setVisibility(JavaVisibility.PUBLIC);
         mGetValue.setReturnType(FullyQualifiedJavaType.getStringInstance());
         mGetValue.addBodyLine("return this.column;");
-        CommentTools.addGeneralMethodComment(mGetValue, introspectedTable);
+        commentGenerator.addGeneralMethodComment(mGetValue, introspectedTable);
         innerEnum.addMethod(mGetValue);
 
         Method constructor = new Method(ENUM_NAME);
         constructor.setConstructor(true);
         constructor.addBodyLine("this.column = column;");
         constructor.addParameter(new Parameter(FullyQualifiedJavaType.getStringInstance(), "column"));
-        CommentTools.addGeneralMethodComment(constructor, introspectedTable);
+        commentGenerator.addGeneralMethodComment(constructor, introspectedTable);
         innerEnum.addMethod(constructor);
-        logger.debug("itfsw(数据Model属性对应Column获取插件):"+topLevelClass.getType().getShortName()+".Column增加构造方法和column属性。");
+        logger.debug("itfsw(数据Model属性对应Column获取插件):" + topLevelClass.getType().getShortName() + ".Column增加构造方法和column属性。");
 
         // Enum枚举
         for (IntrospectedColumn introspectedColumn : introspectedTable.getAllColumns()) {
@@ -120,14 +101,14 @@ public class ModelColumnPlugin  extends PluginAdapter {
         desc.setVisibility(JavaVisibility.PUBLIC);
         desc.setReturnType(FullyQualifiedJavaType.getStringInstance());
         desc.addBodyLine("return this.column + \" DESC\";");
-        CommentTools.addGeneralMethodComment(desc, introspectedTable);
+        commentGenerator.addGeneralMethodComment(desc, introspectedTable);
         innerEnum.addMethod(desc);
 
         Method asc = new Method("asc");
         asc.setVisibility(JavaVisibility.PUBLIC);
         asc.setReturnType(FullyQualifiedJavaType.getStringInstance());
         asc.addBodyLine("return this.column + \" ASC\";");
-        CommentTools.addGeneralMethodComment(asc, introspectedTable);
+        commentGenerator.addGeneralMethodComment(asc, introspectedTable);
         innerEnum.addMethod(asc);
         logger.debug("itfsw(数据Model属性对应Column获取插件):" + topLevelClass.getType().getShortName() + ".Column增加asc()和desc()方法。");
 

src/main/java/com/itfsw/mybatis/generator/plugins/SelectOneByExamplePlugin.java

@@ -16,20 +16,15 @@
 
 package com.itfsw.mybatis.generator.plugins;
 
-import com.itfsw.mybatis.generator.plugins.utils.CommentTools;
+import com.itfsw.mybatis.generator.plugins.utils.BasePlugin;
+import com.itfsw.mybatis.generator.plugins.utils.JavaElementGeneratorTools;
 import com.itfsw.mybatis.generator.plugins.utils.XmlElementGeneratorTools;
 import org.mybatis.generator.api.IntrospectedTable;
-import org.mybatis.generator.api.PluginAdapter;
 import org.mybatis.generator.api.dom.java.*;
 import org.mybatis.generator.api.dom.xml.Attribute;
 import org.mybatis.generator.api.dom.xml.Document;
 import org.mybatis.generator.api.dom.xml.TextElement;
 import org.mybatis.generator.api.dom.xml.XmlElement;
-import org.mybatis.generator.internal.util.StringUtility;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.List;
 
 import static org.mybatis.generator.internal.util.StringUtility.stringHasValue;
 
@@ -41,22 +36,8 @@ import static org.mybatis.generator.internal.util.StringUtility.stringHasValue;
  * @time:2016/12/28 14:56
  * ---------------------------------------------------------------------------
  */
-public class SelectOneByExamplePlugin extends PluginAdapter {
-    public static final String METHOD_NAME = "selectOneByExample";  // 方法名
-    private static final Logger logger = LoggerFactory.getLogger(SelectOneByExamplePlugin.class);
-
-    /**
-     * {@inheritDoc}
-     */
-    @Override
-    public boolean validate(List<String> warnings) {
-        // 插件使用前提是targetRuntime为MyBatis3
-        if (StringUtility.stringHasValue(getContext().getTargetRuntime()) && "MyBatis3".equalsIgnoreCase(getContext().getTargetRuntime()) == false ){
-            logger.warn("itfsw:插件"+this.getClass().getTypeName()+"要求运行targetRuntime必须为MyBatis3！");
-            return false;
-        }
-        return true;
-    }
+public class SelectOneByExamplePlugin extends BasePlugin {
+    public static final String METHOD_SELECT_ONE_BY_EXAMPLE = "selectOneByExample";  // 方法名
 
     /**
      * Java Client Methods 生成
@@ -70,17 +51,13 @@ public class SelectOneByExamplePlugin extends PluginAdapter {
     @Override
     public boolean clientGenerated(Interface interfaze, TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
         // 方法生成
-        Method method = new Method(METHOD_NAME);
-        // 方法可见性 interface会忽略
-        // method.setVisibility(JavaVisibility.PUBLIC);
-        // 返回值类型
-        FullyQualifiedJavaType returnType = introspectedTable.getRules().calculateAllFieldsClass();
-        method.setReturnType(returnType);
-        // 添加参数
-        FullyQualifiedJavaType type = new FullyQualifiedJavaType(introspectedTable.getExampleType());
-        method.addParameter(new Parameter(type, "example"));
-        // 添加方法说明
-        CommentTools.addGeneralMethodComment(method, introspectedTable);
+        Method method = JavaElementGeneratorTools.generateMethod(
+                METHOD_SELECT_ONE_BY_EXAMPLE,
+                JavaVisibility.DEFAULT,
+                introspectedTable.getRules().calculateAllFieldsClass(),
+                new Parameter(new FullyQualifiedJavaType(introspectedTable.getExampleType()), "example")
+        );
+commentGenerator.addGeneralMethodComment(method, introspectedTable);
 
         // interface 增加方法
         interfaze.addMethod(method);
@@ -104,10 +81,10 @@ public class SelectOneByExamplePlugin extends PluginAdapter {
         // 生成查询语句
         XmlElement selectOneElement = new XmlElement("select");
         // 添加注释(!!!必须添加注释，overwrite覆盖生成时，@see XmlFileMergerJaxp.isGeneratedNode会去判断注释中是否存在OLD_ELEMENT_TAGS中的一点，例子：@mbg.generated)
-        CommentTools.addComment(selectOneElement);
+        commentGenerator.addComment(selectOneElement);
 
         // 添加ID
-        selectOneElement.addAttribute(new Attribute("id", METHOD_NAME));
+        selectOneElement.addAttribute(new Attribute("id", METHOD_SELECT_ONE_BY_EXAMPLE));
 
         // ----------------------------------------- 表中是否有blob类型字段 ---------------------------------------
         if (introspectedTable.hasBLOBColumns()){

src/main/java/com/itfsw/mybatis/generator/plugins/SelectiveEnhancedPlugin.java

@@ -0,0 +1,293 @@
+/*
+ * Copyright (c) 2017.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.itfsw.mybatis.generator.plugins;
+
+import com.itfsw.mybatis.generator.plugins.utils.BasePlugin;
+import com.itfsw.mybatis.generator.plugins.utils.PluginTools;
+import org.mybatis.generator.api.IntrospectedColumn;
+import org.mybatis.generator.api.IntrospectedTable;
+import org.mybatis.generator.api.dom.java.*;
+import org.mybatis.generator.api.dom.xml.*;
+import org.mybatis.generator.codegen.mybatis3.MyBatis3FormattingUtilities;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * ---------------------------------------------------------------------------
+ * Selective 增强插件
+ * ---------------------------------------------------------------------------
+ * @author: hewei
+ * @time:2017/4/20 15:39
+ * ---------------------------------------------------------------------------
+ */
+public class SelectiveEnhancedPlugin extends BasePlugin {
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean validate(List<String> warnings) {
+
+        // 插件使用前提是使用了ModelColumnPlugin插件
+        if (!PluginTools.checkDependencyPlugin(ModelColumnPlugin.class, getContext())) {
+            logger.warn("itfsw:插件" + this.getClass().getTypeName() + "插件需配合com.itfsw.mybatis.generator.plugins.ModelColumnPlugin插件使用！");
+            return false;
+        }
+
+        // 插件配置位置最好是在末尾
+        if (PluginTools.getConfigPlugins(getContext()).size() - 1 != PluginTools.getPluginIndex(SelectiveEnhancedPlugin.class, getContext())){
+            logger.warn("itfsw:插件" + this.getClass().getTypeName() + "插件建议配置在所有插件末尾以便最后调用，否则某些Selective方法得不到增强！");
+        }
+
+        return super.validate(warnings);
+    }
+
+    /**
+     * Model Methods 生成
+     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
+     * @param topLevelClass
+     * @param introspectedTable
+     * @return
+     */
+    @Override
+    public boolean modelBaseRecordClassGenerated(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
+        // import
+        topLevelClass.addImportedType(FullyQualifiedJavaType.getNewMapInstance());
+        topLevelClass.addImportedType(FullyQualifiedJavaType.getNewHashMapInstance());
+
+        // field
+        Field selectiveColumnsField = new Field("selectiveColumns", new FullyQualifiedJavaType("Map<String, Boolean>"));
+        commentGenerator.addFieldComment(selectiveColumnsField, introspectedTable);
+        selectiveColumnsField.setVisibility(JavaVisibility.PRIVATE);
+        selectiveColumnsField.setInitializationString("new HashMap<String, Boolean>()");
+        topLevelClass.addField(selectiveColumnsField);
+
+        // Method isSelective
+        Method mIsSelective = new Method("isSelective");
+        commentGenerator.addGeneralMethodComment(mIsSelective, introspectedTable);
+        mIsSelective.setVisibility(JavaVisibility.PUBLIC);
+        mIsSelective.setReturnType(FullyQualifiedJavaType.getBooleanPrimitiveInstance());
+        mIsSelective.addBodyLine("return this.selectiveColumns.size() > 0;");
+        topLevelClass.addMethod(mIsSelective);
+
+        // Method isSelective
+        Method mIsSelective1 = new Method("isSelective");
+        commentGenerator.addGeneralMethodComment(mIsSelective1, introspectedTable);
+        mIsSelective1.setVisibility(JavaVisibility.PUBLIC);
+        mIsSelective1.setReturnType(FullyQualifiedJavaType.getBooleanPrimitiveInstance());
+        mIsSelective1.addParameter(new Parameter(FullyQualifiedJavaType.getStringInstance(), "column"));
+        mIsSelective1.addBodyLine("return this.selectiveColumns.get(column) != null;");
+        topLevelClass.addMethod(mIsSelective1);
+
+        // Method selective
+        Method mSelective = new Method("selective");
+        commentGenerator.addGeneralMethodComment(mSelective, introspectedTable);
+        mSelective.setVisibility(JavaVisibility.PUBLIC);
+        mSelective.setReturnType(topLevelClass.getType());
+        mSelective.addParameter(new Parameter(new FullyQualifiedJavaType(ModelColumnPlugin.ENUM_NAME), "columns", true));
+        mSelective.addBodyLine("this.selectiveColumns.clear();");
+        mSelective.addBodyLine("if (columns != null) {");
+        mSelective.addBodyLine("for (" + ModelColumnPlugin.ENUM_NAME + " column : columns) {");
+        mSelective.addBodyLine("this.selectiveColumns.put(column.value(), true);");
+        mSelective.addBodyLine("}");
+        mSelective.addBodyLine("}");
+        mSelective.addBodyLine("return this;");
+        topLevelClass.addMethod(mSelective);
+
+        return true;
+    }
+
+    /**
+     * SQL Map Methods 生成
+     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
+     * @param document
+     * @param introspectedTable
+     * @return
+     */
+    @Override
+    public boolean sqlMapDocumentGenerated(Document document, IntrospectedTable introspectedTable) {
+        List<Element> rootElements = document.getRootElement().getElements();
+        for (Element rootElement : rootElements) {
+            if (rootElement instanceof XmlElement) {
+                XmlElement xmlElement = (XmlElement) rootElement;
+                List<Attribute> attributes = xmlElement.getAttributes();
+                // 查找ID
+                String id = "";
+                for (Attribute attribute : attributes) {
+                    if (attribute.getName().equals("id")) {
+                        id = attribute.getValue();
+                    }
+                }
+
+                // ====================================== 1. insertSelective ======================================
+                if ("insertSelective".equals(id)) {
+                    List<XmlElement> eles = this.findEle(xmlElement, "trim");
+                    for (XmlElement ele : eles) {
+                        this.replaceEle(ele, "_parameter.");
+                    }
+                }
+                // ====================================== 2. updateByExampleSelective ======================================
+                if ("updateByExampleSelective".equals(id)) {
+                    List<XmlElement> eles = this.findEle(xmlElement, "set");
+                    for (XmlElement ele : eles) {
+                        this.replaceEle(ele, "record.");
+                    }
+                }
+                // ====================================== 3. updateByPrimaryKeySelective ======================================
+                if ("updateByPrimaryKeySelective".equals(id)) {
+                    List<XmlElement> eles = this.findEle(xmlElement, "set");
+                    for (XmlElement ele : eles) {
+                        this.replaceEle(ele, "_parameter.");
+                    }
+                }
+                // ====================================== 4. upsertSelective ======================================
+                if ("upsertSelective".equals(id)) {
+                    List<XmlElement> eles = this.findEle(xmlElement, "trim");
+                    for (XmlElement ele : eles) {
+                        this.replaceEle(ele, "_parameter.");
+                    }
+                }
+                // ====================================== 5. upsertByExampleSelective ======================================
+                if ("upsertByExampleSelective".equals(id)) {
+                    List<XmlElement> eles = this.findEle(xmlElement, "trim");
+                    this.replaceEle(eles.get(0), "record.");
+                    // upsertByExampleSelective的第二个trim比较特殊，需另行处理
+                    this.replaceEleForUpsertByExampleSelective(eles.get(1), "record.", introspectedTable);
+
+                    List<XmlElement> eles1 = this.findEle(xmlElement, "set");
+                    for (XmlElement ele : eles1) {
+                        this.replaceEle(ele, "record.");
+                    }
+                }
+
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 查找当前节点下的指定节点
+     * @param element
+     * @param eleName
+     * @return
+     */
+    private List<XmlElement> findEle(XmlElement element, String eleName) {
+        List<XmlElement> list = new ArrayList<>();
+        List<Element> elements = element.getElements();
+        for (Element ele : elements) {
+            if (ele instanceof XmlElement) {
+                XmlElement xmlElement = (XmlElement) ele;
+                if (eleName.equalsIgnoreCase(xmlElement.getName())) {
+                    list.add(xmlElement);
+                }
+            }
+        }
+        return list;
+    }
+
+    /**
+     * 替换节点if信息
+     * @param element
+     * @param prefix
+     */
+    private void replaceEle(XmlElement element, String prefix) {
+        // choose
+        XmlElement chooseEle = new XmlElement("choose");
+        // when
+        XmlElement whenEle = new XmlElement("when");
+        whenEle.addAttribute(new Attribute("test", prefix + "isSelective()"));
+        for (Element ele : element.getElements()) {
+            // if的text节点
+            XmlElement xmlElement = (XmlElement) ele;
+            TextElement textElement = (TextElement) xmlElement.getElements().get(0);
+
+            // 找出field 名称
+            String text = textElement.getContent().trim();
+            String field = "";
+            if (text.matches(".*\\s*=\\s*#\\{.*\\},?")) {
+                Pattern pattern = Pattern.compile("(.*?)\\s*=\\s*#\\{.*},?");
+                Matcher matcher = pattern.matcher(text);
+                if (matcher.find()){
+                    field = matcher.group(1);
+                }
+            } else if (text.matches("#\\{.*\\},?")) {
+                Pattern pattern = Pattern.compile("#\\{(.*?),.*\\},?");
+                Matcher matcher = pattern.matcher(text);
+                if (matcher.find()){
+                    field = matcher.group(1);
+                }
+            } else {
+                field = text.replaceAll(",", "");
+            }
+
+            XmlElement ifEle = new XmlElement("if");
+            ifEle.addAttribute(new Attribute("test", prefix + "isSelective(\'" + field + "\')"));
+            ifEle.addElement(textElement);
+            whenEle.addElement(ifEle);
+        }
+
+        // otherwise
+        XmlElement otherwiseEle = new XmlElement("otherwise");
+        for (Element ele : element.getElements()) {
+            otherwiseEle.addElement(ele);
+        }
+
+        chooseEle.addElement(whenEle);
+        chooseEle.addElement(otherwiseEle);
+
+        // 清空原始节点，新增choose节点
+        element.getElements().clear();
+        element.addElement(chooseEle);
+    }
+
+    /**
+     * 替换节点upsertByExampleSelective if信息
+     * @param element
+     * @param prefix
+     * @param introspectedTable
+     */
+    private void replaceEleForUpsertByExampleSelective(XmlElement element, String prefix, IntrospectedTable introspectedTable) {
+        // choose
+        XmlElement chooseEle = new XmlElement("choose");
+        // when
+        XmlElement whenEle = new XmlElement("when");
+        whenEle.addAttribute(new Attribute("test", prefix + "isSelective()"));
+        for (IntrospectedColumn introspectedColumn : introspectedTable.getAllColumns()) {
+            XmlElement eleIf = new XmlElement("if");
+            eleIf.addAttribute(new Attribute("test", prefix + "isSelective(\'" + MyBatis3FormattingUtilities.getEscapedColumnName(introspectedColumn) + "\')"));
+
+            eleIf.addElement(new TextElement(MyBatis3FormattingUtilities.getParameterClause(introspectedColumn, prefix) + ","));
+            whenEle.addElement(eleIf);
+        }
+
+        // otherwise
+        XmlElement otherwiseEle = new XmlElement("otherwise");
+        for (Element ele : element.getElements()) {
+            otherwiseEle.addElement(ele);
+        }
+
+        chooseEle.addElement(whenEle);
+        chooseEle.addElement(otherwiseEle);
+
+        // 清空原始节点，新增choose节点
+        element.getElements().clear();
+        element.addElement(chooseEle);
+    }
+}

src/main/java/com/itfsw/mybatis/generator/plugins/UpsertPlugin.java

@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) 2017.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.itfsw.mybatis.generator.plugins;
+
+import com.itfsw.mybatis.generator.plugins.utils.BasePlugin;
+import com.itfsw.mybatis.generator.plugins.utils.JavaElementGeneratorTools;
+import com.itfsw.mybatis.generator.plugins.utils.XmlElementGeneratorTools;
+import org.mybatis.generator.api.IntrospectedTable;
+import org.mybatis.generator.api.dom.java.*;
+import org.mybatis.generator.api.dom.xml.Attribute;
+import org.mybatis.generator.api.dom.xml.Document;
+import org.mybatis.generator.api.dom.xml.TextElement;
+import org.mybatis.generator.api.dom.xml.XmlElement;
+import org.mybatis.generator.codegen.mybatis3.ListUtilities;
+import org.mybatis.generator.internal.util.StringUtility;
+
+import java.util.List;
+import java.util.Properties;
+
+/**
+ * ---------------------------------------------------------------------------
+ * 存在即更新插件
+ * ---------------------------------------------------------------------------
+ * @author: hewei
+ * @time:2017/3/21 10:59
+ * ---------------------------------------------------------------------------
+ */
+public class UpsertPlugin extends BasePlugin {
+    public static final String METHOD_UPSERT = "upsert";  // 方法名
+    public static final String METHOD_UPSERT_SELECTIVE = "upsertSelective";  // 方法名
+    public static final String METHOD_UPSERT_BY_EXAMPLE = "upsertByExample";   // 方法名
+    public static final String METHOD_UPSERT_BY_EXAMPLE_SELECTIVE = "upsertByExampleSelective";   // 方法名
+
+    public static final String PRE_ALLOW_MULTI_QUERIES = "allowMultiQueries";   // property allowMultiQueries
+    private boolean allowMultiQueries = false;  // 是否允许多sql提交
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean validate(List<String> warnings) {
+
+        // 插件使用前提是数据库为MySQL
+        if ("com.mysql.jdbc.Driver".equalsIgnoreCase(this.getContext().getJdbcConnectionConfiguration().getDriverClass()) == false){
+            logger.warn("itfsw:插件" + this.getClass().getTypeName() + "插件使用前提是数据库为MySQL！");
+            return false;
+        }
+
+        // 插件是否开启了多sql提交
+        Properties properties = this.getProperties();
+        String allowMultiQueries = properties.getProperty(PRE_ALLOW_MULTI_QUERIES);
+        this.allowMultiQueries = allowMultiQueries == null ? false : StringUtility.isTrue(allowMultiQueries);
+        if (this.allowMultiQueries){
+            // 提示用户注意信息
+            logger.warn("itfsw:插件" + this.getClass().getTypeName() + "插件您开启了allowMultiQueries支持，注意在jdbc url 配置中增加“allowMultiQueries=true”支持（不怎么建议使用该功能，开启多sql提交会增加sql注入的风险，请确保你所有sql都使用MyBatis书写，请不要使用statement进行sql提交）！");
+        }
+
+        return super.validate(warnings);
+    }
+
+    /**
+     * Java Client Methods 生成
+     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
+     *
+     * @param interfaze
+     * @param topLevelClass
+     * @param introspectedTable
+     * @return
+     */
+    @Override
+    public boolean clientGenerated(Interface interfaze, TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
+        // ====================================== 1. upsert ======================================
+        Method mUpsert = JavaElementGeneratorTools.generateMethod(
+                METHOD_UPSERT,
+                JavaVisibility.DEFAULT,
+                FullyQualifiedJavaType.getIntInstance(),
+                new Parameter(introspectedTable.getRules().calculateAllFieldsClass(), "record")
+        );
+        commentGenerator.addGeneralMethodComment(mUpsert, introspectedTable);
+        // interface 增加方法
+        interfaze.addMethod(mUpsert);
+        logger.debug("itfsw(存在即更新插件):" + interfaze.getType().getShortName() + "增加upsert方法。");
+
+        // ====================================== 2. upsertSelective ======================================
+        Method mUpsertSelective = JavaElementGeneratorTools.generateMethod(
+                METHOD_UPSERT_SELECTIVE,
+                JavaVisibility.DEFAULT,
+                FullyQualifiedJavaType.getIntInstance(),
+                new Parameter(introspectedTable.getRules().calculateAllFieldsClass(), "record")
+        );
+        commentGenerator.addGeneralMethodComment(mUpsertSelective, introspectedTable);
+        // interface 增加方法
+        interfaze.addMethod(mUpsertSelective);
+        logger.debug("itfsw(存在即更新插件):" + interfaze.getType().getShortName() + "增加upsertSelective方法。");
+
+        if (this.allowMultiQueries){
+            // ====================================== 3. upsertByExample ======================================
+            Method mUpsertByExample = JavaElementGeneratorTools.generateMethod(
+                    METHOD_UPSERT_BY_EXAMPLE,
+                    JavaVisibility.DEFAULT,
+                    FullyQualifiedJavaType.getIntInstance(),
+                    new Parameter(introspectedTable.getRules().calculateAllFieldsClass(), "record", "@Param(\"record\")"),
+                    new Parameter(new FullyQualifiedJavaType(introspectedTable.getExampleType()), "example", "@Param(\"example\")")
+            );
+            commentGenerator.addGeneralMethodComment(mUpsertByExample, introspectedTable);
+            // interface 增加方法
+            interfaze.addMethod(mUpsertByExample);
+            logger.debug("itfsw(存在即更新插件):" + interfaze.getType().getShortName() + "增加upsertByExample方法。");
+
+            // ====================================== 4. upsertByExampleSelective ======================================
+            Method mUpsertByExampleSelective = JavaElementGeneratorTools.generateMethod(
+                    METHOD_UPSERT_BY_EXAMPLE_SELECTIVE,
+                    JavaVisibility.DEFAULT,
+                    FullyQualifiedJavaType.getIntInstance(),
+                    new Parameter(introspectedTable.getRules().calculateAllFieldsClass(), "record", "@Param(\"record\")"),
+                    new Parameter(new FullyQualifiedJavaType(introspectedTable.getExampleType()), "example", "@Param(\"example\")")
+            );
+            commentGenerator.addGeneralMethodComment(mUpsertByExampleSelective, introspectedTable);
+            // interface 增加方法
+            interfaze.addMethod(mUpsertByExampleSelective);
+            logger.debug("itfsw(存在即更新插件):" + interfaze.getType().getShortName() + "增加upsertByExampleSelective方法。");
+        }
+
+        return true;
+    }
+
+    /**
+     * SQL Map Methods 生成
+     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
+     *
+     * @param document
+     * @param introspectedTable
+     * @return
+     */
+    @Override
+    public boolean sqlMapDocumentGenerated(Document document, IntrospectedTable introspectedTable) {
+
+        // ====================================== 1. upsert ======================================
+        XmlElement eleUpsert = new XmlElement("insert");
+        eleUpsert.addAttribute(new Attribute("id", METHOD_UPSERT));
+        // 添加注释(!!!必须添加注释，overwrite覆盖生成时，@see XmlFileMergerJaxp.isGeneratedNode会去判断注释中是否存在OLD_ELEMENT_TAGS中的一点，例子：@mbg.generated)
+        commentGenerator.addComment(eleUpsert);
+
+        // 参数类型
+        eleUpsert.addAttribute(new Attribute("parameterType", introspectedTable.getRules().calculateAllFieldsClass().getFullyQualifiedName()));
+
+        // 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
+        XmlElementGeneratorTools.useGeneratedKeys(eleUpsert, introspectedTable);
+
+        // insert
+        eleUpsert.addElement(new TextElement("insert into " + introspectedTable.getFullyQualifiedTableNameAtRuntime()));
+        eleUpsert.addElement(XmlElementGeneratorTools.generateKeys(introspectedTable.getAllColumns()));
+        eleUpsert.addElement(new TextElement("values"));
+        eleUpsert.addElement(XmlElementGeneratorTools.generateValues(introspectedTable.getAllColumns()));
+        eleUpsert.addElement(new TextElement("on duplicate key update "));
+        eleUpsert.addElement(XmlElementGeneratorTools.generateSets(introspectedTable.getAllColumns()));
+
+        document.getRootElement().addElement(eleUpsert);
+        logger.debug("itfsw(存在即更新插件):" + introspectedTable.getMyBatis3XmlMapperFileName() + "增加upsert实现方法。");
+
+        // ====================================== 2. upsertSelective ======================================
+        XmlElement eleUpsertSelective = new XmlElement("insert");
+        eleUpsertSelective.addAttribute(new Attribute("id", METHOD_UPSERT_SELECTIVE));
+        // 添加注释(!!!必须添加注释，overwrite覆盖生成时，@see XmlFileMergerJaxp.isGeneratedNode会去判断注释中是否存在OLD_ELEMENT_TAGS中的一点，例子：@mbg.generated)
+        commentGenerator.addComment(eleUpsertSelective);
+
+        // 参数类型
+        eleUpsertSelective.addAttribute(new Attribute("parameterType", introspectedTable.getRules().calculateAllFieldsClass().getFullyQualifiedName()));
+
+        // 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
+        XmlElementGeneratorTools.useGeneratedKeys(eleUpsertSelective, introspectedTable);
+
+        // insert
+        eleUpsertSelective.addElement(new TextElement("insert into " + introspectedTable.getFullyQualifiedTableNameAtRuntime()));
+        eleUpsertSelective.addElement(XmlElementGeneratorTools.generateKeysSelective(introspectedTable.getAllColumns()));
+        eleUpsertSelective.addElement(new TextElement("values"));
+        eleUpsertSelective.addElement(XmlElementGeneratorTools.generateValuesSelective(introspectedTable.getAllColumns()));
+        eleUpsertSelective.addElement(new TextElement("on duplicate key update "));
+        eleUpsertSelective.addElement(XmlElementGeneratorTools.generateSetsSelective(introspectedTable.getAllColumns(), null, false));
+
+        document.getRootElement().addElement(eleUpsertSelective);
+        logger.debug("itfsw(存在即更新插件):" + introspectedTable.getMyBatis3XmlMapperFileName() + "增加upsertSelective实现方法。");
+
+        if (this.allowMultiQueries){
+            // ====================================== 2. upsertByExample ======================================
+            XmlElement eleUpsertByExample = new XmlElement("insert");
+            eleUpsertByExample.addAttribute(new Attribute("id", METHOD_UPSERT_BY_EXAMPLE));
+            // 参数类型
+            eleUpsertByExample.addAttribute(new Attribute("parameterType", "map"));
+            // 添加注释(!!!必须添加注释，overwrite覆盖生成时，@see XmlFileMergerJaxp.isGeneratedNode会去判断注释中是否存在OLD_ELEMENT_TAGS中的一点，例子：@mbg.generated)
+            commentGenerator.addComment(eleUpsertByExample);
+
+            // 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
+            XmlElementGeneratorTools.useGeneratedKeys(eleUpsertByExample, introspectedTable, "record.");
+
+            // insert
+            eleUpsertByExample.addElement(new TextElement("insert into " + introspectedTable.getFullyQualifiedTableNameAtRuntime()));
+            eleUpsertByExample.addElement(XmlElementGeneratorTools.generateKeys(introspectedTable.getAllColumns()));
+            this.generateExistsClause(introspectedTable, eleUpsertByExample, false);
+
+            // multiQueries
+            eleUpsertByExample.addElement(new TextElement(";"));
+
+            // update
+            eleUpsertByExample.addElement(new TextElement("update " + introspectedTable.getAliasedFullyQualifiedTableNameAtRuntime()));
+            eleUpsertByExample.addElement(new TextElement("set"));
+            eleUpsertByExample.addElement(XmlElementGeneratorTools.generateSets(ListUtilities.removeIdentityAndGeneratedAlwaysColumns(introspectedTable.getAllColumns()), "record."));
+            // update where
+            eleUpsertByExample.addElement(XmlElementGeneratorTools.getUpdateByExampleIncludeElement(introspectedTable));
+
+            document.getRootElement().addElement(eleUpsertByExample);
+            logger.debug("itfsw(存在即更新插件):" + introspectedTable.getMyBatis3XmlMapperFileName() + "增加upsertSelective实现方法。");
+
+            // ====================================== 4. upsertByExampleSelective ======================================
+            XmlElement eleUpsertByExampleSelective = new XmlElement("insert");
+            eleUpsertByExampleSelective.addAttribute(new Attribute("id", METHOD_UPSERT_BY_EXAMPLE_SELECTIVE));
+            // 参数类型
+            eleUpsertByExampleSelective.addAttribute(new Attribute("parameterType", "map"));
+            // 添加注释(!!!必须添加注释，overwrite覆盖生成时，@see XmlFileMergerJaxp.isGeneratedNode会去判断注释中是否存在OLD_ELEMENT_TAGS中的一点，例子：@mbg.generated)
+            commentGenerator.addComment(eleUpsertByExampleSelective);
+
+            // 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
+            XmlElementGeneratorTools.useGeneratedKeys(eleUpsertByExampleSelective, introspectedTable, "record.");
+
+            // insert
+            eleUpsertByExampleSelective.addElement(new TextElement("insert into " + introspectedTable.getFullyQualifiedTableNameAtRuntime()));
+            eleUpsertByExampleSelective.addElement(XmlElementGeneratorTools.generateKeysSelective(introspectedTable.getAllColumns(), "record."));
+            this.generateExistsClause(introspectedTable, eleUpsertByExampleSelective, true);
+
+            // multiQueries
+            eleUpsertByExampleSelective.addElement(new TextElement(";"));
+
+            // update
+            eleUpsertByExampleSelective.addElement(new TextElement("update " + introspectedTable.getAliasedFullyQualifiedTableNameAtRuntime()));
+            eleUpsertByExampleSelective.addElement(new TextElement("set"));
+            eleUpsertByExampleSelective.addElement(XmlElementGeneratorTools.generateSetsSelective(ListUtilities.removeIdentityAndGeneratedAlwaysColumns(introspectedTable.getAllColumns()), "record."));
+
+            // update where
+            eleUpsertByExampleSelective.addElement(XmlElementGeneratorTools.getUpdateByExampleIncludeElement(introspectedTable));
+
+            document.getRootElement().addElement(eleUpsertByExampleSelective);
+            logger.debug("itfsw(存在即更新插件):" + introspectedTable.getMyBatis3XmlMapperFileName() + "增加upsertSelective实现方法。");
+        }
+
+        return true;
+    }
+
+    /**
+     * exists 语句
+     *
+     * @param introspectedTable
+     * @param element
+     * @param selective
+     */
+    private void generateExistsClause(IntrospectedTable introspectedTable, XmlElement element, boolean selective){
+        element.addElement(new TextElement("select"));
+        if (selective){
+            element.addElement(XmlElementGeneratorTools.generateValuesSelective(introspectedTable.getAllColumns(), "record.", false));
+        } else {
+            element.addElement(XmlElementGeneratorTools.generateValues(introspectedTable.getAllColumns(), "record.", false));
+        }
+        element.addElement(new TextElement("from dual where not exists"));
+        element.addElement(new TextElement("("));
+        element.addElement(new TextElement("select 1 from " + introspectedTable.getFullyQualifiedTableNameAtRuntime()));
+
+        // if example
+        element.addElement(XmlElementGeneratorTools.getUpdateByExampleIncludeElement(introspectedTable));
+
+        element.addElement(new TextElement(")"));
+    }
+
+}

src/main/java/com/itfsw/mybatis/generator/plugins/utils/BasePlugin.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2017.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.itfsw.mybatis.generator.plugins.utils;
+
+import com.itfsw.mybatis.generator.plugins.utils.enhanced.IWCommentGenerator;
+import org.mybatis.generator.api.PluginAdapter;
+import org.mybatis.generator.internal.util.StringUtility;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+
+/**
+ * ---------------------------------------------------------------------------
+ * 基础plugin
+ * ---------------------------------------------------------------------------
+ * @author: hewei
+ * @time:2017/4/28 13:57
+ * ---------------------------------------------------------------------------
+ */
+public class BasePlugin extends PluginAdapter {
+    protected static final Logger logger = LoggerFactory.getLogger(BasePlugin.class); // 日志
+    protected IWCommentGenerator commentGenerator = new IWCommentGenerator();  // 注释工具
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean validate(List<String> warnings) {
+        // 插件使用前提是targetRuntime为MyBatis3
+        if (StringUtility.stringHasValue(getContext().getTargetRuntime()) && "MyBatis3".equalsIgnoreCase(getContext().getTargetRuntime()) == false) {
+            logger.warn("itfsw:插件" + this.getClass().getTypeName() + "要求运行targetRuntime必须为MyBatis3！");
+            return false;
+        }
+
+        return true;
+    }
+}

src/main/java/com/itfsw/mybatis/generator/plugins/utils/CommentTools.java

@@ -1,151 +0,0 @@
-/*
- * Copyright (c) 2017.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.itfsw.mybatis.generator.plugins.utils;
-
-import org.mybatis.generator.api.IntrospectedTable;
-import org.mybatis.generator.api.dom.java.*;
-import org.mybatis.generator.api.dom.xml.TextElement;
-import org.mybatis.generator.api.dom.xml.XmlElement;
-import org.mybatis.generator.config.MergeConstants;
-
-/**
- * ---------------------------------------------------------------------------
- * 插件评论生成工具
- * ---------------------------------------------------------------------------
- * @author: hewei
- * @time:2016/12/28 17:57
- * ---------------------------------------------------------------------------
- */
-public class CommentTools {
-
-    /**
-     * 生成通用属性注解
-     *
-     * @param field
-     * @param introspectedTable
-     */
-    public static void addFieldComment(Field field, IntrospectedTable introspectedTable) {
-        StringBuilder sb = new StringBuilder();
-        field.addJavaDocLine("/**"); //$NON-NLS-1$
-        field.addJavaDocLine(" * 这是Mybatis Generator拓展插件生成的属性(请勿删除)."); //$NON-NLS-1$
-        sb.append(" * This field corresponds to the database table "); //$NON-NLS-1$
-        sb.append(introspectedTable.getFullyQualifiedTable());
-        field.addJavaDocLine(sb.toString());
-
-        field.addJavaDocLine(" *");
-        field.addJavaDocLine(" * "+MergeConstants.NEW_ELEMENT_TAG);
-        field.addJavaDocLine(" * @author hewei");
-
-        field.addJavaDocLine(" */"); //$NON-NLS-1$
-    }
-
-    /**
-     * 生成通用内部类注解
-     *
-     * @param innerClass 类
-     * @param introspectedTable 表
-     */
-    public static void addInnerClassComment(InnerClass innerClass, IntrospectedTable introspectedTable) {
-        StringBuilder sb = new StringBuilder();
-        innerClass.addJavaDocLine("/**"); //$NON-NLS-1$
-        innerClass.addJavaDocLine(" * 这是Mybatis Generator拓展插件生成的类(请勿删除)."); //$NON-NLS-1$
-        sb.append(" * This class corresponds to the database table "); //$NON-NLS-1$
-        sb.append(introspectedTable.getFullyQualifiedTable());
-        innerClass.addJavaDocLine(sb.toString());
-        innerClass.addJavaDocLine(" *");
-        innerClass.addJavaDocLine(" * "+MergeConstants.NEW_ELEMENT_TAG);
-        innerClass.addJavaDocLine(" * @author hewei");
-        innerClass.addJavaDocLine(" */"); //$NON-NLS-1$
-    }
-
-    /**
-     * 生成通用内部Enum注释
-     *
-     * @param innerEnum 类
-     * @param introspectedTable 表
-     */
-    public static void addInnerEnumComment(InnerEnum innerEnum, IntrospectedTable introspectedTable) {
-        StringBuilder sb = new StringBuilder();
-        innerEnum.addJavaDocLine("/**"); //$NON-NLS-1$
-        innerEnum.addJavaDocLine(" * 这是Mybatis Generator拓展插件生成的枚举(请勿删除)."); //$NON-NLS-1$
-        sb.append(" * This class corresponds to the database table "); //$NON-NLS-1$
-        sb.append(introspectedTable.getFullyQualifiedTable());
-        innerEnum.addJavaDocLine(sb.toString());
-        innerEnum.addJavaDocLine(" *");
-        innerEnum.addJavaDocLine(" * "+MergeConstants.NEW_ELEMENT_TAG);
-        innerEnum.addJavaDocLine(" * @author hewei");
-        innerEnum.addJavaDocLine(" */"); //$NON-NLS-1$
-    }
-
-    /**
-     * 生成通用方法注解
-     *
-     * @param method 方法
-     * @param introspectedTable 表
-     */
-    public static void addGeneralMethodComment(Method method, IntrospectedTable introspectedTable) {
-        StringBuilder sb = new StringBuilder();
-        method.addJavaDocLine("/**"); //$NON-NLS-1$
-        method.addJavaDocLine(" * 这是Mybatis Generator拓展插件生成的方法(请勿删除).");
-        sb.append(" * This method corresponds to the database table ");
-        sb.append(introspectedTable.getFullyQualifiedTable());
-        method.addJavaDocLine(sb.toString());
-        method.addJavaDocLine(" *");
-        method.addJavaDocLine(" * "+MergeConstants.NEW_ELEMENT_TAG);
-        method.addJavaDocLine(" * @author hewei");
-        method.addJavaDocLine(" */"); //$NON-NLS-1$
-    }
-
-    /**
-     * 生成xml element 注释
-     *
-     * @param xmlElement the xml element
-     */
-    public static void addComment(XmlElement xmlElement) {
-
-        xmlElement.addElement(new TextElement("<!--")); //$NON-NLS-1$
-
-        StringBuilder sb = new StringBuilder();
-        sb.append("  WARNING - "); //$NON-NLS-1$
-        sb.append(MergeConstants.NEW_ELEMENT_TAG);
-        xmlElement.addElement(new TextElement(sb.toString()));
-        xmlElement.addElement(new TextElement("  这个节点为代码生成工具生成，请不要修改!")); //$NON-NLS-1$
-        xmlElement.addElement(new TextElement("  @author hewei"));
-
-        xmlElement.addElement(new TextElement("-->")); //$NON-NLS-1$
-    }
-
-    /**
-     * 生成通用接口注解
-     *
-     * @param interf 接口
-     * @param introspectedTable 表
-     */
-    public static void addInterfaceComment(Interface interf, IntrospectedTable introspectedTable) {
-        StringBuilder sb = new StringBuilder();
-        interf.addJavaDocLine("/**"); //$NON-NLS-1$
-        interf.addJavaDocLine(" * 这是Mybatis Generator拓展插件生成的接口(请勿删除)."); //$NON-NLS-1$
-        sb.append(" * This class corresponds to the database table "); //$NON-NLS-1$
-        sb.append(introspectedTable.getFullyQualifiedTable());
-        interf.addJavaDocLine(sb.toString());
-        interf.addJavaDocLine(" *");
-        interf.addJavaDocLine(" * "+MergeConstants.NEW_ELEMENT_TAG);
-        interf.addJavaDocLine(" * @author hewei");
-        interf.addJavaDocLine(" */"); //$NON-NLS-1$
-    }
-
-}

src/main/java/com/itfsw/mybatis/generator/plugins/utils/JavaElementGeneratorTools.java

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2017.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.itfsw.mybatis.generator.plugins.utils;
+
+import org.mybatis.generator.api.dom.java.*;
+
+/**
+ * ---------------------------------------------------------------------------
+ * Java ele 生成工具
+ * ---------------------------------------------------------------------------
+ * @author: hewei
+ * @time:2017/4/21 16:22
+ * ---------------------------------------------------------------------------
+ */
+public class JavaElementGeneratorTools {
+
+    /**
+     * 生成静态常量
+     *
+     * @param fieldName 常量名称
+     * @param javaType 类型
+     * @param initString 初始化字段
+     * @return
+     */
+    public static Field generateStaticFinalField(String fieldName, FullyQualifiedJavaType javaType, String initString){
+        Field field = new Field(fieldName, javaType);
+        field.setVisibility(JavaVisibility.PUBLIC);
+        field.setStatic(true);
+        field.setFinal(true);
+        if (initString != null){
+            field.setInitializationString(initString);
+        }
+        return field;
+    }
+
+    /**
+     * 生成属性
+     *
+     * @param fieldName 常量名称
+     * @param  visibility 可见性
+     * @param javaType 类型
+     * @param initString 初始化字段
+     * @return
+     */
+    public static Field generateField(String fieldName, JavaVisibility visibility, FullyQualifiedJavaType javaType, String initString){
+        Field field = new Field(fieldName, javaType);
+        field.setVisibility(visibility);
+        if (initString != null){
+            field.setInitializationString(initString);
+        }
+        return field;
+    }
+
+    /**
+     * 生成方法
+     *
+     * @param methodName 方法名
+     * @param visibility  可见性
+     * @param returnType 返回值类型
+     * @param parameters 参数列表
+     * @return
+     */
+    public static Method generateMethod(String methodName, JavaVisibility visibility, FullyQualifiedJavaType returnType, Parameter ... parameters){
+        Method method = new Method(methodName);
+        method.setVisibility(visibility);
+        method.setReturnType(returnType);
+        if (parameters != null){
+            for (Parameter parameter: parameters) {
+                method.addParameter(parameter);
+            }
+        }
+
+        return method;
+    }
+
+    /**
+     * 生成方法实现体
+     *
+     * @param method 方法
+     * @param bodyLines 方法实现行
+     * @return
+     */
+    public static Method generateMethodBody(Method method, String ... bodyLines){
+        if (bodyLines != null){
+            for (String bodyLine: bodyLines){
+                method.addBodyLine(bodyLine);
+            }
+        }
+        return method;
+    }
+
+    /**
+     * 生成Filed的Set方法
+     *
+     * @param field field
+     * @return
+     */
+    public static Method generateSetterMethod(Field field){
+        Method method = generateMethod(
+                "set" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1),
+                JavaVisibility.PUBLIC,
+                null,
+                new Parameter(field.getType(), field.getName())
+        );
+        return generateMethodBody(method, "this." + field.getName() + " = " + field.getName() + ";");
+    }
+
+    /**
+     * 生成Filed的Get方法
+     *
+     * @param field field
+     * @return
+     */
+    public static Method generateGetterMethod(Field field){
+        Method method = generateMethod(
+                "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1),
+                JavaVisibility.PUBLIC,
+                field.getType()
+        );
+        return generateMethodBody(method, "return this." + field.getName() + ";");
+    }
+}

src/main/java/com/itfsw/mybatis/generator/plugins/utils/PluginTools.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2017.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.itfsw.mybatis.generator.plugins.utils;
+
+import org.mybatis.generator.config.Context;
+import org.mybatis.generator.config.PluginConfiguration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * ---------------------------------------------------------------------------
+ * 插件工具集
+ * ---------------------------------------------------------------------------
+ * @author: hewei
+ * @time:2017/4/20 15:43
+ * ---------------------------------------------------------------------------
+ */
+public class PluginTools {
+    private static final Logger logger = LoggerFactory.getLogger(PluginTools.class);
+
+    /**
+     * 检查插件依赖
+     * @param plugin 插件
+     * @param ctx    上下文
+     * @return
+     */
+    public static boolean checkDependencyPlugin(Class plugin, Context ctx) {
+        return getPluginIndex(plugin, ctx) >= 0;
+    }
+
+    /**
+     * 获取插件所在位置
+     *
+     * @param plugin 插件
+     * @param ctx 上下文
+     * @return -1:未找到
+     */
+    public static int getPluginIndex(Class plugin, Context ctx) {
+        List<PluginConfiguration> list = getConfigPlugins(ctx);
+        // 检查是否配置了ModelColumnPlugin插件
+        for (int i = 0; i < list.size(); i++) {
+            PluginConfiguration config = list.get(i);
+            if (plugin.getName().equals(config.getConfigurationType())) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * 获取插件列表
+     * @param ctx 上下文
+     * @return
+     */
+    public static List<PluginConfiguration> getConfigPlugins(Context ctx) {
+        try {
+            // 利用反射获取pluginConfigurations属性
+            Field field = Context.class.getDeclaredField("pluginConfigurations");
+            field.setAccessible(true);
+            return (List<PluginConfiguration>) field.get(ctx);
+        } catch (Exception e) {
+            logger.error("插件检查反射异常", e);
+        }
+        return new ArrayList<>();
+    }
+}

src/main/java/com/itfsw/mybatis/generator/plugins/utils/XmlElementGeneratorTools.java

@@ -19,10 +19,15 @@ package com.itfsw.mybatis.generator.plugins.utils;
 import org.mybatis.generator.api.IntrospectedColumn;
 import org.mybatis.generator.api.IntrospectedTable;
 import org.mybatis.generator.api.dom.xml.Attribute;
+import org.mybatis.generator.api.dom.xml.Element;
 import org.mybatis.generator.api.dom.xml.TextElement;
 import org.mybatis.generator.api.dom.xml.XmlElement;
+import org.mybatis.generator.codegen.mybatis3.MyBatis3FormattingUtilities;
 import org.mybatis.generator.config.GeneratedKey;
 
+import java.util.Iterator;
+import java.util.List;
+
 /**
  * ---------------------------------------------------------------------------
  * Xml 节点生成工具 参考 org.mybatis.generator.codegen.mybatis3.xmlmapper.elements.AbstractXmlElementGenerator
@@ -36,22 +41,19 @@ public class XmlElementGeneratorTools {
     /**
      * This method should return an XmlElement for the select key used to
      * automatically generate keys.
-     *
-     * @param introspectedColumn
-     *            the column related to the select key statement
-     * @param generatedKey
-     *            the generated key for the current table
+     * @param introspectedColumn the column related to the select key statement
+     * @param generatedKey       the generated key for the current table
      * @return the selectKey element
      */
-    public static XmlElement getSelectKey(IntrospectedColumn introspectedColumn, GeneratedKey generatedKey) {
+    public static Element getSelectKey(IntrospectedColumn introspectedColumn, GeneratedKey generatedKey) {
         String identityColumnType = introspectedColumn
                 .getFullyQualifiedJavaType().getFullyQualifiedName();
 
-        XmlElement answer = new XmlElement("selectKey"); //$NON-NLS-1$
-        answer.addAttribute(new Attribute("resultType", identityColumnType)); //$NON-NLS-1$
+        XmlElement answer = new XmlElement("selectKey"); 
+        answer.addAttribute(new Attribute("resultType", identityColumnType)); 
         answer.addAttribute(new Attribute(
-                "keyProperty", introspectedColumn.getJavaProperty())); //$NON-NLS-1$
-        answer.addAttribute(new Attribute("order", //$NON-NLS-1$
+                "keyProperty", introspectedColumn.getJavaProperty())); 
+        answer.addAttribute(new Attribute("order", 
                 generatedKey.getMyBatis3Order()));
 
         answer.addElement(new TextElement(generatedKey
@@ -60,41 +62,319 @@ public class XmlElementGeneratorTools {
         return answer;
     }
 
-    public static XmlElement getBaseColumnListElement(IntrospectedTable introspectedTable) {
-        XmlElement answer = new XmlElement("include"); //$NON-NLS-1$
-        answer.addAttribute(new Attribute("refid", //$NON-NLS-1$
+    public static Element getBaseColumnListElement(IntrospectedTable introspectedTable) {
+        XmlElement answer = new XmlElement("include"); 
+        answer.addAttribute(new Attribute("refid", 
                 introspectedTable.getBaseColumnListId()));
         return answer;
     }
 
-    public static XmlElement getBlobColumnListElement(IntrospectedTable introspectedTable) {
-        XmlElement answer = new XmlElement("include"); //$NON-NLS-1$
-        answer.addAttribute(new Attribute("refid", //$NON-NLS-1$
+    public static Element getBlobColumnListElement(IntrospectedTable introspectedTable) {
+        XmlElement answer = new XmlElement("include"); 
+        answer.addAttribute(new Attribute("refid", 
                 introspectedTable.getBlobColumnListId()));
         return answer;
     }
 
-    public static XmlElement getExampleIncludeElement(IntrospectedTable introspectedTable) {
-        XmlElement ifElement = new XmlElement("if"); //$NON-NLS-1$
-        ifElement.addAttribute(new Attribute("test", "_parameter != null")); //$NON-NLS-1$ //$NON-NLS-2$
+    public static Element getExampleIncludeElement(IntrospectedTable introspectedTable) {
+        XmlElement ifElement = new XmlElement("if"); 
+        ifElement.addAttribute(new Attribute("test", "_parameter != null"));  
 
-        XmlElement includeElement = new XmlElement("include"); //$NON-NLS-1$
-        includeElement.addAttribute(new Attribute("refid", //$NON-NLS-1$
+        XmlElement includeElement = new XmlElement("include"); 
+        includeElement.addAttribute(new Attribute("refid", 
                 introspectedTable.getExampleWhereClauseId()));
         ifElement.addElement(includeElement);
 
         return ifElement;
     }
 
-    public static XmlElement getUpdateByExampleIncludeElement(IntrospectedTable introspectedTable) {
-        XmlElement ifElement = new XmlElement("if"); //$NON-NLS-1$
-        ifElement.addAttribute(new Attribute("test", "_parameter != null")); //$NON-NLS-1$ //$NON-NLS-2$
+    public static Element getUpdateByExampleIncludeElement(IntrospectedTable introspectedTable) {
+        XmlElement ifElement = new XmlElement("if"); 
+        ifElement.addAttribute(new Attribute("test", "_parameter != null"));  
 
-        XmlElement includeElement = new XmlElement("include"); //$NON-NLS-1$
-        includeElement.addAttribute(new Attribute("refid", //$NON-NLS-1$
+        XmlElement includeElement = new XmlElement("include"); 
+        includeElement.addAttribute(new Attribute("refid", 
                 introspectedTable.getMyBatis3UpdateByExampleWhereClauseId()));
         ifElement.addElement(includeElement);
 
         return ifElement;
     }
+
+    /**
+     * 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
+     *
+     * @param element
+     * @param introspectedTable
+     */
+    public static void useGeneratedKeys(XmlElement element, IntrospectedTable introspectedTable){
+        useGeneratedKeys(element, introspectedTable, null);
+    }
+
+    /**
+     * 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
+     *
+     * @param element
+     * @param introspectedTable
+     * @param prefix
+     */
+    public static void useGeneratedKeys(XmlElement element, IntrospectedTable introspectedTable, String prefix){
+        GeneratedKey gk = introspectedTable.getGeneratedKey();
+        if (gk != null) {
+            IntrospectedColumn introspectedColumn = introspectedTable.getColumn(gk.getColumn());
+            // if the column is null, then it's a configuration error. The
+            // warning has already been reported
+            if (introspectedColumn != null) {
+                // 使用JDBC的getGenereatedKeys方法获取主键并赋值到keyProperty设置的领域模型属性中。所以只支持MYSQL和SQLServer
+                element.addAttribute(new Attribute("useGeneratedKeys", "true"));  
+                element.addAttribute(new Attribute("keyProperty", (prefix == null ? "" : prefix) + introspectedColumn.getJavaProperty())); 
+                element.addAttribute(new Attribute("keyColumn", introspectedColumn.getActualColumnName())); 
+            }
+        }
+    }
+
+    /**
+     * 生成keys Ele
+     * @param columns
+     * @return
+     */
+    public static Element generateKeys(List<IntrospectedColumn> columns) {
+        return generateKeys(columns, true);
+    }
+
+    /**
+     * 生成keys Ele
+     * @param columns
+     * @param bracket
+     * @return
+     */
+    public static Element generateKeys(List<IntrospectedColumn> columns, boolean bracket) {
+        return generateCommColumns(columns, null, bracket, 1);
+    }
+
+    /**
+     * 生成keys Selective Ele
+     * @param columns
+     * @return
+     */
+    public static Element generateKeysSelective(List<IntrospectedColumn> columns) {
+        return generateKeysSelective(columns, null);
+    }
+
+    /**
+     * 生成keys Selective Ele
+     * @param columns
+     * @param prefix
+     * @return
+     */
+    public static Element generateKeysSelective(List<IntrospectedColumn> columns, String prefix) {
+        return generateKeysSelective(columns, prefix, true);
+    }
+
+    /**
+     * 生成keys Selective Ele
+     * @param columns
+     * @param prefix
+     * @param bracket
+     * @return
+     */
+    public static Element generateKeysSelective(List<IntrospectedColumn> columns, String prefix, boolean bracket) {
+        return generateCommColumnsSelective(columns, prefix, bracket, 1);
+    }
+
+    /**
+     * 生成values Ele
+     * @param columns
+     * @return
+     */
+    public static Element generateValues(List<IntrospectedColumn> columns) {
+        return generateValues(columns, null);
+    }
+
+    /**
+     * 生成values Ele
+     * @param columns
+     * @param prefix
+     * @return
+     */
+    public static Element generateValues(List<IntrospectedColumn> columns, String prefix) {
+        return generateValues(columns, prefix, true);
+    }
+
+    /**
+     * 生成values Ele
+     * @param columns
+     * @param prefix
+     * @param bracket
+     * @return
+     */
+    public static Element generateValues(List<IntrospectedColumn> columns, String prefix, boolean bracket) {
+        return generateCommColumns(columns, prefix, bracket, 2);
+    }
+
+    /**
+     * 生成values Selective Ele
+     * @param columns
+     * @return
+     */
+    public static Element generateValuesSelective(List<IntrospectedColumn> columns) {
+        return generateValuesSelective(columns, null);
+    }
+
+    /**
+     * 生成values Selective Ele
+     * @param columns
+     * @param prefix
+     * @return
+     */
+    public static Element generateValuesSelective(List<IntrospectedColumn> columns, String prefix) {
+        return generateValuesSelective(columns, prefix, true);
+    }
+
+    /**
+     * 生成values Selective Ele
+     * @param columns
+     * @param prefix
+     * @param bracket
+     * @return
+     */
+    public static Element generateValuesSelective(List<IntrospectedColumn> columns, String prefix, boolean bracket) {
+        return generateCommColumnsSelective(columns, prefix, bracket, 2);
+    }
+
+    /**
+     * 生成sets Ele
+     * @param columns
+     * @return
+     */
+    public static Element generateSets(List<IntrospectedColumn> columns) {
+        return generateSets(columns, null, false);
+    }
+
+    /**
+     * 生成sets Ele
+     * @param columns
+     * @param prefix
+     * @return
+     */
+    public static Element generateSets(List<IntrospectedColumn> columns, String prefix) {
+        return generateSets(columns, prefix, false);
+    }
+
+    /**
+     * 生成sets Ele
+     * @param columns
+     * @param prefix
+     * @param bracket
+     * @return
+     */
+    public static Element generateSets(List<IntrospectedColumn> columns, String prefix, boolean bracket) {
+        return generateCommColumns(columns, prefix, bracket, 3);
+    }
+
+    /**
+     * 生成sets Selective Ele
+     * @param columns
+     * @return
+     */
+    public static Element generateSetsSelective(List<IntrospectedColumn> columns) {
+        return generateSetsSelective(columns, null, false);
+    }
+
+    /**
+     * 生成sets Selective Ele
+     * @param columns
+     * @param prefix
+     * @return
+     */
+    public static Element generateSetsSelective(List<IntrospectedColumn> columns, String prefix) {
+        return generateSetsSelective(columns, prefix, false);
+    }
+
+    /**
+     * 生成sets Selective Ele
+     * @param columns
+     * @param prefix
+     * @param bracket
+     * @return
+     */
+    public static Element generateSetsSelective(List<IntrospectedColumn> columns, String prefix, boolean bracket) {
+        return generateCommColumnsSelective(columns, prefix, bracket, 3);
+    }
+
+    /**
+     * 通用遍历columns
+     * @param columns
+     * @param prefix
+     * @param bracket
+     * @param type    1:key,2:value,3:set
+     * @return
+     */
+    private static Element generateCommColumns(List<IntrospectedColumn> columns, String prefix, boolean bracket, int type) {
+        StringBuffer sb = new StringBuffer(bracket ? "(" : "");
+        Iterator<IntrospectedColumn> columnIterator = columns.iterator();
+        while (columnIterator.hasNext()) {
+            IntrospectedColumn introspectedColumn = columnIterator.next();
+
+            switch (type) {
+                case 3:
+                    sb.append(MyBatis3FormattingUtilities.getEscapedColumnName(introspectedColumn));
+                    sb.append(" = ");
+                    sb.append(MyBatis3FormattingUtilities.getParameterClause(introspectedColumn, prefix));
+                    break;
+                case 2:
+                    sb.append(MyBatis3FormattingUtilities.getParameterClause(introspectedColumn, prefix));
+                    break;
+                case 1:
+                    sb.append(MyBatis3FormattingUtilities.getEscapedColumnName(introspectedColumn));
+                    break;
+            }
+
+            if (columnIterator.hasNext()) {
+                sb.append(", ");
+            }
+        }
+
+        return new TextElement(sb.append(bracket ? ")" : "").toString());
+    }
+
+    /**
+     * 通用遍历columns
+     * @param columns
+     * @param prefix
+     * @param bracket
+     * @param type    1:key,2:value,3:set
+     * @return
+     */
+    private static Element generateCommColumnsSelective(List<IntrospectedColumn> columns, String prefix, boolean bracket, int type) {
+        XmlElement eleTrim = new XmlElement("trim");
+        if (bracket) {
+            eleTrim.addAttribute(new Attribute("prefix", "("));
+            eleTrim.addAttribute(new Attribute("suffix", ")"));
+            eleTrim.addAttribute(new Attribute("suffixOverrides", ","));
+        } else {
+            eleTrim.addAttribute(new Attribute("suffixOverrides", ","));
+        }
+
+        for (IntrospectedColumn introspectedColumn : columns) {
+            XmlElement eleIf = new XmlElement("if");
+            eleIf.addAttribute(new Attribute("test", introspectedColumn.getJavaProperty(prefix) + " != null"));
+
+            switch (type) {
+                case 3:
+                    eleIf.addElement(new TextElement(MyBatis3FormattingUtilities.getEscapedColumnName(introspectedColumn) + " = " + MyBatis3FormattingUtilities.getParameterClause(introspectedColumn, prefix) + ","));
+                    break;
+                case 2:
+                    eleIf.addElement(new TextElement(MyBatis3FormattingUtilities.getParameterClause(introspectedColumn, prefix) + ","));
+                    break;
+                case 1:
+                    eleIf.addElement(new TextElement(MyBatis3FormattingUtilities.getEscapedColumnName(introspectedColumn) + ","));
+                    break;
+            }
+
+            eleTrim.addElement(eleIf);
+        }
+
+        return eleTrim;
+    }
+
 }

src/main/java/com/itfsw/mybatis/generator/plugins/utils/enhanced/IWCommentGenerator.java

@@ -0,0 +1,335 @@
+/*
+ * Copyright (c) 2017.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.itfsw.mybatis.generator.plugins.utils.enhanced;
+
+import org.mybatis.generator.api.CommentGenerator;
+import org.mybatis.generator.api.IntrospectedColumn;
+import org.mybatis.generator.api.IntrospectedTable;
+import org.mybatis.generator.api.dom.java.*;
+import org.mybatis.generator.api.dom.xml.TextElement;
+import org.mybatis.generator.api.dom.xml.XmlElement;
+import org.mybatis.generator.config.MergeConstants;
+import org.mybatis.generator.internal.util.StringUtility;
+
+import java.util.Properties;
+
+/**
+ * ---------------------------------------------------------------------------
+ * 注释生成工具
+ * ---------------------------------------------------------------------------
+ * @author: hewei
+ * @time:2017/4/28 15:11
+ * ---------------------------------------------------------------------------
+ */
+public class IWCommentGenerator implements CommentGenerator {
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addJavaFileComment(org.mybatis.generator.api.dom.java.CompilationUnit)
+     */
+    public void addJavaFileComment(CompilationUnit compilationUnit) {
+        // add no file level comments by default
+    }
+
+    /**
+     * Adds a suitable comment to warn users that the element was generated, and when it was generated.
+     * @param xmlElement the xml element
+     */
+    public void addComment(XmlElement xmlElement) {
+
+        xmlElement.addElement(new TextElement("<!--"));
+
+        StringBuilder sb = new StringBuilder();
+        sb.append("  WARNING - ");
+        sb.append(MergeConstants.NEW_ELEMENT_TAG);
+        xmlElement.addElement(new TextElement(sb.toString()));
+        xmlElement.addElement(new TextElement("  This element is automatically generated by MyBatis Generator, do not modify."));
+        xmlElement.addElement(new TextElement("  @project https://github.com/itfsw/mybatis-generator-plugin"));
+        xmlElement.addElement(new TextElement("-->"));
+    }
+
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addRootComment(org.mybatis.generator.api.dom.xml.XmlElement)
+     */
+    public void addRootComment(XmlElement rootElement) {
+        // add no document level comments by default
+    }
+
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addConfigurationProperties(java.util.Properties)
+     */
+    public void addConfigurationProperties(Properties properties) {
+    }
+
+    /**
+     * This method adds the custom javadoc tag for. You may do nothing if you do not wish to include the Javadoc tag -
+     * however, if you do not include the Javadoc tag then the Java merge capability of the eclipse plugin will break.
+     * @param javaElement       the java element
+     * @param markAsDoNotDelete the mark as do not delete
+     */
+    protected void addJavadocTag(JavaElement javaElement, boolean markAsDoNotDelete) {
+        javaElement.addJavaDocLine(" *");
+        StringBuilder sb = new StringBuilder();
+        sb.append(" * ");
+        sb.append(MergeConstants.NEW_ELEMENT_TAG);
+        if (markAsDoNotDelete) {
+            sb.append(" do_not_delete_during_merge");
+        }
+
+        javaElement.addJavaDocLine(sb.toString());
+        javaElement.addJavaDocLine(" * @project https://github.com/itfsw/mybatis-generator-plugin");
+    }
+
+
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addClassComment(org.mybatis.generator.api.dom.java.InnerClass, org.mybatis.generator.api.IntrospectedTable)
+     */
+    public void addClassComment(InnerClass innerClass, IntrospectedTable introspectedTable) {
+        StringBuilder sb = new StringBuilder();
+
+        innerClass.addJavaDocLine("/**");
+        innerClass.addJavaDocLine(" * This class was generated by MyBatis Generator.");
+
+        sb.append(" * This class corresponds to the database table ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        innerClass.addJavaDocLine(sb.toString());
+
+        addJavadocTag(innerClass, false);
+
+        innerClass.addJavaDocLine(" */");
+    }
+
+    /**
+     * inner inter face 注释
+     *
+     * @param innerInterface
+     * @param introspectedTable
+     */
+    public void addInterfaceComment(Interface innerInterface, IntrospectedTable introspectedTable) {
+        StringBuilder sb = new StringBuilder();
+
+        innerInterface.addJavaDocLine("/**");
+        innerInterface.addJavaDocLine(" * This interface was generated by MyBatis Generator.");
+
+        sb.append(" * This interface corresponds to the database table ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        innerInterface.addJavaDocLine(sb.toString());
+
+        addJavadocTag(innerInterface, false);
+
+        innerInterface.addJavaDocLine(" */");
+    }
+
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addTopLevelClassComment(org.mybatis.generator.api.dom.java.TopLevelClass, org.mybatis.generator.api.IntrospectedTable)
+     */
+    @Override
+    public void addModelClassComment(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
+
+        StringBuilder sb = new StringBuilder();
+
+        topLevelClass.addJavaDocLine("/**");
+
+        String remarks = introspectedTable.getRemarks();
+        if (StringUtility.stringHasValue(remarks)) {
+            topLevelClass.addJavaDocLine(" * Database Table Remarks:");
+            String[] remarkLines = remarks.split(System.getProperty("line.separator")); 
+            for (String remarkLine : remarkLines) {
+                topLevelClass.addJavaDocLine(" *   " + remarkLine); 
+            }
+        }
+        topLevelClass.addJavaDocLine(" *");
+
+        topLevelClass.addJavaDocLine(" * This class was generated by MyBatis Generator.");
+
+        sb.append(" * This class corresponds to the database table ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        topLevelClass.addJavaDocLine(sb.toString());
+
+        addJavadocTag(topLevelClass, true);
+
+        topLevelClass.addJavaDocLine(" */");
+    }
+
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addEnumComment(org.mybatis.generator.api.dom.java.InnerEnum, org.mybatis.generator.api.IntrospectedTable)
+     */
+    public void addEnumComment(InnerEnum innerEnum, IntrospectedTable introspectedTable) {
+
+        StringBuilder sb = new StringBuilder();
+
+        innerEnum.addJavaDocLine("/**");
+        innerEnum.addJavaDocLine(" * This enum was generated by MyBatis Generator.");
+
+        sb.append(" * This enum corresponds to the database table ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        innerEnum.addJavaDocLine(sb.toString());
+
+        addJavadocTag(innerEnum, false);
+
+        innerEnum.addJavaDocLine(" */");
+    }
+
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addFieldComment(org.mybatis.generator.api.dom.java.Field, org.mybatis.generator.api.IntrospectedTable, org.mybatis.generator.api.IntrospectedColumn)
+     */
+    public void addFieldComment(Field field, IntrospectedTable introspectedTable, IntrospectedColumn introspectedColumn) {
+
+        field.addJavaDocLine("/**");
+
+        String remarks = introspectedColumn.getRemarks();
+        if (StringUtility.stringHasValue(remarks)) {
+            field.addJavaDocLine(" * Database Column Remarks:");
+            String[] remarkLines = remarks.split(System.getProperty("line.separator")); 
+            for (String remarkLine : remarkLines) {
+                field.addJavaDocLine(" *   " + remarkLine); 
+            }
+        }
+
+        field.addJavaDocLine(" *");
+        field.addJavaDocLine(" * This field was generated by MyBatis Generator.");
+
+        StringBuilder sb = new StringBuilder();
+        sb.append(" * This field corresponds to the database column ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        sb.append('.');
+        sb.append(introspectedColumn.getActualColumnName());
+        field.addJavaDocLine(sb.toString());
+
+        addJavadocTag(field, false);
+
+        field.addJavaDocLine(" */");
+    }
+
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addFieldComment(org.mybatis.generator.api.dom.java.Field, org.mybatis.generator.api.IntrospectedTable)
+     */
+    public void addFieldComment(Field field, IntrospectedTable introspectedTable) {
+
+        StringBuilder sb = new StringBuilder();
+
+        field.addJavaDocLine("/**");
+        field.addJavaDocLine(" * This field was generated by MyBatis Generator.");
+
+        sb.append(" * This field corresponds to the database table ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        field.addJavaDocLine(sb.toString());
+
+        addJavadocTag(field, false);
+
+        field.addJavaDocLine(" */");
+    }
+
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addGeneralMethodComment(org.mybatis.generator.api.dom.java.Method, org.mybatis.generator.api.IntrospectedTable)
+     */
+    public void addGeneralMethodComment(Method method, IntrospectedTable introspectedTable) {
+
+        StringBuilder sb = new StringBuilder();
+
+        method.addJavaDocLine("/**");
+        method.addJavaDocLine(" * This method was generated by MyBatis Generator.");
+
+        sb.append(" * This method corresponds to the database table ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        method.addJavaDocLine(sb.toString());
+
+        addJavadocTag(method, false);
+
+        method.addJavaDocLine(" */");
+    }
+
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addGetterComment(org.mybatis.generator.api.dom.java.Method, org.mybatis.generator.api.IntrospectedTable, org.mybatis.generator.api.IntrospectedColumn)
+     */
+    public void addGetterComment(Method method, IntrospectedTable introspectedTable, IntrospectedColumn introspectedColumn) {
+
+        StringBuilder sb = new StringBuilder();
+
+        method.addJavaDocLine("/**");
+        method.addJavaDocLine(" * This method was generated by MyBatis Generator.");
+
+        sb.append(" * This method returns the value of the database column ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        sb.append('.');
+        sb.append(introspectedColumn.getActualColumnName());
+        method.addJavaDocLine(sb.toString());
+
+        method.addJavaDocLine(" *");
+
+        sb.setLength(0);
+        sb.append(" * @return the value of ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        sb.append('.');
+        sb.append(introspectedColumn.getActualColumnName());
+        method.addJavaDocLine(sb.toString());
+
+        addJavadocTag(method, false);
+
+        method.addJavaDocLine(" */");
+    }
+
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addSetterComment(org.mybatis.generator.api.dom.java.Method, org.mybatis.generator.api.IntrospectedTable, org.mybatis.generator.api.IntrospectedColumn)
+     */
+    public void addSetterComment(Method method, IntrospectedTable introspectedTable, IntrospectedColumn introspectedColumn) {
+
+        StringBuilder sb = new StringBuilder();
+
+        method.addJavaDocLine("/**");
+        method.addJavaDocLine(" * This method was generated by MyBatis Generator.");
+
+        sb.append(" * This method sets the value of the database column ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        sb.append('.');
+        sb.append(introspectedColumn.getActualColumnName());
+        method.addJavaDocLine(sb.toString());
+
+        method.addJavaDocLine(" *");
+
+        Parameter parm = method.getParameters().get(0);
+        sb.setLength(0);
+        sb.append(" * @param ");
+        sb.append(parm.getName());
+        sb.append(" the value for ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        sb.append('.');
+        sb.append(introspectedColumn.getActualColumnName());
+        method.addJavaDocLine(sb.toString());
+
+        addJavadocTag(method, false);
+
+        method.addJavaDocLine(" */");
+    }
+
+    /* (non-Javadoc)
+     * @see org.mybatis.generator.api.CommentGenerator#addClassComment(org.mybatis.generator.api.dom.java.InnerClass, org.mybatis.generator.api.IntrospectedTable, boolean)
+     */
+    public void addClassComment(InnerClass innerClass, IntrospectedTable introspectedTable, boolean markAsDoNotDelete) {
+
+        StringBuilder sb = new StringBuilder();
+
+        innerClass.addJavaDocLine("/**");
+        innerClass.addJavaDocLine(" * This class was generated by MyBatis Generator.");
+
+        sb.append(" * This class corresponds to the database table ");
+        sb.append(introspectedTable.getFullyQualifiedTable());
+        innerClass.addJavaDocLine(sb.toString());
+
+        addJavadocTag(innerClass, markAsDoNotDelete);
+
+        innerClass.addJavaDocLine(" */");
+    }
+}

src/main/java/com/itfsw/mybatis/generator/plugins/utils/enhanced/InnerInterface.java

@@ -1,22 +1,20 @@
 /*
+ * Copyright (c) 2017.
  *
- *  * Copyright (c) 2017.
- *  *
- *  * Licensed under the Apache License, Version 2.0 (the "License");
- *  * you may not use this file except in compliance with the License.
- *  * You may obtain a copy of the License at
- *  *
- *  *     http://www.apache.org/licenses/LICENSE-2.0
- *  *
- *  * Unless required by applicable law or agreed to in writing, software
- *  * distributed under the License is distributed on an "AS IS" BASIS,
- *  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  * See the License for the specific language governing permissions and
- *  * limitations under the License.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
  *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
-package com.itfsw.mybatis.generator.plugins.utils;
+package com.itfsw.mybatis.generator.plugins.utils.enhanced;
 
 import org.mybatis.generator.api.dom.OutputUtilities;
 import org.mybatis.generator.api.dom.java.*;

src/main/java/com/itfsw/mybatis/generator/plugins/utils/enhanced/InnerInterfaceWrapperToInnerClass.java

@@ -1,22 +1,20 @@
 /*
+ * Copyright (c) 2017.
  *
- *  * Copyright (c) 2017.
- *  *
- *  * Licensed under the Apache License, Version 2.0 (the "License");
- *  * you may not use this file except in compliance with the License.
- *  * You may obtain a copy of the License at
- *  *
- *  *     http://www.apache.org/licenses/LICENSE-2.0
- *  *
- *  * Unless required by applicable law or agreed to in writing, software
- *  * distributed under the License is distributed on an "AS IS" BASIS,
- *  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  * See the License for the specific language governing permissions and
- *  * limitations under the License.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
  *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 
-package com.itfsw.mybatis.generator.plugins.utils;
+package com.itfsw.mybatis.generator.plugins.utils.enhanced;
 
 import org.mybatis.generator.api.dom.java.CompilationUnit;
 import org.mybatis.generator.api.dom.java.FullyQualifiedJavaType;