Fusioncube » cfml

ColdFusion to Flex Object Type Conversion via ColdSpring

Steve Brownlee — Thu, 02 Oct 2008 19:26:04 +0000

The Value Objects

Otherwise known as a transfer object is simply a design pattern for exchanging data between disparate systems. I’m working on a application with a Flex UI and a ColdFusion backend, and I initially discovered that if I return a query directly to Flex, it is converted into an ArrayCollection populated with simple Objects.

What I wanted was an array of specifically typed objects that I could cast as value objects in Flex. Here’s a very simplistic example of an Employee value object in Flex. It has two properties:

Employee ID
Employee Name

Flex Employee Value Object

package net.fusioncube.transferObjects
{
   [RemoteClass(alias="net.fusioncube.model.employee.Employee")]
   [Bindable]
   public class Employee
   {
      private var _employeeID:uint;
      private var _employeeName:String;

      /* constructor */
      public function Effort(employee_id:uint = 0,
                  employee_name:String = "")
      {
         this._employeeID= employee_id;
         this._employeeName= employee_name;
      }

        public function get employee_id():uint
        {
        	return _employeeID;
        }

        public function set employee_id(value:uint):void
        {
        	if(value != 0) _employeeID= value;
        }

        public function get employee_name():String
        {
        	return _employeeName;
        }

        public function set employee_name(value:String):void
        {
        	if(value != "") _employeeName= value;
        }
   }
}

You may have noticed the RemoteClass metadata applied to the Actionscript class. What this does is ensure that this Flex class maps directly to a ColdFusion component value object. To make a ColdFusion component value object is simple: you use the tag for each property and specify each one’s type.

In this example, I’ve also added an init() method, whose use we’ll discover later.

ColdFusion Employee Value Object

Converting a Query to an Employee Array

Again, as a very simple example, let’s say I have an EmployeeService component in my service layer and have a method listEmployees() that simply queries the employees table and returns all rows.


   

   
   select e.* from employees e

Since I don’t want to return a query, and I certainly don’t want to have two methods in every single component – one that returns a query and one that returns an array of objects – I use the handy, dandy AOP feature in ColdSpring to apply an advice that does it at runtime.

QueryToVOAdvice Advice

In this advice, I simply loop over the query’s rows and columns to create a simple structure containing the key/value pairs for each row. It then creates a new component for each query row by passing that structure to the init() function – which you saw above – and adds it to an array.

The result is an array of Employee-typed objects.



   
      
   

   
      

      
      var local = structNew();
      local.queryRow = 1;

      // Create an array to hold the value objects
      local.valueObjectArray = ArrayNew(1);

      // Store the resulting query object from the method execution
      local.queryObject = arguments.methodInvocation.proceed();

      // Loop over the query rows
      for(local.queryRow=1; local.queryRow lte local.queryObject.recordCount; local.queryRow = local.queryRow+1)
      {
         local.voStruct = structNew();

         // Loop over the query columns and create a key/value pair for each value
         // in this row of the query
         for(local.columnNum=1; local.columnNum lte listLen(local.queryObject.columnList); local.columnNum = local.columnNum+1)
         {
            local.columnName = listGetAt(local.queryObject.columnList, local.columnNum);
            local.voStruct[local.columnName] = local.queryObject[local.columnName][local.queryRow];
         }

         // Create an instance of the value object (obtained from the getValueObject method)
         // initializing it with the structure we created.  Add the value object to the array.
         arrayAppend(local.valueObjectArray, createObject('component', arguments.methodInvocation.getTarget().getValueObject()).init(argumentCollection=local.voStruct));
      }

      return local.valueObjectArray;

ValueObject Property

For each of my beans, in this case the Employee bean, I can simply apply an advice in the definition. For this to work, I create a valueObject property in each component.

Employee Bean Definition

Now when I define my Employee bean, I specify the type of the value object (the type that gets returned from the init() function), and then apply the advisor (shown below).


   
      
         
            net.fusioncube.model.employee.Employee
         
      
   
   
      
         queryToValueObjectAdvisor

QueryToValueObjectAdvisor Definition


   
      
   
   
      ^list.*$

The Flex Array of Typed Objects

Here’s an image of an example array I get back from ColdFusion in one of my current apps. You can see that each object was automatically converted into a Teammate (equivalent of an Employee) rather than a simple Object.

Caveat: If you’re passing back queries with a thousand or more rows, and are running CFMX 7 or older, then this solution may cause serious performance problems as object creation is notoriously “slow” in those versions of ColdFusion.

When to use autowiring in ColdSpring

Steve Brownlee — Mon, 15 Sep 2008 19:38:23 +0000

Autowiring in ColdFusion

Most of you may have heard of autowiring, and many of you may have implemented it in an application by now (most likely with Spring, ColdSpring, or Google Guice).

If you don’t know what autowiring is, or are curious about how to do it, I’ll simply direct you to other people who have adequately explained it (see reference links at bottom of article) rather than doing it myself. This article is about when to use it, not how to use it.

Most people I talk to, or have read articles by, promote autowiring as a positive thing. It offers an effective way to automatically inject instantiated components into other components that require their methods. Who wouldn’t be a fan of that??

Nevertheless, there are gadflies who point out that the overuse of autowiring defeats one of the benefits of your bean definition file: a documentation tool. It is the one place in your application that clearly shows how services depends on each other. I believe this is a valid point, as I often use my definition file as a quick reference to my application’s dependencies.

Autowiring Incidental Dependencies

I prefer to use the autowiring feature for beans that are not business logic:

Datasources
Configuration settings
Resource libraries (e.g. Transfer ORM)
Transfer/Value objects

For example, several of my apps are written using Model-Glue, and I define beans to pass the application’s datasource, and transfer service:

Most of my beans require one, or both, of these services, and I’m reluctant to pass them in as constructor arguments since I consider them incidental dependencies, rather than logical dependencies. I see no benefit in having these clutter up my definition file since they offer no help to me, or anyone else, when determining if the Facility component requires the use of the Organization_Demographics component or not.

Instead of having dozens of these definitions filling up my definition file:


   
      
         
            
         
         
            
         
         
            
         
         
            
               
                  
               
               
                  
               
            
         
         
            
         
      
   
   
      
         exceptionLoggingAdvisor

Instead I enjoy looking at a definition file that shows me how I’m wiring my application together.


   
      
         
            
         
         
            
         
         
            
          
      
   
   
      
         exceptionLoggingAdvisor

Reference Links

Joe Rinehart on autowiring
Nando demystifies autowiring
Download a small, sample app that provides autowiring code

Preventing SQL Injection

Steve Brownlee — Thu, 28 Aug 2008 13:44:51 +0000

An old client of mine recently contacted me with a problem. Their home page, several sub-pages, and the administrative section weren’t displaying properly and functionality was broken. Turns out, they were a victim of the recent swarm of SQL injection attacks.

After pulling the old code out of my repository, I discovered that I’d used CFQUERYPARAM (I won’t iterate the hundreds of articles you can find by yourself stating, “USE CFQUERYPARAM, DUMMY!!”) in all of my business logic code, so I couldn’t quite figure out what was going on. While perusing the web for other ideas, I ran across Jason Bartholme’s blog entry about preventing SQL injection attacks. He has a simple bit of code that he put in onRequestStart() so check if the keyword DECLARE was in the URL.

This worked like a charm and allowed me to see what exactly these jerkoffs were doing. Turned out I had left CFQUERYPARAM out of some queries I was running for the Contact Us page and a few product display pages. Once I added the tags, the attacks stopped.

If you’re seeing SQL injection attacks, just add the code to application.cfm or the onRequestStart() function of application.cfc to see if this is the method the attackers are using and what they are doing.

Thanks Jason!

The ColdFusion ServiceRunner – Part I

Steve Brownlee — Wed, 27 Aug 2008 22:54:19 +0000

I’ve been meaning to share this for many reasons, but I’ve been bogged down with projects lately. However, it has allowed the code to mature and get streamlined a bit, so it’s good that some time has passed.

This is a pattern that we’ve come up with at work to handle remote calls to ColdFusion. It is one part of our SOA initiative that allows ColdFusion and Flex developers to make service calls to our core business components using a common approach.

I’ll start at the high level and work my way down. The reason I started this project is because early on I started to notice that there were many common entities used throughout the gamut of application used by my business unit – Facilities, Teammates, Drugs, Treatments, Patients, Doctors, etc…

Each application developer had written their own code to handle retrieving information on each of these entities. I’m sure you can see where the problem is in that, so I won’t belabor the point. To stop the fragmentation, I began diagramming how to create a common service application that could be accessed by any client in the company using a simple interface.

The Remote Call Service – RemotingService.cfc

Let’s start off with the first part of the puzzle: the simple interface for calling ColdFusion Component methods in our service application.

Can’t get more simple than this. Using any remoting technology supporting SOAP, any client can invoke this component’s invokeService() method. This is the one entry point into our service application. As I’m sure you noticed by the application.beanFactory code, we’re using ColdSpring to manage all of our dependencies, AOP features, and event maps (more on this later).

The Service Response Value Object – ResponseVO.cfc

The next concept we tackled was not returning complex objects; we wanted a simple and logical structure to what gets returned to the client. Also we didn’t want the response object sitting around in memory sucking up RAM on the machine. We wanted this object to be created and destroyed on each remote request (shows below in the ServiceRunner code).

What got created was a simple Value Object that defines the keys of the response: name of the event, a success boolean, the data object, and an error structure (which is only populated if an error occurs).

The Service Runner – ServiceRunner.cfc

Once we’d defined how services would be called and what the response would be, we then had to write the mechanism to actually execute the method and populate the response VO. The service runner is defined as a bean via ColdSpring (shown below) and is instantiated from the RemotingService component (shown above).

The RemotingService then calls the public run() method which creates a VO, executes the requested event using the private runEvent() method, and then returns the populated VO.

Defining Events as Beans – EventMaps.xml

To define our events, we create a bean for each one using the RemoteEventMap.cfc as the template for each one. The RemoteEventMap (code shown below) has two properties: beanName and methodName. These are used in the runEvent() method of the ServiceRunner (shown above) to obtain the properties needed for the CFINVOKE tag that executes the actual method we need.


   
   
]>

   
      
         
      
      
         
            metricsAdvisor
         
      
   

   
      
         FacilityService
      
      
         getHeldFacilities

The Event Bean – RemoteEventMap.cfc

This is the simple RemoteEventMap that each event creates as a bean.

In Part II – which I will hopefully finish up tomorrow – I will show implementation examples of this pattern for ColdFusion and for Flex.

Invoking ColdSpring beans with ajaxCFC

Steve Brownlee — Tue, 20 May 2008 16:07:43 +0000

As a heavy user of Rob Gonda’s ajaxCFC library, I’ve incorporated it into almost every app I’ve written in the past two years. The only restriction that required me to write workarounds was the fact that you could only invoke ColdFusion Components directly. The thing is, I also love ColdSpring to manage dependencies and to implement my Aspect Oriented Programming components.

What I want is to be able to call my ColdSpring beans with ajaxCFC so that I can make my asynchronous calls, get serialized data back, and all the while utilizing the dependencies set up in my beans. Well, I finally got around to modifying Rob’s code to allow for this. I use the jQuery branch, so my solution currently only works for that implementation. I may try to work on the DWR version, but that’s unlikely because I don’t use it.

There are three changes to how you invoke ajaxCFC in order to work with ColdSpring beans.

The URL Attribute

Instead of the URL value being the path to your logic component, its value should be the path to the ajax.cfc component

url:'com/company/common/ajax/ajax.cfc'

The Bean Attribute

This property’s value will be the name of the ColdSpring bean you want to use.

bean: 'Facility'

The Factory Attribute

This property’s value will be the name of your ColdSpring bean factory.

factory:'application.beanFactory'

A Complete Invocation

Here’s a sample call stripped directly from one of my applications

$.AjaxCFC({
	url:'com/company/common/ajax/ajax.cfc',
	bean: 'Facility',
	factory:'application.beanFactory',
	method: 'getFacilities',
	data: { 'orderby':orderByField },
	useDefaultErrorHandler: false,
	success: function(results) {
		$('#facilitySelectContainer').html(results);
	},
	error: function(results) {
		Ext.MessageBox.alert('Error Notification', 'There was an error while loading the facilities. Please try again.')
	}
});

The Code

There are two files you need to replace.

ajax.cfc
jquery.AjaxCFC.js

Download ColdSpring-enabled ajaxCFC

Calling Oracle functions in ColdFusion – BOOLEAN restriction

Steve Brownlee — Wed, 07 May 2008 19:54:30 +0000

I was trying to call an Oracle function from ColdFusion today and was just receiving error, after error, after error… well you get the point. Long story short, I couldn’t successfully get a response since there is no binding between ColdFusion and the Oracle BOOLEAN type, and the function was returning BOOLEAN. So I changes the response to 0/1 and it works.

Just something to keep in mind.


    select myPackage.myFunction(myArg1, myArg2) response from dual

Using overloaded Java methods via ColdFusion

Steve Brownlee — Wed, 26 Mar 2008 15:03:22 +0000

While helping a colleague out with a tricky problem accessing Excel files, I downloaded the Java Excel API library from SourceForge. After a quick scan of the documentation, I started to write some ColdFusion code.


jxlWorkbook = createObject('java','jxl.Workbook');
file = createObject('java','java.io.File').init("C:\\temp\\test.xls");
excelFile = jxlWorkbook.getWorkbook(file);

I’m immediately alerted with the message

The selected method getWorkbook was not found.

Either there are no methods with the specified method name and argument types,
or the method getWorkbook is overloaded with arguments types that ColdFusion can't
decipher reliably. If this is a Java object and you verified that the method exists,
you may need to use the javacast function to reduce ambiguity.

I dump out the object, and there are actually 5 method signatures for getWorkbook() and the one I want accepts a single argument of type java.io.File. I also know that the JavaCast() function certainly can’t handle a complex type like java.io.File. What’s a poor coder to do? I thought this was the end of the line, but figured I’d try something anyway…


jxlWorkbook = createObject('java','jxl.Workbook');
excelFile = jxlWorkbook.getWorkbook(createObject('java','java.io.File').init("C:\\temp\\test.xls"));

Lo, and behold, that worked perfectly! I never knew that you could use createObject() inside a method call.

There was another snag that I’d never ran across before: another method of the library wouldn’t accept integers passed from ColdFusion. In a simple from-to loop producing an index, the value of the index wasn’t being accepted by the method.


	
		col, row)>
		#currentCell.getContents()#

I had to use JavaCast() to force them into the native int type.

ColdSpring Remote Proxies as WebServices… Whew!

Steve Brownlee — Tue, 11 Mar 2008 20:59:48 +0000

You know the word caveat, right? Well, today I learned that there are a few caveats when setting up ColdSpring remote proxy beans.

When invoking a webservice that has logically optional arguments, you still have to pass all defined arguments with the omit attribute set to yes on the tag (see Listing 1.1 below). Otherwise you’ll get the result of a Java method exception. It will look something like this – ” Web service operation “someMethod” with parameters {ARGUMENT={1}} could not be found”
When you have optional arguments in a component method that you want to access as a webservice, you have to provide a default value for each one. Otherwise, you’ll get premature end of file Axis errors (see Listing 1.2 below)
You must define the (somewhat) undocumented beanFactoryName property of ColdSpring’s RemoteFactoryBean. This will be the package name of where your ColdSpring definitions are located in the application namespace. For those using Model-Glue, this will be {app name}.framework (see Listing 1.3 below)

Listing 1.1


billGroupService = createObject("webservice", "http://localhost/webapps/charm/remote/BillingGroup.cfc?wsdl");


	
	omit="yes">
	omit="yes">
	omit="yes">

Listing 1.2


	default="" type="string" required="false" />
	default="" type="string" required="false" />
	default="" type="string" required="false" />
	default="" type="string" required="false" />

Listing 1.3


	
		
			exceptionLoggingAdvisor
			metricsAdvisor
		
	
	
		
	
	
		BillingGroup
	
	
		/webapps/charm/remote/
	
	
		charm.framework
	
	
		*

Find list elements using Regular Expressions

Steve Brownlee — Tue, 16 Jan 2007 19:29:41 +0000

A colleague of mind asked me this afternoon if I knew of a way, in ColdFusion, and one of line of code, to determine if all of the elements in a short list are contained in a larger list. He also wanted to discount the order of the elements in the larger list – the elements could be anywhere. I quickly indexed my mental store of ColdFusion list functions, and nothing came to mind, so my first answer was no. Then I thought about it for a minute and realized that he could use my trusted friend and companion – regular expressions.

I figured if there was a way to convert the list itself into a regular expression pattern using lookaheads, then it would be a snap. I then went to LiveDocs and discovered the ListChangeDelims() function which I had never used before. It was perfect.

Works like a charm and all done on one line of ColdFusion.

How CFLOCK doesn’t

Steve Brownlee — Tue, 21 Nov 2006 22:03:04 +0000

I’ve one word for you, just one word… frames.

Amazing how simple it is to completely bust the CFLOCK tag. First, you create a simple page that has frames and loads another page into each frame.

Now for the code that is supposed to lock in the first frame, then release and then get picked up subsequently by the second frame.




	
	
	


	
		#id#: got lock @ #timeformat(now(), "hh:mm:ss")#-#gettickcount()#

		
		

		 
		
			
		

		#id#: give up lock @ #timeformat(now(), "hh:mm:ss")#

If you run this simple code, you’ll see that the lock is not honored and the threads in each frame are run simultaneously.