ColdSpring is a framework for ColdFusion Components, inspired by the Spring Framework for Java, and its core focus is to manage the dependencies within your CFC "model."

Dependencies are more common than you think: when one CFC needs another CFC to perform a task, it depends on that other CFC (and those two CFCs are known as "collaborators"). When a CFC needs a piece of configuration data, such as a datasource name, it depends on that piece of data. ColdSpring enables you to declaratively supply your CFCs with their dependencies, freeing you from having to write the code to do so (which unfortunately ends up in just about each and every component). ColdSpring practices what many refer to as "inversion-of-control." This simply means that the control of creating objects and resolving their dependencies is lifted out of the code and into the code's "container," which in this case is ColdSpring. "Dependency-Injection" is probably a better term to describe what ColdSpring does: it injects dependencies into your CFCs as they are created.

Also part of ColdSpring is the first aspect-oriented-programming (AOP) framework for CFCs (which we'll cover in further detail shortly).

For building an application like the Pet Market, ColdSpring would typically be used in conjunction with one of the other MVC application frameworks like Fusebox, Mach-II, or Model-Glue. However, for the purposes of this article, we were unable to use one of those frameworks, so we took the approach of attempting to retrofit a brand new ColdSpring-managed model on top of the existing Pet Market application. This means that our version of the Pet Market should be used to examine how ColdSpring manages a model regardless of the application framework used. (The code for this article can be downloaded from www.cfpetmarket.com.)

Figure 1 provides a picture of where ColdSpring sits in the overall Pet Market application architecture.

Figure 1 is an example of typical MVC (Model-View-Controller) architecture. The "Service," "DAO," "Gateway," and "Utility" components are part of our Pet Market model. Each component is "managed" by ColdSpring, meaning ColdSpring is responsible for both creating the component and resolving its dependencies. When the controller layer needs to talk to a model component, it simply asks ColdSpring for the component. After retrieving a component from ColdSpring, the controller layer would call methods directly on that component, so ColdSpring doesn't really "sit between" the controller and the model.

To use ColdSpring with your application, you need to write some code to create a ColdSpring "BeanFactory". The BeanFactory is typically the only ColdSpring CFC that you will interact with, thus setting up ColdSpring for use within an application is trivial. It's worth mentioning that none of this is necessary if you are using the Mach-II or ModelGlue application frameworks, as both offer hooks to handle creating the ColdSpring BeanFactory automatically. However, to see how we set up ColdSpring in the Pet Market application, take a look at our application.cfm, the relevant part of which is shown here:

<cfif not structKeyExists(application,"beanFactory")
		or structKeyExists(url,"reloadApp")>
	<cflock name="PetMarket_Startup" timeout="25">
		<cfif not structKeyExists(application,"beanFactory")
			or structKeyExists(url,"reloadApp")>
			<cfset application.beanFactory = createObject('component',
			 'coldspring.beans.DefaultXmlBeanFactory').init()/>
<cfset application.beanFactory.loadBeans(expandPath("./components.xml"))/>
		</cfif>
	</cflock>
</cfif>

All we are doing here is creating the ColdSpring BeanFactory and placing it in the application scope. The <cfif/> and <cflock/> blocks are necessary to ensure that the BeanFactory starts up in a thread-safe manner, because as you can see from the code, we are storing the BeanFactory in the application scope and we want to make sure that all requests wait while the BeanFactory is created (this only happens once during application "startup"). In order to tell ColdSpring about your CFCs, we need to supply it with a set of "bean definitions," which are written in a simple XML format. We named our configuration file components.xml. You can see this done in the code above, where we are passing components.xml's file path into the BeanFactory using the loadBeans() method. Here's a quick sample of our bean definitions:

<beans>
	<!-- Session Service Definition -->
	<bean id="SessionService" 
	class="petmarket.util.UsageSessionService" />

	...

	<!-- User Service -->
	<bean id="UserService"
	class="petmarket.component.user.UserService">
		<!-- needs a UserDAO -->
		<property name="UserDAO">
			<bean id="UserDAO"
			class="petmarket.component.user.UserDAO"/>
		</property>
		<!-- also needs the session service -->
		<property name="SessionService">
			<ref bean="SessionService"/>
		</property>
	</bean>
</beans>

Use <bean/> tags to define your CFCs. You may have heard the term "bean" used in a number of different contexts related to CFC development, but here it's chosen because ColdSpring expects that, in order to take advantage of certain features, you adhere to the Java programming language's JavaBean specification/conventions. Now we will take a look at the XML above in detail. First we defined a <bean/> and gave it an ID of "SessionService". The class attribute, "petmarket.util.UsageSessionService", tells ColdSpring which CFC it should use when asked for the "SessionService". You will also see the "UserService" <bean/> definition, but this one is a bit more complex. We define the ID and class just like our SessionService, however, we also define some <property/> tags within the <bean/> tag. First we define a "UserDAO" <property/> (DAO stands for "Data Access Object", it's part of the gritty details of our Pet Market model but has nothing to do with ColdSpring itself). Whatever you put between the <property></property> tags will be injected, by ColdSpring, when the CFC is actually created. Thus, we have defined an "inner-bean" within the UserDAO property, meaning ColdSpring will create a UserDAO CFC and pass that into the UserService when it is created. You must provide ColdSpring with a way to do this, and, in the case of <property/>, ColdSpring expects there to be a "setter method" that will accept the UserDAO, and it must be named "setUserDAO". This is where ColdSpring relies on the JavaBeans spec, meaning that you adhere to the JavaBean convention of providing setter methods for public properties. The setter method within our UserService that accepts the UserDAO looks like this:

<cffunction name="setUserDAO" access="public"
returntype="void" output="false" hint="Dependency: userDAO">
    <cfargument name="UserDAO" type="petmarket.component.user.UserDAO"
    required="true"/>
    <cfset variables.userDAO = arguments.UserDAO />
</cffunction>

• ColdFusion Developer's Journal Special "Frameworks" Focus Issue: Mach-II