| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><head> |
| <title>NetBeans Server-Skeleton Module Tutorial</title> |
| <link rel="Stylesheet" href="https://netbeans.org/netbeans.css" type="text/css" title="NetBeans OpenSource Style"> |
| </head> |
| |
| |
| <h1>NetBeans Server-Skeleton Module Tutorial</h1> |
| <div class="feedback-box"><a href="https://netbeans.org/about/contact_form.html?to=3&subject=Feedback:%20Server%20Skeleton%20Module%20Tutorial">Feedback</a></div> |
| |
| |
| |
| <p>This tutorial is intended to ease the <i>initial</i> phase of developing NetBeans modules that provide |
| support for web deployment servers, such as the Tomcat Web Server or the Sun Java System Application Server. |
| It provides the code |
| for a skeleton server module, together with a detailed procedure for creating it from scratch and a full |
| description of each of its parts. Since this is "just" a <i>skeleton</i> module, server-specific features |
| that relate to starting and stopping, deploying, undeploying, and property customization are not covered here. However, after you create and |
| install the skeleton server module, you will have enough functionality to be able to register a new deployment server in the |
| Server Manager and assign it to an application via the New Project wizard and the Project Properties dialog box. And, you will |
| have a working framework on top of which you can build your own server module for the NetBeans IDE. At the end of the tutorial, |
| you will be pointed to comparable deployment servers in NetBeans CVS, which you can explore to see how server-specific |
| features are implemented elsewhere. |
| |
| <p>The following topics are covered below:</p> |
| <ul> |
| <li><a href="#gettingtoknowthesample">Getting to Know the Sample</a></li> |
| <ul> |
| <li><a href="#installing">Installing the Software</a></li> |
| <li><a href="#installing-sample">Installing the Sample</a></li> |
| <li><a href="#introducing-sample">Introducing the Sample</a></li> |
| <li><a href="#introducing-sources">Introducing the Sources</a></li> |
| </ul> |
| <li><a href="#settingupthemoduleproject">Setting Up the module Project</a></li> |
| <ul> |
| <li><a href="#creatingthemoduleproject">Creating the module Project</a></li> |
| <li><a href="#specifying">Specifying the module's Dependencies</a></li> |
| </ul> |
| <li><a href="#creatingandgettingtoknowthemainfiles">Creating the Factory Classes</a></li> |
| <ul> |
| <li><a href="#MyDeploymentFactory"><tt>MyDeploymentFactory.java</tt></a> |
| <li><a href="#MyJ2eePlatformFactory"><tt>MyJ2eePlatformFactory.java</tt></a> |
| <li><a href="#MyOptionalFactory"><tt>MyOptionalFactory.java</tt></a> |
| <li><a href="#MyRegistryNodeFactory"><tt>MyRegistryNodeFactory.java</tt></a> |
| </ul> |
| <li><a href="#creatingandgettingtoknowtheimplementationfiles">Creating the Implementation Classes</a></li> |
| <ul> |
| <li><a href="#ConfigurationSupportImpl"><tt>ConfigurationSupportImpl.java</tt></a> |
| <li><a href="#MyConfiguration"><tt>MyConfiguration.java</tt></a> |
| <li><a href="#MyDeploymentManager"><tt>MyDeploymentManager.java</tt></a> |
| <li><a href="#MyInstantiatingIterator"><tt>MyInstantiatingIterator.java</tt></a> |
| <li><a href="#MyJ2eePlatformImpl"><tt>MyJ2eePlatformImpl.java</tt></a> |
| <li><a href="#MyStartServer"><tt>MyStartServer.java</tt></a> |
| <li><a href="#MyInstanceNode"><tt>MyInstanceNode.java</tt></a> |
| </ul> |
| <li><a href="#finetuning">Setting Up the Supporting Resources</a></li> |
| <li><a href="#building">Building and Installing the Module</a></li> |
| <li><a href="#addingserverspecific">Adding Server-Specific Code</a></li> |
| |
| |
| </ul> |
| <p><a name="top"></a>Once the software is installed, this tutorial can be completed in 60 minutes. |
| |
| <p>For more information on working with NetBeans modules, see the <a href="https://netbeans.org/kb/trails/platform.html"> |
| NetBeans Module and Rich-Client Application tutorials page</a> on the NetBeans website. If you have questions, visit the |
| <a href="http://wiki.netbeans.org/wiki/view/NetBeansDeveloperFAQ"> NetBeans Developer FAQ</a> or use the feedback link |
| at the top of this page.</p> |
| |
| <br /> |
| <!-- ===================================================================================== --> |
| <h2><a name="gettingtoknowthesample"></a>Getting to Know the Sample</h2> |
| <p>Before you start writing the module, you have to make sure you have all of the necessary software. |
| In addition, you might want to play with the sample before building it yourself. Getting to know the |
| sample lets you know what you are in for during the rest of this tutorial!</p> |
| <div class="indent"> |
| |
| <h3 class="tutorial"><a name="installing"></a>Installing the Software</h3> |
| |
| |
| <p>Before you begin, you need to install the following software on your |
| computer:</p> |
| <ul> |
| <li>NetBeans IDE 5.5 (<a href="http://www.netbeans.info/downloads/download.php?a=n&p=1">download</a>). Note that |
| this tutorial was originally written for NetBeans IDE 5.0, but that version of |
| this tutorial is no longer supported.</li> |
| <li>Java Standard Development Kit (JDK™) version |
| 1.4.2 (<a href="http://java.sun.com/j2se/1.4.2/download.html">download</a>) |
| or 5.0 (<a href="http://java.sun.com/j2se/1.5.0/download.jsp">download</a>)</li> |
| </ul> |
| |
| <h3 class="tutorial"><a name="installing-sample"></a>Installing the Sample</h3> |
| <p>Take the following steps to install the sample: |
| <ol><p><li>Unzip the <a href="https://netbeans.org/files/documents/4/519/myserver.zip">attached file</a>. |
| <p><li>In the IDE, choose File > Open Project and browse to the folder that contains the unzipped file. |
| Open the module project. It should look as follows: |
| <p><img border="1" src="../images/tutorials/myserver/projects-window.png" alt="All source files."> |
| <p><li>In the Projects window, right-click the "My Server Module" |
| project node and choose Install/Reload in Target Platform. The target |
| instance of the IDE opens and the module is installed. Alternatively, if you want to |
| install the module in the current instance of the IDE, choose Install/Reload in Development IDE instead.</ol> |
| |
| <h3 class="tutorial"><a name="introducing-sample"></a>Introducing the Sample</h3> |
| <ol> |
| <p><li>Choose Tools > Server Manager, click Add Server and notice that a new server is available: |
| <p><img src="../images/tutorials/myserver/choose-server.png" alt="Choose my server."> |
| <p><li>Select "My Server" and type a name, such as "Test Server", in the Name textfield: |
| <p><img src="../images/tutorials/myserver/add-server-instance2.png" alt="Set instance properties."> |
| <p><li>Click Next. The basis of an installation form implementation is displayed: |
| <p><img src="../images/tutorials/myserver/add-server-instance.png" alt="Set instance properties."> |
| <p>See <a href="#MyInstantiatingIterator"><tt>MyInstantiatingIterator.java</tt></a> for related code details. |
| <p><li>Click Finish. A new node appears in the Servers list and the basis of a customizer implementation is displayed in the |
| main part of the panel: |
| <p><img src="../images/tutorials/myserver/add-server-instance3.png" alt="Set customizer properties."> |
| <p>See <a href="#MyInstanceNode"><tt>MyInstanceNode.java</tt></a> for related code details. |
| <p><li>Click Close. Open the Runtime window (Ctrl-5) and notice the new "Test Server" node under the Servers node. When you right-click the node, the |
| basis of your menu implementation is displayed: |
| <p><img border="1" src="../images/tutorials/myserver/runtime-window.png" alt="Runtime window."> |
| |
| <p>Even though the skeleton server cannot be started, you can assign it as a target server |
| to an application, as shown in the next step. |
| <p><li>Assign the server as an application's target server, either while creating the web application |
| or afterwards, while customizing it: |
| <ul><p><li>Choose File > New Project (Ctrl-Shift-N). Under Categories, select Web and under Projects select |
| Web Application. Click Next. In the Name and Location panel, notice that the Server drop-down includes the |
| new server instance: |
| <p><img src="../images/tutorials/myserver/name-and-location-panel.png" alt="Name and location panel."></li> |
| <p><li>Right-click an existing web application and choose Properties. The Project Properties dialog box opens. In the Run panel, |
| notice that the Server drop-down includes the |
| new server type: |
| <p><img src="../images/tutorials/myserver/run-panel.png" alt="Run panel."></li></ul> |
| </p> |
| </ol> |
| |
| <p>Now that you know exactly what functionality the skeleton server provides, let's look at the sources!</p> |
| |
| <h3 class="tutorial"><a name="introducing-sources"></a>Introducing the Sources</h3> |
| |
| <p>The sample consists of factory classes, implementation classes, and supporting files. <p>Below, |
| each are introduced in turn:</p> |
| |
| |
| <ul><li><p><b>Factory Classes.</b> The module uses the Factory pattern to instantiate the implementation classes. The module's factories |
| are highlighted in the illustration below: |
| <p><img border="1" src="../images/tutorials/myserver/projects-window-factories.png" alt="Main files."> |
| <p>The factories are introduced in alphabetical order: |
| <p><table width="76%" border="1"> |
| |
| <tbody><tr> |
| <td> |
| <div align="left"><b>File</b></div> |
| </td> |
| <td> |
| <div align="left"><b>Description</b></div> |
| |
| </td> |
| </tr> |
| <tr> |
| <td align="left" valign="top"><tt><a href="#MyDeploymentFactory">MyDeploymentFactory.java</a></tt></td> |
| <td> |
| |
| An implementation of the <tt><a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/factories/DeploymentFactory.html">DeploymentFactory</a></tt> interface, which produces instances of <tt><a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/DeploymentManager.html">DeploymentManager</a></tt> interface implementations, such as <a href="#MyDeploymentManager"><tt>MyDeploymentManager</tt></a>. |
| |
| |
| </td> |
| </tr> |
| <tr> |
| <td align="left" valign="top"><tt><a href="#MyJ2eePlatformFactory">MyJ2eePlatformFactory.java</a></tt></td> |
| |
| <td> |
| An implementation of the <tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/J2eePlatformFactory.html">J2eePlatformFactory</a></tt> abstract class, which produces instances of <tt><a href="http://www.netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/J2eePlatformImpl.html">J2eePlatformImpl</a></tt> abstract class implementations, such as <a href="#MyJ2eePlatformImpl"><tt>MyJ2eePlatformImpl</tt></a>. |
| |
| |
| |
| </td> |
| </tr> |
| |
| <tr> |
| <td align="left" valign="top"><tt><a href="#MyOptionalFactory">MyOptionalFactory.java</a></tt></td> |
| <td> |
| |
| An implementation of the <tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/OptionalDeploymentManagerFactory.html">OptionalDeploymentManagerFactory</a></tt> abstract class. Although its name implies that it |
| is <i>optional</i>, it isn't. You need to at least implement its methods for starting, stopping, and |
| registering the server in the IDE. Therefore, the <tt><a href="#MyOptionalFactory">MyOptionalFactory</a></tt> class produces instances of the |
| <a href="#MyStartServer"><tt>MyStartServer</tt></a> and <a href="#MyInstantiatingIterator"><tt>MyInstantiatingIterator</tt></a> implementation classes.</td> |
| </tr> |
| <tr> |
| <td align="left" valign="top"><tt><a href="#MyRegistryNodeFactory">MyRegistryNodeFactory.java</a></tt></td> |
| <td> |
| An implementation of the <tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/RegistryNodeFactory.html">RegistryNodeFactory</a></tt> interface. The purpose of this factory is to |
| produce one or more registry nodes, which in this case is <a href="#MyInstanceNode"><tt>MyInstanceNode</tt></a>, |
| as user interface representations in the Runtime window. |
| </td> |
| </tr> |
| |
| </tbody> |
| </table> |
| |
| <li><p><b>Implementation Classes.</b> The implementation classes are instantiated by the factories. The module's implementation |
| classes are highlighted in the illustration below: |
| <p><img border="1 "src="../images/tutorials/myserver/projects-window-mainfunctionality.png" alt="Main files."> |
| <p>The implementation classes are introduced in alphabetical order: |
| <p><table width="76%" border="1"> |
| |
| <tbody><tr> |
| <td> |
| <div align="left"><b>File</b></div> |
| </td> |
| <td> |
| <div align="left"><b>Description</b></div> |
| |
| </td> |
| </tr> |
| <tr> |
| <td align="left" valign="top"><a href="#ConfigurationSupportImpl"><tt>ConfigurationSupportImpl.java</tt></a></td> |
| <td> |
| |
| An implementation of the NetBeans API's <a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/ConfigurationSupport.html">ConfigurationSupport</a> |
| interface. This class is the NetBeans extension of the <a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/DeploymentConfiguration.html">DeploymentConfiguration</a> interface, which is a J2EE API class and |
| therefore could not be changed. This extension adds life cycle management and additional module change |
| notifications support. |
| |
| </td> |
| </tr> |
| <tr> |
| <td align="left" valign="top"><a href="#MyConfiguration"><tt>MyConfiguration.java</tt></a></td> |
| <td> |
| |
| An implementation of the <a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/DeploymentConfiguration.html">DeploymentConfiguration</a> interface. |
| The purpose of this class is to provide support for server-specific configuration, in other words, it relates to deployment descriptors. |
| </td> |
| </tr> |
| <tr> |
| <td align="left" valign="top"><a href="#MyDeploymentManager"><tt>MyDeploymentManager.java</tt></a></td> |
| <td> |
| |
| A dummy implementation of the <tt><a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/DeploymentManager.html">DeploymentManager</a></tt> interface, which does nothing |
| more than return <a href="#MyConfiguration"><tt>MyConfiguration.java</tt></a>. |
| It is up to you to provide other server-specific implementation features. |
| |
| |
| </td> |
| </tr> |
| |
| |
| <tr> |
| <td align="left" valign="top"><a href="#MyInstantiatingIterator"><tt>MyInstantiatingIterator.java</tt></a></td> |
| <td> |
| |
| Creates a wizard for the registration of new server type instances in the IDE. The current |
| implementation lets the user specify the Display Name only; other properties are |
| hardcoded in order to keep the implementation as simple as possible. |
| |
| |
| |
| </td> |
| </tr> |
| <tr> |
| <td align="left" valign="top"><a href="#MyJ2eePlatformImpl"><tt>MyJ2eePlatformImpl.java</tt></a></td> |
| <td> |
| An implementation of <tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/J2eePlatformImpl.html">J2eePlatformImpl</a></tt>, which is used to describe the target environment that |
| J2EE applications are built against and subsequently deployed to. It provides a set of server |
| libraries, supported module types, and J2EE specification versions. |
| </td> |
| </tr> |
| <tr> |
| <td align="left" valign="top"><a href="#MyStartServer"><tt>MyStartServer.java</tt></a></td> |
| <td> |
| An implementation of the <tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/StartServer.html">StartServer</a></tt> abstract class. Its purpose is to provide ability to start, |
| stop, and determine the state of the server. |
| </td> |
| </tr> |
| <tr> |
| <td align="left" valign="top"><a href="#MyInstanceNode"><tt>MyInstanceNode.java</tt></a></td> |
| <td> |
| Represents the new server in the Runtime window. The <tt>j2eeserver</tt> module, however, |
| adds to each node a set of default features, such as the capability to display the running status and |
| a default set of menu items. |
| </tr> |
| |
| </tbody> |
| </table> |
| |
| <li><p><b>Supporting Resources.</b> The module's supporting resources are highlighted in the illustration below: |
| <p><img border="1" src="../images/tutorials/myserver/projects-window-supporting.png" alt="Supporting files."> |
| <p>The supporting resources in the Java packages are introduced in alphabetical order below: |
| <p><table width="76%" border="1"> |
| |
| <tbody><tr> |
| <td> |
| <div align="left"><b>File</b></div> |
| </td> |
| <td> |
| <div align="left"><b>Description</b></div> |
| |
| </td> |
| </tr> |
| |
| <tr> |
| <td align="left" valign="top"><tt><a href="#Bundle.properties">Bundle.properties</a></tt></td> |
| |
| <td> |
| This is a standard Java properties file, which uses the syntax <tt>Key=Value</tt>. Keys are |
| code names for things that appear in the source code, with values designating those |
| things which will be displayed to the user. |
| This file is useful for localization. For example, by creating a properties file such |
| as <tt>Bundle_ja.properties</tt>, and filling all the values with Japanese, this module will automatically display |
| everything in Japanese, if the |
| user is running the IDE in Japanese mode. |
| |
| |
| </td> |
| |
| </tr> |
| <tr> |
| <td align="left" valign="top"><tt><a href="#layer.xml">layer.xml</a></tt></td> |
| |
| <td> |
| Registers the new server type in the NetBeans filesystem. |
| </td> |
| </tr> |
| <tr> |
| <td align="left" valign="top"><tt><a href="#nbdep.xml">nbdep.xml</a></tt></td> |
| |
| <td> |
| Specifies the icon to be used in the Runtime window, |
| the URL for obtaining the disconnected <tt>DeploymentManager</tt> instance, the |
| <tt>container-limitation element</tt> that specifies what kind of deployments are supported, |
| and the context path. |
| </td> |
| </tr> |
| |
| <tr> |
| <td align="left" valign="top"><tt><a href="#server.gif">server.gif</a></tt></td> |
| |
| <td> |
| Icon for the new server type's node in the IDE. |
| </td> |
| |
| </tr> |
| |
| </tbody> |
| </table> |
| |
| |
| <p>For basic information each of the Important Files, see the |
| <a href="https://netbeans.org/kb/articles/quickstart-nbm.html">Introduction to NetBeans Module Development</a>.</ul> |
| </ul |
| <p>We have now looked at the features provided by the server skeleton and at each of the |
| files that you need to create it from scratch. Let's now go through the whole process from |
| start to finish, during which we will recreate the whole server skeleton. At the end, we will |
| look at further resources worth exploring when building your own server implementation on top |
| of the server skeleton.</p> |
| </div> |
| <br /> |
| |
| <!-- ===================================================================================== --> |
| <h2><a name="settingupthemoduleproject"></a>Setting Up the module Project</h2> |
| <p>The first step in creating a server module is setting up your project in the IDE. |
| The IDE provides a wizard that |
| sets up the source structure and all the basic files |
| needed when you start creating a module.</p> |
| <div class="indent"> |
| |
| <h3 class="tutorial"><a name="creatingthemoduleproject"></a>Creating the Module Project</h3> |
| <ol> |
| <p><li>Choose File > New Project. Under Categories, select NetBeans Plug-in Modules. Under Projects, |
| select Module Project. Click Next.</li> |
| <p><li>In the Name and Location panel, type <tt>My Server Module</tt> in Project Name. |
| Change the |
| Project Location to any directory on your computer, such as <tt>c:\mymodules</tt>. Leave the Standalone Module radiobutton |
| selected. If not selected, select the Set as Main Project checkbox. |
| Click Next. |
| |
| <p><li>In the Basic Module Configuration panel, replace <tt>org.yourorghere.myservermodule</tt> in Code Name Base |
| with <tt>org.netbeans.modules.j2ee.myservermodule</tt>. Leave <tt>My Server Module</tt> as the Module Display Name. |
| Change the location of the localizing bundle and XML layer, so that they will be stored in a |
| package with the name <tt>org.netbeans.modules.j2ee.myserver.resources</tt>. Click Finish.</ol> |
| |
| <p> The IDE creates the <tt>My Server Module</tt> |
| project. The project contains all of your sources and |
| project metadata, such as the project's Ant build script. The project |
| opens in the IDE. You can view its logical structure in the Projects window (Ctrl-1) and its |
| file structure in the Files window (Ctrl-2). For example, the Projects window should now look as follows: |
| |
| <p><img border="1" src="../images/tutorials/myserver/projects-window-original.png" alt="original projects window"> |
| |
| <p>For basic information on each of the files created by the New Project wizard, see the |
| <a href="https://platform.netbeans.org/tutorials/quickstart-nbm.html">Introduction to NetBeans Module Development</a>. |
| |
| <h3 class="tutorial"><a name="specifying"></a>Specifying the Module's Dependencies</h3> |
| |
| <p>You will need to subclass several classes that belong to NetBeans APIs. |
| Each has to be declared as a module dependency. Use the Project Properties dialog box for this purpose, as shown below. |
| <ol> |
| <li>In the Projects window, right-click the <tt>My Server Module</tt> project and choose Properties. |
| In the Project Properties dialog box, click Libraries. |
| <p><li>For each of the APIs displayed in the list below, click "Add..." in the Libraries panel, |
| select the name from the Module list, and then click OK to confirm it: |
| |
| <p align="left"><img src="../images/tutorials/myserver/libraries-panel.png" alt="Basic Module Configuration panel."></li> |
| |
| <p><li>Click OK to exit the Project Properties dialog box. |
| <p><li>In the Projects window, double-click Project Metadata and note that the APIs you selected have been |
| declared as module dependencies.</li> |
| |
| </ol> |
| |
| |
| </div> |
| <br /> |
| |
| <!-- ===================================================================================== --> |
| |
| <h2><a name="creatingandgettingtoknowthemainfiles"></a>Creating the Factory Classes</h2> |
| <p>The implementation classes are implemented by the factories. In this section, you will create and examine each of them: |
| <ul> |
| <li><a href="#MyDeploymentFactory"><tt>MyDeploymentFactory.java</tt></a> |
| <li><a href="#MyJ2eePlatformFactory"><tt>MyJ2eePlatformFactory.java</tt></a> |
| <li><a href="#MyOptionalFactory"><tt>MyOptionalFactory.java</tt></a> |
| <li><a href="#MyRegistryNodeFactory"><tt>MyRegistryNodeFactory.java</tt></a> |
| </ul> |
| |
| <div class="indent"> |
| <h3 class="tutorial"><a name="MyDeploymentFactory"></a>MyDeploymentFactory.java</h3> |
| |
| |
| <p>The <tt>MyDeploymentFactory</tt> class is an implementation of <tt><a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/factories/DeploymentFactory.html">DeploymentFactory</a></tt>, which produces instances of the <a href="#MyDeploymentManager"><tt>MyDeploymentManager</tt></a> implementation class.</p> |
| <p>The following are the interesting methods in this class: |
| |
| <ul> |
| <p><li><tt><a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/factories/DeploymentFactory.html#handlesURI(java.lang.String)">handlesURI()</a>.</tt> Determines whether the given <tt>MyDeploymentFactory</tt> can handle the specifed URI. |
| <p><li><tt><a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/factories/DeploymentFactory.html#getDeploymentManager(java.lang.String,%20java.lang.String,%20java.lang.String)">getDeploymentManager()</a>.</tt> Creates a <tt>connected</tt> <tt>DeploymentManager</tt> instance. This instance provides access |
| to J2EE resources. |
| <p><li><tt><a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/factories/DeploymentFactory.html#getDisconnectedDeploymentManager(java.lang.String)">getDisconnectedDeploymentManager()</a>.</tt> Creates a <tt>disconnected</tt> <tt>DeploymentManager</tt> instance. This instance provides |
| access to configuration support. |
| </ul> |
| |
| <p>Our new server instance will use the <tt>deployer:myserver</tt> prefix so that the URL |
| used to obtain a connected deployment manager looks |
| like this: <tt>deployer:myserver:localhost:8080</tt>. |
| <p>Do the following to create the <tt>MyDeploymentFactory</tt> class: |
| |
| <ol> |
| <p><li>Right-click the <tt>org.netbeans.modules.j2ee.myserver</tt> node and choose New > File/Folder. Under |
| Categories, choose Java Classes. Under File Types, choose Java Class. |
| Click Next and type <tt>MyDeploymentFactory</tt> in Class Name. Click Finish. The new Java class opens in the Source Editor. |
| <p><li>Replace the default code with the code below: |
| <pre class="examplecode">package org.netbeans.modules.j2ee.myserver; |
| |
| import javax.enterprise.deploy.shared.factories.DeploymentFactoryManager; |
| import javax.enterprise.deploy.spi.DeploymentManager; |
| import javax.enterprise.deploy.spi.exceptions.DeploymentManagerCreationException; |
| import javax.enterprise.deploy.spi.factories.DeploymentFactory; |
| import org.openide.ErrorManager; |
| import org.openide.util.NbBundle; |
| |
| public class MyDeploymentFactory implements DeploymentFactory { |
| |
| public static final String URI_PREFIX = "deployer:myserver"; // NOI18N |
| private static DeploymentFactory instance; |
| |
| public static synchronized DeploymentFactory create() { |
| if (instance == null) { |
| instance = new MyDeploymentFactory(); |
| DeploymentFactoryManager.getInstance().registerDeploymentFactory(instance); |
| } |
| return instance; |
| } |
| |
| public boolean handlesURI(String uri) { |
| return uri != null && uri.startsWith(URI_PREFIX); |
| } |
| |
| public DeploymentManager getDeploymentManager(String uri, String uname, String passwd) throws DeploymentManagerCreationException { |
| if (!handlesURI(uri)) { |
| throw new DeploymentManagerCreationException("Invalid URI:" + uri); // NOI18N |
| } |
| return new MyDeploymentManager(); |
| } |
| |
| public DeploymentManager getDisconnectedDeploymentManager(String uri) throws DeploymentManagerCreationException { |
| if (!handlesURI(uri)) { |
| throw new DeploymentManagerCreationException("Invalid URI:" + uri); // NOI18N |
| } |
| return new MyDeploymentManager(); |
| } |
| |
| public String getProductVersion() { |
| return "0.1"; // NOI18N |
| } |
| |
| public String getDisplayName() { |
| return NbBundle.getMessage(MyDeploymentFactory.class, "TXT_DisplayName"); // NOI18N |
| } |
| }</pre> |
| |
| </ol> |
| <h3 class="tutorial"><a name="MyJ2eePlatformFactory"></a>MyJ2eePlatformFactory.java</h3> |
| <p>The <tt>MyJ2eePlatformFactory</tt> class is an implementation of the <tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/J2eePlatformFactory.html">J2eePlatformFactory</a></tt> class. |
| The implementation is very simple -- it produces instances of the <a href="#MyJ2eePlatformImpl"><tt>MyJ2eePlatformImpl</tt></a> class. |
| <p>Do the following to create the <tt>MyJ2eePlatformFactory</tt> class: |
| <ol> |
| <p><li>Right-click the <tt>org.netbeans.modules.j2ee.myserver</tt> node, choose New > Java Class, |
| and type <tt>MyJ2eePlatformFactory</tt> in Class Name. Click Finish. The new Java class opens in the Source Editor. |
| <p><li>Replace the default code with the code below: |
| |
| <pre class="examplecode">package org.netbeans.modules.j2ee.myserver; |
| |
| import javax.enterprise.deploy.spi.DeploymentManager; |
| import org.netbeans.modules.j2ee.deployment.plugins.api.J2eePlatformFactory; |
| import org.netbeans.modules.j2ee.deployment.plugins.api.J2eePlatformImpl; |
| |
| public class MyJ2eePlatformFactory extends J2eePlatformFactory { |
| public J2eePlatformImpl getJ2eePlatformImpl(DeploymentManager dm) { |
| return new MyJ2eePlatformImpl(); |
| } |
| }</pre> |
| |
| </ol> |
| |
| |
| <h3 class="tutorial"><a name="MyOptionalFactory"></a>MyOptionalFactory.java</h3> |
| |
| |
| <p>The <tt>MyOptionalFactory</tt> class is an implementation of <tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/OptionalDeploymentManagerFactory.html">OptionalDeploymentManagerFactory</a></tt>. |
| Despite its name, this factory class is <i>not</i> optional. At least two methods need to be implemented: |
| |
| <ul> |
| <p><li><tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/OptionalDeploymentManagerFactory.html#getStartServer(javax.enterprise.deploy.spi.DeploymentManager)">getStartServer()</a>.</tt> Starts and stops the server. |
| <p><li><tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/OptionalDeploymentManagerFactory.html#getAddInstanceIterator()">getAddInstanceIterator()</a>.</tt> Creates the wizard for registering the server in the IDE. |
| </ul> |
| |
| <p>The other two methods are not implemented here: |
| <ul> |
| <p><li><tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/OptionalDeploymentManagerFactory.html#getIncrementalDeployment(javax.enterprise.deploy.spi.DeploymentManager)">getIncrementalDeployment()</a>.</tt> Creates <tt>IncrementalDeployment</tt>, which offers an |
| alternative way, which is more convenient for development.. |
| <p><li><tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/OptionalDeploymentManagerFactory.html#getFindJSPServlet(javax.enterprise.deploy.spi.DeploymentManager)">getFindJSPServlet()</a>.</tt> Creates <tt>FindJSPServlet</tt>, |
| which lets modules specify the location of servlets generated for JSPs. |
| </ul> |
| |
| <p>Do the following to create the MyOptionalFactory class: |
| |
| <ol> |
| <p><li>Right-click the <tt>org.netbeans.modules.j2ee.myserver</tt> node, choose New > Java Class, |
| and type <tt>MyOptionalFactory</tt> in Class Name. Click Finish. The new Java class opens in the Source Editor. |
| <p><li>Replace the default code with the code below: |
| <pre class="examplecode">package org.netbeans.modules.j2ee.myserver; |
| |
| import javax.enterprise.deploy.spi.DeploymentManager; |
| import org.netbeans.modules.j2ee.deployment.plugins.api.FindJSPServlet; |
| import org.netbeans.modules.j2ee.deployment.plugins.api.IncrementalDeployment; |
| import org.netbeans.modules.j2ee.deployment.plugins.api.OptionalDeploymentManagerFactory; |
| import org.netbeans.modules.j2ee.deployment.plugins.api.StartServer; |
| import org.openide.WizardDescriptor.InstantiatingIterator; |
| |
| public class MyOptionalFactory extends OptionalDeploymentManagerFactory { |
| |
| public StartServer getStartServer(DeploymentManager dm) { |
| return new MyStartServer(); |
| } |
| |
| public IncrementalDeployment getIncrementalDeployment(DeploymentManager dm) { |
| return null; |
| } |
| |
| public FindJSPServlet getFindJSPServlet(DeploymentManager dm) { |
| return null; |
| } |
| |
| public InstantiatingIterator getAddInstanceIterator() { |
| return new MyInstantiatingIterator(); |
| } |
| }</pre> |
| |
| </ol> |
| |
| |
| |
| <h3 class="tutorial"><a name="MyRegistryNodeFactory"></a>MyRegistryNodeFactory.java</h3> |
| |
| <p>The <tt>MyRegistryNodeFactory</tt> class is an implementation of <tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/RegistryNodeFactory.html">RegistryNodeFactory</a></tt>. The purpose of this factory is to |
| produce server and target nodes, which are used as user interface representations in the Runtime window. |
| Since the new server type only has one target and its Admin Server is therefore also a target server, |
| you do not need to implement the target node. |
| |
| <ol> |
| <p><li>Right-click the <tt>org.netbeans.modules.j2ee.myserver</tt> node, choose New > Java Class, |
| and type <tt>MyRegistryNodeFactory</tt> in Class Name. Click Finish. The new Java class opens in the Source Editor. |
| <p><li>Replace the default code with the code below: |
| <pre class="examplecode">package org.netbeans.modules.j2ee.myserver.nodes; |
| |
| import org.netbeans.modules.j2ee.deployment.plugins.api.RegistryNodeFactory; |
| import org.openide.nodes.Children; |
| import org.openide.nodes.Node; |
| import org.openide.util.Lookup; |
| |
| public class MyRegistryNodeFactory implements RegistryNodeFactory { |
| |
| public Node getTargetNode(Lookup lookup) { |
| return null; |
| } |
| |
| public Node getManagerNode(Lookup lookup) { |
| return new MyInstanceNode(lookup); |
| } |
| }</pre> |
| |
| |
| </ol> |
| |
| |
| </div> |
| <br /> |
| |
| <!-- ===================================================================================== --> |
| |
| <h2><a name="creatingandgettingtoknowthemainfiles"></a>Creating the Implementation Classes</h2> |
| <p>The implementation classes are implemented by the factories. In this section, you will create and examine each of them: |
| <ul> |
| <li><a href="#ConfigurationSupportImpl"><tt>ConfigurationSupportImpl.java</tt></a> |
| <li><a href="#MyConfiguration"><tt>MyConfiguration.java</tt></a> |
| <li><a href="#MyDeploymentManager"><tt>MyDeploymentManager.java</tt></a> |
| <li><a href="#MyInstantiatingIterator"><tt>MyInstantiatingIterator.java</tt></a> |
| <li><a href="#MyJ2eePlatformImpl"><tt>MyJ2eePlatformImpl.java</tt></a> |
| <li><a href="#MyStartServer"><tt>MyStartServer.java</tt></a> |
| <li><a href="#MyInstanceNode"><tt>MyInstanceNode.java</tt></a> |
| </ul> |
| |
| <div class="indent"> |
| |
| <h3 class="tutorial"><a name="ConfigurationSupportImpl"></a>ConfigurationSupportImpl.java</h3> |
| |
| <p>An implementation of the NetBeans API's <a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/ConfigurationSupport.html">ConfigurationSupport</a> |
| interface. This class is the NetBeans extension of the <a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/DeploymentConfiguration.html">DeploymentConfiguration</a> interface, which is a J2EE API class and |
| therefore could not be changed. This extension adds life cycle management and additional module change |
| notifications support. |
| |
| <ol> |
| <p><li>Right-click the <tt>org.netbeans.modules.j2ee.myserver</tt> node, choose New > Java Class, |
| and type <tt>ConfigurationSupportImpl</tt> in Class Name. Click Finish. The new Java class opens in the Source Editor. |
| |
| <p><li>Replace the default code with the code below: |
| |
| <pre class="examplecode"> |
| package org.netbeans.modules.j2ee.myserver; |
| |
| import java.io.File; |
| import javax.enterprise.deploy.model.DDBean; |
| import javax.enterprise.deploy.model.DeployableObject; |
| import javax.enterprise.deploy.spi.DeploymentConfiguration; |
| import javax.enterprise.deploy.spi.exceptions.ConfigurationException; |
| import org.netbeans.modules.j2ee.deployment.common.api.OriginalCMPMapping; |
| import org.netbeans.modules.j2ee.deployment.plugins.api.ConfigurationSupport; |
| |
| |
| public class ConfigurationSupportImpl extends ConfigurationSupport { |
| |
| public void setMappingInfo(DeploymentConfiguration config, OriginalCMPMapping[] mappings) { |
| } |
| |
| public void ensureResourceDefined(DeploymentConfiguration config, DDBean bean) { |
| } |
| |
| public String getWebContextRoot(DeploymentConfiguration config, DeployableObject deplObj) |
| throws ConfigurationException { |
| return ((MyConfiguration)config).getContextPath(); |
| } |
| |
| public void setWebContextRoot(DeploymentConfiguration config, DeployableObject deplObj, String contextRoot) |
| throws ConfigurationException { |
| ((MyConfiguration)config).setContextPath(contextRoot); |
| } |
| |
| public void initConfiguration(DeploymentConfiguration config, File[] files, |
| File resourceDir, boolean keepUpdated) throws ConfigurationException { |
| ((MyConfiguration)config).init(files[0]); |
| } |
| |
| public void disposeConfiguration(DeploymentConfiguration config) { |
| } |
| |
| public void updateResourceDir(DeploymentConfiguration config, File resourceDir) { |
| } |
| }</pre> |
| </ol><p> |
| |
| <h3 class="tutorial"><a name="MyConfiguration"></a>MyConfiguration.java</h3> |
| |
| <p>An implementation of the <a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/DeploymentConfiguration.html">DeploymentConfiguration</a> interface. |
| The purpose of this class is to provide support for server-specific configuration, in other words, it relates to deployment descriptors. |
| |
| <p><b>Note:</b> The previous versions of the j2eeserver API |
| required plug-ins to use the <tt>DConfigBean</tt> based model for s |
| erver specific-deployment descriptor representations; this is not needed anymore. |
| Plug-ins are now allowed to use any model representation they want, typically a schema2beans-based model, a |
| nd are also in charge of saving and loading the deployment configuration. Because of the redesign, |
| the following <tt>DeploymentConfiguration</tt> methods are no longer used: <tt>getDConfigBeanRoot()</tt>, |
| <tt>removeDConfigBean()</tt>, <tt>restore()</tt>, <tt>restoreDConfigBean()</tt>, and |
| <tt>saveDConfigBean()</tt>. On the other hand, new methods were added through the <tt>ConfigurationSupport</tt> interface. |
| |
| <ol> |
| <p><li>Right-click the <tt>org.netbeans.modules.j2ee.myserver</tt> node, choose New > Java Class, |
| and type <tt>MyConfiguration</tt> in Class Name. Click Finish. The new Java class opens in the Source Editor. |
| |
| <p><li>Replace the default code with the code below: |
| |
| <pre class="examplecode"> |
| package org.netbeans.modules.j2ee.myserver; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.OutputStreamWriter; |
| import java.io.PrintWriter; |
| import javax.enterprise.deploy.model.DDBean; |
| import javax.enterprise.deploy.model.DDBeanRoot; |
| import javax.enterprise.deploy.model.DeployableObject; |
| import javax.enterprise.deploy.model.XpathEvent; |
| import javax.enterprise.deploy.model.XpathListener; |
| import javax.enterprise.deploy.spi.DConfigBeanRoot; |
| import javax.enterprise.deploy.spi.DeploymentConfiguration; |
| import javax.enterprise.deploy.spi.exceptions.BeanNotFoundException; |
| import javax.enterprise.deploy.spi.exceptions.ConfigurationException; |
| import org.openide.ErrorManager; |
| import org.openide.filesystems.FileLock; |
| import org.openide.filesystems.FileObject; |
| import org.openide.filesystems.FileUtil; |
| |
| |
| public class MyConfiguration implements DeploymentConfiguration, XpathListener { |
| |
| private DeployableObject deplObj; |
| |
| public MyConfiguration (DeployableObject deplObj) { |
| this.deplObj = deplObj; |
| } |
| |
| public void init(File file) { |
| try { |
| FileObject folder = FileUtil.toFileObject(file.getParentFile()); |
| if (folder == null) { |
| ErrorManager.getDefault().log(ErrorManager.INFORMATIONAL, "The parent folder does not exist!"); // NOI18N |
| return; |
| } |
| PrintWriter pw = null; |
| FileLock lock = null; |
| try { |
| String name = file.getName(); |
| FileObject fo = folder.getFileObject(name); |
| if (fo == null) { |
| fo = folder.createData(name); |
| } |
| lock = fo.lock(); |
| pw = new PrintWriter(new OutputStreamWriter(fo.getOutputStream(lock))); |
| pw.println("<MyServer path=\"/mypath\"/>"); // NOI18N |
| } finally { |
| if (pw != null) { |
| pw.close(); |
| } |
| if (lock != null) { |
| lock.releaseLock(); |
| } |
| } |
| } catch (IOException ex) { |
| ErrorManager.getDefault().notify(ErrorManager.INFORMATIONAL, ex); |
| } |
| |
| // web.xml represented as DDBean model |
| DDBeanRoot root = deplObj.getDDBeanRoot(); |
| if (root != null) { |
| // here we will listen to resource reference changes |
| root.addXpathListener("/web-app/resource-ref", this); // NOI18N |
| } |
| } |
| |
| public String getContextPath() throws ConfigurationException { |
| // TODO: replace this with reading the context path from the server specific DD |
| return "/mypath"; |
| } |
| |
| public void setContextPath(String contextPath) throws ConfigurationException { |
| // TODO: here put the code that will store the context path in the server specific DD |
| } |
| |
| // XpathListener implementation ------------------------------------------- |
| |
| public void fireXpathEvent(XpathEvent xpe) { |
| DDBean eventDDBean = xpe.getBean(); |
| if ("/web-app/resource-ref".equals(eventDDBean.getXpath())) { // NIO18N |
| // new resource reference added |
| if (xpe.isAddEvent()) { |
| String[] name = eventDDBean.getText("res-ref-name"); // NOI18N |
| String[] type = eventDDBean.getText("res-type"); // NOI18N |
| String[] auth = eventDDBean.getText("res-auth"); // NOI18N |
| // TODO: take appropriate steps here |
| } |
| } |
| } |
| |
| // JSR-88 methods --------------------------------------------------------- |
| |
| public DeployableObject getDeployableObject () { |
| return deplObj; |
| } |
| |
| public void save(OutputStream os) throws ConfigurationException { |
| } |
| |
| public DConfigBeanRoot getDConfigBeanRoot (DDBeanRoot dDBeanRoot) |
| throws ConfigurationException { |
| return null; |
| } |
| |
| public void removeDConfigBean (DConfigBeanRoot dConfigBeanRoot) |
| throws BeanNotFoundException { |
| } |
| |
| public void restore (InputStream is) |
| throws ConfigurationException { |
| } |
| |
| public DConfigBeanRoot restoreDConfigBean (InputStream is, DDBeanRoot dDBeanRoot) |
| throws ConfigurationException { |
| return null; |
| } |
| |
| public void saveDConfigBean (OutputStream os, DConfigBeanRoot dConfigBeanRoot) |
| throws ConfigurationException { |
| } |
| }</pre> |
| </ol><p> |
| |
| |
| |
| <h3 class="tutorial"><a name="MyDeploymentManager"></a>MyDeploymentManager.java</h3> |
| |
| <p>A dummy implementation of the <tt><a href="http://java.sun.com/j2ee/1.4/docs/api/javax/enterprise/deploy/spi/DeploymentManager.html">DeploymentManager</a></tt> interface, which does nothing |
| more than return <a href="#MyConfiguration"><tt>MyConfiguration.java</tt></a>. |
| It is up to you to provide other server-specific implementation features. |
| |
| <ol> |
| <p><li>Right-click the <tt>org.netbeans.modules.j2ee.myserver</tt> node and choose New > File/Folder. Under |
| Categories, choose Java Classes. Under File Types, choose Java Class. |
| Click Next and type <tt>MyDeploymentManager</tt> in Class Name. Click Finish. The new Java class opens in the Source Editor. |
| |
| <p><li>Replace the default code with the code below: |
| |
| <pre class="examplecode">package org.netbeans.modules.j2ee.myserver; |
| |
| import java.io.File; |
| import java.io.InputStream; |
| import javax.enterprise.deploy.model.DeployableObject; |
| import javax.enterprise.deploy.shared.DConfigBeanVersionType; |
| import javax.enterprise.deploy.shared.ModuleType; |
| import javax.enterprise.deploy.spi.DeploymentConfiguration; |
| import javax.enterprise.deploy.spi.DeploymentManager; |
| import javax.enterprise.deploy.spi.Target; |
| import javax.enterprise.deploy.spi.TargetModuleID; |
| import javax.enterprise.deploy.spi.exceptions.DConfigBeanVersionUnsupportedException; |
| import javax.enterprise.deploy.spi.exceptions.InvalidModuleException; |
| import javax.enterprise.deploy.spi.exceptions.TargetException; |
| import javax.enterprise.deploy.spi.status.ProgressObject; |
| |
| public class MyDeploymentManager implements DeploymentManager { |
| |
| public ProgressObject <span class="java-layer-method">distribute(Target[] target, File file, File file2) |
| throws IllegalStateException { |
| return null; |
| } |
| |
| public DeploymentConfiguration <span class="java-layer-method">createConfiguration(DeployableObject deployableObject) |
| throws InvalidModuleException { |
| return new <a href="#MyConfiguration"><tt>MyConfiguration</tt></a>(deployableObject); |
| } |
| |
| public ProgressObject <span class="java-layer-method">redeploy(TargetModuleID[] targetModuleID, InputStream inputStream, InputStream inputStream2) |
| throws UnsupportedOperationException, IllegalStateException { |
| return null; |
| } |
| |
| public ProgressObject <span class="java-layer-method">distribute(Target[] target, InputStream inputStream, InputStream inputStream2) |
| throws IllegalStateException { |
| return null; |
| } |
| |
| public ProgressObject <span class="java-layer-method">undeploy(TargetModuleID[] targetModuleID) throws IllegalStateException { |
| return null; |
| } |
| |
| public ProgressObject <span class="java-layer-method">stop(TargetModuleID[] targetModuleID) throws IllegalStateException { |
| return null; |
| } |
| |
| public ProgressObject <span class="java-layer-method">start(TargetModuleID[] targetModuleID) throws IllegalStateException { |
| return null; |
| } |
| |
| public void <span class="java-layer-method">setLocale(java.util.Locale locale) throws UnsupportedOperationException { |
| } |
| |
| public boolean <span class="java-layer-method">isLocaleSupported(java.util.Locale locale) { |
| return false; |
| } |
| |
| public TargetModuleID[] <span class="java-layer-method">getAvailableModules(ModuleType moduleType, Target[] target) |
| throws TargetException, IllegalStateException { |
| return null; |
| } |
| |
| public TargetModuleID[] <span class="java-layer-method">getNonRunningModules(ModuleType moduleType, Target[] target) |
| throws TargetException, IllegalStateException { |
| return null; |
| } |
| |
| public TargetModuleID[] <span class="java-layer-method">getRunningModules(ModuleType moduleType, Target[] target) |
| throws TargetException, IllegalStateException { |
| return null; |
| } |
| |
| public ProgressObject <span class="java-layer-method">redeploy(TargetModuleID[] targetModuleID, File file, File file2) |
| throws UnsupportedOperationException, IllegalStateException { |
| return null; |
| } |
| |
| public void <span class="java-layer-method">setDConfigBeanVersion(DConfigBeanVersionType dConfigBeanVersionType) |
| throws DConfigBeanVersionUnsupportedException { |
| } |
| |
| public boolean <span class="java-layer-method">isDConfigBeanVersionSupported(DConfigBeanVersionType dConfigBeanVersionType) { |
| return false; |
| } |
| |
| public void <span class="java-layer-method">release() { |
| } |
| |
| public boolean <span class="java-layer-method">isRedeploySupported() { |
| return false; |
| } |
| |
| public java.util.Locale <span class="java-layer-method">getCurrentLocale() { |
| return null; |
| } |
| |
| public DConfigBeanVersionType <span class="java-layer-method">getDConfigBeanVersion() { |
| return null; |
| } |
| |
| public java.util.Locale <span class="java-layer-method">getDefaultLocale() { |
| return null; |
| } |
| |
| public java.util.Locale[] <span class="java-layer-method">getSupportedLocales() { |
| return null; |
| } |
| |
| public Target[] <span class="java-layer-method">getTargets() throws IllegalStateException { |
| return null; |
| } |
| }</pre> |
| |
| </ol> |
| |
| |
| <h3 class="tutorial"><a name="MyInstantiatingIterator"></a>MyInstantiatingIterator.java</h3> |
| |
| <p>The <tt>MyInstantiatingIterator</tt> class is used to create a wizard for registration of the new server in the IDE. |
| The implementation described below lets you specify the display name only. Here, all the |
| other properties are hard coded to keep the |
| implementation as simple as possible. |
| |
| <p>Notice the URL variable used in the <tt>instantiate()</tt> method. It is passed to the <tt>InstanceProperties.createInstanceProperties()</tt> method, |
| which does the actual server registration. The URL parameter is the same as the one used by the <tt>DeploymenManager</tt>. |
| This way we ensure that our server controls the newly created server instance. |
| |
| |
| <ol> |
| <p><li>Right-click the <tt>org.netbeans.modules.j2ee.myserver</tt> node, choose New > Java Class, |
| and type <tt>MyInstantiatingIterator</tt> in Class Name. Click Finish. The new Java class opens in the Source Editor. |
| <p><li>Replace the default code with the code below: |
| <pre class="examplecode">package org.netbeans.modules.j2ee.myserver; |
| |
| import java.awt.Component; |
| import java.awt.Label; |
| import java.io.IOException; |
| import java.util.HashSet; |
| import java.util.Set; |
| import javax.swing.JPanel; |
| import javax.swing.event.ChangeListener; |
| import org.openide.WizardDescriptor; |
| import org.openide.WizardDescriptor.Panel; |
| import org.openide.util.HelpCtx; |
| import org.netbeans.modules.j2ee.deployment.plugins.api.InstanceProperties; |
| import org.openide.DialogDisplayer; |
| import org.openide.ErrorManager; |
| import org.openide.NotifyDescriptor; |
| import org.openide.util.NbBundle; |
| |
| |
| public class MyInstantiatingIterator implements WizardDescriptor.InstantiatingIterator { |
| |
| private final static String PROP_DISPLAY_NAME = "ServInstWizard_displayName"; // NOI18N |
| |
| |
| private InstallPanel panel; |
| private WizardDescriptor wizard; |
| |
| public void removeChangeListener(ChangeListener l) { |
| } |
| |
| public void addChangeListener(ChangeListener l) { |
| } |
| |
| public void uninitialize(WizardDescriptor wizard) { |
| } |
| |
| public void initialize(WizardDescriptor wizard) { |
| this.wizard = wizard; |
| } |
| |
| public void previousPanel() { |
| } |
| |
| public void nextPanel() { |
| } |
| |
| public String name() { |
| return NbBundle.getMessage(MyInstantiatingIterator.class, "MSG_InstallerName"); |
| } |
| |
| public Set instantiate() throws IOException { |
| Set result = new HashSet(); |
| String displayName = getDisplayName(); |
| String url = "deployer:myserver:localhost:8080"; // NOI18N |
| String username = "username"; // NOI18N |
| String password = "password"; // NOI18N |
| try { |
| InstanceProperties ip = InstanceProperties.createInstanceProperties( |
| url, username, password, displayName); |
| result.add(ip); |
| } catch (Exception ex) { |
| DialogDisplayer.getDefault().notify(new NotifyDescriptor.Message( |
| NbBundle.getMessage(MyInstantiatingIterator.class, "MSG_CreateFailed", displayName), |
| NotifyDescriptor.ERROR_MESSAGE)); |
| } |
| return result; |
| } |
| |
| public boolean hasPrevious() { |
| return false; |
| } |
| |
| public boolean hasNext() { |
| return false; |
| } |
| |
| public Panel current() { |
| if (panel == null) { |
| panel = new InstallPanel(); |
| } |
| return panel; |
| } |
| |
| private String getDisplayName() { |
| return (String)wizard.getProperty(PROP_DISPLAY_NAME); |
| } |
| |
| private static class InstallPanel implements WizardDescriptor.Panel { |
| public void removeChangeListener(ChangeListener l) { |
| } |
| |
| public void addChangeListener(ChangeListener l) { |
| } |
| |
| public void storeSettings(Object settings) { |
| } |
| |
| public void readSettings(Object settings) { |
| } |
| |
| public boolean isValid() { |
| return true; |
| } |
| |
| public HelpCtx getHelp() { |
| return HelpCtx.DEFAULT_HELP; |
| } |
| |
| public Component getComponent() { |
| JPanel panel = new JPanel(); |
| panel.add(new Label("< Put your installation form implementation here! >")); // NOI18N |
| return panel; |
| } |
| } |
| } |
| </ol><p> |
| |
| |
| |
| <h3 class="tutorial"><a name="MyJ2eePlatformImpl"></a>MyJ2eePlatformImpl.java</h3> |
| |
| <p>The <tt>MyJ2eePlatformImpl</tt> class is an implementation of <tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/J2eePlatformImpl.html">J2eePlatformImpl</a></tt>, which is used to describe the target environment that |
| J2EE applications are built against and subsequently deployed to. It provides a set of server |
| libraries, supported module types, and J2EE specification versions. |
| |
| <p>Note: Since the current implementation of <tt>MyJ2eePlatformImpl.java</tt> does not provide the J2EE API libraries, |
| your Web or EJB project will not compile, unless you provide those explicitly in the Libraries panel of the Project Properties dialog box. |
| |
| <ol> |
| <p><li>Right-click the <tt>org.netbeans.modules.j2ee.myserver</tt> node, choose New > Java Class, |
| and type <tt>MyJ2eePlatformImpl</tt> in Class Name. Click Finish. The new Java class opens in the Source Editor. |
| <p><li>Replace the default code with the code below: |
| |
| <pre class="examplecode">package org.netbeans.modules.j2ee.myserver; |
| |
| import java.io.File; |
| import java.util.HashSet; |
| import java.util.Set; |
| import org.netbeans.api.java.platform.JavaPlatform; |
| import org.netbeans.api.java.platform.JavaPlatformManager; |
| import org.netbeans.modules.j2ee.deployment.devmodules.api.J2eeModule; |
| import org.netbeans.modules.j2ee.deployment.plugins.api.J2eePlatformImpl; |
| import org.netbeans.spi.project.libraries.LibraryImplementation; |
| |
| import org.openide.util.NbBundle; |
| import org.openide.util.Utilities; |
| |
| public class MyJ2eePlatformImpl extends J2eePlatformImpl { |
| |
| public boolean isToolSupported(String toolName) { |
| return false; |
| } |
| |
| public File[] getToolClasspathEntries(String toolName) { |
| return new File[0]; |
| } |
| |
| public Set getSupportedSpecVersions() { |
| Set result = new HashSet(); |
| result.add(J2eeModule.J2EE_14); |
| //result.add(J2eeModule.JAVA_EE_5); |
| return result; |
| } |
| |
| public java.util.Set getSupportedModuleTypes() { |
| Set result = new HashSet(); |
| result.add(J2eeModule.EAR); |
| result.add(J2eeModule.WAR); |
| result.add(J2eeModule.EJB); |
| return result; |
| } |
| |
| public java.io.File[] getPlatformRoots() { |
| return new File[0]; |
| } |
| |
| public LibraryImplementation[] getLibraries() { |
| return new LibraryImplementation[0]; |
| } |
| |
| public java.awt.Image getIcon() { |
| return Utilities.loadImage("org/netbeans/modules/j2ee/myserver/resources/server.gif"); // NOI18N |
| |
| } |
| |
| public String getDisplayName() { |
| return NbBundle.getMessage(MyJ2eePlatformImpl.class, "MSG_MyServerPlatform"); |
| } |
| |
| public Set getSupportedJavaPlatformVersions() { |
| Set versions = new HashSet(); |
| versions.add("1.4"); // NOI18N |
| versions.add("1.5"); // NOI18N |
| return versions; |
| } |
| |
| public JavaPlatform getJavaPlatform() { |
| return JavaPlatformManager.getDefault().getDefaultPlatform(); |
| } |
| |
| }</pre> |
| |
| |
| </ol> |
| |
| |
| |
| |
| <h3 class="tutorial"><a name="MyStartServer"></a>MyStartServer.java</h3> |
| |
| |
| <p>The <tt>MyStartServer</tt> class is an implementation of the <tt><a href="https://netbeans.org/download/dev/javadoc/org-netbeans-modules-j2eeserver/org/netbeans/modules/j2ee/deployment/plugins/api/StartServer.html">StartServer</a></tt> interface. Its purpose is to provide ability to start, |
| stop, and determine the state of the server. The current implementation says that the server is always stopped and it cannot be started. |
| The server-specific implementation is left up to you to complete for the server in question. |
| |
| <ol> |
| <p><li>Right-click the <tt>org.netbeans.modules.j2ee.myserver</tt> node, choose New > Java Class, |
| and type <tt>MyStartServer</tt> in Class Name. Click Finish. The new Java class opens in the Source Editor. |
| <p><li>Replace the default code with the code below: |
| |
| <pre class="examplecode">package org.netbeans.modules.j2ee.myserver; |
| |
| import javax.enterprise.deploy.spi.Target; |
| import javax.enterprise.deploy.spi.status.ProgressObject; |
| import org.netbeans.modules.j2ee.deployment.plugins.api.ServerDebugInfo; |
| import org.netbeans.modules.j2ee.deployment.plugins.api.StartServer; |
| |
| public class MyStartServer extends StartServer { |
| |
| public ProgressObject <span class="java-layer-method">startDebugging(Target target) { |
| return null; |
| } |
| |
| public boolean <span class="java-layer-method">isDebuggable(Target target) { |
| return false; |
| } |
| |
| public boolean <span class="java-layer-method">isAlsoTargetServer(Target target) { |
| return true; |
| } |
| |
| public ServerDebugInfo <span class="java-layer-method">getDebugInfo(Target target) { |
| return null; |
| } |
| |
| public boolean <span class="java-layer-method">supportsStartDeploymentManager() { |
| return false; |
| } |
| |
| public ProgressObject <span class="java-layer-method">stopDeploymentManager() { |
| return null; |
| } |
| |
| public ProgressObject <span class="java-layer-method">startDeploymentManager() { |
| return null; |
| } |
| |
| public boolean <span class="java-layer-method">needsStartForTargetList() { |
| return false; |
| } |
| |
| public boolean <span class="java-layer-method">needsStartForConfigure() { |
| return false; |
| } |
| |
| public boolean <span class="java-layer-method">needsStartForAdminConfig() { |
| return false; |
| } |
| |
| public boolean <span class="java-layer-method">isRunning() { |
| return false; |
| } |
| }</pre> |
| |
| </ol><p> |
| |
| <h3 class="tutorial"><a name="MyInstanceNode"></a>MyInstanceNode.java</h3> |
| |
| <p>The <tt>MyInstanceNode</tt> class represents instances of the new server type as a node in the Runtime window. |
| A default set of features is added to the node -- these features display the server's status and provide default menu items |
| such as <tt>Start</tt>, <tt>Refresh</tt>, and <tt>Remove</tt>. This is done by a standard filter node |
| that exists on top of the node provided by the module. The <tt>MyInstanceNode</tt> class defines a dummy customizer |
| implementation which is displayed in the Tools menu's Server Manager. |
| |
| <ol> |
| <p><li>Right-click the <tt>org.netbeans.modules.j2ee.myserver.nodes</tt> node, choose New > Java Class, |
| and type <tt>MyInstanceNode</tt> in Class Name. Click Finish. The new Java class opens in the Source Editor. |
| <p><li>Replace the default code with the code below: |
| |
| <pre class="examplecode">package org.netbeans.modules.j2ee.myserver.nodes; |
| |
| import java.awt.Component; |
| import java.awt.Label; |
| import javax.swing.JPanel; |
| import org.openide.nodes.AbstractNode; |
| import org.openide.nodes.Children; |
| import org.openide.nodes.Node; |
| import org.openide.util.Lookup; |
| import org.openide.util.NbBundle; |
| |
| public class MyInstanceNode extends AbstractNode implements Node.Cookie { |
| |
| private static String ICON_BASE = "org/netbeans/modules/j2ee/myserver/resources/server.gif"; <span class="java-block-comment">// NOI18N |
| |
| public MyInstanceNode(Lookup lookup) { |
| super(new Children.Array()); |
| getCookieSet().add(this); |
| setIconBaseWithExtension(ICON_BASE); |
| } |
| |
| public String getDisplayName() { |
| return NbBundle.getMessage(MyInstanceNode.class, "TXT_MyInstanceNode"); |
| } |
| |
| public String getShortDescription() { |
| return "http://localhost:8080"; // NOI18N |
| } |
| |
| public javax.swing.Action[] getActions(boolean context) { |
| return new javax.swing.Action[]{}; |
| } |
| |
| public boolean hasCustomizer() { |
| return true; |
| } |
| |
| public Component getCustomizer() { |
| JPanel panel = new JPanel(); |
| panel.add(new Label("< Put your customizer implementation here! >")); <span class="java-block-comment">// NOI18N |
| return panel; |
| } |
| }</pre> |
| |
| |
| |
| |
| </ol> |
| |
| </div> |
| <br /> |
| |
| <!-- ===================================================================================== --> |
| |
| <h2><a name="finetuning"></a>Setting Up the Supporting Files</h2> |
| <p>Once you have coded the main files, you must register your module in the <tt>layer.xml</tt> file and in the |
| <tt>nbdep.xml</tt> file. You must also define labels and texts you want to display to the user, using |
| the <tt>Bundle.properties</tt> files.</p> |
| <div class="indent"> |
| |
| <h3 class="tutorial">Registering the New Server in the NetBeans Filesystem</h3> |
| |
| <ol><a name="layer.xml"></a><li>Add the following entry between the <tt><filesystem></tt> tags in the <tt>layer.xml</tt> file: |
| |
| <pre class="examplecode"> <folder name="J2EE"> |
| <folder name="DeploymentPlugins"> |
| <folder name="MyServer"> |
| |
| <file name="Descriptor" url="nbdep.xml"/> |
| |
| <file name="Factory.instance"> |
| <attr name="instanceCreate" methodvalue="org.netbeans.modules.j2ee.myserver.MyDeploymentFactory.create"/> |
| <attr name="instanceClass" stringvalue="<a href="#MyDeploymentFactory">org.netbeans.modules.j2ee.myserver.MyDeploymentFactory</a>"/> |
| <attr name="instanceOf" stringvalue="javax.enterprise.deploy.spi.factories.DeploymentFactory"/> |
| </file> |
| |
| <file name="RegistryNodeFactory.instance"> |
| <attr name="instanceClass" stringvalue="<a href="#MyRegistryNodeFactory">org.netbeans.modules.j2ee.myserver.nodes.MyRegistryNodeFactory</a>"/> |
| <attr name="instanceOf" stringvalue="org.netbeans.modules.j2ee.deployment.plugins.api.RegistryNodeFactory"/> |
| </file> |
| |
| <file name="J2eePlatformFactory.instance"> |
| <attr name="instanceCreate" newvalue="org.netbeans.modules.j2ee.myserver.MyJ2eePlatformFactory"/> |
| <attr name="instanceClass" stringvalue="<a href="#MyJ2eePlatformFactory">org.netbeans.modules.j2ee.myserver.MyJ2eePlatformFactory</a>"/> |
| <attr name="instanceOf" stringvalue="org.netbeans.modules.j2ee.deployment.plugins.api.J2eePlatformFactory"/> |
| </file> |
| |
| <file name="OptionalFactory.instance"> |
| <attr name="instanceCreate" newvalue="org.netbeans.modules.j2ee.myserver.MyOptionalFactory"/> |
| <attr name="instanceClass" stringvalue="<a href="#MyOptionalFactory">org.netbeans.modules.j2ee.myserver.MyOptionalFactory</a>"/> |
| <attr name="instanceOf" stringvalue="org.netbeans.modules.j2ee.deployment.plugins.api.OptionalDeploymentManagerFactory"/> |
| </file> |
| |
| <file name="ConfigurationSupportImpl.instance"> |
| <attr name="instanceCreate" newvalue="<a href="#ConfigurationSupportImpl">org.netbeans.modules.j2ee.myserver.ConfigurationSupportImpl</a>"/> |
| <attr name="instanceOf" stringvalue="org.netbeans.modules.j2ee.deployment.plugins.api.ConfigurationSupport"/> |
| </file> |
| |
| <folder name="DeploymentFileNames"> |
| <folder name="WAR"> |
| <file name="WEB-INF\myserver-web.xml"/> |
| </folder> |
| </folder> |
| |
| </folder> |
| </folder> |
| |
| </folder></pre> |
| <a name="nbdep.xml"></a><li>Right-click <tt>org.netbeans.modules.j2ee.myserver.resources</tt> and choose New > File/Folder. Under categories, |
| select XML. Under File Types, select XML Document. Click Next. Type <tt>nbdep</tt> in File Name, click Next and then |
| click Finish. Replace the content of <tt>nbdep.xml</tt> with the following code: |
| |
| <pre class="examplecode"> <netbeans-deployment> |
| |
| <!-- |
| The icon element contains a path to the icon to be used to present the server |
| in the server registry. |
| --> |
| <icon>org/netbeans/modules/j2ee/myserver/resources/server</icon> |
| |
| <!-- |
| The disconnected-string element contains the String parameter to DeploymentFactory.getDisconnectedDeploymentManager() |
| --> |
| <disconnected-string>deployer:myserver</disconnected-string> |
| |
| <!-- |
| The container-limitation element modifies a plugin to say that not all j2ee deployments are valid. |
| For example, a web-only server would include |
| <container-limitation> <war-deploy/> </container-limitation> |
| to indicate that only war deployments are accepted. |
| If a container-limitation element is not present, all j2ee deployments are assumed valid. |
| If a container-limitation element is present, then only j2ee deployment types explicitly |
| mentioned are allowed. |
| --> |
| <container-limitation> |
| <ear-deploy/> |
| <war-deploy/> |
| <ejbjar-deploy/> |
| </container-limitation> |
| |
| <web-context-root> |
| <xpath>/</xpath> |
| <prop-name>contextRoot</prop-name> |
| </web-context-root> |
| |
| </netbeans-deployment></pre></ol> |
| |
| |
| <a name="Bundle.properties"></a><h3 class="tutorial">Localizing the module</h3> |
| <p>The module is localized using <tt>Bundle.properties</tt> files. |
| A <tt>Bundle.properties</tt> file provides |
| language-specific strings for the user interface provided by other files in the package. When you used the New Project wizard |
| to create the module, the IDE created a <tt>Bundle.properties</tt> file in the |
| <tt>org.netbeans.modules.j2ee.myserver.resources</tt> package. Now you will add <tt>key=value</tt> pairs |
| to the IDE-generated <tt>Bundle.properties</tt> file and create two additional <tt>Bundle.properties</tt> files |
| for the other packages. |
| <ol><li>In <tt>org.netbeans.modules.j2ee.myserver.resources</tt>, |
| add the following properties to the <tt>Bundle.properties</tt> file: |
| |
| <pre class="examplecode">OpenIDE-Module-Name=My Server Module |
| OpenIDE-Module-Display-Category=J2EE |
| OpenIDE-Module-Short-Description=My Server Module |
| OpenIDE-Module-Long-Description=My Server Module</pre> |
| |
| <li>Right-click <tt>org.netbeans.modules.j2ee.myserver</tt> and choose New > File/Folder. Under Categories, |
| select Other. Under File Types, select Properties File. Click Next. Type <tt>Bundle</tt> in File Name and then |
| click Finish. Add the following properties to the <tt>Bundle.properties</tt> file: |
| |
| <pre class="examplecode">TXT_DisplayName=My Server |
| MSG_InstallerName=My Server Installer |
| MSG_CreateFailed=Cannot create {0} server instance. |
| MSG_MyServerPlatform=My Server Platform</pre> |
| |
| <li>Create another <tt>Bundle.properties</tt> file in the <tt>org.netbeans.modules.j2ee.myserver.nodes</tt> package, and |
| add the following properties to it: |
| |
| <pre class="examplecode">TXT_MyInstanceNode=My Server Instance |
| TXT_MyTargetNode=My Target Instance</pre> |
| |
| |
| </ol> |
| |
| <a name="server.gif"></a><h3 class="tutorial">Getting the Icon</h3> |
| |
| <p>Make sure that you have a 16x16 icon |
| named <tt>server.gif</tt> in the <tt>org.netbeans.modules.j2ee.myserver.resources</tt> package. |
| For example, you can find some 16x16 icons at the following location |
| within the IDE's installation directory: |
| |
| <pre class="examplecode">enterprise3\jakarta-tomcat-5.5.17\server\webapps\admin\images</pre> |
| |
| |
| </div> |
| <br /> |
| <!-- ======================================================================================= --> |
| |
| <h2><a name="building"></a>Building and Installing the Module</h2> |
| <p>The IDE uses an Ant build script to build and install your module. The build script is created for you |
| when you create the module project.</p> |
| <div class="indent"> |
| <h3 class="tutorial">Installing the Server-Skeleton Module</h3> |
| |
| <ul> |
| <li>In the Projects window, right-click the <tt>My Server Module</tt> project and choose Install/Reload |
| in Target Platform. |
| <p>The module is built and installed in the target IDE or Platform. The target IDE or Platform opens so that you |
| can try out your new module. The default target IDE or Platform is the |
| installation used by the current instance of the development IDE. Note that when you run your module, you will be using |
| a temporary test user directory, not the development IDE's user directory. |
| </ul> |
| |
| <h3 class="tutorial">Using the Server-Skeleton Module</h3> |
| |
| <ol> |
| |
| <li>Choose Tools > Server Manager, click Add Server and notice that a new server is available: |
| <p><img src="../images/tutorials/myserver/choose-server.png" alt="Choose my server."> |
| </p><p></p></li> |
| |
| |
| <li>Use the module as described in <a href="#introducing-sample">Introducing the Sample</a>. |
| </ol> |
| |
| </div> |
| |
| <!-- ======================================================================================== --> |
| |
| <h2><a name="addingserverspecific"></a>Adding Server-Specific Code</h2> |
| |
| <p>Before adding server-specific code, have a look at how others have done it. |
| <ol> |
| <p><li>Download the open-source server modules for JBoss, WebLogic, and WebSphere, following the instructions found |
| on the <a href="http://serverplugins.netbeans.org/">Server Plugins Project</a> page.</li> |
| <p><li>Open the sources of one or more of the downloaded server modules in the IDE and browse through them. For example, |
| if you open the sources of the JBoss module, the Projects window looks as follows: |
| <p><img src="../images/tutorials/myserver/jboss-server.png" alt="JBoss server in Projects window."> |
| <p>Note that in the illustration above, the selected files are those that are discussed in this tutorial. |
| </li> |
| <p><li>Examine the sources, using this tutorial and the <a href="https://netbeans.org/download/dev/javadoc/">NetBeans API List (Current Development Version)</a> to help you.</li> |
| |
| <p>Here are some j2eeserver API classes worth looking at: |
| |
| <p><ul><li><b>IncrementalDeployment.</b> |
| This interface allows modules to use |
| incremental deployment instead of the standard JSR-88 deployment. |
| <li><b>UISupport.</b> |
| This class provides support for showing the server |
| output in the Output window along with the toolbar |
| with the server state management actions.</ul> |
| |
| <p><li>Create your own server module! |
| |
| </ol> |
| |
| |
| <!-- ======================================================================================== --> |
| |
| <h2><a name="nextsteps"></a>Next Steps</h2> |
| |
| <p>For more information about creating and developing NetBeans modules, see the following resources: |
| <ul> |
| <p><li><a href="https://platform.netbeans.org/tutorials.html">Tutorials</a></li> |
| <p><li><a href="https://netbeans.org/download/dev/javadoc/">NetBeans API List (Current Development Version)</a></li> |
| </ul> |
| </p> |
| |
| |
| |
| <!-- ======================================================================================== --> |
| |
| <h2><a name="version"></a>Versioning and Known Issues in this Tutorial</h2> |
| |
| <p> |
| |
| <table width="76%" border="1"> |
| <tbody> |
| <tr> |
| <td> |
| <div align="left"><b>Version</b></div> |
| </td> |
| <td> |
| <div align="left"><b>Date</b></div> |
| </td> |
| <td> |
| <div align="left"><b>Changes</b></div> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| 1 |
| </td> |
| <td> |
| 25 June 2005 |
| </td> |
| <td> |
| Initial version |
| </td> |
| </tr> |
| <tr> |
| <td> |
| 2 |
| </td> |
| <td> |
| 4 July 2006 |
| </td> |
| <td> |
| Updated for NetBeans IDE 5.5, using diff from Stepan Herold. |
| Also: changed the download to the new module, |
| changed all screenshots, changed instances of "plugin" and "plug-in", where |
| relevant to "module", cleaned up a lot. <p>Following files are new or have undergone change |
| for 5.5: |
| <ul> |
| <li>New: ConfigurationSupportImpl.java and MyConfiguration.java</li> |
| <li>Deleted: DeploymentPlanSplitter.java</li> |
| <li>Changed: MyDeploymentManager.java, MyJ2eePlatformImpl.java, MyInstanceNode.java, |
| layer.xml, project.xml</li> |
| </ul> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| 3 |
| </td> |
| <td> |
| 10 August 2006 |
| </td> |
| <td> |
| <ul> |
| <li>Changed forward slash to backward slash in <tt>layer.xml</tt> |
| <li>Added period at end of his paragraph... |
| </ul> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| |
| </td> |
| <td> |
| |
| </td> |
| <td> |
| |
| </td> |
| </tr> |
| |
| </tbody> |
| </table> |
| |
| <p></p> |
| |
| <table width="76%" border="1"> |
| <tbody> |
| <tr> |
| <td> |
| <b>Issue Number</b> |
| </td> |
| <td> |
| <b>Description</b> |
| </td> |
| <td> |
| <b>Status</b> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| 1 |
| </td> |
| <td> |
| Code and tutorial itself need to be reviewed. Code needs to be tested |
| on multiple platforms. (Created on Windows XP, tested nowhere else yet. Tried |
| to avoid potential problems by avoiding spaces in names, etc.) |
| </td> |
| <td> |
| Done. |
| </td> |
| </tr> |
| <tr> |
| <td> |
| 2 |
| </td> |
| <td> |
| Tutorial needs to be updated once Phase III and IV are complete. |
| </td> |
| <td> |
| Done. |
| </td> |
| </tr> |
| <tr> |
| <td> |
| 3 |
| </td> |
| <td> |
| Some APIs used in this tutorial have deprecated methods. This will |
| produce errors in the Output window, but should not impact functioning |
| of module. |
| </td> |
| <td> |
| Fixed. |
| </td> |
| </tr> |
| <tr> |
| <td> |
| 4 |
| </td> |
| <td> |
| JSR 88 is helpful in understanding this module. However, this |
| JSR not yet been referred to in this tutorial. |
| </td> |
| <td> |
| To be fixed. |
| </td> |
| </tr> |
| <tr> |
| <td> |
| 5 |
| </td> |
| <td> |
| Javadoc links not yet provided for all classes and methods used in this module, |
| although most have been done already. |
| </td> |
| <td> |
| To be fixed. |
| </td> |
| </tr> |
| <tr> |
| <td> |
| 6 |
| </td> |
| <td> |
| Open questions, specific to version 2 of this tutorial: |
| <ul> |
| <li>How to make the server skeleton support Java EE 5? (Annotations, no deployment descriptors?)</li> |
| <li>Previous version was possible to select Start/Stop/etc. Why not anymore?</li> |
| <li>Migration path?</li> |
| <li>Why no more deploymentplansplitter?</li> |
| <li>Why now deployment descriptor goes to WEB-INF instead of META-INF?</li> |
| <li>Why has DeploymentFileNames in layer.xml moved?</li> |
| <li>Picture of JBoss at end to be changed too (does it use MyConfiguration.java, etc?</li> |
| </ul> |
| </td> |
| <td> |
| To be answered. |
| </td> |
| </tr> |
| |
| </tbody> |
| </table><p></p> |
| <hr><p></p> |
| </body> |
| </html> |