"X-Application Java API" and "Tamno API for Java"

[Guille]

X-Application Version: 3.1.2
Tamino Version : 3.1.1
Platform : NT
WebContainer : Tomcat 3.3.1
JDK Version : 1.3.1_02

Hi,
Please, I would like to know if “XApplication Java API” is based on “Tamino API for Java”. I am using XApplication API and I would like to use the “Pool Connection” feature.

If the answer is yes. How can I use the Connection Pool?

Thanks in advance,
Guillermo

[Michael_Hartmeier]

Yes, X-Application Java API is based on Tamino API for Java. All X-Application Java code that accesses Tamino API for Java is encapsulated in the classes TaminoStore and TaminoElementIterator (in com.softwareag.xtools.xapplication.store).
These classes provide exactly the functionallity we need for X-Application. But since we don’t use the connection pool, there is no built-in way to use the connection pool. What you could do is change the X-Application sources, but I’m not sure if this is the correct approach for your scenario …

Michael

Software AG Germany, Darmstadt

[Guille]

I am working in Consist Argentina and we have a product for Content Management based in Bolero-Tamino. Now we are thinking to migrate to Java-Tamino and we have seen that XApplication Java Api is easy to use.
We beleive that we will have lot of users reading and writing in Tamino. A Connection Pool would allow manage better the database resources.
Do you have any suggestion?

[Michael_Hartmeier]

If I understand correctly, you consider writing a Java Applications (a servlet?), and now you have to choose between using Tamino API for Java and X-Application’s Java API?

Or do you write some kind of JSP application that accesses Tamino?

Michael

Software AG Germany, Darmstadt

[Guille]

We will use servlets. The problem with Tamino API for Java is that it give us an TXMLObject (SAX,DOM,JDOM) and we are looking an easy way to manage the xml object when it is read from Tamino. We don’t want to use a class generator like Breeze. With XApplication-API is easy to write code and maintain it.

[Michael_Hartmeier]

One of the goals of X-Application’s Java API is to simplify programming against Tamino. I think we’re doing quite fine here: Compare to Tamino API for Java, X-Application’s API requires you to know much less classes e.g. to load or store objects from Tamino.

However: this is achived by restricting the functionality we provide: less functionality can be provided with a simplified API – X-Application does not provide all functionality provided by Tamino API for Java. In particular, the connection pool functionality is currently not available.

We might add more functionality in future versions, but there will remain limitations since we will most certainly stick with the current simple store interface.

What you could think about: take X-Application’s store package as a starting point for your implementation and add the features you need
(I suppose the will be more features missing than only the connection pool). This way you could start with a simplified interface and add all features you need. And maybe you could event contribute some of your additions to this forum!!

Michael

Software AG Germany, Darmstadt

[Guille]

Ok Michael. Thanks a lot for your help.

Guillermo.

[Harald_Wolf]

Hello,

here is the documentation part of the underlying Tamino Java API. This API is delivered together with its documentation on the Tamino Server CD.

In this documentation you find how to use and configure the Connection Pool in the class …API/connection/TConnectionPoolManager.java (see snippet below).
You need to use the connection pool manager at the appropriate places in the X-Application Store.

If you manage to make the X-Application TaminoStore ConnectionPool ready we would welcome your solution in the Contribution Forum so that other users could benefit from your improvement.

/**
** TConnectionPoolManager is capable of managing a number of connection pools.
** You can obtain pooled connections from a specific pool from the manager by invoking
** TConnectionPoolManager.getConnection(). Once a pooled connection is no longer used,
** you can return it to the pool by closing it.
** This class implements the singleton pattern, i.e. there is always only
** one instance of this class available.

** You can configure the TConnectionPoolManager in the following ways:

**

**
• By an XML configuration file.
  
  ** The configuration file is called ManagedConnectionPools.xml and must be available in the classpath.
  ** When the TConnectionPoolManager is instantiated it reads the configuration file and
  ** initializes the configured number of connection pools.
  ** The configuration file ManagedConnectionPools.xml has to have
  ** the following structure:
  
  ** [code:1:1d18c216f2]
  **
  **
  **
  ** myDatabaseURI
  ** myUserIdIfGiven
  ** myPasswordIfGiven
  ** myInitConnectionsAsAnInteger
  ** myMaxConnectionsAsAnInteger
  ** MyTimeoutAsSeconds
  **
  **
  ** [/code:1:1d18c216f2]
  **
  ** The element ManagedConnectionPools can contain multiple ConnectionPool elements each of which describes
  ** a managed pool.
  
  ** If this file does not exist you may use the additional method or both.
  **
• Programmatically.
  
  ** By calling the method TConnectionPoolManager.addConnectionPool() as often as needed. For each required
  ** connection pool the same information as specified within the above configuration file has to be given.
  **
• Mixed mode.
  
  ** It is possible to initialize the connection pool manager first “statically” via the configuration file and
  ** then add additional connection pools programmatically.
  **

** If you want to ensure that the connection pool manager does not contain any “statical” initialization, call
** TConnectionPoolManager.release() before adding connection pools programmatically.
**/

Regards, Harald