Set a few shell variables to represent root directories. For the purposes of the follow-on steps, PROJECT_BASEDIR is the root directory for this exercise. In the example below, the user has chosen a directory of $HOME/proj/784/exercises to be the root directory for all class exercises and named the root directory for this project "ex1". An alternative for CLASS_HOME might be c:/jhu/784. M2_REPO is the path to your Maven repository.

export CLASS_HOME=$HOME/proj/784
export PROJECT_BASEDIR=$CLASS_HOME/exercises/ex1
mkdir -p $PROJECT_BASEDIR
cd $PROJECT_BASEDIR
export M2_REPO=$HOME/.m2/repository

Create project directory structure. In this example, the developer used $HOME/proj/784 for all work in this class.

$PROJECT_BASEDIR
|-- src
|   |-- main
|   |   `-- java
|   |       `-- myorg
|   |           `-- mypackage
|   |               `-- ex1
|   `-- test
|       |-- resources
|       `-- java
|           `-- myorg
|               `-- mypackage
|                   `-- ex1
`-- target
    |-- classes
    |-- test-classes
    `-- test-reports
    

mkdir -p src/main/java/myorg/mypackage/ex1
mkdir -p src/test/java/myorg/mypackage/ex1
mkdir -p src/test/resources
mkdir -p target/classes
mkdir -p src/test/java/myorg/mypackage/ex1
mkdir -p target/test-classes
mkdir -p target/test-reports

Add the following Java implementation class to $PROJECT_BASEDIR/src/main/java/myorg/mypackage/ex1/App.java

package myorg.mypackage.ex1;


public class App {

    public int returnOne() { 

        System.out.println( "Here's One!" );

        return 1; 

    }


    public static void main( String[] args ) {

        System.out.println( "Hello World!" );

    }

}

Add the following Java test class to $PROJECT_BASEDIR/src/test/java/myorg/mypackage/ex1/AppTest.java

package myorg.mypackage.ex1;


import static org.junit.Assert.*;


import org.junit.Test;


/**

 * Unit test for simple App.

 */

public class AppTest {


    @Test

    public void testApp() {

        System.out.println("testApp");

        App app = new App();

        assertTrue("app didn't return 1", app.returnOne() == 1);

    }

}

Compile the application and place it in target/ex1.jar. The compiled classes will go in target/classes.

javac src/main/java/myorg/mypackage/ex1/App.java -d target/classes
jar cvf target/ex1.jar -C target/classes .
jar tf target/ex1.jar

$ javac src/main/java/myorg/mypackage/ex1/App.java -d target/classes
$ jar cvf target/ex1.jar -C target/classes .
added manifest
adding: myorg/(in = 0) (out= 0)(stored 0%)
adding: myorg/mypackage/(in = 0) (out= 0)(stored 0%)
adding: myorg/mypackage/ex1/(in = 0) (out= 0)(stored 0%)
adding: myorg/mypackage/ex1/App.class(in = 519) (out= 350)(deflated 32%)

$ jar tf target/ex1.jar
META-INF/
META-INF/MANIFEST.MF
myorg/
myorg/mypackage/
myorg/mypackage/ex1/
myorg/mypackage/ex1/App.class

Compile the JUnit test and place the compiled tests in target/test-classes.

export JUNIT_JARS="$M2_REPO/junit/junit/4.12/junit-4.12.jar:$M2_REPO/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar"
javac -classpath "target/ex1.jar:$JUNIT_JARS" src/test/java/myorg/mypackage/ex1/AppTest.java -d target/test-classes

Verify you have your "production" class from src/main compiled into target/classes directory, your unit test class from src/test compiled into target/test-classes directory, and the Java archive with the production class is in target directory.

target
|-- classes
|   `-- myorg
|       `-- mypackage
|           `-- ex1
|               `-- App.class
|-- ex1.jar
|-- test-classes
|   `-- myorg
|       `-- mypackage
|           `-- ex1
|               `-- AppTest.class
`-- test-reports

Run the JUnit test framework.

java -classpath "target/ex1.jar:$JUNIT_JARS:target/test-classes" org.junit.runner.JUnitCore myorg.mypackage.ex1.AppTest

JUnit version 4.12
.testApp
Here's One!

Time: 0.003

OK (1 test)

Change add/remove a test that will fail, re-compile the test class, and re-run.

    //AppTest.java

    @Test

    public void testFail() {

        System.out.println("testFail");

        App app = new App();

        assertTrue("app didn't return 0", app.returnOne() == 0);

    }

javac -classpath "target/ex1.jar:$JUNIT_JARS" src/test/java/myorg/mypackage/ex1/AppTest.java -d target/test-classes
java -classpath "target/ex1.jar:$JUNIT_JARS:target/test-classes" org.junit.runner.JUnitCore myorg.mypackage.ex1.AppTest

JUnit version 4.12
.testApp
Here's One!
.testFail
Here's One!
E
Time: 0.007
There was 1 failure:
1) testFail(myorg.mypackage.ex1.AppTest)
java.lang.AssertionError: app didn't return 0
        at org.junit.Assert.fail(Assert.java:93)
        at org.junit.Assert.assertTrue(Assert.java:43)
        at myorg.mypackage.ex1.AppTest.testFail(AppTest.java:26)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
...
        at org.junit.runner.JUnitCore.main(JUnitCore.java:45)

FAILURES!!!
Tests run: 2,  Failures: 1

Create a build.properties file in $PROJECT_BASEDIR. This will be used to define any non-portable property values. Place the most non-portable base variables (.e.g, M2_REPO location) towards the top and build lower-level paths from them. This makes the scripts much easier to port to another environment. If you still have your maven repository in your $HOME directory, you can make use of ${user.home} environment variable rather than a hard-coded path.

#ex1 build.properties
#M2_REPO=c:/jhu/repository
M2_REPO=${user.home}/.m2/repository

junit.classpath=${M2_REPO}/junit/junit/4.10/junit-4.10.jar

Create a build.xml file in $PROJECT_BASEDIR. Note the following key elements.

<?xml version="1.0" encoding="utf-8" ?> 

<!-- ex1 build.xml 

-->

<project name="ex1" default="" basedir=".">

    <property file="build.properties"/>



    <property name="artifactId" value="ex1"/>

    <property name="src.dir"    value="${basedir}/src"/>

    <property name="build.dir"  value="${basedir}/target"/>



    <target name="echo">

        <echo>basedir=${basedir}</echo>

        <echo>artifactId=${artifactId}</echo>

        <echo>src.dir=${src.dir}</echo>

        <echo>build.dir=${build.dir}</echo>

        <echo>junit.classpath=${junit.classpath}</echo>

    </target>

</project>

Sanity check your build.xml and build.properties file with the echo target.

$ ant echo
Buildfile: /home/jim/proj/784/exercises/ex1/build.xml

echo:
     [echo] basedir=/home/jim/proj/784/exercises/ex1
     [echo] artifactId=ex1
     [echo] src.dir=/home/jim/proj/784/exercises/ex1/src
     [echo] build.dir=/home/jim/proj/784/exercises/ex1/target
     [echo] junit.classpath=/home/jim/.m2/repository/junit/junit/4.10/junit-4.10.jar

BUILD SUCCESSFUL
Total time: 0 seconds

Add the "package" target to compile and archive your /src/main classes. Note the following tasks in this target.

    <target name="package">

        <mkdir dir="${build.dir}/classes"/>

        <javac srcdir="${src.dir}/main/java"

               destdir="${build.dir}/classes"

               debug="true"

               source="1.8"

               target="1.8"

               includeantruntime="false">

               <classpath>

               </classpath>

        </javac>



        <jar destfile="${build.dir}/${artifactId}.jar">

            <fileset dir="${build.dir}/classes"/>

        </jar>

    </target>

Execute the "package" target just added. This should compile the production class from src/main into target/classes and build a Java archive with the production class in target/.

$ rm -rf target/; ant package
Buildfile: /home/jim/proj/784/exercises/ex1/build.xml

package:
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/classes
    [javac] Compiling 1 source file to /home/jim/proj/784/exercises/ex1/target/classes
      [jar] Building jar: /home/jim/proj/784/exercises/ex1/target/ex1.jar

BUILD SUCCESSFUL
Total time: 2 seconds

build.xml:26: Unable to find a javac compiler;
com.sun.tools.javac.Main is not on the classpath.
Perhaps JAVA_HOME does not point to the JDK.
It is currently set to ".../jre"

$ find . -type f
./src/main/java/myorg/mypackage/ex1/App.java
./src/test/java/myorg/mypackage/ex1/AppTest.java
./build.properties
./build.xml
./target/classes/myorg/mypackage/ex1/App.class
./target/ex1.jar

Add the "test" target to compile your /src/test classes. Make this the default target for your build.xml file. Note too that it should depend on the successful completion of the "package" target and include the produced archive in its classpath.

<project name="ex1" default="test" basedir=".">

...

    <target name="test" depends="package">

        <mkdir dir="${build.dir}/test-classes"/>

        <javac srcdir="${src.dir}/test/java"

               destdir="${build.dir}/test-classes"

               debug="true"

               source="1.8"

               target="1.8"

               includeantruntime="false">

               <classpath>

                   <pathelement location="${build.dir}/${artifactId}.jar"/>

                   <pathelement path="${junit.classpath}"/>

               </classpath>

        </javac>

    </target>

Execute the new "test" target after clearing out the contents of the target directory. Note that the target directory gets automatically re-populated with the results of the "compile" target and augmented with the test class from src/test compiled into target/test-classes.

$ rm -rf target/; ant
Buildfile: /home/jim/proj/784/exercises/ex1/build.xml

package:
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/classes
    [javac] Compiling 1 source file to /home/jim/proj/784/exercises/ex1/target/classes
      [jar] Building jar: /home/jim/proj/784/exercises/ex1/target/ex1.jar

test:
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/test-classes
    [javac] Compiling 1 source file to /home/jim/proj/784/exercises/ex1/target/test-classes

BUILD SUCCESSFUL
Total time: 3 seconds

> find . -type f
./src/main/java/myorg/mypackage/ex1/App.java
./src/test/java/myorg/mypackage/ex1/AppTest.java
./build.properties
./build.xml
./target/classes/myorg/mypackage/ex1/App.class
./target/ex1.jar
./target/test-classes/myorg/mypackage/ex1/AppTest.class

Add the junit task to the test target. The junit task is being configured to run in batch mode and write a TXT and XML reports to the target/test-reports directory. See Ant docs for more details on the junit task. Make special note of the following:

        <mkdir dir="${build.dir}/test-reports"/>

        <junit printsummary="true" fork="true">

               <classpath>

                   <pathelement path="${junit.classpath}"/>

                   <pathelement location="${build.dir}/${artifactId}.jar"/>

                   <pathelement location="${build.dir}/test-classes"/>

               </classpath>



            <batchtest fork="true" todir="${build.dir}/test-reports">

                <fileset dir="${build.dir}/test-classes">

                    <include name="**/*Test*.class"/>

                </fileset>

            </batchtest>



            <formatter type="plain"/>

            <formatter type="xml"/>

        </junit>

BUILD FAILED

/home/jim/proj/784/exercises/ex1/build.xml:57: Problem: failed to create task or type junit
Cause: the class org.apache.tools.ant.taskdefs.optional.junit.JUnitTask was not found.        
        This looks like one of Ant's optional components.
Action: Check that the appropriate optional JAR exists in
        -/usr/share/ant/lib
        -/home/jim/.ant/lib
        -a directory added on the command line with the -lib argument

Do not panic, this is a common problem.
The commonest cause is a missing JAR.

This is not a bug; it is a configuration problem

Execute the updated "test" target with the JUnit test.

$ rm -rf target; ant
package:
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/classes
    [javac] Compiling 1 source file to /home/jim/proj/784/exercises/ex1/target/classes
      [jar] Building jar: /home/jim/proj/784/exercises/ex1/target/ex1.jar

test:
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/test-classes
    [javac] Compiling 1 source file to /home/jim/proj/784/exercises/ex1/target/test-classes
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/test-reports
    [junit] Running myorg.mypackage.ex1.AppTest
    [junit] Tests run: 2, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 15.143 sec
    [junit] Test myorg.mypackage.ex1.AppTest FAILED

BUILD SUCCESSFUL
Total time: 17 seconds

$ find . -type f
./src/main/java/myorg/mypackage/ex1/App.java
./src/test/java/myorg/mypackage/ex1/AppTest.java
./build.properties
./build.xml
./target/classes/myorg/mypackage/ex1/App.class
./target/ex1.jar
./target/test-classes/myorg/mypackage/ex1/AppTest.class
./target/test-reports/TEST-myorg.mypackage.ex1.AppTest.txt
./target/test-reports/TEST-myorg.mypackage.ex1.AppTest.xml

Test output of each test is in the TXT and XML reports.

$ more target/test-reports/TEST-myorg.mypackage.ex1.AppTest.txt 
Testsuite: myorg.mypackage.ex1.AppTest
Tests run: 2, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 15.246 sec
------------- Standard Output ---------------
testApp
Here's One!
testFail
Here's One!
------------- ---------------- ---------------

Testcase: testApp took 0.007 sec
Testcase: testFail took 0.022 sec
        FAILED
app didn't return 0
junit.framework.AssertionFailedError: app didn't return 0
        at myorg.mypackage.ex1.AppTest.testFail(AppTest.java:26)

Add a clean target to the build.xml file to delete built artifacts. See Ant docs for details on the delete task.

    <target name="clean">

        <delete dir="${build.dir}"/>

    </target>

Re-run and use the new "clean" target you just added.

$ ant clean test
Buildfile: /home/jim/proj/784/exercises/ex1/build.xml

clean:
   [delete] Deleting directory /home/jim/proj/784/exercises/ex1/target

package:
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/classes
    [javac] Compiling 1 source file to /home/jim/proj/784/exercises/ex1/target/classes
      [jar] Building jar: /home/jim/proj/784/exercises/ex1/target/ex1.jar

test:
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/test-classes
    [javac] Compiling 1 source file to /home/jim/proj/784/exercises/ex1/target/test-classes
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/test-reports
    [junit] Running myorg.mypackage.ex1.AppTest
    [junit] Tests run: 2, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 15.123 sec
    [junit] Test myorg.mypackage.ex1.AppTest FAILED

BUILD SUCCESSFUL
Total time: 17 seconds

Comment out the bogus testFail and rerun.

$ cat src/test/java/myorg/mypackage/ex1/AppTest.java
...
    //@Test
    public void testFail() {

$ ant clean test
Buildfile: /home/jim/proj/784/exercises/ex1/build.xml

clean:
   [delete] Deleting directory /home/jim/proj/784/exercises/ex1/target

package:
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/classes
    [javac] Compiling 1 source file to /home/jim/proj/784/exercises/ex1/target/classes
      [jar] Building jar: /home/jim/proj/784/exercises/ex1/target/ex1.jar

test:
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/test-classes
    [javac] Compiling 1 source file to /home/jim/proj/784/exercises/ex1/target/test-classes
    [mkdir] Created dir: /home/jim/proj/784/exercises/ex1/target/test-reports
    [junit] Running myorg.mypackage.ex1.AppTest
    [junit] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 15.161 sec

BUILD SUCCESSFUL
Total time: 17 seconds

Change the System.out() calls in App and AppTest from Part A to use SLF logging API. The slf4j-api Javadoc and manual will be helpful in understanding this interface.

package myorg.mypackage.ex1;


import org.slf4j.Logger;

import org.slf4j.LoggerFactory;


public class App {

    private static Logger logger = LoggerFactory.getLogger(App.class);


    public int returnOne() { 

        //System.out.println( "Here's One!" );

        logger.debug( "Here's One!" );

        return 1; 

    }


    public static void main( String[] args ) {

        //System.out.println( "Hello World!" );

        logger.info( "Hello World!" );

    }

}

package myorg.mypackage.ex1;

...

import static org.junit.Assert.*;

import org.junit.Test;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;


public class AppTest {

    private static Logger logger = LoggerFactory.getLogger(AppTest.class);

...

    @Test

    public void testApp() {

        //System.out.println("testApp");

        logger.info("testApp");

        App app = new App();

        assertTrue("app didn't return 1", app.returnOne() == 1);

    }

}

Add a log4j.xml configuration file to the directory structure. Place this file in src/test/resources/log4j.xml. This file is used to control logging output. Refer to the log4j manual for possible information on how to configure and use log4j. It doesn't matter whether you use a log4j.xml format or log4j.properties format. Of note, the implementation we are using is based on "Log4j 1" -- which reached its end of life in 2015. It still works but all energy in this area is within "Log4j 2".

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">



<log4j:configuration 

    xmlns:log4j="http://jakarta.apache.org/log4j/" 

    debug="false">

   

    <appender name="CONSOLE" class="org.apache.log4j.ConsoleAppender">

        <param name="Target" value="System.out"/>



        <layout class="org.apache.log4j.PatternLayout">

            <param name="ConversionPattern" 

                   value="%-5p %d{dd-MM HH:mm:ss,SSS} (%F:%M:%L)  -%m%n"/>

        </layout>

    </appender>



    <appender name="logfile" class="org.apache.log4j.RollingFileAppender">

        <param name="File" value="target/log4j-out.txt"/>

        <param name="Append" value="false"/>

        <param name="MaxFileSize" value="100KB"/>

        <param name="MaxBackupIndex" value="1"/>

        <layout class="org.apache.log4j.PatternLayout">

            <param name="ConversionPattern" 

                   value="%-5p %d{dd-MM HH:mm:ss,SSS} [%c] (%F:%M:%L)  -%m%n"/>

        </layout>

   </appender>



   <logger name="myorg.mypackage">

      <level value="debug"/>

      <appender-ref ref="logfile"/>  

   </logger>



   <root>

      <priority value="info"/>    

      <appender-ref ref="CONSOLE"/>  

   </root>   

   

</log4j:configuration>

Add the slf4j-api.jar to the compile classpaths and the slf4j-api.jar, slf4j-log4j.jar, and log4j.jar to the runtime classpath used during tests. Also add an additional task to copy the log4j.xml file into target/test-classes so that it is seen by the classloader as a resource. Realize that your classes have no compilation dependencies on log4j. Log4j is only used if it is located at runtime.

# ex1 build.properties
junit.classpath=${M2_REPO}/junit/junit/4.12/junit-4.12.jar:\
${M2_REPO}/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar

slf4j-api.classpath=${M2_REPO}/org/slf4j/slf4j-api/1.7.25/slf4j-api-1.7.25.jar
slf4j-log4j.classpath=${M2_REPO}/org/slf4j/slf4j-log4j12/1.7.25/slf4j-log4j12-1.7.25.jar
log4j.classpath=${M2_REPO}/log4j/log4j/1.2.17/log4j-1.2.17.jar

    <target name="echo">

        ...

        <echo>slf4j-api.classpath=${slf4j-api.classpath}</echo>

        <echo>slf4j-log4j.classpath=${slf4j-log4j.classpath}</echo>

        <echo>log4j.classpath=${log4j.classpath}</echo>

    </target>

        <javac srcdir="${src.dir}/main/java"

               destdir="${build.dir}/classes"

               debug="true"

               source="1.8"

               target="1.8"

               includeantruntime="false">

               <classpath>

                   <pathelement path="${slf4j-api.classpath}"/>

               </classpath>

        </javac>

        <javac srcdir="${src.dir}/test/java"

               destdir="${build.dir}/test-classes"

               debug="true"

               source="1.8"

               target="1.8"

               includeantruntime="false">

               <classpath>

                   <pathelement location="${build.dir}/${artifactId}.jar"/>

                   <pathelement path="${junit.classpath}"/>

                   <pathelement path="${slf4j-api.classpath}"/>

               </classpath>

        </javac>



        <copy todir="${build.dir}/test-classes">

            <fileset dir="${src.dir}/test/resources"/>

        </copy>

        <junit printsummary="true" fork="true">

               <classpath>

                   <pathelement path="${junit.classpath}"/>

                   <pathelement location="${build.dir}/${artifactId}.jar"/>

                   <pathelement location="${build.dir}/test-classes"/>

                   <pathelement path="${commons-logging.classpath}"/>

                   <pathelement path="${log4j.classpath}"/>

               </classpath>

        ...

Test application and inspect reports. All loggers inherit from the root logger and may only extend its definition; not limit it. Notice that the root logger's priority filter "info" value allows log.info() (warning and fatal) messages to printed to the console. The myorg.mypackage logger's level filter allows log.debug() messages from the myorg.mypackage.* classes to appear in both the console and logfile. This means that any Java classes not in our package hierarchy will only have INFO or higher priority messages logged.

$ ant clean test
Buildfile: /home/jcstaff/proj/784/exercises/ex1/build.xml

clean:
   [delete] Deleting directory /home/jcstaff/proj/784/exercises/ex1/target

package:
    [mkdir] Created dir: /home/jcstaff/proj/784/exercises/ex1/target/classes
    [javac] Compiling 1 source file to /home/jcstaff/proj/784/exercises/ex1/target/classes
      [jar] Building jar: /home/jcstaff/proj/784/exercises/ex1/target/ex1.jar

test:
    [mkdir] Created dir: /home/jcstaff/proj/784/exercises/ex1/target/test-classes
    [javac] Compiling 1 source file to /home/jcstaff/proj/784/exercises/ex1/target/test-classes
     [copy] Copying 1 file to /home/jcstaff/proj/784/exercises/ex1/target/test-classes
    [mkdir] Created dir: /home/jcstaff/proj/784/exercises/ex1/target/test-reports
    [junit] Running myorg.mypackage.ex1.AppTest
    [junit] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 15.127 sec

BUILD SUCCESSFUL
Total time: 17 seconds

You won't see the output come to stdout when using Ant, but you can locate all output in the FILE logger output defined to be in target/log4j-out.txt. This behavior will get a little better under Maven.

$ more target/log4j-out.txt 
INFO  13-08 18:24:21,983 [myorg.mypackage.ex1.AppTest] (AppTest.java:testApp:18)  -testApp
DEBUG 13-08 18:24:21,986 [myorg.mypackage.ex1.App] (App.java:returnOne:11)  -Here's One!

Your project structure should look like the following at this point.

> find . -type f
./src/main/java/myorg/mypackage/ex1/App.java
./src/test/java/myorg/mypackage/ex1/AppTest.java
./src/test/resources/log4j.xml
./build.properties
./build.xml
./target/classes/myorg/mypackage/ex1/App.class
./target/ex1.jar
./target/test-classes/myorg/mypackage/ex1/AppTest.class
./target/test-classes/log4j.xml
./target/test-reports/TEST-myorg.mypackage.ex1.AppTest.txt
./target/test-reports/TEST-myorg.mypackage.ex1.AppTest.xml
./target/log4j-out.txt

Change the logging level so that only the App class performs logs to the logfile. By extending the logger name specification all the way to the class, we further limit which classes apply to this logger.

    <logger name="myorg.mypackage.ex1.App">

      <level value="debug"/>

      <appender-ref ref="logfile"/>

   </logger>

After re-running the build you should notice the DEBUG for only the App is included because of the change we made to the logger outside the code.

$ more target/log4j-out.txt 
DEBUG 26-08 23:07:04,809 [myorg.mypackage.ex1.App] (App.java:returnOne:11)  -Here's One!

Repeat after me. "I will never use System.out.println() in this class." Doing so will make it difficult for your deployed components to have their logs controlled and accessible as it is instantiated in unit testing, integration testing, and deployment environments.

Create a pom.xml file in project basedir. This will be used to define your entire project. Refer to the Maven POM Reference for details about each element.

<?xml version="1.0"?>

<project>

    <modelVersion>4.0.0</modelVersion>



    <groupId>myorg.myproject</groupId>

    <artifactId>ex1</artifactId>



    <name>My First Simple Project</name>

    <version>1.0-SNAPSHOT</version>



    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    </properties>



    <dependencies>

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-api</artifactId>

            <version>1.7.25</version>

            <scope>compile</scope>

        </dependency>



        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.12</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-log4j12</artifactId>

            <version>1.7.25</version>

            <scope>test</scope>

        </dependency>

        <dependency>

            <groupId>log4j</groupId>

            <artifactId>log4j</artifactId>

            <version>1.2.17</version>

            <scope>test</scope>

        </dependency>

    </dependencies>



    <build>

        <plugins>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-compiler-plugin</artifactId>

                <version>3.7.0</version>

                <configuration>

                    <source>1.8</source>

                    <target>1.8</target>

                </configuration>

            </plugin>

        </plugins>

    </build>

</project>

Your project tree should look like the following at this point.

> find . -type f
./src/main/java/myorg/mypackage/ex1/App.java
./src/test/java/myorg/mypackage/ex1/AppTest.java
./src/test/resources/log4j.xml
./build.properties
./build.xml
./pom.xml

Note that the pom.xml file is not required to have an assigned schema. However, adding one does allow for XML editing tools to better assist in creating a more detailed POM. Replace the project element from above with the following declarations to assign an XML schema.

<project xmlns="http://maven.apache.org/POM/4.0.0" 

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

Run the package "phase" and watch the project compile, assemble, and test. Maven has many well-known phases that correspond to the lifecycle of build steps that goes into validating, preparing, building, testing, and deploying artifacts of a module. You can find out more about Maven phases here I refer to this page very often.

$ mvn package
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building JavaSE::Simple Module Exercise Solution 5.0.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ firstSimpleModuleEx ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory /home/jim/proj/784/exercises/ex1/src/main/resources
[INFO]
[INFO] --- maven-compiler-plugin:3.7.0:compile (default-compile) @ firstSimpleModuleEx ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /home/jim/proj/784/exercises/ex1/target/classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ firstSimpleModuleEx ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 1 resource
[INFO]
[INFO] --- maven-compiler-plugin:3.7.0:testCompile (default-testCompile) @ firstSimpleModuleEx ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to /home/jim/proj/784/exercises/ex1/target/test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ firstSimpleModuleEx ---
[INFO] Surefire report directory: /home/jim/proj/784/exercises/ex1/target/surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running myorg.mypackage.ex1.AppTest
INFO  13-08 19:03:19,264 (AppTest.java:testApp:18)  -testApp
DEBUG 13-08 19:03:19,267 (App.java:returnOne:11)  -Here's One!
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.13 sec

Results :

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0

[INFO]
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ firstSimpleModuleEx ---
[INFO] Building jar: /home/jim/proj/784/exercises/ex1/target/firstSimpleModuleEx-5.0.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.553 s
[INFO] Finished at: 2018-08-13T19:03:19-04:00
[INFO] Final Memory: 19M/309M
[INFO] ------------------------------------------------------------------------
[WARNING] The requested profile "h2db" could not be activated because it does not exist.

The contents of your development tree should look as follows.

> find . -type f
./build.xml
./build.properties
./pom.xml
./target/surefire-reports/TEST-myorg.mypackage.ex1.AppTest.xml
./target/surefire-reports/myorg.mypackage.ex1.AppTest.txt
./target/log4j-out.txt
./target/maven-archiver/pom.properties
./target/ex1-1.0-SNAPSHOT.jar
./target/test-classes/myorg/mypackage/ex1/AppTest.class
./target/test-classes/log4j.xml
./target/classes/myorg/mypackage/ex1/App.class
./target/maven-status/...
./src/test/resources/log4j.xml
./src/test/java/myorg/mypackage/ex1/AppTest.java
./src/main/java/myorg/mypackage/ex1/App.java

For *fun*, lets add a README that could be used to describe something about your project and have it be processed as part of the documentation for the module. You do not need to do this for class projects, but walking through this may be helpful in understanding how the course website is created from the source you have on your disk. Maven supports a couple of documentation generation languages, but lets just use HTML to keep this simple. Place the following content to src/site/resources/README.html

mkdir -p src/site/resources

$ cat src/site/resources/README.html 



<?xml version="1.0"?>

<html>

    <head>

        <title>My First Project</title>

    </head>

<body>

    <section><h1>My First Project</h1></section>

    <p/>

    This is my first project. Take a look at 

    <p/>

    <ul>

        <li>this ....</li>

        <li>that ....</li>

        <li>or <a href="./index.html">go home</a></li>

    </ul>

    </section>

</body>

</html>

The above is enough to provide the page. Now add a link to it from the project menu. Add the following content to src/site/site.xml

$ cat src/site/site.xml



<?xml version="1.0" encoding="UTF-8"?>

<project name="${project.name}">

  <body>

    <menu name="Content">

        <item name="README" href="README.html"/>

    </menu>

  </body>

</project>

You must also specify a version# for the maven-site-plugin and maven-project-info-reports-plugin in the pom.xml. Maven is extremely version-aware.

<plugins>

...

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-site-plugin</artifactId>

                <version>3.4</version>

            </plugin>



            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-project-info-reports-plugin</artifactId>

                <version>2.8</version>

            </plugin>

</plugins>

> find . -type f
./src/main/java/myorg/mypackage/ex1/App.java
./src/test/java/myorg/mypackage/ex1/AppTest.java
./src/test/resources/log4j.xml
./src/site/resources/README.html
./src/site/site.xml
./build.properties
./build.xml
./pom.xml

Build the site and open target/site/index.html in your browser. You should see a link to the README on the left side.

$ mvn site                                                                                                                                                       
[INFO] Scanning for projects...   
...
[INFO] BUILD SUCCESS

$ find target/site/ -name *.html

target/site/plugin-management.html
target/site/index.html
target/site/mail-lists.html
target/site/issue-tracking.html
target/site/license.html
target/site/project-info.html
target/site/dependency-info.html
target/site/README.html
target/site/dependencies.html
target/site/team-list.html
target/site/source-repository.html
target/site/integration.html
target/site/distribution-management.html
target/site/project-summary.html
target/site/plugins.html

            <!-- exclude this modules from site generation -->

            <plugin> 

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-site-plugin</artifactId>

                <version>3.4</version>

                <configuration>

                    <skip>false</skip>

                    <skipDeploy>false</skipDeploy>

                </configuration>

            </plugin>

Okay, that was a lot of work to just copy an html file. Now lets add javadoc to our project and create a link to it. Add the following contents to the bottom of the pom.xml file.

...

    </build>

    <reporting>

        <plugins>

            <plugin>

                <artifactId>maven-javadoc-plugin</artifactId>

                <groupId>org.apache.maven.plugins</groupId>

                <version>3.0.1</version>

                <configuration>

                    <detectLinks>false</detectLinks>

                    <detectOfflineLinks>true</detectOfflineLinks>

                    <show>private</show>

                    <source>1.8</source>

                    <additionalparam>-Xdoclint:none</additionalparam>

                    <failOnError>false</failOnError>

                    <links>

                        <link>http://download.oracle.com/javase/8/docs/api/</link>

                        <link>https://javaee.github.io/javaee-spec/javadocs/</link>

                    </links>

                </configuration>

            </plugin>

        </plugins>

    </reporting>

We could create a link the the apidocs/index.html like we did with README.html, but that would be something we'd keep having to update each time we added a new report. Lets add a property to the site.xml menu so a link to Javadoc and other reports can drop in automatically.

# src/site/site.xml

<?xml version="1.0" encoding="UTF-8"?>

<project name="${project.name}">

  <body>

    <menu name="Content">

        <item name="README" href="README.html"/>

    </menu>



    <menu ref="reports"/>



  </body>

</project>

Re-generate the site documentation with the site target. Open the target/site/index.html page and you should now see a menu item for "Project Reports" -> "JavaDocs". Our App class should be included in the Javadoc.

Let's start a settings.xml file to store properties that are specific to our build site. You can find details about each setting at the following URL.

cat $HOME/.m2/settings.xml



<?xml version="1.0"?>

<settings xmlns="http://maven.apache.org/POM/4.0.0"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">



</settings>

If your $HOME directory path contains spaces, you will want to provide an override for the localRepository. Provide a custom path that does not contain spaces. This value will default to a "$HOME/.m2/repository" directory.

    <!-- this overrides the default $HOME/.m2/repository location. -->

    <localRepository>c:/jhu/repository</localRepository>

Add the following specification to either the settings.xml file or the local pom.xml file. If you specify it to the local pom.xml file -- it will only apply to that project. If you specify it in the settings.xml file -- it will be global to all projects in your area. More will be covered on this later. However, it should be noted that this profile is not active unless someone specifically asks for it (-Pdebugger) or the "debugger" environment variable is set (-Ddebugger=(anything)).

    <profiles>

        <profile>

            <id>debugger</id>

            <!-- this should only be activated when performing interactive

                 debugging -->

            <activation>

                <property>

                    <name>debugger</name>

                </property>

            </activation>

            <properties>

                <surefire.argLine>-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 -Xnoagent -Djava.compiler=NONE</surefire.argLine>

            </properties>                                  

        </profile>

    </profiles>

Although not needed for this class -- at times you will need access to a dependency that is not available in a Maven repository. COTS libraries are generally not available at ibiblio.org. You must download it and manually install it locally.

This step will go though importing a stand-alone archive into the repository to resolve any dependencies. Start by declaring a dependency before we do the import. Note that a new scope property was added. See the Dependency Mechanism Intro Page for a discussion of scope, but in this case it is indicating that it should only be present on the command line and not the runtime classpath.

        <dependency>

            <groupId>foo</groupId>

            <artifactId>bar</artifactId>

            <version>1.1</version>

            <scope>provided</scope>

        </dependency>

Attempt the build the module with the missing dependency. The build should fail but note that Maven attempted all known external repositores.

> mvn package
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building My First Simple Project 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
Downloading: http://webdev.apl.jhu.edu/~jcs/maven2/foo/bar/1.1/bar-1.1.pom
Downloading: http://webdev.apl.jhu.edu/~jcs/maven2-snapshot/foo/bar/1.1/bar-1.1.pom
Downloading: http://repo1.maven.org/maven2/foo/bar/1.1/bar-1.1.pom
[WARNING] The POM for foo:bar:jar:1.1 is missing, no dependency information available
Downloading: http://webdev.apl.jhu.edu/~jcs/maven2/foo/bar/1.1/bar-1.1.jar
Downloading: http://webdev.apl.jhu.edu/~jcs/maven2-snapshot/foo/bar/1.1/bar-1.1.jar
Downloading: http://repo1.maven.org/maven2/foo/bar/1.1/bar-1.1.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD FAILURE
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.437s
[INFO] Finished at: Wed Feb 02 12:20:51 EST 2011
[INFO] Final Memory: 2M/15M
[INFO] ------------------------------------------------------------------------
[ERROR] Failed to execute goal on project ex1: Could not resolve dependencies for project myorg.myproject:ex1:jar:1.0-SNAPSHOT: 
Could not find artifact foo:bar:jar:1.1 in webdev-baseline (http://webdev.apl.jhu.edu/~jcs/maven2) -> [Help 1]

The old error message provided for Maven 2 was much better if a manual install is what you really needed. The newer (Maven 3) one does not provide instruction. In this case, manually install a jar file that represents the declaration. Assign it a groupId of foo, an artifactId of bar, and a version of 1.1. Don't forget to add the -DgeneratePom=true or you will get a download warning everytime you try to build. All we need is a valid .jar file. If you don't have one laying around, just create one with valid structure.

$ touch bar.jar
$ mvn install:install-file -DgroupId=foo -DartifactId=bar -Dversion=1.1 -Dpackaging=jar -Dfile=bar.jar -DgeneratePom=true

[INFO] Scanning for projects...
[INFO]                                                                         
[INFO] ------------------------------------------------------------------------
[INFO] Building My First Simple Project 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] 
[INFO] --- maven-install-plugin:2.4:install-file (default-cli) @ ex1 ---
[INFO] Installing /home/jim/proj/784/exercises/ex1/bar.jar to /home/jim/.m2/repository/foo/bar/1.1/bar-1.1.jar
[INFO] Installing /tmp/mvninstall5322334237902777597.pom to /home/jim/.m2/repository/foo/bar/1.1/bar-1.1.pom
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

After successfully installing the dummy archive, you should be able to locate the JAR and other supporting files in the local repository. Be sure to look where you have directed localRepository in $HOME/.m2/settings.xml

$ find /home/jim/.m2/repository/foo/bar/

/home/jim/.m2/repository/foo/bar/

/home/jim/.m2/repository/foo/bar/1.1

/home/jim/.m2/repository/foo/bar/1.1/bar-1.1.pom.lastUpdated

/home/jim/.m2/repository/foo/bar/1.1/_remote.repositories

/home/jim/.m2/repository/foo/bar/1.1/bar-1.1.jar.lastUpdated

/home/jim/.m2/repository/foo/bar/1.1/bar-1.1.jar

/home/jim/.m2/repository/foo/bar/1.1/bar-1.1.pom

/home/jim/.m2/repository/foo/bar/maven-metadata-local.xml

Notice that Maven always makes sure there is a POM file present -- whether it had to generate it or not.

$ more /home/jim/.m2/repository/foo/bar/1.1/bar-1.1.pom



<?xml version="1.0" encoding="UTF-8"?>

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <modelVersion>4.0.0</modelVersion>

  <groupId>foo</groupId>

  <artifactId>bar</artifactId>

  <version>1.1</version>

  <description>POM was created from install:install-file</description>

</project>

Now try running "mvn package" and it should successfully resolve the fake dependency on the bar.jar.

One last thing...Maven pulls in definitions from many places in the build environment. If you ever want to know what the total sum of those sources are (the "effective POM"), the execute the help:effective-pom goal.

 $ mvn help:effective-pom

[INFO] Scanning for projects...



...



<project xmlns...

  <modelVersion>4.0.0</modelVersion>

  <groupId>myorg.myproject</groupId>

  <artifactId>ex1</artifactId>

  <version>1.0-SNAPSHOT</version>

  <name>My First Simple Project</name>

  <properties>

    <jboss.home>/opt/wildfly-13.0.0.Final</jboss.home>

    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

  </properties>

  <dependencies>

    <dependency>

      <groupId>foo</groupId>

      <artifactId>bar</artifactId>

      <version>1.1</version>

      <scope>provided</scope>

    </dependency>

...

Prepare your environment to run the database in server mode for this exercise by following the instructions defined in Development Environment Setup.

Start the database and web server server in a directory where you wish to create database files. Your h2.jar file source be located in M2_REPO/com/h2database/h2/*/h2*.jar to name at least one location. Another location is JBOSS_HOME/modules/com/h2database/h2/main/h2*.jar

cd /tmp

java -jar h2.jar

This should result in a database server process and access to a web-based database UI through the following local URL: http://localhost:8082/login.jsp

Connect to the database server from the web-based UI.

Driver Class: org.h2.Driver

JDBC URL: jdbc:h2:tcp://localhost:9092/./h2db/ejava</jdbc.url>

User Name: sa

Password: 

Look in the directory where you started the server. After connecting with a relative URL using the UI, there should be a new "h2db" directory with one or more files called "ejava*". You want to make sure you use the same URL in the UI and application so you are seeing the same instance of the database.

If you use file-based mode, the connection information would look like the following where "./h2db/ejava" must point to the exact same path your JVM under test uses. This can be a relative or fully-qualified path.

Driver Class: org.h2.Driver

JDBC URL: jdbc:h2:./target/h2db/ejava

User Name: sa

Password: 

Create a root directory for your project and populate with a pom.xml file

<?xml version="1.0"?>

<project

    xmlns="http://maven.apache.org/POM/4.0.0"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <modelVersion>4.0.0</modelVersion>



    <groupId>myorg.jpa</groupId>

    <artifactId>entityMgrEx</artifactId>

    <version>1.0-SNAPSHOT</version>



    <name>Entity Manager Exercise</name>



</project>

Define a remote repository to use to download hibernate artifacts

 <!-- needed to resolve some hibernate dependencies -->

    <repositories>

        <repository>

            <id>jboss-nexus</id>

            <name>JBoss Nexus Repository</name>

            <url>https://repository.jboss.org/nexus/content/groups/public-jboss/</url>

        </repository>

    </repositories> 

Add property definitions for versions of dependencies and plugins we will be using.

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <java.source.version>1.8</java.source.version>

        <java.target.version>1.8</java.target.version>



        <jboss.host>localhost</jboss.host>

        <db.host>${jboss.host}</db.host>



        <maven-compiler-plugin.version>3.7.0</maven-compiler-plugin.version>

        <maven-jar-plugin.version>3.1.0</maven-jar-plugin.version>

        <maven-surefire-plugin.version>2.22.0</maven-surefire-plugin.version>

        <sql-maven-plugin.version>1.5</sql-maven-plugin.version>



        <h2db.version>1.4.197</h2db.version>

        <javax.persistence-api.version>2.2</javax.persistence-api.version>

        <hibernate-entitymanager.version>5.3.1.Final</hibernate-entitymanager.version>

        <junit.version>4.12</junit.version>

        <log4j.version>1.2.17</log4j.version>

        <slf4j.version>1.7.25</slf4j.version>

        <ejava.version>5.0.0-SNAPSHOT</ejava.version>

    </properties>

Add a dependencyManagement section to define and configure the dependencies we will be using to work with JPA. These are passive definitions -- meaning they don't actually add any dependencies to your project. They just define the version and possible exclusions for artifacts so all child/leaf projects stay consistent.

    <dependencyManagement>

        <dependencies>

            <dependency>

                <groupId>javax.persistence</groupId>

                <artifactId>javax.persistence-api</artifactId>

                <version>${javax.persistence-api.version}</version>

            </dependency>

            <dependency>

                <groupId>org.hibernate</groupId>

                <artifactId>hibernate-core</artifactId>

                <version>${hibernate-entitymanager.version}</version>

            </dependency>

            <dependency>

                <groupId>junit</groupId>

                <artifactId>junit</artifactId>

                <version>${junit.version}</version>

            </dependency>

            <dependency>

                <groupId>org.slf4j</groupId>

                <artifactId>slf4j-api</artifactId>

                <version>${slf4j.version}</version>

            </dependency>

            <dependency>

                <groupId>org.slf4j</groupId>

                <artifactId>slf4j-log4j12</artifactId>

                <version>${slf4j.version}</version>

            </dependency>

            <dependency>

              <groupId>log4j</groupId>

              <artifactId>log4j</artifactId>

              <version>${log4j.version}</version>

            </dependency>

        </dependencies>

    </dependencyManagement>