Why Maven-2?

This article is followed by a previous piece of learning notes for continuing to record Maven: [url] http://jackycheng2007.iteye.com/blog/923791
[/Url]

Magic Weapon 2. Pom project object model-continue 
Project inheritance-Project inheritance 
As mentioned above, the project is regarded as an object in maven. In this case, there must be an inherited function. This function is useful, so that our project profile can be reused. Imagine if you have many similar projects, such as a series of projects developed using SSH, there must be a lot of duplicates in the POM of each project. With inheritance, you can extract all the public parts and then inherit each sub-project to achieve reuse. Originally, inheritance reflects the relationship between is-a. The subprojects under a supper project are inherently related to is-a with the supper project. This is not an abuse of inheritance, haha.
How can we inherit it?

Next, the last example in the previous article, if there is a sub-module that needs to inherit from it:

Java code  

1. <Project>
2. <Parent>
3. <Groupid> com. mycompany. app </groupid>
4. <Artifactid> my-app </artifactid>
5. <Version> 1 </version>
6. </Parent>
7. <Modelversion> 4.0.0 </modelversion>
8. <Artifactid> my-module </artifactid>
9. </Project>

This sub-module inherits the groupid and version information of the parent module. Wait. Here is a problem. Just rely on
<Groupid> com. mycompany. app </groupid>. How can I find the POM er POM in the submodule?
Yes, if the supper project has been installed in the local repository or the POM er Pom is in the agreed directory, that is, the sub-module's upper-level directory (as follows), you can.

Reference my-app | -- my-Module
| '-- Pom. xml
'-- Pom. xml

So, unfortunately, none of these two are true? For example:

Reference.
| -- My-Module
| '-- Pom. xml
'-- Parent
'-- Pom. xml

You can also specify the location:

Java code  

1. <Project>
2. <Parent>
3. <Groupid> com. mycompany. app </groupid>
4. <Artifactid> my-app </artifactid>
5. <Version> 1 </version>
6. <Relativepath>.../parent/POM. xml </relativepath>
7. </Parent>
8. <Modelversion> 4.0.0 </modelversion>
9. <Artifactid> my-module </artifactid>
10. </Project>

Project aggregation-project set 
Through project inheritance, we can use the POM of the parent project when managing or building sub-projects. In turn? If we want to build a complete project, do we often need to assemble multiple sub-projects for packaging. Project aggregation solves this problem.
How can this problem be solved? The following two conditions must be met:

The packaging value in the POM of the parent project is set to "pom ".
Customize the sub-project directory in the POM of the Parent Project

If we want to integrate my-module into my-app, make the following changes:

Java code  

1. <Project>
2. <Modelversion> 4.0.0 </modelversion>
3. <Groupid> com. mycompany. app </groupid>
4. <Artifactid> my-app </artifactid>
5. <Version> 1 </version>
6. <Packaging> pom </packaging>
8. <Modules>
9. <Module> my-module </module>
10. </Modules>
11. </Project>

There is no write path above, because the maven directory convention is followed. If not, write:

Java code  

1. <Project>
2. <Modelversion> 4.0.0 </modelversion>
3. <Groupid> com. mycompany. app </groupid>
4. <Artifactid> my-app </artifactid>
5. <Version> 1 </version>
6. <Packaging> pom </packaging>
8. <Modules>
9. <Module> ../My-module </module>
10. </Modules>
11. </Project>

It can be seen that conventions are a good way to save code and form consensus easily.
Project interpolation and variables-use variables 
In pom, you may use the same string segment in multiple places, such as the path. Meven supports variable declarations and references, so that you can prevent hard code.
How to reference variables? Take a look at the following:

Java code  

1. <Version >$ {project. Version} </version>

The $ symbol is enclosed in braces and accessed hierarchically by vertices. Very convenient. If there is an inheritance relationship, the subclass value is used.
What are the available variables?

Project model variables 
Any single-value element in POM can be referenced as a variable, for example:

Reference $ {project. groupid}, $ {project. Version}, $ {project. Build. sourcedirectory}

Special Variables 
$ {Basedir}: directory of the current project
$ {Project. baseuri}: URI. Since Maven 2.1.0, directory of the current project
$ {Maven. Build. timestamp}, Project Build start time. Since Maven 2.1.0-M1

Properties 
You can also reference the properties defined in POM as variables.

Java code  

1. <Project>
2. ...
3. <Properties>
4. <Mavenversion> 2.1 </mavenversion>
5. </Properties>
6. <Dependencies>
7. <Dependency>
8. <Groupid> org. Apache. MAVEN </groupid>
9. <Artifactid> Maven-artifact </artifactid>
10. <Version >$ {mavenversion} </version>
11. </Dependency>
12. <Dependency>
13. <Groupid> org. Apache. MAVEN </groupid>
14. <Artifactid> Maven-project </artifactid>
15. <Version >$ {mavenversion} </version>
16. </Dependency>
17. </Dependencies>
18. ...
19. </Project>

Through properties, you can customize some variables. Haha.