{"id":20792,"date":"2014-02-02T15:00:31","date_gmt":"2014-02-02T13:00:31","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=20792"},"modified":"2014-02-01T11:05:04","modified_gmt":"2014-02-01T09:05:04","slug":"findbugs-maven-plugin-tutorial","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2014\/02\/findbugs-maven-plugin-tutorial.html","title":{"rendered":"FindBugs Maven Plugin Tutorial"},"content":{"rendered":"

FindBugs<\/a> is a static code analysis tool which identifies problems found from Java code.<\/p>\n

We can integrate FindBugs into our build process by using the FindBugs Maven plugin<\/a>. This blog post identifies four typical use cases and describes how we can configure the FindBugs Maven plugin to support each use case.<\/p>\n

The described use cases are:
\n 
\n 
\n <\/p>\n

    \n
  1. Create FindBugs report as a part of the project reports.<\/li>\n
  2. Fail the build if FindBugs finds problems from the source code.<\/li>\n
  3. Create a XML report without failing the build.<\/li>\n
  4. Create both XML and HTML reports without creating the site.<\/li>\n<\/ol>\n

    Let\u2019s get started.<\/p>\n

    Use Case 1: Create Findbugs Report as a Part of the Project Reports<\/h2>\n

    Sometimes we don\u2019t want to run static code analysis every time when our project is compiled. Instead we want to run it manually when we need it. If this is the case, our best option is to create the FindBugs report when we create the site of the project.<\/p>\n

    We can do this by following these steps:<\/p>\n

      \n
    1. Add the declaration of the FindBugs Maven plugin to the reporting<\/em> section of the pom.xml<\/em> file.<\/li>\n
    2. Configure the FindBugs Maven plugin by following these steps:\n
        \n
      1. Ensure that most accurate analysis is performed.<\/li>\n
      2. Ensure that all bugs are reported.<\/li>\n
      3. Ensure that XML report is generated.<\/li>\n<\/ol>\n<\/li>\n<\/ol>\n

        The relevant part of the pom.xml<\/em> file looks as follows:<\/p>\n

        <reporting>\r\n    <plugins>\r\n        <plugin>\r\n            <groupId>org.codehaus.mojo<\/groupId>\r\n            <artifactId>findbugs-maven-plugin<\/artifactId>\r\n            <version>2.5.2<\/version>\r\n            <configuration>\r\n                <!--\r\n                   Enables analysis which takes more memory but finds more bugs.\r\n                   If you run out of memory, changes the value of the effort element\r\n                   to 'low'.\r\n               -->\r\n                <effort>Max<\/effort>\r\n                <!-- Reports all bugs (other values are medium and max) -->\r\n                <threshold>Low<\/threshold>\r\n                <!-- Produces XML report -->\r\n                <xmlOutput>true<\/xmlOutput>\r\n            <\/configuration>\r\n        <\/plugin>\r\n    <\/plugins>\r\n<\/reporting><\/pre>\n
        \n
        The report is created only when the project is compiled<\/a>.\n<\/p>\n<\/blockquote>\n
        In other words, when we want to create the FindBugs report, we have to run the following command at command prompt:<\/p>\n
        mvn clean compile site<\/pre>\n
        Let\u2019s move on and find out how we can fail the build if FindBugs finds problems from our source code.<\/p>\n
        Use Case 2: Fail the Build if Problems Are Found<\/h2>\n
        If we want to be sure that our code doesn\u2019t contain even a minor problem, it might be good idea to run static code analysis every time when our project is compiled. Of course, this makes sense only if the build is failed when a problem is found.<\/p>\n
        In other words, we have to configure the FindBugs Maven plugin to fail the build if problems are found. We can do this by following these steps:<\/p>\n
          \n
        1. Add the plugin declaration to the plugins<\/em> section of the pom.xml<\/em> file.<\/li>\n
        2. Configure the FindBugs Maven plugin by following these steps:\n
            \n
          1. Ensure that most accurate analysis is performed.<\/li>\n
          2. Ensure that all bugs are reported.<\/li>\n
          3. Ensure that XML report is generated.<\/li>\n
          4. Configure the plugin to create the XML report to the directory ${project.build.directory}\/findbugs<\/em>.<\/li>\n<\/ol>\n<\/li>\n
          5. Add an execution which runs the plugin\u2019s check<\/em> goal during the compile<\/em> Maven lifecycle phase.<\/li>\n<\/ol>\n
            The relevant part of the pom.xml<\/em> file looks as follows:<\/p>\n
            <build>\r\n    <plugins>\r\n        <plugin>\r\n            <groupId>org.codehaus.mojo<\/groupId>\r\n            <artifactId>findbugs-maven-plugin<\/artifactId>\r\n            <version>2.5.2<\/version>\r\n            <configuration>\r\n                <!--\r\n                   Enables analysis which takes more memory but finds more bugs.\r\n                   If you run out of memory, changes the value of the effort element\r\n                   to 'Low'.\r\n               -->\r\n                <effort>Max<\/effort>\r\n                <!-- Reports all bugs (other values are medium and max) -->\r\n                <threshold>Low<\/threshold>\r\n                <!-- Produces XML report -->\r\n                <xmlOutput>true<\/xmlOutput>\r\n                <!-- Configures the directory in which the XML report is created -->\r\n                <findbugsXmlOutputDirectory>${project.build.directory}\/findbugs<\/findbugsXmlOutputDirectory>\r\n            <\/configuration>\r\n            <executions>\r\n                <!--\r\n                   Ensures that FindBugs inspects source code when project is compiled.\r\n               -->\r\n                <execution>\r\n                    <id>analyze-compile<\/id>\r\n                    <phase>compile<\/phase>\r\n                    <goals>\r\n                        <goal>check<\/goal>\r\n                    <\/goals>\r\n                <\/execution>\r\n            <\/executions>\r\n        <\/plugin>\r\n    <\/plugins>\r\n<\/build><\/pre>\n
            This configuration ensures that the check goal of the Maven FindBugs plugin is invoked during the compile Maven lifecycle phase. If FindBugs finds problems from the source code, it fails the build.
             
            <\/div> <\/div><\/p>\n
            Let\u2019s move on and find out how we can create XML report without creating the site or failing the build.<\/p>\n
            Use Case 3: Create XML Report Without Failing the Build<\/h2>\n
            If we want to integrate Jenkins with FindBugs<\/a>, we need to find a way to create XML reports without failing the build.<\/p>\n
            We can configure the FindBugs Maven plugin to do this by following these steps:<\/p>\n
              \n
            1. Configure the FindBugs Maven plugin as described in the previous section (Use case 2).<\/li>\n
            2. Ensure that the build doesn\u2019t fail if problems are found by setting the value of the failOnError<\/em> configuration property to false<\/em>.<\/li>\n<\/ol>\n
              The relevant part of the pom.xml<\/em> file looks as follows:<\/p>\n
              <build>\r\n    <plugins>\r\n        <plugin>\r\n            <groupId>org.codehaus.mojo<\/groupId>\r\n            <artifactId>findbugs-maven-plugin<\/artifactId>\r\n            <version>2.5.2<\/version>\r\n            <configuration>\r\n                <!--\r\n                   Enables analysis which takes more memory but finds more bugs.\r\n                   If you run out of memory, changes the value of the effort element\r\n                   to 'Low'.\r\n               -->\r\n                <effort>Max<\/effort>\r\n                <!-- Build doesn't fail if problems are found -->\r\n                <failOnError>false<\/failOnError>\r\n                <!-- Reports all bugs (other values are medium and max) -->\r\n                <threshold>Low<\/threshold>\r\n                <!-- Produces XML report -->\r\n                <xmlOutput>true<\/xmlOutput>\r\n                <!-- Configures the directory in which the XML report is created -->\r\n                <findbugsXmlOutputDirectory>${project.build.directory}\/findbugs<\/findbugsXmlOutputDirectory>\r\n            <\/configuration>\r\n            <executions>\r\n                <!--\r\n                   Ensures that FindBugs inspects source code when project is compiled.\r\n               -->\r\n                <execution>\r\n                    <id>analyze-compile<\/id>\r\n                    <phase>compile<\/phase>\r\n                    <goals>\r\n                        <goal>check<\/goal>\r\n                    <\/goals>\r\n                <\/execution>\r\n            <\/executions>\r\n        <\/plugin>\r\n    <\/plugins>\r\n<\/Build><\/pre>\n
              We can now create the XML report by compiling the project.<\/p>\n
              The last use case describes how we can create both XML and HTML reports without creating the site or failing the build. Let\u2019s see how this is done.<\/p>\n
              Use Case 4: Create Both XML and HTML Reports Without Creating the Site<\/h2>\n
              If we want to create both XML and HTML reports without creating the project site or failing the build, we have to follow these steps:<\/p>\n
                \n
              1. Configure the FindBugs Maven plugin as described in the previous section (use case 3).<\/li>\n
              2. Add the declaration of the XML Maven Plugin<\/a> to the plugins<\/em> section of the pom.xml<\/em> file.<\/li>\n
              3. Configure the plugin by following these steps:\n
                  \n
                1. Create a transformation set which transforms all XML files found from the ${project.build.directory}\/findbugs<\/em> directory and writes the results of the XSLT transformation to the same directory.<\/li>\n
                2. Configure stylesheet which specifies the output of the XSLT transformation. The FindBugs library provides five stylesheets which can be used for this purpose. The available stylesheets are described in the sample configuration.<\/li>\n
                3. Ensure that all output files of the XSLT transformation have the file extension .html<\/em>.<\/li>\n<\/ol>\n<\/li>\n
                4. Add an execution which invokes the transform<\/em> goal of the XML Maven plugin during the compile<\/em> Maven lifecycle phase.<\/li>\n
                5. Add FindBugs (version 2.0.1) as the dependency of the plugin.<\/li>\n<\/ol>\n
                  The relevant part of the pom.xml<\/em> file looks as follows:<\/p>\n
                  <build>\r\n    <plugins>\r\n        <plugin>\r\n            <groupId>org.codehaus.mojo<\/groupId>\r\n            <artifactId>findbugs-maven-plugin<\/artifactId>\r\n            <version>2.5.2<\/version>\r\n            <configuration>\r\n                <!--\r\n                   Enables analysis which takes more memory but finds more bugs.\r\n                   If you run out of memory, changes the value of the effort element\r\n                   to 'Low'.\r\n               -->\r\n                <effort>Max<\/effort>\r\n                <!-- Build doesn't fail if problems are found -->\r\n                <failOnError>false<\/failOnError>\r\n                <!-- Reports all bugs (other values are medium and max) -->\r\n                <threshold>Low<\/threshold>\r\n                <!-- Produces XML report -->\r\n                <xmlOutput>true<\/xmlOutput>\r\n                <!-- Configures the directory in which the XML report is created -->\r\n                <findbugsXmlOutputDirectory>${project.build.directory}\/findbugs<\/findbugsXmlOutputDirectory>\r\n            <\/configuration>\r\n            <executions>\r\n                <!--\r\n                   Ensures that FindBugs inspects source code when project is compiled.\r\n               -->\r\n                <execution>\r\n                    <id>analyze-compile<\/id>\r\n                    <phase>compile<\/phase>\r\n                    <goals>\r\n                        <goal>check<\/goal>\r\n                    <\/goals>\r\n                <\/execution>\r\n            <\/executions>\r\n        <\/plugin>\r\n        <plugin>\r\n            <groupId>org.codehaus.mojo<\/groupId>\r\n            <artifactId>xml-maven-plugin<\/artifactId>\r\n            <version>1.0<\/version>\r\n            <configuration>\r\n                <transformationSets>\r\n                    <transformationSet>\r\n                        <!-- Configures the source directory of XML files. -->\r\n                        <dir>${project.build.directory}\/findbugs<\/dir>\r\n                        <!-- Configures the directory in which the FindBugs report is written.-->\r\n                        <outputDir>${project.build.directory}\/findbugs<\/outputDir>\r\n                        <!-- Selects the used stylesheet. -->\r\n                        <!-- <stylesheet>fancy-hist.xsl<\/stylesheet> -->\r\n                        <stylesheet>default.xsl<\/stylesheet>\r\n                        <!--<stylesheet>plain.xsl<\/stylesheet>-->\r\n                        <!--<stylesheet>fancy.xsl<\/stylesheet>-->\r\n                        <!--<stylesheet>summary.xsl<\/stylesheet>-->\r\n                        <fileMappers>\r\n                            <!-- Configures the file extension of the output files. -->\r\n                            <fileMapper\r\n                                   implementation=\"org.codehaus.plexus.components.io.filemappers.FileExtensionMapper\">\r\n                                <targetExtension>.html<\/targetExtension>\r\n                            <\/fileMapper>\r\n                        <\/fileMappers>\r\n                    <\/transformationSet>\r\n                <\/transformationSets>\r\n            <\/configuration>\r\n            <executions>\r\n                <!-- Ensures that the XSLT transformation is run when the project is compiled. -->\r\n                <execution>\r\n                    <phase>compile<\/phase>\r\n                    <goals>\r\n                        <goal>transform<\/goal>\r\n                    <\/goals>\r\n                <\/execution>\r\n            <\/executions>\r\n            <dependencies>\r\n                <dependency>\r\n                    <groupId>com.google.code.findbugs<\/groupId>\r\n                    <artifactId>findbugs<\/artifactId>\r\n                    <version>2.0.1<\/version>\r\n                <\/dependency>\r\n            <\/dependencies>\r\n        <\/plugin>\r\n    <\/plugins>\r\n<\/build><\/pre>\n
                  \n
                  This solution was originally described in this StackOverflow question<\/a>.<\/p>\n<\/blockquote>\n
                  We can now create both HTML and XML reports by compiling our project.<\/p>\n
                  Summary<\/h2>\n
                  We have now identified four typical use cases of the FindBugs Maven plugin and learned how we can configure the plugin to support each use case.<\/p>\n
                  If you know a use case that wasn\u2019t covered by this tutorial, please let me know by leaving a comment to this blog post.<\/p>\n