Before creating your first Maven project, it is a good idea to make sure that the IDE is correctly configured to use your local Maven installation and local Maven repository. You should not use the embedded Maven snapshot to develop your project.

1. Open the Options window in the IDE.
2. Select the Miscellaneous category in the Options window and click the Maven tab.
3. Specify the location of your local Maven installation (requires 2.0.9 or newer).
4. Check that the location of the local Maven repository is correct.
5. Click OK to close the Options window.

If Maven is not installed on your system, you can download the installer from the Maven site.

Local and remote Maven repositories are used for code completion and when building projects. You should update the indexes for the Maven remote repositories to ensure that any artifacts you may need are readily available when you develop your project. You can configure how often the IDE checks for updates in the Maven tab of the Options window. You can perform an immediate check for updates and explore your local and remote Maven repositories from the Maven Repository Browser.

1. Choose Window > Other > Maven Repository Browser.
2. Click Update Indexes (   ) at the top of the Maven Repository Browser window.

When you click Update Indexes, the IDE will check and download the most recent index for each of your Maven remote repositories. An index represents the current state of the artifacts located in the repository and is used to provide a reference to the artifacts that are available to your application. By default, the IDE does not download an artifact from a repository until the artifact is explicitly required.

Note. Indexes are quite large and it can take some time to update them all.

When developing Maven applications you typically do not need to specify an application server until you build the application. However, to take advantage of some of the code generation features in the IDE, for this tutorial you will set the target server before you start writing your code. By setting the deployment server, the IDE is able to recognize the technologies supported by the server and enable various options in some wizards to generate code that is optimized for that server.

1. Start the GlassFish server.
2. Right-click the EJB project node in the Projects window and choose Properties.
3. Select the Run category in the Properties window.
4. Select the GlassFish Server. Click OK.

By specifying GlassFish as the deployment server before coding, the IDE will enable the option of selecting JTA in the wizard for creating the persistence unit. You can also select to use any of the datasources registered with the server.

Creating the Persistence Unit

In this exercise you create a persistence unit in the EJB project. The persistence unit specifies the database connection details and specifies how transactions are managed. For this application you will specify JTA in the New Persistence Unit wizard because you want the GlassFish server to manage the transactions.

To create the persistence unit, perform the following steps.

1. Right-click the EJB project node and choose New > Other from the popup menu to open the New File wizard.
2. Select Persistence Unit from the Persistence category. Click Next.
3. Select EclipseLink as the Persistence Provider in the New Persistence Unit dialog box.
4. Select a datasource (for example, select jdbc/sample if you want to use JavaDB).

   The datasource jdbc/sample is bundled with the IDE when you install the IDE and the GlassFish server, but you can specify a different datasource if you want to use a different database.

   You can keep the other default options (persistence unit name, EclipseLink persistence provider).

5. Ensure that Use Java Transaction APIs is selected and that the Table Generation Strategy is set to Create so that the tables based on your entity classes are created when the application is deployed. Click Finish.

When you click Finish, the IDE creates the XML file persistence.xml and opens the file in the editor. In the Projects window, you can see that the file was created in the Other Sources > src/main/resources > META-INF directory. The file contains details about connecting to the database and how transactions are managed. If you click XML in the editor, you can see the following elements in persistence.xml.

<persistence-unit name="com.mycompany_MavenEnterpriseApp-ejb_ejb_1.0-SNAPSHOTPU" transaction-type="JTA">
    <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
    <jta-data-source>jdbc/sample</jta-data-source>
    <exclude-unlisted-classes>false</exclude-unlisted-classes>
    <properties>
      <property name="eclipselink.ddl-generation" value="create-tables"/>
    </properties>
</persistence-unit>
            

You can see that JTA is specified as the transaction type and that the application will use the registered datasource jdbc/sample.

Creating the Entity Class

In this exercise you will create an entity class in the EJB project to represent the objects that will be persisted to the database. To create the NewsEntity entity class, perform the following steps.

1. Right-click the EJB module in the Projects window and choose New > Other to open the New File wizard.
2. Select Entity Class from the Persistence category. Click Next.
3. Type NewsEntity for the Class Name.
4. Type ejb for the Package and leave the Primary Key Type as Long. Click Finish.

When you click Finish, the entity class NewsEntity.java opens in the Source Editor. In the Source Editor, add some fields by performing the following steps.

1. Add the following field declarations to the class.

   private String title;
   private String body;

2. Right-click in the Source Editor and choose Insert Code and select Getter and Setter in the popup menu.
3. In the Generate Getters and Setters dialog box, select the body and title fields. Click Generate.
4. Fix your imports and save your changes.

Creating the Message-Driven Bean

In this exercise you will create a message-driven bean in the EJB project. A message-driven bean is an enterprise bean that enables the asynchronous exchange of messages. The NewsApp application uses a message-driven bean to receive and process messages sent to the queue by a servlet in the web module.

To use a message-driven bean in an application, the connector resources used by the bean need to be registered with the server. When you are deploying to the GlassFish server, you can create the resources directly on the server through the Admin Console or you can create the resources on deployment by specifying the details in the sun-resources.xml file. When the application is deployed to the server, the server registers the resources based on sun-resources.xml. When you use the New File wizard in the IDE to create a message-driven bean, the IDE will generate the elements in sun-resources.xml for you.

In a Maven project, the sun-resources.xml file is located in the src/main/setup directory under the project node in the Files window.

1. Right-click the EJB module in the Projects window and choose New > Other to open the New File wizard.
2. From the Java EE category, select Message-Driven Bean. Click Next.
3. Type NewMessage for the EJB Name.
4. Select ejb from the Package drop-down list.
5. Click the Add button next to the Project Destination field to open the Add Message Destination dialog box.
6. In the Add Message Destination dialog box, type jms/NewMessage and select Queue for the destination type. Click OK.
   
7. Make sure that the project destination is correct. Click Finish.
   

   When you click Finish, the IDE generates the bean class and adds the following annotations that identify the class as a message-driven bean and configuration properties.

   @MessageDriven(mappedName = "jms/NewMessage", activationConfig =  {
           @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
           @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue")
       })
   public class NewMessage implements MessageListener {
   
       public NewMessage() {
       }
   
       public void onMessage(Message message) {
       }
   }

8. Inject the MessageDrivenContext resource into the class by adding the following annotated field to the class.

   public class NewMessageBean implements MessageListener {
   
   @Resource
   private MessageDrivenContext mdc;
   

9. Introduce the entity manager into the class by adding the following annotated field (in bold).

   public class NewMessage implements MessageListener {
   
   @Resource
   private MessageDrivenContext mdc;
   @PersistenceContext(unitName="com.mycompany_MavenEnterpriseApp-ejb_ejb_1.0-SNAPSHOTPU")
   private EntityManager em;
                      

   The @PersistenceContext annotation specifies the context by declaring the persistence unit. The unitName value is the name of the persistence unit.

10. Add the following save method (in bold).

    public NewMessage() {
    }
    
    public void onMessage(Message message) {
    }
    
    public void save(Object object) {
        em.persist(object);
    }

11. Modify the onMessage method by adding the following (in bold) to the body:

    public void onMessage(Message message) {
         ObjectMessage msg = null;
         try {
              if (message instanceof ObjectMessage) {
              msg = (ObjectMessage) message;
                  NewsEntity e = (NewsEntity) msg.getObject();
                  save(e);
              }
         } catch (JMSException e) {
              e.printStackTrace();
              mdc.setRollbackOnly();
         } catch (Throwable te) {
              te.printStackTrace();
         }
    }

12. Fix your import statements (Ctrl-Shift-I) and save your changes.

    Note: When generating the import statements, you want to make sure to import the jms and javax.annotation.Resource libraries.

For more details about message-driven beans, see the chapter What is a Message-Driven Bean? in the Java EE 6 Tutorial, Part I.

Creating the Session Bean

In this exercise you will use a wizard to create a session bean facade for the NewsEntity entity class. The wizard will generate some common methods create, edit and find methods that can be accessed from the servlets in the webapp project.

1. Right-click the EJB module and choose New > Other.
2. From the Persistence category, select Session Beans for Entity Classes and click Next.
3. Select ejb.NewsEntity from the list of available entity classes and click Add to move the class to the Selected Entity Classes pane. Click Next.
4. Check that the Package is set to ejb. You do not need to create a local interface.
5. Click Finish.

In Java EE 6, interfaces are optional. In Java EE 5 you needed to create a local interface for the session bean and then call the session bean via the interface. In Java EE 6, the local interface is optional and the servlet in the web module can access the session bean directly via a no-interface facade.

Creating the ListNews Servlet

In this exercise you will create the ListNews servlet that will be used to display a list of posted messages. You will use annotations to inject the session facade and access the findAll method and retrieve the posted messages.

1. Right-click the web module project and choose New > Servlet.
2. Type ListNews for the Class Name.
3. Type web for the Package name. Click Finish.

   When you click Finish, the class ListNews.java opens in the Source Editor.

4. Right-click in the Source Editor and choose Insert Code and select Call Enterprise Bean.
5. In the Call Enterprise Bean dialog box, expand the NewsApp-ejb node and select NewsEntityFacade. Click OK.
   

   When you click OK, the EJB resource is injected into the servlet using the @EJB annotation.

   @WebServlet(name = "ListNews", urlPatterns = {"/ListNews"})
   public class ListNews extends HttpServlet {
       @EJB
       private NewsEntityFacade newsEntityFacade;

6. In the processRequest method, modify the method by uncommenting the code and adding the following lines (in bold) to the body of the method:

   out.println("<h1>Servlet ListNews at " + request.getContextPath () + "</h1>");
   
   List news = newsEntityFacade.findAll();
   for (Iterator it = news.iterator(); it.hasNext();) {
     NewsEntity elem = (NewsEntity) it.next();
     out.println(" <b>"+elem.getTitle()+" </b><br />");
     out.println(elem.getBody()+"<br /> ");
   }
   out.println("<a href='PostMessage'>Add new message</a>");
   
   out.println("</body>");
      

7. Fix your imports (Ctrl-Shift-I) and save your changes.

   When generating the import statements, you want to import the java.util libraries.

Creating the PostMessage Servlet

In this exercise you will create the PostMessage servlet that will be used to post messages. You will use annotations to inject the JMS resources you created directly into the servlet, specifying the variable name and the name to which it is mapped. You will then add the code to send the JMS message and the code for the HTML form for adding a message.

1. Right-click the web module project and choose New > Servlet.
2. Type PostMessage for the Class Name.
3. Select web for the Package name. Click Finish.

   When you click Finish, the class PostMessage.java opens in the Source Editor.

4. In the Source Editor, use annotations to inject the ConnectionFactory and Queue resources by adding the following field declarations.

   @WebServlet(name="PostMessage", urlPatterns={"/PostMessage"})
   public class PostMessage extends HttpServlet {
      @Resource(mappedName="jms/NewMessageFactory")
      private  ConnectionFactory connectionFactory;
   
      @Resource(mappedName="jms/NewMessage")
      private  Queue queue;

5. Fix your imports (Ctrl-Shift-I) to import the javax.jms libraries.
   

   Note. If the IDE does not offer javax.jms as an option, you can search the repositories for the correct artifact by clicking the suggestion icon in the margin next to private ConnectionFactory connectionFactory; and choosing Search Dependency at Maven Repositories.

   

   You can use the Search in Maven Repositories dialog to locate and select the artifact that contains ConnectionFactory.

   
6. Add the following code to send the JMS messages to the processRequest method.

   response.setContentType("text/html;charset=UTF-8");
   
   // Add the following code to send the JMS message
   String title=request.getParameter("title");
   String body=request.getParameter("body");
   if ((title!=null) && (body!=null)) {
       try {
           Connection connection = connectionFactory.createConnection();
           Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
           MessageProducer messageProducer = session.createProducer(queue);
   
           ObjectMessage message = session.createObjectMessage();
           // here we create NewsEntity, that will be sent in JMS message
           NewsEntity e = new NewsEntity();
           e.setTitle(title);
           e.setBody(body);
   
           message.setObject(e);
           messageProducer.send(message);
           messageProducer.close();
           connection.close();
           response.sendRedirect("ListNews");
   
       } catch (JMSException ex) {
           ex.printStackTrace();
       }
   }

7. Uncomment the code to print the HTML and add the web form for adding a message.

   out.println("Servlet PostMessage at " + request.getContextPath() + "</h1>");
   
   // The following code adds the form to the web page
   out.println("<form>");
   out.println("Title: <input type='text' name='title'><br/>");
   out.println("Message: <textarea name='body'></textarea><br/>");
   out.println("<input type='submit'><br/>");
   out.println("</form>");
   
   out.println("</body>");
       

8. Fix your imports (Ctrl-Shift-I) and save your changes.

   Note. You want to import the javax.jms libraries for Connection, ConnectionFactory, Session and Queue.

Working With Project Dependencies

In this exercise you will modify the pom.xml of the Webapp project to prevent the EJB archive from being included in the WAR when packaging. This will prevent the EAR archive from containing two copies of the EJB archive.

Each Maven project contains a pom.xml file that contains details about the contents of archives. Any external libraries that are required by the project are listed as dependencies in pom.xml. You can modify pom.xml to specify the dependencies that need to be included when packaging the archive.

In this application, the EJB JAR and the WAR archives will be packaged in an EAR archive. If you look at the pom.xml of the Assembly project, you can see that the EJB and WAR are declared as dependencies.

If you look at the pom.xml of the Webapp project, you can see that the EJB archive is declared as a dependency. The Webapp project requires the EJB archive as a dependency, but for this application you do not want the EJB archive to be included in the WAR during packaging. The EJB archive will be available and provided to the Webapp as part of the EAR archive.

You can right-click in pom.xml and choose Show Dependency Graph to see a visual representation of the project dependencies. You can place your cursor over an artifact to display a tooltip with the artifact details.

Perform the following steps to modify the pom.xml of the Webapp project to add a scope element to the dependency on the EJB archive.

1. Expand the Project Files node under the Webapp project.
2. Double-click pom.xml to open the file in the editor.
3. Modify the dependency on the MavenEnterpriseApp-ejb artifact by editing the POM to add the following <scope>provided</scope> element.

   <dependency>
       <groupId>com.mycompany</groupId>
       <artifactId>MavenEnterpriseApp-ejb</artifactId>
       <scope>provided</scope>
       <version>1.0-SNAPSHOT</version>
   </dependency>

4. Save your changes.

You can use the code completion in the POM editor to help you edit the file.

By declaring that the dependency is provided, Maven will not package the artifact when building the WAR archive.

Building with Dependencies

The Maven build framework proceeds through a specific sequence of phases, and each phase consists of one or more goals and can be configured to use various Maven plugins. The Build with Dependencies menu item is mapped to the install phase of the Maven build lifecycle and is configured to use the Reactor plugin. When you choose Build with Dependencies in the popup menu, Maven builds the application and any required dependencies and copies the build artifacts to the local repository.

You can modify how Maven phases and goals are mapped to menu actions in the Actions panel of the project's Properties dialog box.

To build the EAR archive, perform the following step.

• Right-click the Assembly project node and choose Build with Dependencies.

When you build the Assembly project using the Reactor plugin, the dependencies of the sub-projects are built before the Assembly project is built. The Output window displays the build order.

The results of the build are also displayed in the Output window.

After you build the Assembly project, you can see the final EAR archive inside the target directory under the Assembly project node in the Files window.

If you used the default artifact name com.mycompany, you can use the Maven Repository Browser to view the build artifacts by expanding com.mycompany in the Local Repository.

For more details about building Maven projects, see Maven - Introduction to the Build Lifecycle at maven.apache.org.

Deploying From the IDE

In this exercise you will modify the Maven goal that is mapped to the Run action. After you modify the action you can use the Run action to deploy the EAR to the server.

1. Right-click the Assembly project node in the Projects window and choose Properties.
2. Select Actions from the list of Categories in the left panel of the Properties window.
3. Select Run Project from the list of Actions in the right panel.
4. In the Execute Goals text field, delete the package goal and type install. Click OK.
   
5. Right-click the Assembly project node in the Projects window and choose Run.
6. Select the GlassFish server in the Select Deployment Server dialog. Click OK.
   

After you select the deployment server, the IDE creates the JMS resources on the server and deploys the EAR archive.

Deploying From the GlassFish Admin Console

In this exercise you will deploy the EAR archive using the Deploy tool in the GlassFish Admin Console.

1. Expand the Servers node in the Services window.
2. Start the GlassFish server.
3. Right-click the GlassFish server node and choose View Admin Console to open the GlassFish Admin Console in your browser.
4. Click the Applications node in the left pane of the Admin Console.
5. Click the Deploy button in the main pane of the Admin Console.
6. Click Browse to locate the EAR archive for the enterprise application.

   The EAR archive is located in the target directory inside the enterprise application directory on your local system.

7. Click OK.

When you click OK, the GlassFish deploy tool deploys the application.

Note. If you deploy the application using the deploy tool, you will also need to manually create the resources that are required by the application if they do not exist.