Jump to content

Adobe ColdFusion

From Wikipedia, the free encyclopedia

This is an old revision of this page, as edited by Toby Woodwark (talk | contribs) at 12:30, 29 June 2006 (→Technical Mailing Lists: NPOV; typo). The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

This article is about the computer programming language. For the nuclear reactions, see Cold fusion.
File:Cfmx7 splash.gif

ColdFusion is the original and most common implementation of a tag and ECMAScript-based programming language — ColdFusion Markup Language (CFML) and CFSCRIPT, respectively — which is typically used in web application development for the generation of dynamic web pages. Originally a product of Allaire, in 2001 the company was purchased by Macromedia, who subsequently merged with Adobe Systems in 2005.

ColdFusion resembles a scripting language, and is best suited for data-driven web sites. More advanced users can use ColdFusion as a productivity layer above a J2EE platform or use ColdFusion as middleware in a service oriented architecture (SOA), generating web services or Flash remoting.

Recently, ColdFusion has also become a layer to handle asynchronous events such as SMS and instant messaging via its gateway interface.

ColdFusion also provides a number of value-added services out of the box:

  • conversion from HTML to PDF and FlashPaper
  • client-side form validation including rich forms using Flash
  • GUI widgets such as datagrids and date pickers
  • platform-independent database querying via ODBC or JDBC
  • data retrieval from common enterprise systems such as Active Directory, LDAP, POP, HTTP, FTP
  • client and server cache management
  • session, client, and application management
  • file indexing and searching service based on Verity K2
  • XML parsing, querying, and validation
  • Server clustering
  • GUI administration
  • Task scheduling

Other implementations of CFML offer similar or enhanced functionality, such as running in a .NET environment or image manipulation.


ColdFusion MX

Somewhere before 2000, Allaire began work on rewriting the basis of ColdFusion using Java (codenamed "Neo"), which would allow for greater portability among different platforms.

On January 16, 2001, Allaire announced that it would be merging with Macromedia. Shortly after the merger, Macromedia continued with the incremental release of ColdFusion 5.00 and in June 2002, Macromedia released Macromedia ColdFusion MX (6.0), extending the naming convention of Macromedia's line of products. ColdFusion MX was completely rebuilt from the ground up and was based on the Java 2 Platform, Enterprise Edition (J2EE) platform. ColdFusion MX was also designed to integrate well with Macromedia Flash using Macromedia Flash Remoting MX.

Starting from the MX (6.0) release, ColdFusion is compiled to bytecode, like JSP and ASP.NET. The compiled .class files are readily accessible, and are cached until their source changes, like JSPs.

With the release of ColdFusion MX, the CFML language was also extended to support basic OOP. Apart from the tag-based CFML syntax, ColdFusion supports embedded scripts that can be written in a JavaScript-like language, known as CFScript.

ColdFusion MX 7

With the release of ColdFusion 7.0, the naming convention was amended, rendering the product name "Macromedia ColdFusion MX 7". CFMX 7 added Flash-based web forms and a report builder that output in Adobe PDF as well as Flash Paper, RTF and Excel. The Adobe PDF output is also available as a wrapper to any HTML page, converting that page to a quality printable document. The enterprise edition also added Gateways. (These provide interaction with such things as IM Services, SMS, Directory Watchers, and an asynchronous execution... or add your own gateways.) XML support was boosted in this version to include native schema checking.

Rich Forms

With its newest release, Macromedia included a subset of its Macromedia Flex 1.5 technology. Its stated purpose is to allow for rich forms in HTML pages using CFML to generate Flash movies. These Flash forms can actually be used to implement rich internet applications, but with limited efficacy due to the Actionscript restrictions in place on Flash forms by Macromedia.

Flash forms also provide additional widgets for data input, such as data pickers and data grids.

In previous versions of ColdFusion, some form validation and additional widgets were available using a combination of Java applets and Javascript. This option persists for those who do not wish to use Flash, however not all features are supported.

An example: 

<cfform format="flash" method="post" width="400" height="400">
	<cfinput type="text" name="username" label="Username" required="yes" />
	<cfinput type="password" name="password" label="Password" required="yes" />
	<cfinput type="submit" name="submit" value="Sign In" />
</cfform>

PDF and Flashpaper Generation

ColdFusion can generate PDF or FlashPaper documents using standard HTML (i.e. no additional coding is needed to generate documents for print). CFML authors simply place HTML and CSS within a pair of cfdocument tags and specify the desired format (flashpaper or pdf). The generated document can then either be saved to disk or sent to the client's browser.

Object Oriented Coding In ColdFusion

ColdFusion was originally not an object-oriented programming language, and even today lacks some OO features. With the MX release (6+), ColdFusion introduced the component language construct which resembles classes in OO languages. Each component may contain any number of properties and methods. One component may also extend another (inheritance). Components only support single inheritance. ColdFusion does not currently support Java-style interfaces, but does support Ruby-style mixins. ColdFusion components use the file extension cfc to differentiate them from ColdFusion templates (.cfm). It's also worth mentioning that due to the MX layered architecture, full OO support is available by embedding pure java into your CFML (similar to how JSPs also support embedding of Java).

Component methods may be made available as web services with no additional coding and configuration. All that is required is for a method's access to be declared 'remote'. ColdFusion automatically generates a WSDL at the URL for the component thusly: http://path/to/components/Component.cfc?wsdl. Aside from SOAP, the services are offered in Flash Remoting binary format.

Methods which are declared remote may also be invoked via a HTTP GET request. Consider the GET request as shown. 

http://path/to/components/Component.cfc?method=search&query=your+query&mode=strict

This will invoke the component's search function, passing "your query" and "strict" as arguments.

The ColdFusion server will automatically generate documentation for a component if you navigate to its URL and insert the appropriate code within the component's declarations. This is an application of component introspection, available to developers of ColdFusion components. Access to a component's documentation requires a password.

Mixing ColdFusion and Java

ColdFusion runs as a web application and can be deployed in a number of supported servlet containers, including Jakarta Tomcat, Macromedia JRun, and IBM WebSphere, and even on a .NET app server (New Atlanta).

Because of ColdFusion's Java code-base, it is possible to mix Java classes with ColdFusion code to create a variety of applications and utilize existing Java libraries. ColdFusion has access to all the underlying Java classes, allowing usage of Java classes. ColdFusion also supports mixed usage of JSP custom tag libraries alongside CFML.

Prior to ColdFusion 7.0.1, ColdFusion components could only be used by Java or .NET by declaring them as web services. However, beginning in ColdFusion MX 7.0.1, it is now possible to utilize ColdFusion components directly within Java classes using the CFCProxy class.

Custom Tags

ColdFusion provides several ways to implement custom tags, i.e. those not included in the core ColdFusion language. The traditional and most common way is using CFML. A standard CFML page can be interpretted as a tag, with the tag name corresponding to the file name prefixed with "cf_". For example, the file IMAP.cfm can be used as the tag "cf_imap". Attributes used within the tag are available in the ATTRIBUTES scope of the tag implementation page. CFML pages are accessible in the same directory as the calling page, via a special directory in the ColdFusion web application, or via a CFIMPORT tag in the calling page. The latter method does not necessarily require the "cf_" prefix for the tag name.

A second way is the development of CFX tags using Java or C++. CFX tags are prefixed with "cfx_", for example "cfx_imap". Tags are added to the ColdFusion runtime environment using the ColdFusion administrator, where JAR or DLL files are registered as custom tags.

Finally, ColdFusion supports JSP tag libraries from the JSP 2.0 language specification. JSP tags are included in CFML pages using the CFIMPORT tag.

Query of Queries

ColdFusion uniquely supports query of queries, alternatively known as queries in memory. Given a variable of QUERY data type, ColdFusion can sort and retrieve selected rows from the result set using standard SQL. Note than in ColdFusion, a query datatype can be generated by methods other than standard database queries. For example, ColdFusion returns a query from a request to list the contents of a directory. For example: 

<cfdirectory action="list" directory="/path/to/directory/" name="listing" />
<!--- Get all XML files --->
<cfquery name="xmlFiles" dbtype="query">
  SELECT * FROM dirListing WHERE name LIKE '%.xml'
</cfquery> 	
<!--- Get all image files --->
<cfquery name="imageFiles" dbtype="query">
  SELECT * FROM dirListing WHERE name LIKE '%.jpg' OR name LIKE '%.gif' OR name LIKE '%.png'
</cfquery>

Queries in memory often result in a performance improvement as the ColdFusion server does not have to query the database server multiple times. In the above example, only a single query of the file system was needed, saving processing overhead.

Alternative Server Environments

ColdFusion originated as proprietary technology based on Web technology industry standards. However, it is becoming a less closed technology through the availability of competing products. Products include New Atlanta's BlueDragon, IgniteFusion, Railo, Coral Web Builder and DigitalLattice Orange.

In fact, one could now make the argument that ColdFusion is even less platform bound than say raw J2EE or .NET, simply because ColdFusion will run on top of a .NET app server (New Atlanta), or on top of any servlet container or J2EE application server (WebSphere, JBoss, Geronimo, Tomcat etc.) In theory, you could move a ColdFusion app unchanged from a J2EE app server to a .NET app server.

Currently, alternative server platforms generally support ColdFusion MX 6.1 functionality, with minor changes or feature enhancements.

Acronyms

The acronym for the ColdFusion Markup Language is CFML. When ColdFusion templates are saved to disk, they are traditionally given the extension .cfm or .cfml. The .cfc extension is used for ColdFusion Components. The original extension was DBM or DBML, which stood for Database Markup Language. When talking about ColdFusion, most users use the Acronym CF and this is used for numerous ColdFusion resources such as user groups (CFUGs) and sites.

CFMX is the common abbreviation for ColdFusion versions 6 and 7 (aka ColdFusion MX).

Code example

Query your database: 

<cfquery name="nameofquery" datasource="odbc_connection">
  SELECT * 
  FROM table
  WHERE field = 'foo'
</cfquery>

Loop through your records: 

<cfoutput query="nameofquery">
   #field_from_query#   
   <!---Above is a variable reference. This text is a comment --->
</cfoutput>

Set and display a variable: 

<cfset sMyVar = "A Variable defined in CFML">
Here is the contents of the variable: <cfoutput>#sMyVar#</cfoutput>

Define and use a function: 

<cffunction name="AddTwoNumbers" returntype="numeric" output="false" hint="I add two numbers.">
 <cfargument name="NumberOne" type="numeric" required="true" hint="I am the first number.">
 <cfargument name="NumberTwo" type="numeric" required="true" hint="I am the second number.">
 <cfreturn arguments.NumberOne + arguments.NumberTwo>
</cffunction>

<cfoutput>#AddTwoNumbers(2, 2)#</cfoutput>

Define a component (class): 

<cfcomponent extends="anotherComponent">
 <cfproperty name="property" type="string">  
 <cffunction name="init">
  <cfreturn THIS>
 </cffunction>
 <cffunction name="getSomeProperty" access="public" returntype="string">
  <cfreturn property>
 </cffunction>
 <cffunction name="setProperty" access="public" returntype="void">
  <cfargument name="property" type="string" required="true">
  <cfset property = arguments.property>
 </cffunction>
</cfcomponent>

Instantiate a Java class: 

<cfset myPath = "C:\MyFile.txt">
<cfset myFile = CreateObject("java","java.io.File").init(myPath)>
<cfset fis = CreateObject("java","java.io.FileInputStream").init(myFile)>

Dump the results of a query (for debugging): 

<cfquery datasource="#dsn#" name="myQuery">
 SELECT * FROM myTable
</cfquery> 
<cfdump var="#myQuery#">

Consume a web service: 

<cfset ws = CreateObject("webservice", "http://web.service/service?wsdl")>
<cfset result = ws.fun()>

or 

<cfinvoke webservice="http://web.service/service?wsdl" method="fun" returnVariable="result">

Syntax

CFML provides two different syntax formats for you to use, each with their own pros and cons.

Tag-based Syntax

CFML follows an XML/HTML-like syntax in that all commands are written in the format: 

<cfcommand argument="something">Some text</cfcommand>
<cfset variable = "some data">

Note that ColdFusion is not strictly XML because not all attributes have name value pairs and tags need not be well-formed. CFML more closely resembles HTML 4.0 syntax than XML. Since ColdFusion 6.0, the CFML syntax can almost entirely be expressed using XML format, with the key exception of CFIF/CFELSEIF/CFELSE tags.

CFSCRIPT Syntax

An additional syntax format is available that is similar to Javascript: 

<cfscript>
  command('argument 1', 'argument 2');
</cfscript>

This second format provides a cleaner migration path for people with experience in C-style languages: C, C++, Java, Javascript, etc. One thing to remember is that to use this syntax you must include the cfscript command around the code block -- you can't just launch into cfscript. Almost everything that can be done in tags can be done using CFSCRIPT. Some exceptions are:

  • SQL queries , which require the CFQUERY tag. Note that in ColdFusion, QUERY is a type which can be created in CFSCRIPT.
  • Throwing and rethrowing exceptions. (Since ColdFusion MX 6.0, try {} and catch() {} are available to cfscript.)
  • Most protocol-based client functionality, such as FTP, HTTP, POP, and LDAP. These are exposed via tags.

Since the introduction of UDFs, however, it is possible to define a UDF using tag-based syntax that can be called from within cfscript blocks: 

 <cffunction name="readUserData" access="public" returntype="numeric" output="false">
   <cfargument name="userId" type="numeric" required="true">
   <cfargument name="dsn" type="string" required="true">
   <cfset var userData = "">
   <cfset var rslt = "">
   <cfquery name="userData" datasource="#arguments.dsn#" result="rslt">
      select *
      from tblUser
      where userId = <cfqueryparam value="#arguments.userId#" cfsqltype="cf_sql_integer">
   </cfquery>
   <cfreturn userData>
 </cffunction>
 <cfscript>
   userData = readUserData(110, "myDataSource");
 </cfscript>

This allows the passing of arguments to tag-based constructs within cffunction blocks. Also, since ColdFusion MX 6.0 extended createObject() to include CFCs, it is possible to use both custom CFCs and Java objects in CFSCRIPT. Using Java objects to obtain access to protocol-based client functionality often defeats the whole purpose of using ColdFusion. Obviously, using CFCs or cffunction-based UDFs to provide script-style code access to the tag-based language features of ColdFusion is the preferred method.

Generally, CFSCRIPT is used perform simple statements–such as multiple assignments–in lieu of multiple CFSET tags.

CFSCRIPT can also be used to define UDFs: 

 <cfscript>
   function addTwoNumbers(a,b) {
     return a+b;
   }
 </cfscript>

In this case, however, it is impossible to define the content type detection that ColdFusion provides for arguments (string, numeric, query, struct, array, etc.), access restrictions on the UDF (public, private, package, remote), whether or not the UDF is allowed to generate output, or the return value content type (as with arguments). Using CFSCRIPT to define UDFs is handy for smaller tasks or simple things that aren't reliant on the various attributes that the CFFUNCTION and CFARGUMENT tags provide.

Coldfusion 8 (Codename: Scorpio)

Development is underway at Adobe to get a version 8 of ColdFusion released by late 2006 / early 2007. New features could include enhancements such as native image editing, access to the server internals from CF code and modifications to the presentation tier.

Criticism

Choices of scripting languages for any task are subject to much debate in the IT community. Criticisms of ColdFusion include:

  • ColdFusion is expensive, especially compared to its competitors, which are almost always free. Even Microsoft-based scripting solutions such as ASP.NET are technically free if you own a PC or server running some version of Windows. It can be argued that the rapid deployment of ColdFusion applications negates the cost of the server, since most applications can be built at manpower savings that significantly make up for the cost of the server. Nevertheless, the initial cost of a project remains relatively high.
  • Many scripting languages such as PHP, Ruby, Perl and Python are open-source. While the language of CFML itself is well-documented, ColdFusion's server code is not readily viewable or modifiable. Applications built using ColdFusion are viewable and modifiable unless they were deployed as a binary CAR file (similar to a JAR file).
  • CFML syntax is much different from traditional programming languages, which use a C-style syntax. Although CFScript offers this alternative, ColdFusion code is often written in CFML. CFML is certainly not alone in using tag-based syntax. JSP and .NET are examples of other scripting languages which feature tags.
  • ColdFusion is slow. Because ColdFusion is another layer of abstraction above a J2EE server, ColdFusion execution times can be slower than competing languages. Historically, the initial loading of a ColdFusion page had been slower than many competing scripting languages, but since ColdFusion 6.1, pages are directly compiled into native Java class files. The ColdFusion server can also cache pages and offers caching of database queries, which can greatly enhance performance.
  • ColdFusion libraries and extensions are few and rarely free. This criticism is somewhat negated by ColdFusion interoperability with Java, specifically JSP tag libraries, but is now generally seen as inaccurate among the ColdFusion development community, as there are many open source libraries available, such as those on CFLib and CFOpen.
  • ColdFusion lacks features present in other scripting languages. A significant omission from ColdFusion's tag library, for example, is the ability to manipulate common image formats. Another of note is a client IMAP tag. Missing features are often available as extensions, with the caveat on extensions as above.
  • ColdFusion lacks advanced object-oriented features such as multiple inheritance. ColdFusion supports single inheritance only, and makes little distinction between instance and class (virtual and static) properties and methods. ColdFusion doesn't offer constructor syntax per se, but rather forces an object factory pattern to return object instances. A common idiom is to use init to indicate a method which is the contructor for each component. Methods are implicitly virtual if they reference the THIS scope. There are several techniques available to provide mixin functionality.
  • CFScript is not ECMA-compliant. ColdFusion does include some server-side Actionscript functionality which is ECMA-script compliant. However, this feature is rarely used.

Development Aides

The following tools and frameworks are available:

Development Tools / Environments

Code Frameworks

  • ColdSpring - makes the configuration and dependencies of your CFCs easier to manage by using the inversion-of-control pattern
  • Fusebox - created in 1998, this was the first framework for use with ColdFusion. Fusebox 4.1 is the current version
  • Mach-II - the first ColdFusion OO framework based on the MVC pattern
  • Model-Glue - an OO framework based on the MVC pattern
  • onTap - a feature-rich framework for rapid application development (MVC controller, SQL language abstraction, form automation, i18n internationalization, etc.)
  • Tartan - a command-driven service framework for ColdFusion.

ColdFusion-Focused Podcasts

  • ColdFusion Weekly - A "virtually live" call-in podcast focused on events and issues in the ColdFusion community with hosts Matt Woodward and Peter Farrell.
  • ColdFusion Podcast - A ColdFusion focused podcast with hosts Bryan Kaiser and Michael Haynie.
  • Helms and Peters Out Loud - Explores topics in software and web development with hosts Hal Helms and Jeff Peters.

ColdFusion-Focused Magazines

Technical Mailing Lists

  • ColdFusion Technical Talk at House of Fusion - A high-volume list that tends to stay on the topic of ColdFusion and web development. For CFML developers of all skill levels.
  • CFCDev at CFCZone - A medium-volume list largely discussing object-oriented development practices and frameworks. For advanced CFML developers and those applying OOP principles in ColdFusion.
  • CFDJ at Sys-Con.

See also

Retrieved from "https://en.wikipedia.org/enwiki/w/index.php?title=Adobe_ColdFusion&oldid=61185664"