[maven-release-plugin] prepare release v1.0.5

1. 增加了数据Model属性对应Column获取插件（ModelColumnPlugin）；
2. 强化了example的orderBy方法； 3. 强化批量插入插件，实现按需插入指定字段；
2017-01-17 18:10:44 +08:00 · 2017-01-17 18:09:48 +08:00 · 2017-01-17 09:30:35 +08:00 · 2017-01-16 18:34:47 +08:00 · 2017-01-16 18:18:49 +08:00 · 2017-01-16 18:18:32 +08:00
15 changed files with 1383 additions and 173 deletions
@@ -4,11 +4,14 @@
  
 ---------------------------------------
 插件列表：  
-* 查询单条数据插件
-* MySQL分页插件
-* 数据Model链式构建插件
-* Example Criteria 增强插件(example,andIf)
-* Example 目标包修改插件
+* 查询单条数据插件（SelectOneByExamplePlugin）
+* MySQL分页插件（LimitPlugin）
+* 数据Model链式构建插件（ModelBuilderPlugin）
+* Example Criteria 增强插件（ExampleEnhancedPlugin（CriteriaBuilderPlugin这个是老版本叫法，已经弃用））
+* Example 目标包修改插件（ExampleTargetPlugin）
+* 批量插入插件（BatchInsertPlugin）
+* 逻辑删除插件（LogicalDeletePlugin）
+* 数据Model属性对应Column获取插件（ModelColumnPlugin）
  
 ---------------------------------------
 Maven引用：  
@@ -16,7 +19,7 @@ Maven引用：
 <dependency>
  <groupId>com.itfsw</groupId>
  <artifactId>mybatis-generator-plugin</artifactId>
-  <version>1.0.1</version>
+  <version>1.0.5</version>
 </dependency>
 ```
 ---------------------------------------
@@ -41,7 +44,7 @@ public interface TbMapper {
 }
 ```
 ### 2. MySQL分页插件
-对应表Example类增加了方法  
+对应表Example类增加了Mysql分页方法，limit(Integer rows)、limit(Integer offset, Integer rows)和page(Integer page, Integer pageSize)  
 插件：
 ```xml
 <!-- MySQL分页插件 -->
@@ -74,8 +77,9 @@ public class TbExample {
     * @mbg.generated
     * @author hewei
     */
-    public void limit(Integer rows) {
+    public TbExample limit(Integer rows) {
        this.rows = rows;
+        return this;
    }

    /**
@@ -85,9 +89,10 @@ public class TbExample {
     * @mbg.generated
     * @author hewei
     */
-    public void limit(Integer offset, Integer rows) {
+    public TbExample limit(Integer offset, Integer rows) {
        this.offset = offset;
        this.rows = rows;
+        return this;
    }

    /**
@@ -97,9 +102,10 @@ public class TbExample {
     * @mbg.generated
     * @author hewei
     */
-    public void page(Integer page, Integer pageSize) {
+    public TbExample page(Integer page, Integer pageSize) {
        this.offset = page * pageSize;
        this.rows = pageSize;
+        return this;
    }
    
    // offset 和 rows 的getter&setter
@@ -119,6 +125,19 @@ public class TbExample {
        offset = null;
    }
 }
+public class Test {
+    public static void main(String[] args) {
+        this.tbMapper.selectByExample(
+                new TbExample()
+                .createCriteria()
+                .andField1GreaterThan(1)
+                .example()
+                .limit(10)  // 查询前10条
+                .limit(10, 10)  // 查询10~20条
+                .page(1, 10)    // 查询第2页数据（每页10条）
+        );
+    }
+}
 ```
 ### 3. 数据Model链式构建插件
 这个是仿jquery的链式调用强化了表的Model的赋值操作  
@@ -141,13 +160,15 @@ public class Test {
    }
 }
 ```
-### 4. Example Criteria 增强插件(example,andIf)
-* 表Example增加Criteria的快速返回example()方法。  
-* Criteria链式调用增强，以前如果有按条件增加的查询语句会打乱链式查询构建，现在有了andIf(boolean ifAdd, CriteriaAdd add)方法可一直使用链式调用下去。  
+### 4. Example 增强插件(example,andIf,orderBy)
+* Criteria的快速返回example()方法。  
+* Criteria链式调用增强，以前如果有按条件增加的查询语句会打乱链式查询构建，现在有了andIf(boolean ifAdd, CriteriaAdd add)方法可一直使用链式调用下去。
+* Example增强了setOrderByClause方法，新增orderBy(String orderByClause)方法直接返回example，增强链式调用，可以一路.下去了。
+* 继续增强orderBy(String orderByClause)方法，增加orderBy(String ... orderByClauses)方法，配合数据Model属性对应Column获取插件（ModelColumnPlugin）使用效果更佳。   
 插件：
 ```xml
 <!-- Example Criteria 增强插件 -->
-<plugin type="com.itfsw.mybatis.generator.plugins.CriteriaBuilderPlugin"/>
+<plugin type="com.itfsw.mybatis.generator.plugins.ExampleEnhancedPlugin"/>
 ```
 使用：  
 ```java
@@ -155,12 +176,13 @@ public class Test {
    public static void main(String[] args) {
        // -----------------------------------example-----------------------------------
        // 表Example.Criteria增加了工厂方法example()支持，使用后可链式构建查询条件使用example()返回Example对象
-        TbExample ex = new TbExample()
-                    .createCriteria()
-                    .andField1EqualTo(1)
-                    .andField2EqualTo("xxx")
-                    .example();
-        this.tbMapper.selectByExample(ex);
+        this.tbMapper.selectByExample(
+                new TbExample()
+                .createCriteria()
+                .andField1EqualTo(1)
+                .andField2EqualTo("xxx")
+                .example()
+        );
        
        // -----------------------------------andIf-----------------------------------
        // Criteria增强了链式调用，现在一些按条件增加的查询条件不会打乱链式调用了
@@ -178,13 +200,13 @@ public class Test {
        this.tbMapper.selectByExample(oldEx);

        // new
-        TbExample newEx;
-        newEx = new TbExample()
+        this.tbMapper.selectByExample(
+                new TbExample()
                .createCriteria()
                .andField1EqualTo(1)
                .andField2EqualTo("xxx")
                // 如果随机数大于0.5，附加Field3查询条件
-                .andIf(Math.random() > 0.5, new TbExample.Criteria.CriteriaAdd() {
+                .andIf(Math.random() > 0.5, new TbExample.Criteria.ICriteriaAdd() {
                    @Override
                    public TbExample.Criteria add(TbExample.Criteria add) {
                        return add.andField3EqualTo(2)
@@ -196,8 +218,26 @@ public class Test {
                        .andField3EqualTo(2)
                        .andField4EqualTo(new Date())
                )
-                .example();
-        this.tbMapper.selectByExample(newEx);
+                .example()
+        );
+        
+        // -----------------------------------orderBy-----------------------------------
+        // old
+        TbExample ex = new TbExample();
+        ex.createCriteria().andField1GreaterThan(1);
+        ex.setOrderByClause("field1 DESC");
+        this.tbMapper.selectByExample(ex);
+
+        // new
+        this.tbMapper.selectByExample(
+                new TbExample()
+                .createCriteria()
+                .andField1GreaterThan(1)
+                .example()
+                .orderBy("field1 DESC")
+                // 这个配合数据Model属性对应Column获取插件（ModelColumnPlugin）使用
+                .orderBy(Tb.Column.field1.asc(), Tb.Column.field3.desc())
+        );
    }
 }
 ```
@@ -210,4 +250,152 @@ Mybatis Generator 插件默认把Model类和Example类都生成到一个包下
    <!-- 修改Example类生成到目标包下 -->
    <property name="targetPackage" value="com.itfsw.mybatis.generator.dao.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插入列！  
+插件：
+```xml
+<!-- 批量插入插件 -->
+<plugin type="com.itfsw.mybatis.generator.plugins.BatchInsertPlugin"/>
+```
+使用：  
+```java
+public class Test {
+    public static void main(String[] args) {
+        // 构建插入数据
+        List<Tb> list = new ArrayList<>();
+        list.add(
+                new Tb.Builder()
+                .field1(0)
+                .field2("xx0")
+                .field3(0)
+                .createTime(new Date())
+                .build()
+        );
+        list.add(
+                new Tb.Builder()
+                .field1(1)
+                .field2("xx1")
+                .field3(1)
+                .createTime(new Date())
+                .build()
+        );
+        // 普通插入，插入所有列
+        this.tbMapper.batchInsert(list);
+        // !!!下面按需插入指定列（类似于insertSelective），需要数据Model属性对应Column获取插件（ModelColumnPlugin）插件
+        this.tbMapper.batchInsert(list, Tb.Column.field1, Tb.Column.field2, Tb.Column.field3, Tb.Column.createTime);
+    }
+}
+```
+### 7. 逻辑删除插件
+因为很多实际项目数据都不允许物理删除，多采用逻辑删除，所以单独为逻辑删除做了一个插件，方便使用。  
+插件：
+```xml
+<xml>
+    <!-- 逻辑删除插件 -->
+    <plugin type="com.itfsw.mybatis.generator.plugins.LogicalDeletePlugin">
+        <!-- 这里配置的是全局逻辑删除列和逻辑删除值，当然在table中配置的值会覆盖该全局配置 -->
+        <!-- 逻辑删除列类型只能为数字、字符串或者布尔类型 -->
+        <property name="logicalDeleteColumn" value="del_flag"/>
+        <!-- 未设置该属性或者该属性的值为null或者NULL,逻辑删除时会把该字段置为NULL。 -->
+        <property name="logicalDeleteValue" value="9"/>
+    </plugin>
+    
+    <table tableName="tb">
+        <!-- 这里可以单独表配置逻辑删除列和删除值，覆盖全局配置 -->
+        <property name="logicalDeleteColumn" value="del_flag"/>
+        <property name="logicalDeleteValue" value="1"/>
+    </table>
+</xml>
+```
+使用：  
+```java
+public class Test {
+    public static void main(String[] args) {
+        // 1. 逻辑删除ByExample
+        this.tbMapper.logicalDeleteByExample(
+                new TbExample()
+                .createCriteria()
+                .andField1EqualTo(1)
+                .example()
+        );
+
+        // 2. 逻辑删除ByPrimaryKey
+        this.tbMapper.logicalDeleteByPrimaryKey(1L);
+
+        // 3. 同时Example中提供了一个快捷方法来过滤逻辑删除数据
+        this.tbMapper.selectByExample(
+                new TbExample()
+                .createCriteria()
+                .andField1EqualTo(1)
+                // 新增了一个andDeleted方法过滤逻辑删除数据
+                .andDeleted(true)
+                // 当然也可直接使用逻辑删除列的查询方法，我们数据Model中定义了一个逻辑删除常量DEL_FLAG
+                .andDelFlagEqualTo(Tb.DEL_FLAG)
+                .example()
+        );
+    }
+}
+```
+### 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)。  
+
+插件：
+```xml
+<!-- 数据Model属性对应Column获取插件 -->
+<plugin type="com.itfsw.mybatis.generator.plugins.ModelColumnPlugin"/>
+```
+使用：  
+```java
+public class Test {
+    public static void main(String[] args) {
+        // 1. 获取Model对应column
+        String column = Tb.Column.createTime.value();
+
+        // 2. 配合Example Criteria 增强插件（ExampleEnhancedPlugin）使用orderBy方法
+        // old
+        this.tbMapper.selectByExample(
+                new TbExample()
+                .createCriteria()
+                .andField1GreaterThan(1)
+                .example()
+                .orderBy("field1 DESC, field3 ASC")
+        );
+
+        // better
+        this.tbMapper.selectByExample(
+                new TbExample()
+                .createCriteria()
+                .andField1GreaterThan(1)
+                .example()
+                .orderBy(Tb.Column.field1.desc(), Tb.Column.field3.asc())
+        );
+        
+        // 3. 配合批量插入插件（BatchInsertPlugin）使用实现按需插入指定列
+        List<Tb> list = new ArrayList<>();
+        list.add(
+                new Tb.Builder()
+                .field1(0)
+                .field2("xx0")
+                .field3(0)
+                .field4(new Date())
+                .build()
+        );
+        list.add(
+                new Tb.Builder()
+                .field1(1)
+                .field2("xx1")
+                .field3(1)
+                .field4(new Date())
+                .build()
+        );
+        // 这个会插入表所有列
+        this.tbMapper.batchInsert(list);
+        // 下面按需插入指定列（类似于insertSelective）
+        this.tbMapper.batchInsert(list, Tb.Column.field1, Tb.Column.field2, Tb.Column.field3, Tb.Column.createTime);
+    }
+}
 ```
@@ -3,7 +3,7 @@

    <groupId>com.itfsw</groupId>
    <artifactId>mybatis-generator-plugin</artifactId>
-    <version>1.0.2</version>
+    <version>1.0.5</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.2</tag>
+      <tag>v1.0.5</tag>
  </scm>

    <!-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++distribution++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -->
@@ -0,0 +1,329 @@
+/*
+ * 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.CommentTools;
+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.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;
+
+/**
+ * ---------------------------------------------------------------------------
+ * 批量插入插件
+ * ---------------------------------------------------------------------------
+ * @author: hewei
+ * @time:2017/1/13 9:33
+ * ---------------------------------------------------------------------------
+ */
+public class BatchInsertPlugin extends PluginAdapter {
+    private static final Logger logger = LoggerFactory.getLogger(BatchInsertPlugin.class);
+    public static final String METHOD_BATCH_INSERT = "batchInsert";  // 方法名
+    private boolean hasModelBuilderPlugin;  // 是否配置了ModelBuilderPlugin插件
+
+    /**
+     * {@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
+                && "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;
+        }
+        return true;
+    }
+
+    /**
+     * 初始化
+     * 具体执行顺序 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));
+            // 添加方法说明
+            CommentTools.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\")"));
+            // 添加方法说明
+            CommentTools.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)
+            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$
+                }
+            }
+
+            // 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());
+
+
+        // 添加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);
+    }
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014.
+ * 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.
@@ -16,12 +16,6 @@

 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 org.mybatis.generator.api.IntrospectedTable;
-import org.mybatis.generator.api.PluginAdapter;
-import org.mybatis.generator.api.dom.java.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

@@ -35,115 +29,16 @@ import java.util.List;
 * @time:2016/12/28 14:56
 * ---------------------------------------------------------------------------
 */
-public class CriteriaBuilderPlugin extends PluginAdapter {
+@Deprecated
+public class CriteriaBuilderPlugin extends ExampleEnhancedPlugin{
    private static final Logger logger = LoggerFactory.getLogger(CriteriaBuilderPlugin.class);
+
    /**
     * {@inheritDoc}
     */
-    public boolean validate(List<String> warnings) {
-        return true;
-    }
-
-    /**
-     * ModelExample Methods 生成
-     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
-     *
-     * @param topLevelClass
-     * @param introspectedTable
-     * @return
-     */
    @Override
-    public boolean modelExampleClassGenerated(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
-        List<InnerClass> innerClasses = topLevelClass.getInnerClasses();
-        for (InnerClass innerClass : innerClasses) {
-            if ("Criteria".equals(innerClass.getType().getShortName())) {
-                // 工厂方法
-                addFactoryMethodToCriteria(topLevelClass, innerClass, introspectedTable);
-                // andIf
-                addAndIfMethodToCriteria(topLevelClass, innerClass, introspectedTable);
-            }
-        }
-
-        List<Method> methods = topLevelClass.getMethods();
-        for (Method method : methods) {
-            if (!"createCriteriaInternal".equals(method.getName()))
-                continue;
-            method.getBodyLines().set(0, "Criteria criteria = new Criteria(this);");
-            logger.debug("itfsw:CriteriaBuilder修改Example的createCriteriaInternal方法，修改构造Criteria时传入Example对象");
-        }
-        return true;
-    }
-
-    /**
-     * 添加工厂方法
-     *
-     * @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);
-
-        // overwrite constructor
-        List<Method> methods = innerClass.getMethods();
-        for (Method method : methods) {
-            if (method.isConstructor()) {
-                method.addParameter(new Parameter(topLevelClass.getType(), "example"));
-                method.addBodyLine("this.example = example;");
-                logger.debug("itfsw:CriteriaBuilder修改Criteria的构造方法，增加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:CriteriaBuilder增加工厂方法example");
-    }
-
-
-    /**
-     * 增强Criteria的链式调用，添加andIf(boolean addIf, CriteriaAdd add)方法，实现链式调用中按条件增加查询语句
-     *
-     * @param topLevelClass
-     * @param innerClass
-     * @param introspectedTable
-     */
-    private void addAndIfMethodToCriteria(TopLevelClass topLevelClass, InnerClass innerClass, IntrospectedTable introspectedTable){
-        // 添加接口CriteriaAdd
-        InnerInterface criteriaAddInterface = new InnerInterface("ICriteriaAdd");
-        criteriaAddInterface.setVisibility(JavaVisibility.PUBLIC);
-        CommentTools.addInterfaceComment(criteriaAddInterface, introspectedTable);
-
-        // ICriteriaAdd增加接口add
-        Method addMethod = new Method("add");
-        addMethod.setReturnType(innerClass.getType());
-        addMethod.addParameter(new Parameter(innerClass.getType(), "add"));
-        CommentTools.addGeneralMethodComment(addMethod, introspectedTable);
-        criteriaAddInterface.addMethod(addMethod);
-        logger.debug("itfsw:Criteria.ICriteriaAdd增加接口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:Criteria增加方法andIf");
+    public boolean validate(List<String> warnings) {
+        logger.warn("itfsw:插件"+this.getClass().getTypeName()+"插件已经过时，请使用com.itfsw.mybatis.generator.plugins.ExampleEnhancedPlugin插件替换！");
+        return super.validate(warnings);
    }
 }
@@ -0,0 +1,186 @@
+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 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;
+
+/**
+ * ---------------------------------------------------------------------------
+ * Example 增强插件
+ * ---------------------------------------------------------------------------
+ * @author: hewei
+ * @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;
+    }
+
+    /**
+     * ModelExample Methods 生成
+     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
+     *
+     * @param topLevelClass
+     * @param introspectedTable
+     * @return
+     */
+    @Override
+    public boolean modelExampleClassGenerated(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
+        List<InnerClass> innerClasses = topLevelClass.getInnerClasses();
+        for (InnerClass innerClass : innerClasses) {
+            if ("Criteria".equals(innerClass.getType().getShortName())) {
+                // 工厂方法
+                addFactoryMethodToCriteria(topLevelClass, innerClass, introspectedTable);
+                // andIf
+                addAndIfMethodToCriteria(topLevelClass, innerClass, introspectedTable);
+            }
+        }
+
+        List<Method> methods = topLevelClass.getMethods();
+        for (Method method : methods) {
+            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对象");
+        }
+
+        // orderBy方法
+        addOrderByMethodToExample(topLevelClass, introspectedTable);
+
+        return true;
+    }
+
+    /**
+     * 添加工厂方法
+     *
+     * @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);
+
+        // overwrite constructor
+        List<Method> methods = innerClass.getMethods();
+        for (Method method : methods) {
+            if (method.isConstructor()) {
+                method.addParameter(new Parameter(topLevelClass.getType(), "example"));
+                method.addBodyLine("this.example = example;");
+                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");
+    }
+
+
+    /**
+     * 增强Criteria的链式调用，添加andIf(boolean addIf, CriteriaAdd add)方法，实现链式调用中按条件增加查询语句
+     *
+     * @param topLevelClass
+     * @param innerClass
+     * @param 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");
+
+        // ICriteriaAdd增加接口add
+        Method addMethod = new Method("add");
+        addMethod.setReturnType(innerClass.getType());
+        addMethod.addParameter(new Parameter(innerClass.getType(), "add"));
+        CommentTools.addGeneralMethodComment(addMethod, introspectedTable);
+        criteriaAddInterface.addMethod(addMethod);
+        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");
+    }
+
+    /**
+     * Example增强了setOrderByClause方法，新增orderBy(String orderByClause)方法直接返回example，增强链式调用，可以一路.下去了。
+     *
+     * @param topLevelClass
+     * @param 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");
+
+        // 添加orderBy
+        Method mOrderByMore = new Method("orderBy");
+        mOrderByMore.setVisibility(JavaVisibility.PUBLIC);
+        mOrderByMore.setReturnType(topLevelClass.getType());
+        mOrderByMore.addParameter(new Parameter(FullyQualifiedJavaType.getStringInstance(), "orderByClauses", true));
+
+        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)");
+    }
+}
@@ -1,6 +1,6 @@
 /*
 *
- *  * Copyright (c) 2014.
+ *  * 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.
@@ -22,6 +22,7 @@ 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;

@@ -38,15 +39,20 @@ import java.util.Properties;
 */
 public class ExampleTargetPlugin extends PluginAdapter {
    public static final String TARGET_PACKAGE_KEY = "targetPackage";  // 配置targetPackage名
-    private static final Logger logger = LoggerFactory.getLogger(CriteriaBuilderPlugin.class);
+    private static final Logger logger = LoggerFactory.getLogger(ExampleTargetPlugin.class);

-    private String targetPackage;   // 目标包
+    private static String targetPackage;   // 目标包

    /**
     * {@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;
+        }
        // 获取配置的目标package
        Properties properties = getProperties();
        this.targetPackage = properties.getProperty(TARGET_PACKAGE_KEY);
@@ -74,7 +80,7 @@ public class ExampleTargetPlugin extends PluginAdapter {

        introspectedTable.setExampleType(newExampleType);

-        logger.debug("itfsw:修改"+exampleType+"的包到"+this.targetPackage);
+        logger.debug("itfsw(Example 目标包修改插件):修改"+introspectedTable.getExampleType()+"的包到"+this.targetPackage);
    }

 }
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014.
+ * 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.
@@ -23,6 +23,7 @@ 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;

@@ -41,9 +42,21 @@ public class LimitPlugin extends PluginAdapter {
    /**
     * {@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;
    }
+
    /**
     * ModelExample Methods 生成
     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
@@ -69,7 +82,7 @@ public class LimitPlugin extends PluginAdapter {
        rows.setType(integerWrapper);
        CommentTools.addFieldComment(rows, introspectedTable);
        topLevelClass.addField(rows);
-        logger.debug("itfsw:分页插件增加Example的offset和rows字段");
+        logger.debug("itfsw(MySQL分页插件):"+topLevelClass.getType().getShortName()+"增加offset和rows字段");

        // 增加getter && setter 方法
        Method setOffset = new Method();
@@ -103,38 +116,44 @@ public class LimitPlugin extends PluginAdapter {
        getRows.addBodyLine("return rows;");
        CommentTools.addGeneralMethodComment(getRows, introspectedTable);
        topLevelClass.addMethod(getRows);
-        logger.debug("itfsw:分页插件增加Example的offset和rows的getter和setter");
+        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);
        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);
        topLevelClass.addMethod(setLimit2);
-        logger.debug("itfsw:分页插件增加Example的limit方法");
+        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);
        topLevelClass.addMethod(setPage);
-        logger.debug("itfsw:分页插件增加Example的page方法");
+        logger.debug("itfsw(MySQL分页插件):"+topLevelClass.getType().getShortName()+"增加page方法");

        // !!! clear 方法增加 offset 和 rows的清理
        List<Method> methodList = topLevelClass.getMethods();
@@ -142,7 +161,7 @@ public class LimitPlugin extends PluginAdapter {
            if (method.getName().equals("clear")){
                method.addBodyLine("rows = null;");
                method.addBodyLine("offset = null;");
-                logger.debug("itfsw:分页插件修正Example的clear方法,增加rows和offset字段的清空");
+                logger.debug("itfsw(MySQL分页插件):"+topLevelClass.getType().getShortName()+"修改clear方法,增加rows和offset字段的清空");
            }
        }

@@ -174,6 +193,8 @@ public class LimitPlugin extends PluginAdapter {

        element.addElement(ifLimitNotNullElement);

+        logger.debug("itfsw(MySQL分页插件):"+introspectedTable.getMyBatis3XmlMapperFileName()+"selectByExample方法增加分页条件。");
+
        return true;
    }

@@ -0,0 +1,419 @@
+/*
+ * 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.CommentTools;
+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.*;
+
+/**
+ * ---------------------------------------------------------------------------
+ * 逻辑删除插件
+ * ---------------------------------------------------------------------------
+ * @author: hewei
+ * @time:2017/1/13 14:08
+ * ---------------------------------------------------------------------------
+ */
+public class LogicalDeletePlugin extends PluginAdapter {
+    private static final Logger logger = LoggerFactory.getLogger(LogicalDeletePlugin.class);
+
+    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 DEL_FLAG_NAME = "DEL_FLAG";  // 逻辑删除标志位常量名称
+
+    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;
+    }
+
+    /**
+     * 初始化阶段
+     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
+     *
+     * @param introspectedTable
+     * @return
+     */
+    @Override
+    public void initialized(IntrospectedTable introspectedTable) {
+        // 1. 首先获取全局配置
+        Properties properties = getProperties();
+        String logicalDeleteColumn = properties.getProperty(LOGICAL_DELETE_COLUMN_KEY);
+        this.logicalDeleteValue = properties.getProperty(LOGICAL_DELETE_VALUE_KEY);
+        // 2. 获取表单独配置，如果有则覆盖全局配置
+        if (introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_COLUMN_KEY) != null){
+            logicalDeleteColumn = introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_COLUMN_KEY);
+        }
+        if (introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_VALUE_KEY) != null){
+            this.logicalDeleteValue = introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_VALUE_KEY);
+        }
+        // 3. 判断该表是否存在逻辑删除列
+        this.logicalDeleteColumn = null;
+        List<IntrospectedColumn> columns = introspectedTable.getAllColumns();
+        for (IntrospectedColumn column : columns) {
+            if (column.getActualColumnName().equalsIgnoreCase(logicalDeleteColumn)){
+                // 判断字段类型
+                JDBCType type = JDBCType.valueOf(column.getJdbcType());
+                if (JDBCType.BIGINT == type
+                        || JDBCType.BIT == type
+                        || JDBCType.BOOLEAN == type
+                        || JDBCType.CHAR == type
+                        || JDBCType.DECIMAL == type
+                        || JDBCType.DOUBLE == type
+                        || JDBCType.FLOAT == type
+                        || JDBCType.INTEGER == type
+                        || JDBCType.LONGNVARCHAR == type
+                        || JDBCType.LONGVARCHAR == type
+                        || JDBCType.NCHAR == type
+                        || JDBCType.NUMERIC == type
+                        || JDBCType.NVARCHAR == type
+                        || JDBCType.SMALLINT == type
+                        || JDBCType.TINYINT == type
+                        || JDBCType.VARCHAR == type){
+                    this.logicalDeleteColumn = column;
+                } else {
+                    logger.warn("itfsw(逻辑删除插件):"+introspectedTable.getFullyQualifiedTable()+"逻辑删除列("+introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_COLUMN_KEY)+")的类型不在支持范围（请使用数字列，字符串列，布尔列）！");
+                }
+            }
+        }
+
+        if (introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_COLUMN_KEY) != null && this.logicalDeleteColumn == null){
+            logger.warn("itfsw(逻辑删除插件):"+introspectedTable.getFullyQualifiedTable()+"没有找到您配置的逻辑删除列("+introspectedTable.getTableConfigurationProperty(LOGICAL_DELETE_COLUMN_KEY)+")！");
+        }
+    }
+
+    /**
+     * 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 (this.logicalDeleteColumn != null){
+            // 1. 逻辑删除ByExample
+            Method mLogicalDeleteByExample = new Method(METHOD_LOGICAL_DELETE_BY_EXAMPLE);
+            // 返回值类型
+            mLogicalDeleteByExample.setReturnType(FullyQualifiedJavaType.getIntInstance());
+            // 添加参数
+            FullyQualifiedJavaType type = new FullyQualifiedJavaType(introspectedTable.getExampleType());
+            mLogicalDeleteByExample.addParameter(new Parameter(type, "example"));
+            // 添加方法说明
+            CommentTools.addGeneralMethodComment(mLogicalDeleteByExample, introspectedTable);
+            // interface 增加方法
+            interfaze.addMethod(mLogicalDeleteByExample);
+            logger.debug("itfsw(逻辑删除插件):"+interfaze.getType().getShortName()+"增加方法logicalDeleteByExample。");
+
+            // 2. 判断是否有主键，生成主键删除方法
+            if (introspectedTable.hasPrimaryKeyColumns()){
+                // 1. 逻辑删除ByExample
+                Method mLogicalDeleteByPrimaryKey = new Method(METHOD_LOGICAL_DELETE_BY_PRIMARY_KEY);
+                // 返回值类型
+                mLogicalDeleteByPrimaryKey.setReturnType(FullyQualifiedJavaType.getIntInstance());
+
+                // 添加参数
+                Set<FullyQualifiedJavaType> importedTypes = new TreeSet<FullyQualifiedJavaType>();
+                if (introspectedTable.getRules().generatePrimaryKeyClass()) {
+                    FullyQualifiedJavaType type1 = new FullyQualifiedJavaType(introspectedTable.getPrimaryKeyType());
+                    importedTypes.add(type1);
+                    mLogicalDeleteByPrimaryKey.addParameter(new Parameter(type1, "key")); //$NON-NLS-1$
+                } else {
+                    // no primary key class - fields are in the base class
+                    // if more than one PK field, then we need to annotate the
+                    // parameters
+                    // for MyBatis
+                    List<IntrospectedColumn> introspectedColumns = introspectedTable.getPrimaryKeyColumns();
+                    boolean annotate = introspectedColumns.size() > 1;
+                    if (annotate) {
+                        importedTypes.add(new FullyQualifiedJavaType("org.apache.ibatis.annotations.Param")); //$NON-NLS-1$
+                    }
+                    StringBuilder sb = new StringBuilder();
+                    for (IntrospectedColumn introspectedColumn : introspectedColumns) {
+                        FullyQualifiedJavaType type1 = introspectedColumn.getFullyQualifiedJavaType();
+                        importedTypes.add(type1);
+                        Parameter parameter = new Parameter(type1, introspectedColumn.getJavaProperty());
+                        if (annotate) {
+                            sb.setLength(0);
+                            sb.append("@Param(\""); //$NON-NLS-1$
+                            sb.append(introspectedColumn.getJavaProperty());
+                            sb.append("\")"); //$NON-NLS-1$
+                            parameter.addAnnotation(sb.toString());
+                        }
+                        mLogicalDeleteByPrimaryKey.addParameter(parameter);
+                    }
+                }
+
+                // 添加方法说明
+                CommentTools.addGeneralMethodComment(mLogicalDeleteByPrimaryKey, introspectedTable);
+                // interface 增加方法
+                interfaze.addImportedTypes(importedTypes);
+                interfaze.addMethod(mLogicalDeleteByPrimaryKey);
+                logger.debug("itfsw(逻辑删除插件):"+interfaze.getType().getShortName()+"增加方法logicalDeleteByPrimaryKey。");
+            }
+        }
+        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 (this.logicalDeleteColumn != null){
+            // 1. 逻辑删除ByExample
+            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);
+
+            StringBuilder sb = new StringBuilder();
+            sb.append("update "); //$NON-NLS-1$
+            sb.append(introspectedTable.getAliasedFullyQualifiedTableNameAtRuntime());
+            sb.append(" set ");
+            // 更新逻辑删除字段
+            sb.append(this.logicalDeleteColumn.getActualColumnName());
+            sb.append(" = ");
+
+            // 判断字段类型
+            JDBCType type = JDBCType.valueOf(this.logicalDeleteColumn.getJdbcType());
+            if (this.logicalDeleteValue == null || "NULL".equalsIgnoreCase(this.logicalDeleteValue)){
+                sb.append("NULL");
+            } else if (JDBCType.CHAR == type
+                    || JDBCType.LONGNVARCHAR == type
+                    || JDBCType.LONGVARCHAR == type
+                    || JDBCType.NCHAR == type
+                    || JDBCType.NVARCHAR == type
+                    || JDBCType.VARCHAR == type){
+                sb.append("'");
+                sb.append(this.logicalDeleteValue);
+                sb.append("'");
+            } else {
+                sb.append(this.logicalDeleteValue);
+            }
+
+            logicalDeleteByExample.addElement(new TextElement(sb.toString()));
+
+            logicalDeleteByExample.addElement(XmlElementGeneratorTools.getUpdateByExampleIncludeElement(introspectedTable));
+            document.getRootElement().addElement(logicalDeleteByExample);
+            logger.debug("itfsw(逻辑删除插件):"+introspectedTable.getMyBatis3XmlMapperFileName()+"增加方法logicalDeleteByExample的实现。");
+
+            // 2. 判断是否有主键，生成主键删除方法
+            if (introspectedTable.hasPrimaryKeyColumns()){
+                XmlElement logicalDeleteByPrimaryKey = new XmlElement("update"); //$NON-NLS-1$
+                logicalDeleteByPrimaryKey.addAttribute(new Attribute("id", METHOD_LOGICAL_DELETE_BY_PRIMARY_KEY));
+
+                String parameterClass;
+                if (introspectedTable.getRules().generatePrimaryKeyClass()) {
+                    parameterClass = introspectedTable.getPrimaryKeyType();
+                } else {
+                    // PK fields are in the base class. If more than on PK
+                    // field, then they are coming in a map.
+                    if (introspectedTable.getPrimaryKeyColumns().size() > 1) {
+                        parameterClass = "map"; //$NON-NLS-1$
+                    } else {
+                        parameterClass = introspectedTable.getPrimaryKeyColumns().get(0).getFullyQualifiedJavaType().toString();
+                    }
+                }
+                logicalDeleteByPrimaryKey.addAttribute(new Attribute("parameterType", parameterClass));
+                CommentTools.addComment(logicalDeleteByPrimaryKey);
+
+                StringBuilder sb1 = new StringBuilder();
+                sb1.append("update "); //$NON-NLS-1$
+                sb1.append(introspectedTable.getAliasedFullyQualifiedTableNameAtRuntime());
+                sb1.append(" set ");
+                // 更新逻辑删除字段
+                sb1.append(this.logicalDeleteColumn.getActualColumnName());
+                sb1.append(" = ");
+
+                // 判断字段类型
+                JDBCType type1 = JDBCType.valueOf(this.logicalDeleteColumn.getJdbcType());
+                if (this.logicalDeleteValue == null || "NULL".equalsIgnoreCase(this.logicalDeleteValue)){
+                    sb1.append("NULL");
+                } else if (JDBCType.CHAR == type1
+                        || JDBCType.LONGNVARCHAR == type1
+                        || JDBCType.LONGVARCHAR == type1
+                        || JDBCType.NCHAR == type1
+                        || JDBCType.NVARCHAR == type1
+                        || JDBCType.VARCHAR == type1){
+                    sb1.append("'");
+                    sb1.append(this.logicalDeleteValue);
+                    sb1.append("'");
+                } else {
+                    sb1.append(this.logicalDeleteValue);
+                }
+
+                logicalDeleteByPrimaryKey.addElement(new TextElement(sb1.toString()));
+
+                boolean and = false;
+                for (IntrospectedColumn introspectedColumn : introspectedTable.getPrimaryKeyColumns()) {
+                    sb.setLength(0);
+                    if (and) {
+                        sb.append("  and "); //$NON-NLS-1$
+                    } else {
+                        sb.append("where "); //$NON-NLS-1$
+                        and = true;
+                    }
+
+                    sb.append(MyBatis3FormattingUtilities.getEscapedColumnName(introspectedColumn));
+                    sb.append(" = "); //$NON-NLS-1$
+                    sb.append(MyBatis3FormattingUtilities.getParameterClause(introspectedColumn));
+                    logicalDeleteByPrimaryKey.addElement(new TextElement(sb.toString()));
+                }
+
+                document.getRootElement().addElement(logicalDeleteByPrimaryKey);
+                logger.debug("itfsw(逻辑删除插件):"+introspectedTable.getMyBatis3XmlMapperFileName()+"增加方法logicalDeleteByPrimaryKey的实现。");
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Model 生成
+     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
+     *
+     * @param topLevelClass
+     * @param introspectedTable
+     * @return
+     */
+    @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);
+            logger.debug("itfsw(逻辑删除插件):"+topLevelClass.getType().getShortName()+"增加方法DEL_FLAG的常量。");
+        }
+        return true;
+    }
+
+    /**
+     * ModelExample Methods 生成
+     * 具体执行顺序 http://www.mybatis.org/generator/reference/pluggingIn.html
+     *
+     * @param topLevelClass
+     * @param introspectedTable
+     * @return
+     */
+    @Override
+    public boolean modelExampleClassGenerated(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
+        if (this.logicalDeleteColumn != null){
+            // 引入 Model类
+            FullyQualifiedJavaType model = introspectedTable.getRules().calculateAllFieldsClass();
+            topLevelClass.addImportedType(model);
+
+            List<InnerClass> innerClasses = topLevelClass.getInnerClasses();
+            for (InnerClass innerClass : innerClasses) {
+                if ("Criteria".equals(innerClass.getType().getShortName())) {
+                    // 增加逻辑删除条件
+                    Method method = new Method(METHOD_LOGICAL_DELETE);
+                    CommentTools.addGeneralMethodComment(method, introspectedTable);
+                    method.setVisibility(JavaVisibility.PUBLIC);
+                    method.setReturnType(innerClass.getType());
+                    method.addParameter(new Parameter(FullyQualifiedJavaType.getBooleanPrimitiveInstance(), "deleted"));
+
+                    StringBuffer sb = new StringBuffer();
+                    sb.append("return deleted ? ");
+
+                    String modelName = model.getShortName();
+
+                    // 调用EqualTo方法
+                    StringBuilder equalToMethodName = new StringBuilder();
+                    equalToMethodName.append(this.logicalDeleteColumn.getJavaProperty());
+                    equalToMethodName.setCharAt(0, Character.toUpperCase(equalToMethodName.charAt(0)));
+                    equalToMethodName.insert(0, "and"); //$NON-NLS-1$
+                    equalToMethodName.append("EqualTo");
+                    sb.append(equalToMethodName);
+                    sb.append("("+modelName + "." + DEL_FLAG_NAME + ")");
+
+                    sb.append(" : ");
+
+                    // 调用NotEqualTo 方法
+                    StringBuilder notEqualToMethodName = new StringBuilder();
+                    notEqualToMethodName.append(this.logicalDeleteColumn.getJavaProperty());
+                    notEqualToMethodName.setCharAt(0, Character.toUpperCase(notEqualToMethodName.charAt(0)));
+                    notEqualToMethodName.insert(0, "and"); //$NON-NLS-1$
+                    notEqualToMethodName.append("NotEqualTo");
+                    sb.append(notEqualToMethodName);
+                    sb.append("("+modelName + "." + DEL_FLAG_NAME + ")");
+
+                    sb.append(";");
+
+                    method.addBodyLine(sb.toString());
+
+                    innerClass.addMethod(method);
+                    logger.debug("itfsw(逻辑删除插件):"+topLevelClass.getType().getShortName()+"."+innerClass.getType().getShortName()+"增加andDeleted方法。");
+                }
+            }
+        }
+        return true;
+    }
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014.
+ * 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.
@@ -22,6 +22,7 @@ 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;

@@ -42,7 +43,13 @@ public class ModelBuilderPlugin extends PluginAdapter {
    /**
     * {@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;
    }

@@ -62,22 +69,23 @@ public class ModelBuilderPlugin extends PluginAdapter {
        InnerClass innerClass = new InnerClass(BUILDER_CLASS_NAME);
        innerClass.setVisibility(JavaVisibility.PUBLIC);
        innerClass.setStatic(true);
-        CommentTools.addClassComment(innerClass, introspectedTable);
-        logger.debug("itfsw:生成内部Builder类");
+        CommentTools.addInnerClassComment(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);
        innerClass.addField(f);

        // 构造构造方法
        Method constructor = new Method(BUILDER_CLASS_NAME);
        constructor.setVisibility(JavaVisibility.PUBLIC);
        constructor.setConstructor(true);
-        constructor.addBodyLine(new StringBuilder("this.obj = new ")
-                .append(topLevelClass.getType().getShortName()).append("();").toString());
+        constructor.addBodyLine(new StringBuilder("this.obj = new ").append(topLevelClass.getType().getShortName()).append("();").toString());
+        CommentTools.addGeneralMethodComment(constructor, introspectedTable);
        innerClass.addMethod(constructor);
-        logger.debug("itfsw:生成内部Builder类构造方法");
+        logger.debug("itfsw(数据Model链式构建插件):"+topLevelClass.getType().getShortName()+".Builder增加的构造方法。");

        // ！！可能Model存在复合主键情况，字段要加上这些
        if (topLevelClass.getSuperClass() != null && topLevelClass.getSuperClass().compareTo(new FullyQualifiedJavaType(introspectedTable.getPrimaryKeyType())) == 0){
@@ -94,7 +102,7 @@ public class ModelBuilderPlugin extends PluginAdapter {
                method.addBodyLine(new StringBuilder().append("return this;").toString());
                CommentTools.addGeneralMethodComment(method, introspectedTable);
                innerClass.addMethod(method);
-                logger.debug("itfsw:生成内部Builder类的复合主键字段对应方法"+field.getName());
+                logger.debug("itfsw(数据Model链式构建插件):"+topLevelClass.getType().getShortName()+".Builder增加"+method.getName()+"方法(复合主键)。");
            }
        }

@@ -112,7 +120,7 @@ public class ModelBuilderPlugin extends PluginAdapter {
            method.addBodyLine(new StringBuilder().append("return this;").toString());
            CommentTools.addGeneralMethodComment(method, introspectedTable);
            innerClass.addMethod(method);
-            logger.debug("itfsw:生成内部Builder类的普通字段对应方法"+field.getName());
+            logger.debug("itfsw(数据Model链式构建插件):"+topLevelClass.getType().getShortName()+".Builder增加"+method.getName()+"方法。");
        }

        Method build = new Method("build");
@@ -121,7 +129,7 @@ public class ModelBuilderPlugin extends PluginAdapter {
        build.addBodyLine("return this.obj;");
        CommentTools.addGeneralMethodComment(build, introspectedTable);
        innerClass.addMethod(build);
-        logger.debug("itfsw:生成内部Builder类的build方法");
+        logger.debug("itfsw(数据Model链式构建插件):"+topLevelClass.getType().getShortName()+".Builder增加build方法。");

        topLevelClass.addInnerClass(innerClass);
        return true;
@@ -0,0 +1,137 @@
+/*
+ * 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.CommentTools;
+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;
+
+/**
+ * ---------------------------------------------------------------------------
+ * 数据Model属性对应Column获取插件
+ * ---------------------------------------------------------------------------
+ * @author: hewei
+ * @time:2017/1/17 11:20
+ * ---------------------------------------------------------------------------
+ */
+public class ModelColumnPlugin  extends PluginAdapter {
+    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
+     */
+    @Override
+    public boolean modelBaseRecordClassGenerated(TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
+        List<Field> fields = topLevelClass.getFields();
+
+        // 生成内部枚举
+        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类。");
+
+        // 生成属性和构造函数
+        Field columnField = new Field("column", FullyQualifiedJavaType.getStringInstance());
+        columnField.setVisibility(JavaVisibility.PRIVATE);
+        columnField.setFinal(true);
+        CommentTools.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);
+        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);
+        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);
+        innerEnum.addMethod(constructor);
+        logger.debug("itfsw(数据Model属性对应Column获取插件):"+topLevelClass.getType().getShortName()+".Column增加构造方法和column属性。");
+
+        // Enum枚举
+        for (IntrospectedColumn introspectedColumn : introspectedTable.getAllColumns()) {
+            Field field = JavaBeansUtil.getJavaBeansField(introspectedColumn, context, introspectedTable);
+
+            StringBuffer sb = new StringBuffer();
+            sb.append(field.getName());
+            sb.append("(\"");
+            sb.append(introspectedColumn.getActualColumnName());
+            sb.append("\")");
+
+            innerEnum.addEnumConstant(sb.toString());
+            logger.debug("itfsw(数据Model属性对应Column获取插件):" + topLevelClass.getType().getShortName() + ".Column增加" + field.getName() + "枚举。");
+        }
+
+        // asc 和 desc 方法
+        Method desc = new Method("desc");
+        desc.setVisibility(JavaVisibility.PUBLIC);
+        desc.setReturnType(FullyQualifiedJavaType.getStringInstance());
+        desc.addBodyLine("return this.column + \" DESC\";");
+        CommentTools.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);
+        innerEnum.addMethod(asc);
+        logger.debug("itfsw(数据Model属性对应Column获取插件):" + topLevelClass.getType().getShortName() + ".Column增加asc()和desc()方法。");
+
+        topLevelClass.addInnerEnum(innerEnum);
+        return true;
+    }
+}
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014.
+ * 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.
@@ -25,6 +25,7 @@ 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;

@@ -49,6 +50,11 @@ public class SelectOneByExamplePlugin 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;
+        }
        return true;
    }

@@ -63,11 +69,10 @@ public class SelectOneByExamplePlugin extends PluginAdapter {
     */
    @Override
    public boolean clientGenerated(Interface interfaze, TopLevelClass topLevelClass, IntrospectedTable introspectedTable) {
-        logger.debug("itfsw:生成"+interfaze.getType()+"对应SelectOneByExample方法...");
        // 方法生成
        Method method = new Method(METHOD_NAME);
-        // 方法可见性
-        method.setVisibility(JavaVisibility.PUBLIC);
+        // 方法可见性 interface会忽略
+        // method.setVisibility(JavaVisibility.PUBLIC);
        // 返回值类型
        FullyQualifiedJavaType returnType = introspectedTable.getRules().calculateAllFieldsClass();
        method.setReturnType(returnType);
@@ -79,6 +84,7 @@ public class SelectOneByExamplePlugin extends PluginAdapter {

        // interface 增加方法
        interfaze.addMethod(method);
+        logger.debug("itfsw(查询单条数据插件):"+interfaze.getType().getShortName()+"增加SelectOneByExample方法。");
        return true;
    }

@@ -92,8 +98,6 @@ public class SelectOneByExamplePlugin extends PluginAdapter {
     */
    @Override
    public boolean sqlMapDocumentGenerated(Document document, IntrospectedTable introspectedTable) {
-        logger.debug("itfsw:生成表"+introspectedTable.getAliasedFullyQualifiedTableNameAtRuntime()+"("+ (introspectedTable.hasBLOBColumns() ? "有" : "无")+"Blob类型)的mapping.xml对应SelectOneByExample方法...");
-
        //数据库表名
        String tableName = introspectedTable.getAliasedFullyQualifiedTableNameAtRuntime();

@@ -172,6 +176,7 @@ public class SelectOneByExamplePlugin extends PluginAdapter {

        // 添加到根节点
        document.getRootElement().addElement(selectOneElement);
+        logger.debug("itfsw(查询单条数据插件):"+introspectedTable.getMyBatis3XmlMapperFileName()+"增加SelectOneByExample方法("+(introspectedTable.hasBLOBColumns() ? "有" : "无")+"Blob类型))。");

        return true;
    }
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014.
+ * 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.
@@ -17,10 +17,7 @@
 package com.itfsw.mybatis.generator.plugins.utils;

 import org.mybatis.generator.api.IntrospectedTable;
-import org.mybatis.generator.api.dom.java.Field;
-import org.mybatis.generator.api.dom.java.InnerClass;
-import org.mybatis.generator.api.dom.java.Interface;
-import org.mybatis.generator.api.dom.java.Method;
+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;
@@ -62,7 +59,7 @@ public class CommentTools {
     * @param innerClass 类
     * @param introspectedTable 表
     */
-    public static void addClassComment(InnerClass innerClass, IntrospectedTable 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$
@@ -75,6 +72,25 @@ public class CommentTools {
        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$
+    }
+
    /**
     * 生成通用方法注解
     *
@@ -1,6 +1,6 @@
 /*
 *
- *  * Copyright (c) 2014.
+ *  * 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.
@@ -1,6 +1,6 @@
 /*
 *
- *  * Copyright (c) 2014.
+ *  * 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.
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014.
+ * 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.
Author	SHA1	Message	Date
hewei	fc71a45d7a	[maven-release-plugin] prepare release v1.0.5	2017-01-17 18:10:44 +08:00
hewei	cf5c29c71a	1. 增加了数据Model属性对应Column获取插件（ModelColumnPlugin）； 2. 强化了example的orderBy方法； 3. 强化批量插入插件，实现按需插入指定字段；	2017-01-17 18:09:48 +08:00
何伟	9ee5ec9e20	Update README.md	2017-01-17 09:30:35 +08:00
hewei	1d2d2d1a47	README.md 修改	2017-01-16 18:34:47 +08:00
hewei	638a640996	[maven-release-plugin] prepare for next development iteration	2017-01-16 18:18:49 +08:00
hewei	4b3adacece	[maven-release-plugin] prepare release v1.0.4	2017-01-16 18:18:32 +08:00
hewei	51b8abee4d	版本说明	2017-01-16 18:18:01 +08:00
hewei	5662c7f91b	版本说明	2017-01-16 18:14:48 +08:00
hewei	7e403d1dc4	统一插件调试日志格式	2017-01-16 17:47:55 +08:00
hewei	38417972a1	ExampleEnhancedPlugin 插件增加OrderBy方法	2017-01-16 17:02:01 +08:00
hewei	ce099f8112	ExampleEnhancedPlugin 插件替换CriteriaBuilderPlugin插件，上个插件命名容易引起误解	2017-01-16 16:32:02 +08:00
hewei	384467ef99	Mysql分页插件增强链式调用。	2017-01-16 16:24:59 +08:00
hewei	b1a61bbbf4	[maven-release-plugin] prepare for next development iteration	2017-01-13 18:22:47 +08:00
hewei	7d910b7160	[maven-release-plugin] prepare release v1.0.3	2017-01-13 18:22:29 +08:00
hewei	d8e61cef5a	README.md增加新插件描述	2017-01-13 18:21:24 +08:00
hewei	fc0d2adfd7	增加逻辑删除插件	2017-01-13 17:54:27 +08:00
hewei	2cfa1ddd2d	修正批量插入插件	2017-01-13 14:01:47 +08:00
hewei	d12454d3aa	增加一些必要验证，同时增加批量插入插件	2017-01-13 13:21:19 +08:00
hewei	d412fb37d3	一些修正和新增插件	2017-01-13 10:02:28 +08:00
hewei	a316fceb49	版本更新	2017-01-12 18:48:57 +08:00
hewei	a88e4ab07a	[maven-release-plugin] prepare for next development iteration	2017-01-12 18:38:17 +08:00