| |
A walk in the JCA park
A walk through the JCA park
Our JCA developers have written an article which is being published on the onjava.com website this month (hopefully!) which talks in general
about the Java2 Connector Architecture (JCA -- yes, I know that was
already used by the Java Cryptography API, but it's about time they
ceded it to the common cause ....), the new capabilities introduced in
JCA 1.5 such as message inflow, and then discussed how JCA can be
used to access legacy applications.
Rather than just stopping at the
article, we've also produced a how-to which demonstrates this stuff for
real. It walks through setting up an environment to enable a J2EE
application running on OC4J to access a sample application running on
BEA Tuxedo 8.1.
The interesting thing about this was
that the J2EE and JCA side of it was the cake part of the operation.
The J2EE application was able to lookup a JCA resource adapter to get a
connection using the standard JCA API, establish an interaction and
then obtain some data. The configuration of the resource adapter itself
was pretty straight forward too -- deploy it to OC4J using the
admin.jar utility and specify some properties in a configuration file.
What was eye opening was the
middle-middle ware section. I used to somewhat naively think that the
resource adapters would handle most of the work themselves and there
wasn't many other moving pieces -- plonk down a resource adapter for a
specific legacy system and away you go! The truth is that isn't really
the case.
For this example, we used the
Attunity JCA legacy resource adapter to get access to the Tuxedo
system. This in turn, requires the Attunity Connect Server, which
basically acts as the broker between the resource adapter and the
target system. To facilitate the data exchange, you need to model the
data which goes in and out of the systems, and also define the
interaction points with the back end system -- all captured in
meta-data. To create this meta-data, the Attunity folks have a tool
called Attunity Studio. This is quite a nice GUI and pretty easily
lets you perform the required mappings. For our simple example, the
mapping wasn't very hard, but I can see where it has the potential to
get complex pretty quickly.
To get it all working involved quite
a bits of software, and quite a bit of configuration across the
different pieces. But the best thing was that it worked -- after
everything was in place, we were able to interact with the application
running on the Tuxedo system from our J2EE application. And what's
better, it's all written up as a how-to in case anyone else is wanting
to see how it's done.
Keep an eye out for the article on http://www.onjava.com soon and the how-to which I'll post on the OC4J OTN site -- http://otn.oracle.com/tech/java/oc4j.
© Copyright 2004 buttso.
Last update: 3/24/2004; 3:39:45 PM.
|
|
