|Publication number||US7734677 B2|
|Application number||US 11/536,182|
|Publication date||Jun 8, 2010|
|Filing date||Sep 28, 2006|
|Priority date||Sep 29, 2005|
|Also published as||US20080244623|
|Publication number||11536182, 536182, US 7734677 B2, US 7734677B2, US-B2-7734677, US7734677 B2, US7734677B2|
|Inventors||Thomas Graser, Matthias Haeussler, Bernd Jostmeyer, Juergen Schneider|
|Original Assignee||International Business Machines Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (9), Classifications (6), Legal Events (4)|
|External Links: USPTO, USPTO Assignment, Espacenet|
1. Field of the Invention
The present invention relates to management of distributed computing environments consisting of application servers and Backend Systems that may reside on multiple nodes, and particularly to a method and respective system for dynamically integrating Backend Systems into a J2EE application server environment.
2. Description of Background
Software system architectures that consist of Backend Systems, application servers, and client applications are called three-tier architectures. To cope with various challenging aspects of the development and deployment of such software architectures, the Java2 Enterprise Edition (J2EE) standard has been defined by Sun Microsystems, with assistance by many other contributors. It consists of a set of sub-standards, each of which describes one key aspect that an application server that conforms to the J2EE standard has to comply to. Implementations of the J2EE standard include IBM WebSphere, BEA WebLogic, and SAP NetWeaver.
One of those sub-standards is the Java2 Connector (J2C) architecture, which defines some system contracts and interfaces that describe how legacy Backend Systems should be attached to a J2EE application server. Those Backend Systems do typically not implement the J2EE standard themselves, but they provide a connector (J2C connectors A, B, C—see
The term “Backend System” is used as a synonym to “Enterprise Information System” (EIS). Typically, these Backend Systems are software applications that may used to store or retrieve data, like databases or transaction systems. However, any server application may be attached to the J2EE application server as a Backend System instance, such that the applications running within the J2EE application server are able to drive all kinds of requests against the Backend System instance that are supported.
In order to add Backend System instances A1-A3 to the scope of the J2EE application server, typically an administrator has to deploy the appropriate JC2 connectors A1-A3 (see
Analogously, in order to remove a particular instance of a Backend System instance from the scope of the J2EE application server, typically an administrator has to remove the previously entered data for that particular Backend System instance.
For the purposes of J2EE application server system administration, the type of Backend Systems is coupled with the identification and access data for the individual Backend System instance, thus requiring that the J2EE application server is restarted each time when a Backend System instance is added or removed.
For J2EE application servers that have the need to interact with a highly dynamic set of Backend Systems, this administrative effort for each Backend System instance is unacceptable. For example, systems management applications have to be able to include and exclude an unpredictable set of Backend Systems of the same type without a service interrupt of the systems management application itself. It is quite common that systems are added and removed over time (within a daily, weekly, or other schedule) as the business needs demand various levels of computing capacity. This is particularly true as businesses increasingly adapt “on demand” technologies into their core processes.
To provide high availability of the application server under these circumstances, one typically deploys the application in a clustered environment. When topology updates have to be made, then one of the cluster nodes is modified at a time, while the other nodes remain online. This procedure is called “rolling update”.
However, if there are no other compelling reasons to build a clustered environment than the ability to provide rolling updates when the topology changes, then this solution is far too expensive, since the cluster infrastructure itself needs to be purchased, deployed, and maintained.
Consequently, it is desirable to provide a method and system for adding, using, removing Backend System instances belonging to the same type of Backend System—which does not conform to the J2EE specification —to or from a J2EE application server environment during runtime without restarting the J2EE application server.
The shortcomings of the prior art are overcome and additional advantages are provided through a method, system and program product for dynamically integrating Backend System instances into a J2EE application server environment, is introduced. The method comprises deploying a J2C connector suitable for Backend System instances belonging to the same type of Backend Systems (A; B; C) into the J2EE application server environment by using a J2C deployment descriptor which does not contain properties for identifying and connecting to a Backend System instance (A1-A3; B1-B3; C1-C3; access data); restarting the J2EE application server; detecting availability of Backend System instances (A1-A3; B1-B3; C1-C3); determining access data to said Backend System instances; persistently storing the access data; reading the access data and passing them as a part of a request to said J2C connector (A; B; C) in any case an operation on the particular Backend System instance has to be performed; and automatically creating a connection with said particular Backend System instance by the J2C connector (A; B; C) at runtime without restarting said J2EE application server.
In one embodiment, the method, system and program product replaces a prior art concept of deploying an own J2C connector for each Backend System instance requiring a restart of the J2EE application server each time a new Backend System instance is added by a J2C connector per type of Backend Systems requiring a single restart of the J2EE application server only. This is achieved by following adaptations and extensions: The deployment descriptor of the J2C connector does not contain properties related to the identification of Backend System instances, so there is no need anymore to provide manually identification information for accessing a particular Backend System instance during the J2C connector deployment.
The identification information is automatically provided to the J2EE application server at runtime by a newly introduced component—Join/Leave manager. The Join/Leave manager has access to the identification data and provides them to the business application running in the J2EE application server.
In one embodiment, the business application provides the new functionality to store, access and use those identification data for each Backend System instance. Therefore it is no longer needed to restart the J2EE application server each time a new Backend System instance is added or removed but only once when the J2C connector is deployed.
Additional features and advantages are realized through the techniques of the present invention. Other embodiments and aspects of the invention are described in detail herein and are considered a part of the claimed invention. For a better understanding of the invention with advantages and features, refer to the description and to the drawings.
The subject matter which is regarded as the invention is particularly pointed out and distinctly claimed in the claims at the conclusion of the specification. The foregoing and other objects, features, and advantages of the invention are apparent from the following detailed description taken in conjunction with the accompanying drawings in which:
The present invention shows that by providing J2EE application code that uses other subsystems that exist in any J2EE application server, these missing access data (data for identifying and connecting to a Backend System instance) may be dynamically entered into the system, used by the system, and removed from the system at runtime without any further need to restart it. Effectively, that J2EE application provides a registry of Backend System instances.
As seen in
An application or its subcomponent that additional implements interfaces for adding access data to, and deleting from a data base, and for automatically reading the access data from the database and providing them to the common J2C connector for creating a connection with a Backend System instance at run-time in any case an operation on a particular Backend System instance has to be performed.
Java Messaging System (JMS) for sending and receiving messages, e.g. receiving access data from newly introduced Join/Leave Manager and sending them to Message Driven Beans being part of the application.
Enterprise Java Beans (EJB) for client application access and various server programming patterns. This includes “entity beans” with Container Managed Persistence (CMP), which can be used to store data persistently (e.g. access data for identifying and connecting to Backend System instances). In addition, this includes Message Driven Beans (MDB) that can be used to receive and process JMS messages.
Finally, a software component called “Join/Leave Manager” is newly introduced. It is not part of the J2EE standard. The Join/Leave Manager obtains knowledge about the availability status of the Backend System instances. With availability status, it is meant the status if the Backend System instance is supposed to be available to the EJB application or if it should not be available at a given time.
It is not relevant for this invention how or when the Join/Leave manager obtains this information. It may rely on input by an administrator or by an automatic detection method.
In a first embodiment the Join/Leave Manager may be embedded into the Backend System instance itself, so that there are Join/Leave managers that each monitors a single Backend System instance only. The availability of each Join/Leave Manager directly reflects the availability of the corresponding Backend System instance.
A further embodiment the Join/Leave Manager is provided as a stand-alone application that reads data from a file or database which identify the Backend System instances to be available for use by the business application. Those data may be manually provided.
A further embodiment the Join/Leave Manager is provided as a stand-alone application that scans the accessible systems in the distributed environment for Backend System instances, e.g. by testing the availability of particular port numbers and by running a test statement against those ports resulting in confirmation that this system and port actually provide the entry-point to a Backend System instance.
Whenever a Backend System instance A1-A3; B1-B3; C1-C3 should become visible to or invisible from the EJB application, then the Join/Leave Manager sends an appropriate JMS message to a well-known JMS destination (see
As long as the data that identifies a particular Backend System instance is available in the registry, the EJB application may present this fact to a client application, or use the information internally only, depending on the application logic.
Whenever some client application or the EJB application itself have the need to contact the Backend System instance and perform some operation against it, then the EJB application may look up the information that is stored in the registry, and pass it to the J2C connector. It uses the information to create a connection to the Backend System instance identified by those data, and forwards the operation request to the Backend System instance. This flow is described in more detail below (
A further embodiment of the present invention the use of JMS and MDB in order to provide join and leave events to the EJB application are not mandatory. Instead, it is also possible to provide appropriate EJB methods within the EJB application that may be called by the Join/Leave manager whenever a Backend System instance joins or leaves.
To understand the crucial difference between the prior art J2C connector and the J2C connector that implements the invention, note that the ConnectionRequestInfo interface is empty, and the J2C specification states that the implementing class typically contains client-specific properties, for example, user name, password, language. Typically, it does not contain properties related to the configuration of a target Backend System instance like server name or port number (see J2C specification version 1.5, section 22.214.171.124). Instead, those data that identify a Backend System instance are kept within the instance of ManagedConnectionFactory itself. The J2C connector's deployment descriptor defines which properties are required by the ManagedConnectionFactory, and an administrator has to provide values that relate to the actual Backend System instance at deployment time (see J2C specification version 1.5, sections 17.4.1 and 17.4.2).
The invention proposes to implement these two aspects differently during development of a J2C connector that is capable of the dynamic behaviour described above: The implementation of the ConnectionRequestInfo interface should contain properties related to the configuration of a target Backend System instance, in addition to any other data that the application needs to identify the client. Therefore, the J2C connector's deployment descriptor does not need to contain those properties, and no related values need to be provided at the time of deployment.
Step 1: The Join/Leave Manager detects or decides otherwise that the Backend System instance A1 is available for use by the EJB application. The business rules or event types that trigger this step are outside the scope of this invention.
Step 2: The Join/Leave Manager creates a JMS message that includes connection information (access data) about the Backend System instance A1. This JMS message is published to a well-known JMS destination.
Step 3: Since an MDB contained in the EJB application is configured to listen to the same JMS destination, the MDB's onMessage method is invoked, and the JMS message is passed in. Step 4: The MDB analyzes the message and creates an entity EJB that contains some or all of the information contained in the message.
Step 5: The data contained in the entity EJB are inserted in the database. The preferred embodiment is to delegate this responsibility to the EJB container by using the Container Managed Persistence (CMP) pattern. Alternatively, one could also use the Bean Managed Persistence (BMP) pattern.
As an optional extension, the MDB may validate the correctness of the information contained in the JMS message by using it to establish a connection to the Backend System instance A1 before creating the entity EJB, as indicated by the dashed arrows.
Step 1: Some client application invokes a session bean request in the EJB application that either directly or indirectly creates the need to contact Backend System instance A2.
Alternatively, the need to contact Backend System instance A2 could arise while processing some JMS message, or while processing a timer-based event. In these cases, the flow is not triggered explicitly by a client application but by some other means.
Step 2: The Session Bean finds the Entity Bean that is related to Backend System instance A2.
Step 3: Finding an Entity Bean translates to selecting a row from the related database.
Step 4: As described in more detail in
Steps 5 and 6: Using the connection to the Backend System instance A2, some operation request is passed to the Backend System instance A2.
Step 1: The Join/Leave Manager initiates the process and decides that the Backend System instance A2 should leave the Backend Systems topology known to the EJB application, based on some rules or events that are outside the scope of this invention.
Step 2: The Join/Leave Manager creates a JMS message that includes identification information about the Backend System instance A2, and that it should be removed. This JMS message is published to a well-known JMS destination.
Step 3: Since an MDB contained in the EJB application is configured to listen to the same JMS destination, the MDB's onMessage method is invoked, and the JMS message is passed in. Step 4: The MDB analyzes the message, and finds and removes the entity EJB that relates to the information contained in the message.
Step 5: The table row related to the entity EJB is deleted from the database. The preferred embodiment is to delegate this responsibility to the EJB container by using the Container Managed Persistence (CMP) pattern. Alternatively, one could also use the Bean Managed Persistence (BMP) pattern.
While the preferred embodiment to the invention has been described, it will be understood that those skilled in the art, both now and in the future, may make various improvements and enhancements which fall within the scope of the claims which follow. These claims should be construed to maintain the proper protection for the invention first described.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US7080092 *||Oct 15, 2002||Jul 18, 2006||Bea Systems, Inc.||Application view component for system integration|
|US7546606 *||Oct 15, 2002||Jun 9, 2009||Bea Systems, Inc.||System and method using a connector architecture for application integration|
|US20040045008 *||Feb 13, 2003||Mar 4, 2004||June Deborah C.||J2ee connector architecture|
|US20040078495 *||Jul 11, 2003||Apr 22, 2004||Richard Mousseau||System and method for implementing J2EE connector architecture|
|US20040098726 *||May 29, 2003||May 20, 2004||International Business Machines Corporation||JMS integration into an application server|
|US20050028164 *||Jul 29, 2003||Feb 3, 2005||Sbc Knowledge Ventures, L.P.||J2EE enterprise information system (EIS) common object request broker architecture (CORBA) connector|
|US20050044197 *||Aug 18, 2003||Feb 24, 2005||Sun Microsystems.Inc.||Structured methodology and design patterns for web services|
|US20060053087 *||Jun 8, 2004||Mar 9, 2006||Pavlov Vladimir K||System and method for deploying enterprise components using deployment descriptors|
|US20060069801 *||Feb 9, 2005||Mar 30, 2006||Rich Charles R||Method and apparatus for identifying and classifying network-based distributed applications|
|U.S. Classification||709/201, 719/328|
|International Classification||G06F15/16, G06F9/44|
|Oct 25, 2006||AS||Assignment|
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION,NEW YO
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:GRASER, THOMAS;HAEUSSLER, MATTHIAS;JOSTMEYER, BERND;AND OTHERS;REEL/FRAME:018431/0180
Effective date: 20061004
|Jan 17, 2014||REMI||Maintenance fee reminder mailed|
|Apr 11, 2014||FPAY||Fee payment|
Year of fee payment: 4
|Apr 11, 2014||SULP||Surcharge for late payment|