十三、自定义插件

惹大佬生气，后果很严重，我要面壁，不要拉我
好了么，赶紧起来做笔记了，不然大佬要生气了
等一下，脚麻啦~~~

面壁.jpg

在前面的章节中，我们通过坐标的方式使用了许多插件，那么我们要如何实现自己的一个插件呢？

编写步骤

1. 使用idea生成maven-archetype-mojo项目，插件本身也是一个maven项目，不过它的打包方式必须是maven-plugin，这里需要说明的一点，在自定义插件的时候，要求命名规范不能是maven-___-plugin,不然会报错，可以声明为___-maven-plugin的形式

idea创建maven插件项目.png

2. 为插件编写目标，每个插件都必须包含一个或者多个插件目标，maven称之为mojo,与java的pojo对应，在编写插件的时候必须提供一个或者多个继承自AbstractMojo的类
3. 为插件提供可配置点：大部分maven插件及其目标都是可配置的，所以在编写mojo的时候需要注意提供可配置的参数
4. 编写代码实现插件目标行为，根据实际需要实现mojo
5. 错误及其异常处理日志，当mojo发生异常的时候，根据情况控制maven状态
6. 测试插件，编写自动化的测试代码测试行为

一个完整的maven自定义插件

下面是编写一个完整的maven统计代码行数的插件步骤：

1. 通过idea创建maven-archetype-mojo类型项目，修改pom文件内容为：

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zheng.plugins</groupId>
    <artifactId>count-maven-plugin</artifactId>
    <packaging>maven-plugin</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>count-maven-plugin Maven Mojo</name>
    <url>http://maven.apache.org</url>
    <dependencies>
        <dependency>
            <groupId>org.apache.maven</groupId>
            <artifactId>maven-plugin-api</artifactId>
            <version>3.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.maven.plugin-tools</groupId>
            <artifactId>maven-plugin-annotations</artifactId>
            <version>3.3</version>
        </dependency>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <target>1.8</target>
                    <source>1.8</source>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
            <!--需要将自定义插件打包到本地仓库后使用-->
            <plugin>
                <groupId>com.zheng.plugins</groupId>
                <artifactId>count-maven-plugin</artifactId>
                <version>1.0-SNAPSHOT</version>
                <executions>
                    <execution>
                        <id>first</id>
                        <phase>install</phase>
                        <goals>
                            <goal>count</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-plugin-plugin</artifactId>
                <version>3.5</version>
            </plugin>
        </plugins>
    </build>
</project>

上面配置的pom.xml中引用的当前插件前提是先要成功把插件打包到本地仓库
插件目标代码

package com.zheng.plugins;
/**
 * 统计目录下各文件代码行数
 * Created by zhenglian on 2017/8/16.
 */
@Mojo(name = "count")
public class CountFileLineMojo extends AbstractMojo {
    /**
     * 默认统计的源文件后缀
     */
    private static final String[] INCLUDE_FILES = {"xml", "java", "properties"};

    /**
     * 代码源文件目录
     */
    @Parameter(property = "project.build.sourceDirectory")
    private File sourceDirectory;

    /**
     * 项目根路径
     */
    @Parameter(property = "project.basedir")
    private File basedir;
    
    /**
     * 测试源文件目录
     */
    @Parameter(property = "project.build.testSourceDirectory")
    private File testSourceDirectory;
    
    /**
     * 供用户自定义用于统计的源文件后缀
     */
    private String[] suffixs;

    /**
     * 执行的目标
     * @throws MojoExecutionException 未知的异常，BUILD ERROR
     * @throws MojoFailureException 已知的业务异常，BUILD FAILURE
     */
    public void execute() throws MojoExecutionException, MojoFailureException {
        if (!Optional.ofNullable(suffixs).isPresent() || suffixs.length == 0) {
            suffixs = INCLUDE_FILES;
        }
        try {
            countDir(sourceDirectory);
            countDir(testSourceDirectory);
        } catch (RuntimeException e) {
            throw new MojoFailureException("发生异常，不能统计", e);
        } catch (Exception e) {
            throw new MojoExecutionException("未知异常，不能统计", e);
        }
    }

    /**
     * 统计某一个文件夹行数
     * @param dir 
     */
    private void countDir(File dir) {
        if (!Optional.ofNullable(dir).isPresent() || !dir.exists()) {
            return;
        }
        List<File> files = new ArrayList<>();
        collectFiles(files, dir);
        if (CollectionUtils.isEmpty(files)) {
            getLog().info("no file to count line.");
            return;
        }

        files.stream()
                .filter(file -> Optional.ofNullable(file).isPresent() && file.exists())
                .forEach(file -> {
                    Integer line = countLine(file);
                    String path = dir.getAbsolutePath().substring(basedir.getAbsolutePath().length());
                    getLog().info(path + ":" + line + " lines of code in " + files.size() + " files");
                });
        
    }

    /**
     * 统计文件行数
     * @param file
     */
    private Integer countLine(File file) {
        if (!Optional.ofNullable(file).isPresent() || file.isDirectory()) {
            throw new RuntimeException("统计的目标文件是目录，无法统计");
        }
        Integer line = 0;
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(file));
            while (reader.ready()) {
                reader.readLine();
                line++;
            }
        } catch (IOException e) {
            throw new RuntimeException("无法读取文件");
        } finally {
            if (Optional.ofNullable(reader).isPresent()) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        return line;
    }

    /**
     * 获取文件夹下的所有文件进行统计
     * @param files 保存所有文件
     * @param file 目标文件
     */
    private void collectFiles(List<File> files, File file) {
        if (file.isDirectory()) {
            for (File f : file.listFiles()) {
                collectFiles(files, f);
            }
        } else { // 文件
            String fileName = file.getName();
            Arrays.stream(suffixs)
                    .filter(suffix -> Optional.ofNullable(suffix).isPresent())
                    .forEach(suffix -> {
                        if (fileName.endsWith("." + suffix)) {
                            files.add(file);
                            return;
                        }
                    });
        }
    }
}

错误处理及日志

maven插件中有两种异常，分别是MojoExecutionException和MojoFailureException
MojoFailureException会提示maven“BUILD FAILURE”，这种错误通常表示maven在运行时发生了预期的错误
MojoExecutionException会提示maven“BUILD ERROR”,这种错误通常表示maven在运行时发生了不可预期的错误
maven的错误日志级别跟log4j类似，被分为：
debug:调试级别的日志，maven默认不会输出该级别日志，可以通过运行maven命令时添加-Xdebug参数打开debug日志
info:消息级别的日志，maven默认会输出该级别的日志
warn:警告级别日志，当maven运行时遇到一些问题或错误，不过这类问题不会终止maven构建
error:错误级别日志，当插件运行时遇到一些问题或者错误，并且这类错误导致maven无法运行，就应该使用这类型级别的日志

好啦，这里只是简单的介绍了一下如何自定义插件并给出了一个简单的自定义插件实现方式，当然您可以根据自己的业务需求实现更加复杂的个性化插件啦