You can create the GAR project either using an archetype, as described in Creating a Coherence Project from a Maven Archetype, or you can create the directories and files manually:

• To use the archetype, run the following command:

  mvn archetype:generate
      -DarchetypeGroupId=com.oracle.coherence.archetype
      -DarchetypeArtifactId=gar-maven-archetype
      -DarchetypeVersion=14.1.2-0-0
      -DgroupId=org.mycompany
      -DartifactId=my-real-app-gar
      -Dversion=1.0-SNAPSHOT
  

• To create the project manually, use the following commands to create the necessary directories:

  mkdir -p my-real-app-gar/src/main/resources/META-INF
  mkdir -p my-real-app-gar/src/main/java/org/mycompany

If you use the archetype, you already have a POM file. Modify that file to match the following example. If you create the project manually, create the POM file (my-real-app-gar/pom.xml) with the following contents:

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <artifactId>my-real-app-gar</artifactId>
  <packaging>gar</packaging>

  <parent>
    <groupId>org.mycompany</groupId>
    <artifactId>my-real-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>

  <dependencies>
    <dependency>
      <groupId>com.oracle.coherence</groupId>
      <artifactId>coherence</artifactId>
      <scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>com.oracle.coherence</groupId>
        <artifactId>gar-maven-plugin</artifactId>
        <extensions>true</extensions>
        <configuration>
          <generatePof>true</generatePof>
        </configuration>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <configuration>
          <forceCreation>true</forceCreation>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Examine the POM file to understand each part of the file:

• The Maven coordinates groupId and version are inherited from the top-level POM and the POM only needs to specify the artifactId and packaging type. Notice that the packaging is gar because you use the Coherence GAR Maven plug-in to build this project into a Coherence GAR file.

  <artifactId>my-real-app-gar</artifactId>
  <packaging>gar</packaging>

• The coordinates of the parent project are set. These coordinates point back to the top-level POM to allow for inheritance of configuration.

  <parent>
    <groupId>org.mycompany</groupId>
    <artifactId>my-real-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>

• The dependencies section identifies any dependencies that this project has. In this case, you depend only on the Coherence library, that is, com.oracle.coherence:coherence:14.1.2-0-0. Notice that the dependency declaration does not need to include the version because that was inherited from the top-level POM file's dependencyManagement section. The scope provided means that this library is just for compilation and does not need to be packaged in the artifact that you build (the GAR file) as it is already provided in the runtime environment.

    <dependencies>
      <dependency>
        <groupId>com.oracle.coherence</groupId>
        <artifactId>coherence</artifactId>
        <scope>provided</scope>
      </dependency>
    </dependencies>
  

• The plugins section includes any plug-ins that you want to run during the build that are not automatically included or included plug-ins for which you need to specify additional configuration, like the maven-jar-plugin. In this case, you must set generatePof to true so that the plug-in looks for POJOs with POF annotations and generates the necessary artifacts. You also must tell the maven-jar-plugin to always regenerate the GAR file. Notice that the versions of the plug-ins are not provided because those are inherited from the top-level POM file's pluginManagement section.

  <plugins>
    <plugin>
      <groupId>com.oracle.coherence</groupId>
      <artifactId>gar-maven-plugin</artifactId>
      <extensions>true</extensions>
      <configuration>
        <generatePof>true</generatePof>
      </configuration>
    </plugin>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <configuration>
        <forceCreation>true</forceCreation>
      </configuration>
    </plugin>
  </plugins>

There are three Coherence configuration files that you need in your GAR project. If you use the archetype, the files already exist, but you need to modify them to match the following examples. If you create the project manually, create these files in the following locations:

my-real-app-gar/src/main/resources/META-INF/pof-config.xml
my-real-app-gar/src/main/resources/META-INF/coherence-application.xml
my-real-app-gar/src/main/resources/META-INF/cache-config.xml

• The following example shows the contents for the pof-config.xml file:

  <?xml version="1.0"?>
  <pof-config
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns="http://xmlns.oracle.com/coherence/coherence-pof-config"
          xsi:schemaLocation="http://xmlns.oracle.com/coherence/coherence-pof-config coherence-pof-config.xsd">
    <user-type-list>
      <include>coherence-pof-config.xml</include>
      <user-type>
        <type-id>1001</type-id>
        <class-name>org.mycompany.Person</class-name>
      </user-type>
    </user-type-list>
  </pof-config>

  This file requires adding the Person type if you created it with the archetype.

• The following example shows the contents for the coherence-application.xml file:

  <?xml version="1.0" encoding="ISO-8859-1"?>
  <coherence-application xmlns="http://xmlns.oracle.com/weblogic/coherence-application">
    <cache-configuration-ref>META-INF/cache-config.xml</cache-configuration-ref>
    <pof-configuration-ref>META-INF/pof-config.xml</pof-configuration-ref>
  </coherence-application>
  

  This file requires little or no modification if you created it with the archetype.

• The cache-config.xml file must be updated if you have used the archetype.

  In this file, create a cache named People, with a caching scheme named real-distributed-gar and a service name of RealDistributedCache, which uses the local backing scheme and is automatically started. If you are not familiar with these terms, see Building Oracle Coherence Projects with Maven. The following shows an example of the file:

  <?xml version="1.0"?>
  <cache-config
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns="http://xmlns.oracle.com/coherence/coherence-cache-config"
      xsi:schemaLocation="http://xmlns.oracle.com/coherence/coherence-cache-config coherence-cache-config.xsd">
    <caching-scheme-mapping>
      <cache-mapping>
        <cache-name>People</cache-name>
        <scheme-name>real-distributed-gar</scheme-name>
      </cache-mapping>
    </caching-scheme-mapping>
  
    <caching-schemes>
      <distributed-scheme>
        <scheme-name>real-distributed-gar</scheme-name>
        <service-name>RealDistributedCache</service-name>
        <backing-map-scheme>
          <local-scheme/>
        </backing-map-scheme>
        <autostart>true</autostart>
      </distributed-scheme>
    </caching-schemes>
  </cache-config>

Create the Person object, which will store information in the cache. Create a new Java class in the following location:

my-real-app-gar/src/main/java/org/mycompany/Person.java

package org.mycompany;

import com.tangosol.io.pof.annotation.Portable;
import com.tangosol.io.pof.annotation.PortableProperty;

@Portable
public class Person {
  @PortableProperty(0)
  public String name;

  @PortableProperty(1)
  public int age;

  public Person() {}

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public String getName() { return this.name; }
  public int getAge() { return this.age; }
}

This POJO tells Coherence what to do with the class. Because the focus of this chapter is on building applications with Maven, it does not go into the details of writing Coherence applications. For more information on Coherence, refer to Building Oracle Coherence Projects with Maven.

Create a small wrapper class that you can use to access the cache. Create another Java class in this location:

my-real-app-gar/src/main/java/org/mycompany/CacheWrapper.java

package org.mycompany;

import java.util.Map;
import java.util.Set;

import org.mycompany.Person;
import com.tangosol.net.CacheFactory;

public class CacheWrapper {
  private static CacheWrapper INSTANCE = new CacheWrapper();
  public static CacheWrapper getInstance() {
    return INSTANCE;
  }

  public Set<Map.Entry<Object, Object>> getPeople() {
    return CacheFactory.getCache("People").entrySet();
  }

  public void addPerson(int personId, String name, int age) {
    CacheFactory.getCache("People").put(personId, new Person(name, age));
  }
}

Later, you can use this class in a servlet to get data from the cache and to add new data to the cache.

You can create the WAR project either using an archetype as described in Building Jakarta EE Projects for WebLogic Server with Maven, or you can create the directories and files manually.

• To use the archetype, run the following command:

  mvn archetype:generate
    -DarchetypeGroupId=com.oracle.weblogic.archetype
    -DarchetypeArtifactId=basic-webapp
    -DarchetypeVersion=14.1.2-0-0
    -DgroupId=org.mycompany
    -DartifactId=my-real-app-war
    -Dversion=1.0-SNAPSHOT

  If you use the archetype, then you must remove any unnecessary files included in the project. For example, the generated AccountBean.java file needs to be removed because the updated POM file will not include all of the dependencies needed to compile it.

• To create the project manually, use the following commands to create the necessary directories:

  mkdir -p my-real-app-war/src/main/webapp/WEB-INF
  mkdir -p my-real-app-war/src/main/java/org/mycompany/servlets

If you use the archetype, the POM file already exists. Modify that file to match the following example. If you created the project manually, then create the POM file (my-real-app-war/pom.xml) with the following contents:

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <artifactId>my-real-app-war</artifactId>
  <packaging>war</packaging>

  <parent>
    <groupId>org.mycompany</groupId>
    <artifactId>my-real-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>

  <dependencies>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>my-real-app-gar</artifactId>
      <version>${project.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>jakarta.servlet</groupId>
      <artifactId>jakarta.servlet-api</artifactId>
      <scope>provided</scope>
    </dependency>
  </dependencies>
</project>

Examine the POM file to understand each part of the file:

• As you saw in the GAR project, you only need to set the artifactId and packaging type coordinates for this project because the groupId and version are inherited from the top-level POM file. Notice that the packaging for this project is war.

  <artifactId>my-real-app-war</artifactId>
  <packaging>war</packaging>

• Define the parent, as you did in the GAR project:

  <parent>
    <groupId>org.mycompany</groupId>
    <artifactId>my-real-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>

• List the dependencies for this project. In this case, there are two dependencies: the GAR project to access the POJO and utility classes you defined there, and the Servlet API. Because the GAR project is built as part of this example application, you use the ${project.groupId} and ${project.version} built-in property references to specify the groupId and version of this dependency.

  <dependencies>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>my-real-app-gar</artifactId>
      <version>${project.version}</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>jakarta.servlet</groupId>
      <artifactId>jakarta.servlet-api</artifactId>
      <scope>provided</scope>
    </dependency>
  </dependencies>

The web application has a simple Jakarta EE deployment descriptor that sets the display-name for the web application. It resides at the following location:

my-real-app-war/src/main/webapp/WEB-INF/web.xml

The following are the contents of this file:

<web-app version="3.1"
         xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
  <display-name>my-real-app-war</display-name>
</web-app>

To create the servlet, locate the MyServlet.java file:

my-real-app-war/src/main/java/org/mycompany/servlets/MyServlet.java

The servlet displays a list of people that are currently in the cache and allows you to add a new person to the cache. The aim of the section is to learn how to build these types of applications with Maven, not to learn how to write Jakarta EE web applications, hence the use of a simplistic servlet.

package org.mycompany.servlets;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;

import org.mycompany.Person;
import org.mycompany.CacheWrapper;

@WebServlet(name = "MyServlet", urlPatterns = "MyServlet")
public class MyServlet extends HttpServlet {
  protected void doPost(HttpServletRequest request,
                        HttpServletResponse response)
    throws ServletException, IOException {
    String id = request.getParameter("id");
    String name = request.getParameter("name");
    String age = request.getParameter("age");
    if (name == null || name.isEmpty() ||
        age == null || age.isEmpty() ||
        id == null || id.isEmpty()) {
      // no need to add a new entry
    } else {
      // we have a new entry - so add it
      CacheWrapper.getInstance().addPerson(Integer.parseInt(id),
        name, Integer.parseInt(age));
    }
    renderPage(request, response);
  }

  protected void doGet(HttpServletRequest request,
                       HttpServletResponse response)
    throws ServletException, IOException {
    renderPage(request, response);
  }

  private void renderPage(HttpServletRequest request,
                          HttpServletResponse response)
    throws ServletException, IOException {
    // get the data
    Set<Map.Entry<Object, Object>> people =
      CacheWrapper.getInstance().getPeople();

    PrintWriter out = response.getWriter();
    out.write("<html><head><title>MyServlet" +
              "</title></head><body>");
    out.write("<h2>Add a new person</h2>");
    out.write("<form name=\"myform\" method=\"POST\">");
    out.write("ID:<input type=\"text\" name=\"id\"/><br/>");
    out.write("Name:<input type=\"text\" name=\"name\"/><br/>");
    out.write("Age:<input type=\"text\" name=\"age\"/><br/>");
    out.write("<input type=\"submit\" name=\"submit\" " +
              "value=\"add\"/>");
    out.write("</form>");
    out.write("<h2>People in the cache now</h2>");
    out.write("<table><tr><th>ID</th><th>Name" +
              "</th><th>Age</th></tr>");
    // for each person in data
    if (people != null) {
      for (Map.Entry<Object, Object> entry : people) {
        out.write("<tr><td>" +
          entry.getKey() +
          "</td><td>" +
          ((Person) entry.getValue()).getName() +
          "</td><td>" +
          ((Person) entry.getValue()).getAge() +
          "</td></tr>");
      }
    }
    out.write("</table></body></html>");
  }
}

Check if the user has entered any data in the form. If so, then add a new person to the cache using that data. Note that this application has fairly minimal error handling. To add the new person to the cache, use the addPerson() method in the CacheWrapper class that you created in your GAR project.

Print out the contents of the cache in a table. In this example, assume that the cache has a reasonably small number of entries, and read them all using the getPeople() method in the CacheWrapper class.

Create the EAR project manually using the following command:

mkdir -p my-real-app-ear/src/main/application/META-INF

There are two files in this project: a POM file and a deployment descriptor:

my-real-app-ear/pom.xml
my-real-app-ear/src/main/application/META-INF/weblogic-application.xml

<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/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <artifactId>my-real-app-ear</artifactId>
  <packaging>ear</packaging>

  <parent>
    <groupId>org.mycompany</groupId>
    <artifactId>my-real-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>

  <dependencies>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>my-real-app-gar</artifactId>
      <version>${project.version}</version>
      <type>gar</type>
    </dependency>
    <dependency>
      <groupId>${project.groupId}</groupId>
      <artifactId>my-real-app-war</artifactId>
      <version>${project.version}</version>
      <type>war</type>
    </dependency>
  </dependencies>

  <build>
    <finalName>my-real-app-ear</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-dependency-plugin</artifactId>
        <executions>
          <execution>
            <id>copy-gar-locally</id>
            <phase>prepare-package</phase>
            <goals>
              <goal>copy</goal>
            </goals>
            <configuration>
              <artifactItems>
                <artifactItem>
                  <groupId>${project.groupId}</groupId>
                  <artifactId>my-real-app-gar</artifactId>
                  <version>${project.version}</version>
                  <type>gar</type>
                </artifactItem>
              </artifactItems>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-ear-plugin</artifactId>
        <configuration>
          <outputFileNameMapping>@{artifactId}@-@{version}@.@{extension}@</outputFileNameMapping>
          <archive>
            <manifest>
              <addClasspath>true</addClasspath>
            </manifest>
          </archive>
          <artifactTypeMappings>
            <artifactTypeMapping type="gar" mapping="jar"/>
          </artifactTypeMappings>
        </configuration>
      </plugin>
    </plugins>
  </build>

  <profiles>
    <profile>
      <id>integration-test</id>
      <activation>
        <property>
          <name>skipITs</name>
          <value>false</value>
        </property>
      </activation>
      <build>
        <plugins>
          <plugin>
            <groupId>com.oracle.weblogic</groupId>
            <artifactId>weblogic-maven-plugin</artifactId>
            <executions>
              <!--Deploy the application to the server-->
              <execution>
                <id>deploy for integration testing</id>
                <phase>pre-integration-test</phase>
                <goals>
                  <goal>deploy</goal>
                </goals>
                <configuration>
                  <adminurl>${wls.admin.url}</adminurl>
                  <user>${wls.admin.user}</user>
                  <password>${wls.admin.pass}</password>
                  <!--The location of the file or directory to be deployed-->
                  <source>${project.build.directory}/${project.build.finalName}.${project.packaging}</source>
                  <!--The target servers where the application is deployed-->
                  <targets>${wls.ear.targets}</targets>
                  <verbose>true</verbose>
                  <name>${project.build.finalName}</name>
                </configuration>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
</project>

Examine the POM file to understand each part of the file:

• As in the previous projects, you only need to specify the artifactId, packaging type, and the parent:

  <artifactId>my-real-app-ear</artifactId>
  <packaging>ear</packaging>
  
  <parent>
    <groupId>org.mycompany</groupId>
    <artifactId>my-real-app</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath>
  </parent>

• The dependencies on the WAR and GAR projects are listed:

  <dependencies>
      <dependency>
          <groupId>${project.groupId}</groupId>
          <artifactId>my-real-app-gar</artifactId>
          <version>${project.version}</version>
          <type>gar</type>
      </dependency>
      <dependency>
          <groupId>${project.groupId}</groupId>
          <artifactId>my-real-app-war</artifactId>
          <version>${project.version}</version>
          <type>war</type>
      </dependency>
  </dependencies>

• The first plug-in configuration is for the maven-dependency-plugin. Configure it to copy the GAR file from the my-real-app-gar project's output (target) directory into the EAR project:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
      <execution>
        <id>copy-gar-locally</id>
        <phase>prepare-package</phase>
        <goals>
          <goal>copy</goal>
        </goals>
        <configuration>
          <artifactItems>
            <artifactItem>
              <groupId>${project.groupId}</groupId>
              <artifactId>my-real-app-gar</artifactId>
              <version>${project.version}</version>
              <type>gar</type>
            </artifactItem>
          </artifactItems>
        </configuration>
      </execution>
    </executions>
  </plugin>

• The second plug-in configuration is for the maven-ear-plugin. You need to tell it to treat a GAR file like a JAR file by adding an artifactTypeMapping, as in the following example:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-ear-plugin</artifactId>
    <configuration>
      <archive>
        <manifest>
          <addClasspath>true</addClasspath>
        </manifest>
      </archive>
      <artifactTypeMappings>
        <artifactTypeMapping type="gar" mapping="jar"/>
      </artifactTypeMappings>
    </configuration>
  </plugin>

• The profile section adds a third plug-in configuration for the weblogic-maven-plugin that tells it how to deploy the resulting EAR file. Notice that the adminurl, user, password, and targets parameters' values are set to properties that will be defined in the top-level POM file.

  The profile is activated by adding -DskipITs=false to the Maven command line. This makes it easier to build the EAR file without needing to deploy it on every build.

  <profile>
    <id>integration-test</id>
    <activation>
      <property>
        <name>skipITs</name>
        <value>false</value>
      </property>
    </activation>
    <build>
      <plugins>
        <plugin>
          <groupId>com.oracle.weblogic</groupId>
          <artifactId>weblogic-maven-plugin</artifactId>
          <executions>
            <!--Deploy the application to the server-->
            <execution>
              <id>deploy for integration testing</id>
              <phase>pre-integration-test</phase>
              <goals>
                <goal>deploy</goal>
              </goals>
              <configuration>
                <adminurl>${wls.admin.url}</adminurl>
                <user>${wls.admin.user}</user>
                <password>${wls.admin.pass}</password>
                <!--The location of the file or directory to be deployed-->
                <source>${project.build.directory}/${project.build.finalName}.${project.packaging}</source>
                <!--The target servers where the application is deployed-->
                <targets>${wls.ear.targets}</targets>
                <verbose>true</verbose>
                <name>${project.build.finalName}</name>
              </configuration>
            </execution>
          </executions>
        </plugin>
      </plugins>
    </build>
  </profile>

After you have completed the POM project, add a deployment descriptor.