This page compares two build tools, Maven and Gradle, and discusses some of the advantages and disadvantages of each.
Introduction to Maven
Maven is a popular build tool for Java and doesn't really need an introduction. If you aren't familiar with what Maven does, there is lots of introductory materialon the web. Maven takes the basic approach that most projects can fit into a few basic configurations. Maven gives a default build process which can be customized where necessary. This has the advantage that the build configuration file (POM) is very simple for ordinary builds. The disadvantage is that Maven isMavenProblemswhen it comes to customizing the build process.
Introduction to Gradle
Gradle is a newer build tool based on the Groovy language and Ant. Gradle provides some default build configurations, but in general takes a more flexible approach than Maven. Everything about the build lifecycle can be customized. This is good in the sense that you have
Maven uses XML to define build scripts. This is the same as Ant and is a safe choice because most people are familiar with using XML for configuration. Gradle build scripts are written in Groovy. The advantage of using a real programming language over XML is that it can more easily define build logic that is more complex than just a series of unchanging steps. Groovy is in general more concise than XML since settings are just method calls instead of xml tags. The disadvatage of using Groovy is that it's probably not as familiar as XML to most Java developers, and using a programming language for writing build scripts might encourage developers to create build scripts as complex and unmanageable as the applications they are building.
Some informal testing seems to suggest that Gradle is about the same or a little slower than Maven. This is unfortunate because both of these build tools seem to be significantly slower than Ant. The jboss application server build takes approximately twice as long using a Maven build vs. the older Ant build.
(Ant is clear winner, Maven and Gradle are about the same)
Maven typically has a single static set of dependencies for a given project. This goes with the Maven idea that a project should have a single artifact and thus only one set of dependencies. This has the advantage of being simple, but can be too inflexible for some projects. Gradle gives much more flexibilty in this respect. Multiple sets of dependencies (dependency configurations) can be created and associated with different parts of the build. For example, in some cases it could be useful to run a testsuite multiple times against different dependency versions. This would be relatively easy in Gradle, but very difficult in Maven.
(Gradle is winner because of simplicity and flexibility, Maven and Ant/Ivy tied for second)
Using Artifact Repositories
Maven has a single repository format. Gradle uses Ivy for dependency management and can be used with an Ivy repository and/or a Maven repository. Deploying to a maven repository is very simple because of the single repository and deployment format. Ant and Gradle require a bit more understanding and configuration.
(Maven wins, Gradle and Ant/Ivy tied for second)
Loading Build System Components
Maven takes the approach that each component of the build (compile, jar, etc) is a plugin. Each plugin has it's own version and dependency tree. The core build system components of Gradle are all contained within the Gradle distribution. The advantage of the Maven model is that individual plugins can be updated in a build without updating the whole build system. The advantage of Gradle's model is that there are no additional core components that need to be downloaded at build time.
Maven and Gradle both do better in this category than Ant. Ant requires the use of Ivy and some non-intuitive configuration if you want to use build components (tasks) that are not included in the standard Ant distribution.
(Maven and Gradle tied, Ant second because it requires more work to set up extra build components)
Access to Build Lifecycle
Maven provides only limited access to the build lifecycle. Plugins can be attached to given phases of the lifecycle but only after the core plugin executes. Gradle is easily the most powerful in this category because it allows easy access to any part of the build and allows Groovy code to be directly executed in the build script. Ant can access any part of the build, but does require the code to be inside tasks so is not as powerful as Gradle.
(Gradle wins easily in this category followed by Ant and then Maven)