Explore topic-wise InterviewSolutions in .

PACKAGE: converts the compiled CODE into a distributable FORMAT, such as a JAR.

install: adds the package to the local repository, allowing it to be USED as a dependency in other projects.

Set the skipTests attribute to true to skip the tests for a certain project.

You MAY also skip the tests by using the following command from the command line:

You can also use the maven.test.skip option to avoid compiling the tests if you have to. Surefire, Failsafe, and the Compiler Plugin all recognize maven.test.skip.

You must go through a properties section in the pom if you want to skip tests by default but have the possibility to re-enable tests from the command line:

And,

This will allow you to run tests with the default tests disabled and EXECUTE them with the following command:

The "skip" parameter and other booleans on the plugin can be used in the same way.

It is now possible to RUN tests in parallel without utilizing TestNG in junit 4.7. It's been feasible since 4.6, but 4.7 will include a number of improvements that will MAKE it a realistic alternative. You may also use spring to execute parallel tests.

You can also use this MAVEN plugin:

Doxia is a content creation framework that aims to give POWERFUL approaches for creating STATIC and dynamic content to its users: Doxia can be used to create static web pages in a web-based publication context, as WELL as in dynamic content creation systems such as blogs, wikis, and content management systems.

Maven MAKES substantial use of Doxia, which powers the project's complete DOCUMENTATION system. It enables Maven to take any Doxia-supported document and output it in any format.

For instance, 'mvn site' is the command used by Maven to produce javadocs for a specific project. Maven calls Doxia document generation and other report generating plugins when this command is run.

The Maven Wagon Plugin, as its NAME suggests, allows you to access numerous Maven Wagon functionalities. To transfer resources to and from Maven repositories, Maven Wagon offers a layer of abstraction over the core transport protocols. Maven Wagon's unified API includes implementations for SEVEN transports.

The following picture depicts the architecture of the Maven Wagon:

The plugin allows you to use the wagon to upload resources from your build to a remote SITE, get resources from a repository and list the contents of a repository. Finally, it may merge a Maven repository to another in a generic fashion by merging the upload and download capabilities.

Project Aggregation specifies the modules from the parent POM instead of specifying the parent POM from the module. As a result, the parent project is AWARE of its modules, and if a Maven command is issued against the parent project, the Maven command is also applied to the parent's modules. For Project Aggregation, you MUST accomplish the following:

• CHANGE the packaging of the parent POMs to "pom."
• Specify the modules' DIRECTORIES in the parent POM (children POMs).

The default behavior includes merging the CONTENT of the configuration element according to the element name. If a certain element EXISTS in the CHILD POM, that value becomes the effective value. The parent value becomes the effective value if the child POM does not have an element but the parent does. It's important to note that this is solely an XML operation, with no code or plugin SETTINGS involved. Only the elements are involved, not their values.

Advanced configuration inheritance includes adding attributes to the children of the configuration element to regulate how child POMs inherit configuration from parent POMs. Combine.children and combine.self are the two attributes. These attributes can be used in a child POM to regulate how Maven integrates the parent's plugin configuration with the child's explicit configuration.

This is primarily to ensure that the dependency GRAPH is predictable, as well as to prevent inheritance effects from ELIMINATING a dependent that should not be EXCLUDED. If you have to use the method of last resort and add an exclusion, make sure you know which of your dependencies is causing the undesirable transitive dependency.

The banned dependencies rule can be specified to fail the BUILD if a troublesome dependency is identified, regardless of path. You'll need to add SPECIFIC exclusions to each path the enforcer detects if the build fails.

The MAVEN release plugin is USED to automate the build and release process. When maven executes the maven-release-plugin, the following activities are performed:

• mvn release:clean - clears the workspace from the previous build and prepares it for a new one.
• mvn release:rollback - If the previous process failed, it ROLLBACKS the workspace.
• mvn release:prepare - It performs the following tasks:
  • Checks the LOCAL workspace for any uncommitted files.
  • Checks for SNAPSHOT dependencies and verifies they aren't present.
  • Prepares the final version for release.
  • Updates the pom to SCM (SVN/Git/Mercurial/CVS).
  • Runs the test cases.
  • Executes the ultimate commit to the SCM.
  • Tags the script/code.
  • Increases the version number and includes the SNAPSHOT as PART of the subsequent releases.
• mvn release:perform - fetches the code from the repository and executes the maven goal to develop and deploy the artifacts.

The SETTINGS.xml PROFILE element is a trimmed VERSION of the pom.xml profile element. It is made up of the elements: activation, repositories, pluginRepositories, and PROPERTIES. These four components are the only ones included in the profile elements since they deal with the build system as a whole (which is what the settings.xml file is for), not individual project object MODEL settings.

If a profile is activated from settings, its values will override any POM or profiles.xml profiles with the same ID.

• Activation: The strength of a profile, like that of the POM's profiles, comes from its capacity to modify specific values only under certain conditions, which are stated via an activation element.
• Repositories: Repositories are remote collections of projects that Maven utilizes to populate the build system's local repository.
• pluginRepositories: Maven plugins are a unique form of artifact in themselves. Plugin repositories may be segregated from other repositories as a result of this. Each of the pluginRepository components specifies a remote source where Maven can look for new plugins.
• Properties: Maven properties, like Ant properties, value placeholders. The notation ${X}, where X is the property, can be used to obtain their values anywhere within a POM.

You have the opportunity to DEFINE your own ARBITRARY properties in addition to the implicit properties. A POM or a Profile can be used to define properties. The properties defined in a POM or a Maven Profile can be referenced in Maven just like any other property. User-defined properties can be used to filter resources via the Maven Resource plugin, or they can be referenced in a POM. In a Maven POM, here's an example of defining some arbitrary properties.

arbitrary.property.x and hibernate.version are two properties defined in the preceding example. In a dependency declaration, hibernate.version is mentioned. It's usual practice in Maven POMs and Profiles to USE the period character as a separator in property names. The following example demonstrates how to define a property in a Maven POM profile.

The Maven software relies heavily on external DEPENDENCIES. It is an intrinsic COMPONENT of the SYSTEM without which it is impossible to find dependencies in a system. We'll need the following information to specify the external dependency:

• It necessitates a GROUP ID that is identical to the library name.
• It necessitates an artifact ID that is identical to the library name.
• The system's dependency scope must be mentioned.
• The system path that corresponds to the PROJECT position must be mentioned.

By incorporating transitive DEPENDENCIES automatically, Maven eliminates the NEED to discover and define libraries that the dependencies require. ACCORDING to transitive DEPENDENCY, if X is DEPENDENT on Y and Y is dependent on Z, then X is dependent on both Y and Z.

The "exclusion" element can be used to exclude any transitive dependency. If X is reliant on Y and Y is reliant on Z, then X can declare Z as excluded.

When splitting a project into submodules isn't practicable (for some reason), optional dependencies are EMPLOYED. The concept is that some of the dependencies are just required for particular project features and will not be required if those features are not USED. Such a feature should ideally be divided into a sub-module that is dependent on the project's main FUNCTIONALITY. Only non-optional dependencies would be included in this new subproject, as you'd NEED them all if you wanted to use the subproject's features.

If a user wants to use functionality associated with an optional dependency, they must redeclare it in their own project. Optional dependencies save storage and memory. They PREVENT troublesome jars from being packed into a WAR, EAR, fat jar, or other formats if they violate a license agreement or cause classpath difficulties.

The TERM "system dependency" refers to the scope system's dependency. These DEPENDENCIES are typically used to LET Maven know the dependencies the JDK or VM provides. System dependencies are typically used to resolve dependencies on JDK-provided artifacts. Some common examples are the Java Authentication and Authorization SERVICE (JAAS) or the JDBC standard extensions.

When multiple VERSIONS of an artifact are encountered, Maven determines which version of the dependency should be used. The earliest DECLARED dependence will be used if two dependency versions are at the same depth in the dependency tree. This is referred to as "dependency mediation."

Dependency management allows project AUTHORS to declare the versions of artifacts that are to be utilized when they are discovered in TRANSITIVE dependencies or dependencies that have no version SPECIFIED.

A Maven installation is configured using the settings.xml file. It's comparable to a pom.xml file, but it's either global or user-specific. The Maven settings.xml file provides ELEMENTS that define the values required to configure Maven's execution in several ways. These values include the location of the local repository, authentication information, and alternate remote repository servers among others.

Let's LOOK at the elements in the settings.xml file that we can change. The settings.xml file's main element, settings, can include up to nine predefined child elements:

The FOLLOWING configurations are included:

• Proxy CONFIGURATION
• Local repository configuration
• Remote repository configuration
• Central repository configuration

Maven clean is a plugin that, as the name implies, attempts to clean the files and DIRECTORIES generated by Maven during the build process. The target folder, which contains all of the CLASS files, documentation, and JAR files, is removed by the plugin.

The Surefire Plugin is used to run an application's unit tests during the test phase of the build LIFECYCLE. It can generate reports in one of two file formats: plain text files or XML files.

The Antrun Plugin allows you to PERFORM Ant tasks directly from within Maven. Your Ant SCRIPTS can even be embedded in the POM!

Everything RELATED to generating documentation for your project is handled by the Maven site lifecycle.

• pre-site- PERFORMS tasks that are necessary PRIOR to actual project site generation.
• site- DEVELOP the project’s site generation.
• post-site- performs tasks that are necessary to FINALIZE project site generation, also prepares for site deployment.
• site-deploy- deploy the developed site documentation to the web server of your choice.

The Maven CLEAN lifecycle takes care of eliminating all temporary files from the output directory, including generated source files, compiled CLASSES, and previous JAR files, among other things.

• pre-clean- performs tasks that are necessary prior to actual project CLEANING.
• clean- delete all files CREATED by the previous build.
• post-clean- performs tasks that are necessary to finalize project cleaning.

The -MVN ARCHETYPE: CREATE is used to start a new project.
After reading the source and resource files, as well as the values of its PARAMETERS and other properties, the archetype is constructed.

Maven Archetype is a Maven plugin that makes it possible to create a project structure based on a template. These archetypes are essentially project templates that Maven generates when you create a new project. Archetype is a Maven project templating TOOLKIT, in a nutshell.

After getting to the directory where the project is located, type the command: – mvn archetype: GENERATE in the command prompt. This aids in CREATING a new project based on an archetype.

There are four steps for creating a project from an archetype:

• prepare a repository reference
• the CHOICE of an archetype,
• that archetype's configuration,
• the efficient creation of the project using the data gathered

In most cases, an archetype is procured from a REMOTE repository. You're ready to go if that repository can be reached using your Maven configuration. You must add the repository to your settings.xml if the repository is not managed and you wish to refer to it directly.