In my last two columns we looked at JavaServer Pages (JSP) and compared ColdFusion development to JSP development. As explained, JSP is designed to dramatically lower the cost of entry into the Java development world, and JRun, in particular (with its tag libraries), does even more to deliver on this promise.

We ColdFusion developers know that a CF-Java convergence is on the way. We also know that when this happens, knowledge of Java won't be required and we'll be able to develop CF code as we do now. However, as explained earlier in this series, there are compelling reasons to consider Java-based development and the Java platform - even for ColdFusion developers and even right now.

Why Leverage Java?
It's no secret - Java is hot, and the sheer mass of available Java re-sources is nothing short of mind-boggling. From books and tutorials, to commercial and publicly available libraries, to interfaces for all sorts of applications and products - the ability to interact with Java opens up all sorts of new avenues for ColdFusion developers.

In addition and as I've written in previous columns, ColdFusion developers need to think about code reuse, abstraction, encapsulation, and componentization. As the next generation of ColdFusion will be built upon a Java platform, using Java components within your code ensures that you're walking the same path Allaire is.

All said and done, ColdFusion developers need to take a good look at Java - right away.

Integrating ColdFusion and Java
ColdFusion provides three ways to interact with Java:

1. The CFX interface (originally designed to allow C/C++ developers to extend CF) supports Java. Using this interface (CFAPI) you can write Java code that can be registered within ColdFusion, then used like any other tag.
2. <CFSERVLET> can be used to execute a servlet in the Java server. This tag is used in conjunction with <CFSERVLETPARAM>, which passes data to the servlet. Data re-turned by <CFSERVLET> may be written out to the client or saved to a variable for further manipulation.
3. <CFOBJECT> (as of ColdFusion 4.5) supports Java objects and Enterprise JavaBeans (EJB). The function equivalent of <CFOBJECT>, CreateObject(), also supports Java.

Of these three options <CF-SERVLET> is, for all intents and purposes, the least useful. You'll seldom want to display servlet results as is (if you did, you'd probably have used the servlet directly); if you need to manipulate the output, you can use <CFHTTP> to call the page.

For leveraging Java within your ColdFusion code <CFOBJECT> is probably the most useful in that it allows you to interact with generic Java (unlike the CFX interface that requires CF-specific Java coding). However, the CFX interface does have an advantage - it's far more CF aware (for example, it can read and write queries).

Java via <CFOBJECT>
<CFOBJECT> was introduced in ColdFusion 3 as a means to connect to COM. The tag was extended in ColdFusion 4 to support CORBA, and was extended again in ColdFusion 4.5 to support Java.

The following code snippet (based on example code that's included with ColdFusion) invokes Java code (see Listing 1) that creates a JPEG image containing user-supplied text:

<CFOBJECT TYPE="JAVA" ACTION="Create" NAME="image" CLASS="HelloWorldGraphic">
<CFSET imglen=image.createImage("Hello Ben")>

<CFOBJECT> requires that the Java class is specified along with a name to refer to the instance. That name is then used to pass attributes and invoke specific methods.

<CFSCRIPT> can also be used to invoke Java code, and the syntax this way is even cleaner:

<CFSCRIPT>
image=CreateObject("Java", "Hello WorldGraphic");
imglen=image.createImage("Hello Ben");
</CFSCRIPT>

As you can see, calling Java code isn't difficult at all. As long as you know the names of the required methods and attributes it's just a matter of calling <CFOBJECT> and <CFSET> (or their <CFSCRIPT> counterparts) as needed.

Custom Tag Wrappers
The examples I used here are rather simplistic - you'll find invoking Java code in real world applications is typically more involved. Ideally, you'll want to write the interface code just once, and custom tags are a perfect way to do this. The following custom tag encapsulates the above code to simplify its use:

<CFPARAM NAME="ATTRIBUTES.message" DEFAULT="">
<CFSCRIPT>
image=CreateObject("Java", "Hello-WorldGraphic");
imglen=image.createImage("#ATTRI-BUTES.message#");
</CFSCRIPT>

<CF_HelloWorldGraphic MESSAGE="Hello Ben">

Summary
Java is an important part of ColdFusion's future, and you'll be hearing lots more about it (and how it affects us CFers) in the next few months. For now, I strongly recommend you look at JRun (you can download the Developer's Edition from the Allaire Web site, www.allaire.com), and when appropriate, consider using Java as a way to extend ColdFusion - together they form the ultimate development platform.