自定义Mybatis逆向工程Maven插件

约定不等于承诺〃 2022-05-31 03:12 272阅读 0赞

我的一篇博客介绍了基于Java Config形式的[Mybatis逆向工程][Mybatis]，通过定义几个java变量，然后运行main方法可以执行逆向工程，这篇博客就是将那个工程改造成一个Maven插件。

开发Maven插件，首先需要创建一个Maven Plugin项目，我是基于IDEA开发的。IDEA如何创建Maven插件项目自行百度，这里就不说了。  
创建好Mojo项目后，需要修改器Pom.xml文件，指定packaging类型为maven-plugin，同时添加开发插件的依赖：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.bob</groupId>
        <artifactId>plugin</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>maven-plugin</packaging>
    
        <properties>
            <maven.version>3.5.2</maven.version>
            <plugin-annotations.version>3.3</plugin-annotations.version>
            <mybatis-generator>1.3.5</mybatis-generator>
        </properties>
    
    
        <dependencies>
    
            <dependency>
                <groupId>org.apache.maven</groupId>
                <artifactId>maven-plugin-api</artifactId>
                <version>${maven.version}</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.maven.plugin-tools</groupId>
                <artifactId>maven-plugin-annotations</artifactId>
                <version>${plugin-annotations.version}</version>
            </dependency>
    
    
            
            <dependency>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-core</artifactId>
                <version>${mybatis-generator}</version>
            </dependency>
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.7.0</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    
    </project>

@Mojo()：定义插件目标，一个插件可以有多个目标，也就是有 多个@Mojo标识的AbstractMojo子类，绑定插件时可以自由选择将哪个目标绑定到Maven生命周期的某个阶段。

下一步你需要有一个类去继承AbstractMojo，重写其execute方法，插件在执行时会调用此方法，也就是说此方法是插件的入口。插件在启动时会实例化一个AbstractMojo的子类，具体实例化谁需要看@Mojo注解在哪层子类上，所以此处我定义了两个类直接或间接继承AbstractMojo，MybatisGeneratorConfig作为配置类，MybatisGenerator是实际执行逆向工程的工具类，MybatisGenerator 继承MybatisGeneratorConfig，将@Mojo标识在MybatisGenerator上。这样MybatisGenerator在执行execute方法时能够获取到MybatisGeneratorConfig里的配置信息。

/** * Mybatis逆向工程解析器 * 基于Mybatis Generator 1.3.5 Release * * @author wb-jjb318191 * @create 2017-09-28 17:08 */
    public abstract class MybatisGenerator extends AbstractMojo { 
    
        /** * 指定要生成的Table */
        @Parameter(required = true)
        protected List<String> tables;
    
        /** * 连接数据库驱动包,默认地址前缀是"targetModule"模块下的resources路径 */
        @Parameter(defaultValue = "mysql-connector-java-5.1.44-bin.jar")
        protected String driverPath;
    
        /** * 指定生成java文件的编码格式 */
        @Parameter(defaultValue = "UTF-8")
        protected String fileEncoding;
    
        /** * 指定JDBC信息 */
        @Parameter(defaultValue = "com.mysql.jdbc.Driver")
        protected String driverClass;
    
        /** * 指定连接数据库的地址 */
        @Parameter(defaultValue = "jdbc:mysql://localhost:3306/project")
        protected String connectionUrl;
    
        /** * 用户名 */
        @Parameter(defaultValue = "root")
        protected String userName;
    
        /** * 密码 */
        @Parameter(defaultValue = "lanboal")
        protected String password;
    
        /** * 指定项目根目录 */
        @Parameter(property = "user.dir")
        private String projectRootPath;
    
        /** * 指定文件生成的模块 */
        @Parameter(defaultValue = "")
        private String targetModule;
    
        /** * java根路径 */
        @Parameter(defaultValue = "\\src\\main\\java")
        private String javaPath;
    
        /** * 资源根路径 */
        @Parameter(defaultValue = "\\src\\main\\resources")
        private String resuorcesPath;
    
        /** * 指定Java Model生成位置 */
        protected String javaModelTargetProject;
    
        /** * java实体类包名 */
        @Parameter(defaultValue = "com.bob.project.mvc.entity.model")
        protected String javaModelPackage;
    
        /** * 指定Java DAO接口生成位置 */
        protected String javaMapperTargetProject;
    
        /** * Mapper接口包名 */
        @Parameter(defaultValue = "com.bob.project.mvc.mapper")
        protected String javaMapperPackage;
    
        /** * 指定Mapper.xml生成位置 */
        protected String sqlmapTargetproject;
    
        /** * Mapper.xml文件路径 */
        @Parameter(defaultValue = "com.bob.project.mvc.mapper", required = false)
        protected String sqlMapperPackage;
    
        /** * 初始化参数 */
        protected void initParameter() {
            if (!"".equals(targetModule)) {
                targetModule = "\\" + targetModule;
            }
            String pathPrefix = projectRootPath + targetModule;
            javaModelTargetProject = pathPrefix + javaPath;
            javaMapperTargetProject = pathPrefix + javaPath;
            sqlmapTargetproject = pathPrefix + resuorcesPath;
            //获取驱动Jar包的路径,若不是本地地址,则加上项目前缀
            if (!driverPath.contains(":")) {
                driverPath = sqlmapTargetproject + "\\" + driverPath;
            }
        }
    
        protected void printParameters() {
            System.out.println("打印逆向工程打印参数");
            System.out.println("tables :" + tables.toString());
            System.out.println("fileEncoding :" + fileEncoding.toString());
            System.out.println("driverPath :" + driverPath.toString());
            System.out.println("driverClass :" + driverClass.toString());
            System.out.println("connectionUrl :" + connectionUrl.toString());
            System.out.println("userName :" + userName.toString());
            System.out.println("password :" + password.toString());
            System.out.println("targetModule :" + targetModule.toString());
            System.out.println("projectRootPath :" + projectRootPath.toString());
            System.out.println("javaModelTargetProject :" + javaModelTargetProject.toString());
            System.out.println("javaMapperTargetProject :" + javaMapperTargetProject.toString());
            System.out.println("sqlmapTargetproject :" + sqlmapTargetproject.toString());
        }
    
    }
    
    /** * Mybatis逆向工程基于Java形式的配置类 * * @author wb-jjb318191 * @create 2017-09-30 9:17 */
    @Mojo(name = "mybatisGenerate")
    public class MybatisGenerator extends MybatisGeneratorConfig { 
    
        @Override
        public void execute() throws MojoExecutionException, MojoFailureException {
            initParameter();
            printParameters();
            try {
                Configuration config = configMybatisGenerator();
                MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, new DefaultShellCallback(true), new ArrayList<String>());
                myBatisGenerator.generate(null);
            } catch (Exception e) {
                System.out.println("逆向工程执行失败");
                e.printStackTrace();
            }
        }
    
        public Configuration configMybatisGenerator() {
            Configuration configuration = new Configuration();
            configuration.addClasspathEntry(driverPath);
            Context context = new Context(null);
            context.setTargetRuntime("MyBatis3");
            context.setId("wb-jjb318191");
            context.addProperty("javaFileEncoding", fileEncoding);
            //设置注解生成器
            context.setCommentGeneratorConfiguration(generateCommentConfiguration());
            //设置JDBC连接配置
            context.setJdbcConnectionConfiguration(generateJDBCConnectionConfiguration());
            //设置JDBC Type 与Java Type之间的映射解析器
            context.setJavaTypeResolverConfiguration(generateJavaTypeResolverConfiguration());
            //设置Java Model生成配置
            context.setJavaModelGeneratorConfiguration(generateJavaModelGeneratorConfiguration());
            //设置DAO层的生成配置
            context.setSqlMapGeneratorConfiguration(generateSqlMapGeneratorConfiguration());
            //设置Mapper.xml生成
            context.setJavaClientGeneratorConfiguration(generateJavaClientGeneratorConfiguration());
            //设置需要生成的Table及生成形式
            for (TableConfiguration tableConfiguration : generateTableConfigurations(context)) {
                context.addTableConfiguration(tableConfiguration);
            }
            configuration.addContext(context);
            return configuration;
        }
    
        /** * 配置注解生成器 * * @return */
        private CommentGeneratorConfiguration generateCommentConfiguration() {
            CommentGeneratorConfiguration configuration = new CommentGeneratorConfiguration();
            configuration.setConfigurationType(GeneralCommentGenerator.class.getName());
            //是否去除自动生成的注释 true：是 ： false:否
            configuration.addProperty("suppressAllComments", "false");
            configuration.addProperty("addRemarkComments", "true");
            return configuration;
        }
    
        /** * 设置数据库连接的信息：驱动类、连接地址、用户名、密码 * * @return */
        private JDBCConnectionConfiguration generateJDBCConnectionConfiguration() {
            JDBCConnectionConfiguration configuration = new JDBCConnectionConfiguration();
            configuration.setDriverClass(driverClass);
            String jdbcSuffix = "?useUnicode=true&characterEncoding=UTF8&useSSL=false";
            configuration.setConnectionURL(connectionUrl + jdbcSuffix);
            configuration.setUserId(userName);
            configuration.setPassword(password);
            return configuration;
        }
    
        /** * 设置JDBC Type 与Java Type之间的映射解析器 * * @return */
        private JavaTypeResolverConfiguration generateJavaTypeResolverConfiguration() {
            JavaTypeResolverConfiguration configuration = new JavaTypeResolverConfiguration();
            //可自定义类型映射解析器
            configuration.setConfigurationType(null);
            //默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL 和 NUMERIC 类型解析为java.math.BigDecimal
            configuration.addProperty("forceBigDecimals", "true");
            return configuration;
        }
    
        /** * 配置Java Model生成 * * @return */
        private JavaModelGeneratorConfiguration generateJavaModelGeneratorConfiguration() {
            JavaModelGeneratorConfiguration configuration = new JavaModelGeneratorConfiguration();
            configuration.setTargetProject(javaModelTargetProject);
            configuration.setTargetPackage(javaModelPackage);
            //是否让schema作为包的后缀
            configuration.addProperty("enableSubPackages", "false");
            //从数据库返回的值被清理前后的空格
            configuration.addProperty("trimStrings", "true");
            return configuration;
        }
    
        /** * 配置Mapper.xml生成 * * @return */
        private SqlMapGeneratorConfiguration generateSqlMapGeneratorConfiguration() {
            SqlMapGeneratorConfiguration configuration = new SqlMapGeneratorConfiguration();
            configuration.setTargetProject(sqlmapTargetproject);
            configuration.setTargetPackage(sqlMapperPackage);
            //是否让schema作为包的后缀
            configuration.addProperty("enableSubPackages", "false");
            return configuration;
        }
    
        /** * 设置DAO生成 * * @return */
        private JavaClientGeneratorConfiguration generateJavaClientGeneratorConfiguration() {
            JavaClientGeneratorConfiguration configuration = new JavaClientGeneratorConfiguration();
            configuration.setConfigurationType("XMLMAPPER");
            configuration.setTargetProject(javaMapperTargetProject);
            configuration.setTargetPackage(javaMapperPackage);
            //是否让schema作为包的后缀
            configuration.addProperty("enableSubPackages", "false");
            return configuration;
        }
    
        private List<TableConfiguration> generateTableConfigurations(Context context) {
            List<TableConfiguration> configurations = new ArrayList<TableConfiguration>();
            for (Object table : tables) {
                TableConfiguration configuration = new TableConfiguration(context);
                configuration.setTableName((String)table);
                configuration.setSelectByExampleStatementEnabled(false);
                configuration.setDeleteByExampleStatementEnabled(false);
                configuration.setCountByExampleStatementEnabled(false);
                configuration.setUpdateByExampleStatementEnabled(false);
                configurations.add(configuration);
            }
            return configurations;
        }
    
    }

还有一个类GeneralCommentGenerator和之前那篇博客的一样，就不列出来了，总共就是三个类。

我在MybatisGeneratorConfig类里的变量上标识了很多@Parameter注解，这些注解指定了插件在配置时能够传入哪些外部参数，Maven插件在启动时实例化@Mojo标识类的对象，同时将外部参数传入到此类(或父类)的属性中。@Parameter可以定义插件配置的形式，是否有默认值，是否仅可读，是否必须等等，若是必须的则在配置插件时必须有值。

以上就是插件的所有代码了，之后执行Maven的install命令，将插件安装到本地maven仓库。

下面就是在其他项目中使用整个插件。

首先需要在项目中引入自定义的maven插件：

<plugins>
                
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-dependency-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
    
                <plugin>
                    <groupId>com.bob</groupId>
                    <artifactId>plugin</artifactId>
                    <version>1.0-SNAPSHOT</version>
                    <configuration>
                        <tables>
                            <table>bank_account</table>
                            <table>emp</table>
                        </tables>
                        <targetModule>project-root</targetModule>
                    </configuration>
                    <executions>
                        <execution>
                            <id>generate</id>
                            <phase>compile</phase>
                            <goals>
                                <goal>mybatisGenerate</goal>  
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>

我默认是在一台电脑上，刚刚已经将插件安装到了本地maven仓库，所以这里引用能够直接生效。  
可以通过Ctrl+左键点击configuration内的配置，查看当前插件的可配置选项。  
我们将逆向工程插件的mybatisGenerate目标绑定到了compile阶段，也就是说在执行maven compile生命周期时会触发此插件的相应目标。  
![这里写图片描述][SouthEast]  
插件配置在了project目录下的pom.xml里，逆向工程的数据库驱动包放在了project-root下，同时制定生成的Model，Mapper接口及Mapper.xml也指向project-root项目。生成的包的路径，数据库地址，用户名，密码等等信息我在插件里做了默认配置，需要的可以在< configuration>覆盖默认配置，同时若项目的结构和我的不相同，只要修改下插件里的默认配置就好了。自行看插件源码，很明了的。

在指定好要生成的数据库表之后，在IDEA里运行complie，就能执行逆向工程插件了，执行完之后务必将< goal>，否则每次编译都会执行此插件了。

[Mybatis]: http://blog.csdn.net/qq_27529917/article/details/78447865
[SouthEast]: /images/20220531/d01a51eefe7b4cd8840538bef0c31047.png