What is POM, Parent, Dependencies?(Part-2)

POM.xml


 POM.xml file is what maven refers to for the project information and build configuration information. 

 Project information typically includes Project version, description, artifacts, etc., where as build configuration includes dependencies(JARs), goals, plugins, repositories, etc., So, a general POM file contains all these details. Since, this post is continuation of the maven series we have started earlier. I am referring to the POM(below fig.) file that we generated using spring boot archetype in the earlier post. For understanding the project creation using archetype refer to Post1 (http://javarephrased.blogspot.in/2016/02/what-is-maven-what-is-archetype-and.html) on maven. 

As you see, we  didn't mention all the details (discussed earlier) in the POM file. Maven do not even force you to provide all the details. To create a Simple POM.xml for a project, modelVersion(1), artifactId(2), groupId(3), version(4) in the below fig. are enough to do the Job. 

Because, maven is smart enough to substitute the details we did not provide with some default values and can run the POM file.  And details like goals, repositories and plugins gets automatically included from Super POM.xml (https://maven.apache.org/ref/3.0.4/maven-model-builder/super-pom.html)(Click to see) through inheritance. 

parent

(9) -Maven supports inheritance. This tag is used for inheriting properties of spring-boot-starter-parent POM.xml (https://github.com/spring-projects/spring-boot/blob/master/spring-boot-starters/spring-boot-starter-parent/pom.xml)(for eg.) project to our project's POM.xml. So, the internal dependencies of spring-boot-starter-parent project(JARS, Plugins, etc.,) can be accessed in our project and even we can access the project's properties defined in spring-boot-starter-parent POM.xml.

 Parent tag usage is limited to 1 per POM file. If you want your POM file to refer to the dependencies from multiple POM files, use import scope instead. The Usage of import tag will be covered in next posts.
Generated POM.xml from Spring-boot Archetype


Dependencies

(6) Every project refers some external JARs. Lets see how we managed these JARs in our projects before the evolution of maven.
  1. Download the JAR file.
  2. Check if the JAR references another JAR files (Transitive dependencies). Note: Though we added Spring-boot-starter Jar as 1 dependency in POM.xml. But, Spring-boot-Starter will additionally require some referenced JARS (see fig. below).  
  3. Copy the main JAR and reference JAR files to project folder
  4. Build
  5. New version of JAR relased, repeat steps (1),(2),(3) and (4)





With maven, all we need to do is create a dependency tag with groupId and artifactId under the dependencies tag of the POM file. 

 How it works?
Maven first checks for this JAR in local repository (<USER_HOME>/.m2). If found, it includes the library and referenced libraries of JAR files to your project's build path. Otherwise, it downloads the artifacts from the Maven central repository and copies it to local repository and then includes it into project's build path. It gets the referenced libraries information by looking at the JAR file's POM.xml file which is available in central repository (http://repo1.maven.org/maven2/org/springframework/boot/spring-boot/1.0.2.RELEASE/spring-boot-1.0.2.RELEASE.pom).

 Maven Central repository(available at http://repo1.maven.org/maven2/) maintains all the popular artifacts(JARS) eg. Spring, hibernate, etc. At the background, The Maven central repository registers to the other open source repositories like GitHub (https://github.com/spring-projects) where all the artifacts for spring (for example) are maintained. Since it has a tie up with open source repositories, any version updates from the open source repositories will be pushed to the maven central repository. So, we don't need to bother about version updates.
   <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

 Also, it offers the scope at which the artifact(JAR) should be applicable. In the above snippet, Junit JAR is limited to the scope of test soruces classpath and  is not applicable for your main sources classpath.

 So far, We have covered, how to generate the project from an archetype, how to include external JARs into your project's build path in the first 2 posts of Maven. Now, we have the infrastructure ready for the project. Lets discuss the next step, how we can build and install the project in the coming posts.  













Comments

Post a Comment

Popular posts from this blog

Distributed database design using CAP theorem

Image
CAP is a theorem/standard which can be applied while designing distributed systems like distributed databases. A distributed database is a set of databases(nodes) which are spread across the network.  These set of databases(nodes) in the distributed database can be either designed as either a  master/slave  or a  sharded model . Consistency -  Database should return the latest write on the DB. Availability -  Database should return data in a decent amount of time .  But, the data might not be latest. Partition tolerant - I n spite of n/w failure, the database should always be available. A distributed database can be designed either as a CP, AP, CA but not with all the 3 capabilities.  AP - Available and Partition tolerant  -  Sharded model (Data is distributed, No Master)  -      Availability  - Because, the data is distributed, any of the nodes can return the data. So, always availabl...
Continue Reading »

SQL Analytical Functions - Partition by (to split resultset into groups)

Partition by:  Splits the resultset into groups.  Employees -Table EMPLOYEE_ID FIRST_NAME SALARY ----------- -------------------- ---------- 100 Steven 24000 101 Neena 17000 102 Lex 17000 103 Alexander 9000 104 Bruce 6000 105 David 4800 106 Valli 4800 107 Diana 4200 select e.employee_id, e.department_id, salary, row_number() over (partition by department_id order by salary desc) as rownumber from employees e; The above query splits the result into small subgroups for every department.  Syntax :  Function(arg1,..., argn) OVER ( [PARTITION BY <..>] [ORDER BY <....>]  [<window_clause>] ) partition by  - create  subgroups for e...
Continue Reading »

Easy approach to work with files in Java - Java NIO(New input output)

  NIO - New IO package. Introduced in 1.4. It is buffer based and non-blocking. Hence, faster than IO package. It supports symbolic links, posix file attributes(works only on OS's which are POSIX compliant), ACL (Access control list). Paths and Files are the main classes Creating a potential file reference: Path path = Paths.get("c:/demo/"); //possible file reference Creating a directory, file, write to the file, read from the file: //create all the non existing directories in the path. Ignores creating a directory, if that directory already exists Path directories = Files.createDirectories("c:/demo/example1/properties/"); Path newFilePath = Files.createFile("c:/demo/README.txt"); //Creating a file //Writting bytes to the file Files.write(newFilePath, "This is a dummy text".getBytes(StandardCharsets.UTF_8)); //Reading bytes from file String readFile = new String(Files.readAllBytes(newFilePath), "UTF-8"); Files.readAllBytes reads all...
Continue Reading »