IBM WebSphere Developer Technical Journal: use Eclipse rich client platform and Rational Application Developer V6 create EJB client

Abstract: This article shows how to build a sample EJB client using the Eclipse Rich Client Platform (RCP), which has become increasingly popularity due to its extensible nature. Besides focusing on how to use Rational Application Developer to build an RCP application, this article also details how to configure an Eclipse RCP application to act as a J2EE application client.

INTRODUCTION

In recent years, as the preparation of an interactive development environment (IDE) tools framework - the popularity of the Eclipse platform have grown significantly. On the Eclipse 3.0 version, the same technology has been extended to support the development of rich client, to the Java developers to use their own sense of the concept can be extended to prepare the rich client platform code capacity.

Rich client development platform called Eclipse Rich Client Platform (RCP). Why highlight the rich client? In n-tiered architecture of the past few years, it is obvious to the development of the rich end-user experience using the browser application more difficult. Browser-based applications often through to JavaScript and HTML combined with a simulation of availability. However, it was clear the application procedures, and seek a richer experience than the use of more rich client technology platform better. Similarly, Eclipse RCP gave developers can create client applications to expand capacity, and these can be expanded client applications can still be added to n-tiered architecture. Eclipse RCP opening of the next generation of rich clients, and the rich client platform (such as IBM Workplace Client Technology) basis.

IBM Rational Application Developer V6 (formerly IBM WebSphere? Studio Application Developer) is based on the Eclipse 3.0 platform. This version of the J2EE developers can create applications with J2EE interactive rich client applications. In this article, we will use Rational Application Developer (hereinafter referred to as Application Developer) in the construction of functional Eclipse Eclipse RCP 3.0 client, they call the configuration in the Application Developer's WebSphere Application Server EJB test components in the environment.

In order to construct Eclipse RCP application, calling it a run on WebSphere Application Server V6 internal corporate bean, we will follow the general steps include:

Installed in WebSphere Application Server for the IBM Application Client. When the deployment of Java to the client workstation, you need to use WebSphere customers with the appropriate software running on WebSphere Application Server in the enterprise bean remote interactive. In this presentation we step configuration process.
The use of the J2EE Application Developer? Perspective in the deployment of WebSphere Application Server EJB temperature converter application, which includes the full functionality of WebSphere Application Server version to test your applications. Through Application Developer, you can with the default WebSphere Application Server examples communications, out of the deployment and management console application (you will need for this demonstration will be Enterprise Archive (EAR) into your work area). (For the sake of convenience we use Application Developer If you are using separate WebSphere Application Server, step is the same.)
The use of plug-in development environment Eclipse RCP Construction client. We will be configured to Eclipse plug-in starter and WebSphere Application Server Java thin client interactive, it is only with the IBM JDK server expansion, needs and WebSphere Application Server to communicate. We in the J2EE Application Client Container choose to do so because it provides a more simple configuration.
Export RCP applications and as an independent application to run. You need to know how to configure your plug-in relevance and JRE can use WebSphere Application Server thin client.

In order to carry out this practice, you need to:

Rational Application Developer V6 (or Eclipse 3)
WebSphere Application Server V6 (through some slight changes, you can also use Eclipse 3 and WebSphere Application Server V5)
In WebSphere Application Server for the IBM Application Client (including WebSphere Application Server V6,)
In this paper, including within the files. These instructions assume that will decompress to download files C: \ root directory.

J2EE application settings

The first thing we need to do is install the WebSphere Application Server for the IBM Application Client, which already included in the WebSphere Application Server V6 (If you do not have clients, you can change your configuration against Application Developer test in the server environment JDK) , and the next application will be deployed to running WebSphere Application Server:

J2EE applications through the use of client installation wizard interface to install. WebSphere running your installation after the start of the interface, select IBM Client for IBM WebSphere Application Server.
Follow the guide, we will install C: \ WebSphere6ND \ AppClient directory on. Download ZIP file in the Windows? Batch (BAT) documents the use of this type path; If you choose another directory, you must modify batch file instead invoked new directory. Figure 1 shows the interface guides the third of the directory of your choice.
We also choose a typical installation, and enter localhost as the host name, as shown in Figure 2.
Then we will be using the Application Developer EAR deployment to the WebSphere Application Server. (This is in order to facilitate the building and testing of the same work area from the plug-in you can only independent WebSphere Application Server configuration examples of applications, as with its dialogue has been configured Eclipse.)
Use Start menu opens Application Developer and find that, as C: \ RCPEJBClient \ workspace of the work area (Figure 3).
Welcome closed the default page (Figure 4).
If you can not find themselves there by default, switch to Switch to the J2EE perspective.
In the search box at the bottom of the view and right-click Servers WebSphere Application Server v6.0 (Figure 5). At this point, Application Developer will be tested WebSphere Application Server default instance is running.
The state should be restored to the "Stopped." Right-click and choose Start server (Figure 6). (You can find the same / Runtimes / profiles / default / bin start the server as well as the implementation startserver server1).
When activated the server, you can right-click the server and choose Run administrative console (or open the browser and visit http://localhost:9060/admin) operation and management console, as shown in Figure 7.
Landing to arbitrary user IDs (8).
Applications launched Festival and choose Install New Application (Figure 9).
Find C: \ RCPEJBClient choose TemperatureEAR.ear and then choose Next (Figure 10). TemeratureEAR application is the Celsius temperature from Fahrenheit temperature converted into simple method (although probably not very accurate).
Pages in the bundle (Figure 11), and chose to retain Next default values.
The next page, the application first step in the development process, select Deploy enterprise beans and then enter the next Step 7 Summary (Figure 12).
Step 7 in the dialog box, select the Finish (Figure 13). Installation requires one minute or two minutes (Figure 14).
Figure 14. Installation of a new application news
When installation is completed, select Save to Master Configuration (Figure 15).
In the preservation of the dialog box, select the Save (Figure 16).
Now, we will be launching applications. From the Applications menu, select Enterprise Applications (Figure 17).
Figure 17. Enterprise applications
Select Start TemperatureEAR then the next choice (Figure 18).
Figure 18. Enterprise applications
The corresponding status bar icon that should have started the application process (Figure 19).
The write-off management console (Figure 20).

RCP create client

We now have to create client applications RCP has been well prepared for, we will be through the use of Plug-in wizard will be used as a simple plug-in. When creating RCP applications, as reuse of the concerns you should always create a number of plug-ins. For example, you can rewrite the case on J2EE to create a single point of the correlation of plug-ins, another view components, as well as an RCP Shell. This allows reuse of different plug-in, for example, J2EE code. However, we will only have the sole use of plug-ins, fundamentally restrict the scope of this article.

Project to create plug-ins

In order to create a plug-in Application Developer projects, from J2EE Perspective, select File => New => Other (21).
In New Project Wizard, identifying choose Show All Wizards. Expanding Plug-in Development and select Plug-in Project (Figure 22).
At this point, to the development of plug-ins you may be opening Plug-tips (Figure 23). If this is the case, select OK.
In Create a new plug-in project in the dialog box (Figure 24), and name of the item: com.ibm.issw.temperature.form. This is a very common plug-naming convention. Make sure you choose the options as shown in Figure 24:
- Because you are adding Java code so you plug the project will also Java project.
- In Eclipse 3.0, you want to use to set up your list of documents related to operation, we have chosen to use of the inventory documents.
Next choice.
The next dialog box, shown in Figure 25 plug-in data implantation, the next choice Next.
We will be using the template build plug-ins. We will build on the future view of the plug-in, select Plug-in with a view and then the next choice Next (Figure 26).
The next dialog box, we will be defined on the View class information. Figure 27 shows in full accordance with input information, the next choice Next.
Finally, in the View Features dialog box (Figure 28), the withdrawal of all the features of choice. (We will view into our own category.) Choose Finish.
Ref asked us to switch to the Plug-in Development Perspective time (Figure 29), select Yes.

J2EE JAR and import EJB client JAR

Now we will be the two JAR into our new plug-in:

J2ee.jar - Plug-ins and EJB client API for interactive, and thus in your class path you need j2ee.jar.
EJB client JAR - contains the necessary client interface, and generates a proxy server connectivity and appropriate operation of the branch line enterprise beans.

In Application Developer, right-click and choose Import plug-in project (Figure 30).
Select File System and then the next choice Next (Figure 31).
There can be a number of you j2ee.jar place. RCP will be used because the running IBM Application Client for WebSphere Application Server, it's best to use JAR, you can / Lib find it, as shown in Figure 32. J2ee.jar identified is the only option. (If you use plug-ins other WebSphere API, such as WebSphere programming model extension, you will also need to be imported, otherwise you do not import other WebSphere runtime JAR in operation during the period, generated EJB agent server code and client code loading containers loaded with WebSphere thin clients in the class library category.) If you have not installed client software, you can from the / Runtimes/base_v6/lib or / Lib was j2ee.jar.
Next, we need to import EJB JAR client, it is necessary long-distance calling code for EJB JAR file. The document includes EJB client interface and has generated RMI / IIOP code. (If you are constructing their own EJB application, you can Application Developer adopted by the right-click your EJB projects and choose Create EJB Client Jar generation client JAR) for this use, download file provided EJB client JAR. Use file system option into JAR file, as mentioned above, to C: \ RCPEJBClient then select TemperatureEJBClient.jar. (Figure 33)
Now we plug the project should include two JAR file, as shown in Figure 34.
Figure 34. Import JAR
We now need to set up the work area in the building, and compile-time type path. This will enable plug-ins in the Eclipse IDE code both internally in the process of constructing automatically compile successfully. Construction at the Class path information in the plug-in configuration editor Build Section updated. Select Build tab, as shown in Figure 35.
Binary Build part to the location (Figure 36) and choose the JAR file shown in the picture. If you choose to implement binary plug-in Construction, JAR need to include in the Build within. For this application, in order to run Eclipse RCP application will be copied manually plug-ins.
As for the success of compiled code, you need to add to JAR compile-time type path. You can add to Build JAR will be at the bottom of some Extra Classpath Entries completed in the middle of this content (Figure 37). This will update the Eclipse Project Build Path.
Construction of the changes pages updated build.properties file. You can choose build.properties tab browsing the document.
As you find and J2EE EJB client runtime code plug code, it needs to add to the plug-in type running path. Through plug-in configuration editor to complete, the editor has tacitly agreed that the way open. (If not, double-click the plug-in.xml open.) Select Runtime tab, and in the running of the library, select the Add button (Figure 37) and then you just add into the JAR.

Running dialog updated plug-in MANIFEST.MF document. And J2EE application procedure is similar to the definition of the list of running path. You can position the View tab MANIFEST.MF list.

SWT to use small window layout view Construction

Now we will have to build view. Download file provided in the View class. We will import such (loading our view templates generated by the class) and then test the relevant parts of the code. Start, we need to define our plug-ins rely on plug-ins. We will be in the view window on the use of standard components toolkit (SWT) layout small window, so we need to set up a small window layout, including the Eclipse plug-in relevance.

Dependencies tab and then choose Select Add (Figure 39). Positioning org.eclispe.ui.forms plugin.
Import download file in the View class, loading generated by the category. In the src folder, right-click com.ibm.issw.temperature.form.views package, and then select Import (Figure 40).
Select File System and then the next choice Next. View directory C: \ RCPEJBClient \ View, and will be three documents into package, as shown in Figure 41.
You should be loading existing category to be a warning. Yes To All options (Figure 42).
Open import of TemperatureView.java (Figure 43).
We will focus on two methods (Figure 44):
- CreatePartControl (combinations) - used to build your SWT different from the small window view.
- HandleEvent () - inner category, click on SWT provides a small window when the command button called logic.
CreatePartContol () method as shown in a list. FormToolkit category code used to create the components on Father components in the circumstances, to create the necessary tags, buttons, and text boxes, and will assign button for interception. View is the interception of the internal category.
List 1 <table bgcolor="#eeeeee" width="100%" cellpadding="5" cellspacing="0" border="1"> <tr> <td>
Public void createPartControl (Composite parent) (= new FormToolkit toolkit (parent.getDisplay ()); form = toolkit.createScrolledForm (parent); form.setText (RcpMessages.getString ( "TemperatureView.Title")); GridLayout layout = new GridLayout (2, false); form.getBody (). setLayout (layout); Label label = toolkit.createLabel (form.getBody (), "Enter temperature in Celsius:"); Text textBox = toolkit.createText (form.getBody ( ), "", SWT.BORDER); GridData gdText = new GridData (8); textBox.setLayoutData (gdText); Button button = toolkit.createButton (form.getBody (), RcpMessages.getString ( "TemperatureView.Button") SWT.PUSH); Label result = toolkit.createLabel (form.getBody (), ""); result.setLayoutData (new GridData (GridData.FILL_HORIZONTAL)); MyListener listener = new MyListener (); listener.setInput (textBox); listener.setResult (result); listener.setParent (parent); listener.setFormToolkit (toolkit); button.addListener (SWT.Selection, listener);)
</ Td> </ tr> </ table>
Internal methods of dealing with incidents such as the list of 2 below. In this category, read the text box, as well as the value of the use of EJB client API calls EJB. Code View EJB home and remote access interface. Next call with the results and the method of filling results labels. (Remember, the best EJB call will be assigned after hiding in the business rather than plug-in code called directly. On paper, we have simplified the code. Usually not recommended from the view of directly invoking EJB.)
List 2. <table Bgcolor="#eeeeee" width="100%" cellpadding="5" cellspacing="0" border="1"> <tr> <td>
Public void handleEvent (Event event) (try (InitialContext ctx = new InitialContext (); String jndi = RcpMessages.getString ( "TemperatureView.JNDIName"); Object obj = ctx.lookup (jndi); TempConverterHome homeRef = (TempConverterHome) PortableRemoteObject. narrow (obj, TempConverterHome.class); TempConverter serviceRef = homeRef.create (); retVal = serviceRef.celciusToFarenheight (Integer.parseInt (textBox.getText ())); System.out.println ( "TemperatureAction.testEJB EJB Successful Return = "+ + retVal); result.setText (textBox.getText () +" degrees Celsius is approximately "+ Integer.toString (retVal) +" degrees Fahrenheit! ");) catch (Exception th) (System.out.println ( "TemperatureAction.testEJB EJB call ex =" + th); th.printStackTrace (); result.setText (th.getClass (). getName () + ":" + th.getMessage ());))
</ Td> </ tr> </ table>
Maybe you have already noted that a document attribute is used to avoid EJB JNDI name of the hard-coded application server, as well as the positioning. When deploying RCP application, you can change the file attributes will be against the actual EJB remote location.
List 3 <table bgcolor="#eeeeee" width="100%" cellpadding="5" cellspacing="0" border="1"> <tr> <td>
TemperatureView.JNDIName = ejb / TempConverter TemperatureView.Title = Celsius to Fahrenheit Temperature Converter TemperatureView.Button = Convert to Fahrenheit
</ Td> </ tr> </ table>
When building plug-ins, you usually need to add plug-ins to your plug-in.xml document and choose expansion point (in which case, you extend the plug-View). For us, this is an additional, because we use in the wizard View template. You can see the Extensions tab, or you can browse plug-in.xml resources. 4 configuration such as expansion of the list indicated.
List 4 <table bgcolor="#eeeeee" width="100%" cellpadding="5" cellspacing="0" border="1"> <tr> <td>

point=”org.eclipse.ui.views”>
name=”Temperature Category”

id=”com.ibm.issw.temperature.form”>
name=”Temperature View”

icon=”icons/sample.gif”

category=”com.ibm.issw.temperature.form”

class=”com.ibm.issw.temperature.form.views.TemperatureView”

id=”com.ibm.issw.temperature.form.views.TemperatureView”>
</ Td> </ tr> </ table>

Create your own table and RCP Perspective

RCP because we are developing applications, the use of the default Eclipse workstations, workstation is customized according to IDE, it is not very satisfactory. Therefore, we will build our own table, as well as perspective drawing. We will import category, download document provides these categories, we have to plug into, the next perspective to the table as well as the plug-in.xml add entries.

Right-click src folder and select Import (Figure 45).
Select File system then select Next. Browse to C: \ RCPEJBClient \ RCPCode \ src folder and into three categories, as shown in Figure 46.
Class will be imported (the default packet), it is root (Figure 47).
Let us test these categories:
- RcpWorkbenchAdvisor - we used to create the table. Set up a kind of code configuration, such as size and the title, and banned some of the default.
  5 list <table bgcolor="#eeeeee" width="100%" cellpadding="5" cellspacing="0" border="1"> <tr> <td>
  Public class RcpWorkbenchAdvisor extends WorkbenchAdvisor (public String getInitialWindowPerspectiveId () (return "MyRCPPerspective";) public void preWindowOpen (IWorkbenchWindowConfigurer configurer) (super.preWindowOpen (configurer); configurer.setInitialSize (new Point (750, 600)); configurer.setShowCoolBar ( false); configurer.setShowStatusLine (false); configurer.setTitle ( "Temperature Converter");))
  </ Td> </ tr> </ table>
- MyRCPPerspective - add to the perspective view. This is the perspective of the initial layout. Construction of the paper because we do not have the plug-in editing so code also prohibited editor region.
  Inventory <table bgcolor="#eeeeee" width="100%" cellpadding="5" cellspacing="0" border="1"> <tr> <td>
  Public class MyRCPPerspective implements IPerspectiveFactory (public void createInitialLayout (IPageLayout layout) (layout.addView ( "com.ibm.issw.temperature.form.views.TemperatureView" IPageLayout.LEFT, 0.66f, IPageLayout.ID_EDITOR_AREA); layout.setEditorAreaVisible (false);))
  </ Td> </ tr> </ table>
- Platform - the main RCP applications category. Created a table and started RCP applications.
  7 list <table bgcolor="#eeeeee" width="100%" cellpadding="5" cellspacing="0" border="1"> <tr> <td>
  Public class TempRCPApplication implements IPlatformRunnable (public Object run (Object args) throws Exception (WorkbenchAdvisor workbenchAdvisor = new RcpWorkbenchAdvisor (); PlatformUI.createDisplay Display display = (); try (int returnCode = PlatformUI.createAndRunWorkbench (display, workbenchAdvisor); if (returnCode == PlatformUI.RETURN_RESTART) (return IPlatformRunnable.EXIT_RESTART;) else (return IPlatformRunnable.EXIT_OK;)) finally (display.dispose ();)))
  </ Td> </ tr> </ table>
Add on the current code, we need to add it to our plug-in to in.xml. Choose Extension tab, and then select Add the following (Figure 48).
Because we are in the preparation of applications, we need to expand org.eclipse.core.runtime.applications (Figure 49).
Select Finish.
In the Extension Details dialog box, add a logo RcpApplication (Figure 50).
Right-click and choose New extend points => application (Figure 51).
Right-click (application) and select New => run (Figure 52).
In the Extension Element Details dialog box, browse TempRCPApplication category (Figure 53). .
Adding perspective, add other options to expand and extend org.eclipse.ui.perspectives point (Figure 54).
Right-click on the point and choose New => perspective (Figure 55).
In the Extension Element Details, as shown in Figure 56 of perspective here:
Updated logo to comply with the class name (Figure 57):
Now for the performance should be extended as shown in Figure 58. By choosing File => Save or Ctrl-S plug-in configuration preservation.

In other words, you can manually add it to direct plug-in.xml document, as shown in the list 8. Additional code as shown in bold type:

8 list <table bgcolor="#eeeeee" width="100%" cellpadding="5" cellspacing="0" border="1"> <tr> <td>

point=”org.eclipse.ui.views”>

name=”Temperature Category”

id=”com.ibm.issw.temperature.form”>

name=”Temperature View”

icon=”icons/sample.gif”

category=”com.ibm.issw.temperature.form”

class=”com.ibm.issw.temperature.form.views.TemperatureView”

id=”com.ibm.issw.temperature.form.views.TemperatureView”>

point=”org.eclipse.core.runtime.applications”>

point=”org.eclipse.ui.perspectives”>

class=”MyRCPPerspective”

name=”com.ibm.issw.temperature.form.perspective1″

id=”MyRCPPerspective”/>

</ Td> </ tr> </ table>

Test your RCP EJB client

We have now run for the RCP EJB prepared for the client. We will be the first from within the RCP Application Developer Application Program unit testing. Next we will be derived for the plug-in development environment and run its external set.

Application Developer internal testing

On the Eclipse version 3.0, you can run plug-ins to create launch configurations. These launch configuration in order to use WebSphere V6 JRE need to set up (including the IBM Application Client for WebSphere Application Server and WebSphere Application Server), conducted by Perspective Preferences added. However, instead of using Eclipse, but we will be using the Application Developer, which has been installed JRE.

Application Developer from the main menu, select Run => Run …. (Figure 59).
In Launch Configuration Wizard, select Run-time workbench and New (60).
MyRCPClient configuration for the naming. Program to Run in part, select your plug-ins, for running applications, choose com.ibm.issw.temperature.form.RcpApplication, JRE choose WebSphere v6 JRE (Figure 61).
For VM arguments through C: \ RCPEJBClient \ Snippet1.txt provided by the code (list 9) Enter the code shown in Figure 61. Can not run. VM arguments against installation of IBM Application Client for WebSphere Application Server directory. If you install it in a different directory is the use of that directory. Otherwise, the use of positioning in Application Developer / Runtimes/base_v6's WebSphere examples.
List 9 <table bgcolor="#eeeeee" width="100%" cellpadding="5" cellspacing="0" border="1"> <tr> <td>
Corbaloc-Djava.naming.provider.url =:: = localhost-Djava.naming.factory.initial com.ibm.websphere.naming.WsnInitialContextFactory-Dserver.root = C: \ WebSphere6ND \ AppClient-Dcom.ibm.CORBA.ConfigURL = file: C: \ WebSphere6ND \ AppClient / properties / sas.client.props-Djava.ext.dirs = "C: \ WebSphere6ND \ AppClient \ java \ jre \ lib \ ext; C: \ WebSphere6ND \ AppClient \ java \ jre \ lib; C: \ WebSphere6ND \ AppClient \ classes; C: \ WebSphere6ND \ AppClient \ lib; C: \ WebSphere6ND \ AppClient \ lib \ ext; C: \ WebSphere6ND \ AppClient \ properties
</ Td> </ tr> </ table>
In the Plug-in tab, we need to include our new plug-ins rely on plug-ins. We can easily follow through shown in Figure 62 hits to complete this sequence content.
Select Apply, then choose Run. Client should be similar to Figure 63.
Import value, and then select Convert to Farenheit.
Should show results, with 64 similar plans. (First time will be spent than later quoted a longer time, because it needs to establish initial WebSphere Application Server communication.)

Construction and operation of the RCP Application Developer external applications

In order to run Application Developer external RCP applications, we will need to use Export Wizard plugin. 3 versions of the Eclipse, there are no RCP application of the export mechanism, but you can use the binary build complete this process. For the purpose of teaching, we will be able to conduct deployment.

Right-click and choose Export Plugin project (Figure 65).
In the Export dialog box (Figure 66) choice deployable plug-ins and fragments, and then select Next.
Plug-ins can be deployed from the dialog box, select clips and the plug-in, select their configured as a directory structure, the next in the directory on its configuration shown in Figure 67. Select Finish.
PDE will be running derived Wizard (Figure 69).
BAT documents we need to start applications. For the sake of simplicity, provided by the download file. BAT file will be from the C: \ RCPEJBClient \ MyRCPApp.bat export plug-in to your copy of the directory.
BAT document will be used by client applications JRE (assuming that the IBM Client for WebSphere Application Server in C: \ WebSphere6ND \ AppClient Otherwise, in order to replace the directory through the application procedures for updating the initial client variables and updated scripts, or for WebSphere Application If you do not use Server Client).
(We test WebSphere Application Server Base on the RCP applications. If, in the production, you will be deployed in clusters called EJB applications, parameters corbaloc Djava.naming.provider.url =:: localhost should have said that as Such a cluster: corbaloc:: :
,: :
URL. )
List of 10 <table bgcolor="#eeeeee" width="100%" cellpadding="5" cellspacing="0" border="1"> <tr> <td>
Set WAS_CLIENT_HOME = C: \ WebSphere6ND \ AppClient start WAS_CLIENT_HOME%% \ java \ jre \ bin \ javaw-Djava.naming.provider.url = corbaloc:: = localhost-Djava.naming.factory.initial com.ibm.websphere.naming . WsnInitialContextFactory-Dserver.root =% WAS_CLIENT_HOME%-Dcom.ibm.CORBA.ConfigURL = file:% WAS_CLIENT_HOME% / properties / sas.client.props-Djava.ext.dirs =% WAS_CLIENT_HOME% \ java \ jre \ lib \ ext ;% WAS_CLIENT_HOME% \ java \ jre \ lib;% WAS_CLIENT_HOME% \ classes;% WAS_CLIENT_HOME% \ lib;% WAS_CLIENT_HOME% \ lib \ ext;% WAS_CLIENT_HOME% \ properties-cp startup.jar org.eclipse.core.launcher.Main - application com.ibm.issw.temperature.form.RcpApplication
</ Td> </ tr> </ table>
Because we personally derived plug-ins, there is a need from our Eclipse installation directory replication startup.jar basis, as well as plug-ins. In Application Developer, based positioning Eclipse Application Developer installation directory to the directory eclipse (69).
Paste startup.jar to configure plug-in directory.
Next, copy the necessary plug-ins:
- Org.eclipse.core.expressions_3.0.0
- Org.eclipse.core.runtime_3.0.1
- Org.eclipse.help_3.0.0
- Org.eclipse.jface_3.0.0
- Org.eclipse.osgi_3.0.1
- Org.eclipse.platform_3.0.1.1
- Org.eclipse.swt.win32_3.0.1
- Org.eclipse.swt_3.0.1
- Org.eclipse.ui.forms_3.0.0
- Org.eclipse.ui.workbench_3.0.1.1
- Org.eclipse.ui_3.0.1
- Org.eclipse.update.configurator_3.0.0
Remember, you can use the script or binary Construction of the building so that the ANT process automation.
MyRCPApp.bat run through applications. (Once again, the initial request later than the request to spend a longer time.)

Concluding remarks

This article describes how to use the Eclipse Rich Client Platform (RCP) Construction EJB client applications. Eclipse platform, including a large number of windows, view, the framework (for example, Eclipse Modeling Framework), as well as other can be used to build strong client application's expansion. Learn how to get the Eclipse RCP applications with the WebSphere Application Server integration build an integrated client applications is essential.

Thanks

Author Wayne Beaton heartfelt thanks to the scrutiny of this article and Improvement.

Download

<table Width="100%" class="data-table-1" cellspacing="0" cellpadding="0" border="0"> <tr> <th> Description </ th> <th> name </ th> <th style="text-align:right;"> size of </ th> <th> download </ th> </ tr> <tr> <td class="tb-row"> Sample Rich Client Platform application </ td> <td nowrap="nowrap"> RCPEJBClient.zip </ td> <td style="text-align:right;" nowrap="nowrap"> 1.6 MB </ td> <td nowrap = "nowrap ">? FTP | HTTP </ td> </ tr> </ table> <table cellspacing="0" cellpadding="0" border="0"> <tr valign="top"> <td colspan =" 5 "> </ td> </ tr> <tr> <td> </ td> <td> information on the download </ td> <td> </ td> <td> </ td> <td> Get Adobe ® Reader ® </ td> </ tr> </ table>
<table Border="0" cellspacing="0" cellpadding="0" width="100%"> <tr> <td>
</ Td> </ tr> </ table> <table class="no-print" cellspacing="0" cellpadding="0" align="right"> <tr align="right"> <td>
<table Border="0" cellpadding="0" cellspacing="0"> <tr> <td valign="middle">
</ Td> <td valign="top" align="right"> </ td> </ tr> </ table> </ td> </ tr> </ table>

About the author <table border="0" cellspacing="0" cellpadding="0" width="100%"> <tr> <td colspan="3"> </ td> </ tr> <tr align = " left "valign =" top "> <td>

</ Td> <td> </ td> <td width="100%">

Roland Barcia is located in the New York / New Jersey Metro area of the IBM Software Services for WebSphere's IT consultants. He is books IBM WebSphere: Deployment and Advanced Configuration one of the authors.

</ Td> </ tr> </ table>
<table Border="0" cellspacing="0" cellpadding="0" width="100%"> <tr> <td colspan="3"> </ td> </ tr> <tr align = "left" valign = "top"> <td>

</ Td> <td> </ td> <td width="100%">

Patrick Nogay is IBM Software Services for WebSphere's IT consultants.

</ Td> </ tr> </ table>

â†‘ Back

Share and Enjoy: These icons link to social bookmarking sites where readers can share and discover new web pages.