Differences

This shows you the differences between two versions of the page.

--- java:build-java-with-mavent-and-ant [2014/12/19 06:47] – [Enhance the build file] admin
+++ java:build-java-with-mavent-and-ant [2015/08/07 01:16] (current) – removed admin
@@ Line 1: / Line 1: @@
-====== maven and ant ======
-===== Build simple application with command line =====
-==== Basic steps to build application ====
-  - step1: create simple application with below directory structure:<code bat>
-md src
-md build\classes
-md build\jar
-</code>
-  - step2: create simple application **src\oata\helloworld.java**:<code java>
-package oata;
-public class helloworld {
-    public static void main(String[] args) {
-        System.out.println("Hello World");
-    }
-}
-</code>
-  - step3:build and run<code bat>
-set PATH=%PATH%;d:\tools\jdk1.7.0_67\bin
-javac -sourcepath src -d build\classes src\oata\helloworld.java
-java -cp build\classes oata.helloworld
-</code>
-  - step4: create manifest and jar file<code>
-echo Main-Class: oata.helloworld>myManifest
-md build\jar
-jar cfm build\jar\helloworld.jar myManifest -C build\classes .
-java -jar build\jar\helloworld.jar
-</code>
-==== compile and run with external libraries ====
-  * compile:<code bat>
-javac -cp "path1\file1.jar";"path2\file2.jar" -sourcepath src -d build\classes src\oata\helloworld.java
-</code>
-  * run:<code bat>
-java -cp "path1\file1.jar";"path2\file2.jar";"build\classes" oata.helloworld
-</code>
-===== Ant =====
-refer:
-  * http://ant.apache.org/manual/index.html
-  * refer: https://ant.apache.org/manual/tutorial-HelloWorldWithAnt.html
-Apache Ant is a Java-based build tool. In theory, it is kind of **like make**, without make's wrinkles.
-Instead of writing shell commands, the configuration files are XML-based, calling out **a target tree** where **various tasks get executed**. Each task is run by an object that implements a particular Task interface. Below are list ant tasks:(refer http://ant.apache.org/manual/index.html at toc **Ant Tasks**)
-  * Archive Tasks
-  * Audit/Coverage Tasks
-  * Compile Tasks
-  * Deployment Tasks
-  * Documentation Tasks
-  * EJB Tasks
-  * Execution Tasks
-  * File Tasks
-  * Java2 Extensions Tasks
-  * Logging Tasks
-  * Mail Tasks
-  * Miscellaneous Tasks
-  * Pre-process Tasks
-  * Property Tasks
-  * Remote Tasks
-  * SCM Tasks
-  * Testing Tasks
-==== create simple xml for building above simple application with ant ====
-  - step1: create build.xml(the same structure of makefile in linux)<code xml>
-<project>
-    <target name="clean">
-        <delete dir="build"/>
-    </target>
-    <target name="compile">
-        <mkdir dir="build/classes"/>
-        <javac srcdir="src" destdir="build/classes"/>
-    </target>
-    <target name="jar">
-        <mkdir dir="build/jar"/>
-        <jar destfile="build/jar/helloworld.jar" basedir="build/classes">
-            <manifest>
-                <attribute name="Main-Class" value="oata.helloworld"/>
-            </manifest>
-        </jar>
-    </target>
-    <target name="run">
-        <java jar="build/jar/helloworld.jar" fork="true"/>
-    </target>
-</project>
-</code> => list targets in build.xml:<code>
-clean, compile, jar, run
-</code> => and list tasks in build.xml:<code>
-delete, mkdir, javac, jar, java
-</code>
-  - step2: build with ant and run<code bat>
-set PATH=%PATH%;D:\tools\apache-ant-1.8.4\bin;d:\tools\jdk1.7.0_67\bin
-ant compile
-ant jar
-ant run
-</code>
-==== Enhance the build file ====
-  - Step1: custom build.xml with content below: <code xml>
-<project name="helloworld" basedir="." default="main">
-    <property name="src.dir"     value="src"/>
-    <property name="build.dir"   value="build"/>
-    <property name="classes.dir" value="${build.dir}/classes"/>
-    <property name="jar.dir"     value="${build.dir}/jar"/>
-    <property name="main-class"  value="oata.helloworld"/>
-    <target name="clean">
-        <delete dir="${build.dir}"/>
-    </target>
-    <target name="compile">
-        <mkdir dir="${classes.dir}"/>
-        <javac srcdir="${src.dir}" destdir="${classes.dir}"/>
-    </target>
-    <target name="jar" depends="compile">
-        <mkdir dir="${jar.dir}"/>
-        <jar destfile="${jar.dir}/${ant.project.name}.jar" basedir="${classes.dir}">
-            <manifest>
-                <attribute name="Main-Class" value="${main-class}"/>
-            </manifest>
-        </jar>
-    </target>
-    <target name="run" depends="jar">
-        <java jar="${jar.dir}/${ant.project.name}.jar" fork="true"/>
-    </target>
-    <target name="clean-build" depends="clean,jar"/>
-    <target name="main" depends="clean,run"/>
-</project>
-</code>
-  - Step2: to build and run, we only run command below:<code>
-ant
-</code>
-==== Using Eclipse to import Ant build ====
-{{:java:ant-eclipse.png|}}
-===== maven =====
-refer: http://maven.apache.org/guides/getting-started/maven-in-five-minutes.html\\
-Maven, a Yiddish word meaning accumulator of knowledge, was originally started as an attempt to simplify the build processes in the Jakarta Turbine project
-Maven’s primary goal is to allow a developer to **comprehend the complete state of a development effort in the shortest period of time**. In order to attain this goal there are several areas of concern that Maven attempts to deal with:
-  * Making the build process easy
-  * Providing a uniform build system
-  * Providing quality project information
-  * Providing guidelines for best practices development
-  * Allowing transparent migration to new features
-==== create simple project with maven ====
-  - Step1: prepare environment<code bat>
-set PATH=%PATH%;D:\tools\apache-maven-3.2.3\bin;D:\tools\jdk1.7.0_67\bin
-set JAVA_HOME=D:\tools\jdk1.7.0_67\
-mvn --version
-</code>
-  - Step2: create simple project<code bat>
-mvn archetype:generate -DgroupId=com.mycompany -DartifactId=simplemaven -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
-</code> And the maven will create the directory tree below:<code>
-simplemaven
-|-- pom.xml
-`-- src
-    |-- main
-    |   `-- java
-    |       `-- com
-    |           `-- mycompany
-    |               `-- App.java
-    `-- test
-        `-- java
-            `-- com
-                `-- mycompany
-                    `-- AppTest.java
-</code>
-  - Step3: Build<code bat>
-cd simplemaven
-mvn package
-</code>
-  - Step4: Run<code bat>
-java -cp target\simplemaven-1.0-SNAPSHOT.jar com.mycompany.App
-</code>Output:<code>
-Hello World!
-</code>
-==== Maven Phases(Or targets) ====
-Although hardly a comprehensive list, these are the most common default lifecycle phases executed:
-  * **validate**: validate the project is correct and all necessary information is available
-  * **compile**: compile the source code of the project
-  * **test**: test the compiled source code using a suitable unit testing framework. These tests should not require the code be packaged or deployed
-  * **package**: take the compiled code and package it in its distributable format, such as a JAR.
-  * **integration-test**: process and deploy the package if necessary into an environment where integration tests can be run
-  * **verify**: run any checks to verify the package is valid and meets quality criteria
-  * **install**: install the package into the local repository, for use as a dependency in other projects locally
-  * **deploy**: done in an integration or release environment, copies the final package to the remote repository for sharing with other developers and projects.
-There are two other Maven lifecycles of note beyond the default list above. They are:
-  * **clean**: cleans up artifacts created by prior builds
-  * **site**: generates site documentation for this project
-Base on mavent phases, we can run command below to clean all files which are generated by maven by prior builds:<code>
-mvn clean
-</code>
-==== Maven 2.x Integration for Eclipse ====
-refer: http://maven.apache.org/eclipse-plugin.html\\
-Go to help->Install New Software: http://download.eclipse.org/technology/m2e/releases
-M2E: The Maven Integration for Eclipse is the official Eclipse project aimed at integrating Maven within the Eclipse IDE. It is released under the EPL 1.0 license.
-Features include:
-  * **Launching Maven builds from within Eclipse**
-  * **Dependency management for Eclipse build path based on Maven’s pom.xml**
-  * Resolving Maven dependencies from the Eclipse workspace without installing to local Maven repository
-  * Automatic downloading of the required dependencies and sources from the remote Maven repositories
-  * **Wizards for creating new Maven projects, pom.xml and to enable Maven support on existing projects**
-  * Quick search for dependencies in remote Maven repositories
-  * Quick fixes in the Java editor for looking up required dependencies/jars by the class or package name
-  * Integration with other Eclipse tools, such as WTP, AJDT, Mylyn, Subclipse and others.
-  * M2E dynamically integrates with your Maven projects with Eclipse while you make changes in the IDE. As you change dependencies, or configurations of Maven plugins in your POMs M2E, will synchronize the Eclipse workspace with those changes.