ColdFusion 10 - Invoking ColdFusion Closures From Within A Java Context, Part II

<cfscript>
// NOTE: Script tags added purely for Gist color-coding only.

component
	output="false"
	hint="I proxy the invocation of a ColdFusion closures and component methods so that they can be more easily invoked from Java."
	{


	// I get called from Java to invoke a ColdFusion closure. Since
	// the Java interface defines this method signature as
	// java.lang.Object[], we will only get one argument that is a
	// Java Array.
	function callClosure( javaArguments ){

		// The first argument being passed-in is the ColdFusion
		// closure to invoke.
		var operator = javaArguments[ 1 ];

		// We need to convert the Java arguments into a ColdFusion
		// argument collection that can be used to invoke the closure.
		var invokeArguments = {};

		// Move the Java arguments in to the closure arguments.
		for (var i = 2 ; i <= arrayLen( javaArguments ) ; i++){

			invokeArguments[ i - 1 ] = javaArguments[ i ];

		}

		// Invoke the closure with the translated argument collection
		// and pass the return value back to the calling context.
		return(
			operator( argumentCollection = invokeArguments )
		);

	}


	// I get called from Java to invoke a ColdFusion component method.
	// Since the Java interface defines this method signature as
	// java.lang.Object[], we will only get one argument that is a
	// Java Array.
	function callMethod( javaArguments ){

		// The first argument is the component instance. The second
		// argument is the method name.
		var target = javaArguments[ 1 ];
		var methodName = javaArguments[ 2 ];

		// We need to convert the Java arguments into a ColdFusion
		// argument collection that be used to invoke the method.
		var invokeArguments = {};

		// Move the Java arguments in to the method arguments.
		for (var i = 3 ; i <= arrayLen( javaArguments ) ; i++){

			invokeArguments[ i - 2 ] = javaArguments[ i ];

		}

		// Invoke the ColdFusion component method with the translated
		// argument collection and pass the return value back to the
		// calling context.
		return(
			invoke( target, methodName, invokeArguments )
		);

	}


}

// NOTE: Script tags added purely for Gist color-coding only.
</cfscript>

// Define the namespace at which our Java Class will be found.
package com.bennadel.cf10;


// Here, we need to define an interface to our ColdFusion Proxy
// component so that we can create a dynamic Java proxy. Since Java
// does not allow for the level of dynamic-structure that ColdFusion
// allows, we have to actually define interfaces to our ColdFusion
// components so that we can build a static Java object around it.
public interface ColdFusionProxy {


	// This is a proxy to closure invocation. This takes a variable
	// number of arguments, the first of which is the closure.
	public java.lang.Object callClosure( Object...argv );

	// This is a proxy to our ColdFusion component method invocation.
	// This takes a variable number of arguments, the first of which
	// is the component, the second of which is the method name.
	public java.lang.Object callMethod( Object...argv );


}

// Define the namespace at which our Java Class will be found.
package com.bennadel.cf10;


// Import classes for short-hand references.
import com.bennadel.cf10.ColdFusionProxy;


public class Core {


	// For this class, we are going to declare a static property to
	// hold an instance of our ColdFusion proxy object. This way,
	// all Java classes in this package can use this to invoke
	// ColdFusion component methods and closures from witihn the
	// Java context.
	private static ColdFusionProxy coldfusionProxy = null;


	// I provide a way to set the ColdFusion proxy. This needs to be
	// done in order for the rest of the package classes to be able
	// to invoke ColdFusion methods.
	public static void setColdFusionProxy( ColdFusionProxy proxy ){

		coldfusionProxy = proxy;

	};


	// I provide a way for the package classes to access the core
	// ColdFusion proxy.
	public static ColdFusionProxy getColdFusionProxy(){

		return( coldfusionProxy );

	};


}

<cfscript>
// NOTE: Script tags added purely for Gist color-coding only.

component
	output="false"
	hint="I define the application settings and event handlers."
	{


	// Define our standard Application settings.
	this.name = hash( getCurrentTemplatePath() );

	// I'm setting the Application Timeout to be SUPER LOW since I
	// was getting some odd caching issues with the CLASS files.
	// ColdFusion didn't seem to always pickup the changes to the
	// file. By setting the application timeout very low, I was able
	// to force the per-app Java libraries to reload.
	this.applicationTimeout = createTimeSpan( 0, 0, 0, 3 );

	// Define our per-application Java library settings. Here, we
	// can tell ColdFusion which ADDITIONAL Java libraries to load
	// when the application starts.
	//
	// NOTE: Since I am doing this demo and writing Java code at the
	// same time, I have the "watchInterval" very low. This will
	// continuously scan the loadPaths[] directories looking for
	// updated JAR and CLASS files.
	this.javaSettings = {
		loadPaths: [
			"./lib/"
		],
		loadColdFusionClassPath: true,
		reloadOnChange: true,
		watchInterval: 2
	};


	// I initialize the application.
	function onApplicationStart(){

		// When the application starts-up, we have to initialize our
		// custom Java libraries with an instance of the ColdFusion
		// proxy component. This will enable all of the custom CLASS
		// files to invoke ColdFusion component methods and closures.
		createObject( "java", "com.bennadel.cf10.Core" )
			.setColdFusionProxy(
				createDynamicProxy(
					new lib.com.bennadel.cf10.ColdFusionProxy(),
					[ "com.bennadel.cf10.ColdFusionProxy" ]
				)
			)
		;

		// Return true so the application can load.
		return( true );

	}


	// I initialize the request.
	function onRequestStart(){

		// Check to see if we need to manually reset the application.
		if (structKeyExists( url, "initApp" )){

			// Explicitly reset the application.
			this.onApplicationStart();

		}

		// Return true so the request can load.
		return( true );

	}


}

// NOTE: Script tags added purely for Gist color-coding only.
</cfscript>

// Define the namespace at which our Java Class will be found.
package com.bennadel.cf10;


// Import classes for short-hand references.
import com.bennadel.cf10.Core;
import com.bennadel.cf10.ColdFusionProxy;
import java.util.Iterator;


// For this demo, we'll create a class that extends the core
// ArrayList class. This way, we can get all of the benefits of
// the ColdFusion Array plus whatever methods we want to add.
public class CFArray extends java.util.ArrayList {


	// I return an initialized component.
	public CFArray(){

		// Property initialize the core ArrayList.
		super();

	}


	// I iterate over the elements in the array and invoke the given
	// opertor on each element.
	public CFArray each( Object operator ){

		// Get our core ColdFusion proxy - this is how we will invoke
		// the ColdFusion closure.
		ColdFusionProxy proxy = Core.getColdFusionProxy();

		// Get the iterator for our ArrayList.
		Iterator iterator = this.iterator();

		// Keep track of the iterations in our iterator - to be
		// passed-in as one of our arguments.
		int iteration = 0;

		// Loop over the entire collection.
		while (iterator.hasNext()){

			// For this item, invoke the closure. Since it's hard to
			// invoke the ColdFusion closure directly from Java,
			// we'll use our ColdFusion proxy to invoke it. For this,
			// our closure will be the first argument; then,
			// arguments 2..N will be the operator arguments.
			proxy.callClosure(
				operator,
				iterator.next(),
				++iteration
			);

		}

		// Return this object reference for method chaining.
		return( this );

	}


}

<cfscript>


	// Create our custom Array class. When we initialize it, we have
	// to pass in our Closure proxy which will act as a tunnel when
	// we invoke our ColdFusion closure from Java.
	friends = createObject( "java", "com.bennadel.cf10.CFArray" ).init();


	// Initialize our custom ColdFUsion array with some values.
	arrayAppend(
		friends,
		[ "Tricia", "Joanna", "Sarah", "Anna" ],
		true
	);


	// Iterate over each item in the array. Notice that friends.each()
	// is a JAVA method that we passing a COLDFUSION CLOSURE into.
	friends.each(
		function( friend, index ){

			writeOutput( "#index#) Hey #friend#, what it be like?" );
			writeOutput( "<br />" );

		}
	);


</cfscript>