ColdFusion 9 Developer Tutorial: Create robust professional web applications with ColdFusion

We start by creating a file that ends with .cfc when creating CFCs. Non-CFC files that you have been creating up to this point, and will also continue to create, end with .cfm.

Each CFC is wrapped by a set of tags and has one or more functions, which are also referred to as methods. We will be creating an object class. There are different types of objects, and a CFC is the type we normally use in ColdFusion. Now, let us look at some empty code, so you can get an idea of what one might look like:

<cfcomponent>
  <cffunction>
  </cffunction>
</cfcomponent>>

Certainly, we cannot do much with this segment of code. This is just for us to get a first glimpse of CFC code. Here, we get an idea of what it is and start our journey of discovery. You see there is a <cfcomponent> tag that surrounds the whole CFC. You can add additional attributes, but for now we are going to keep it as simple as possible and try to learn how to write CFCs without getting bogged...

Our first object is a generic model of a product. There are things that different products have in common. This object will be a combination of the common attributes and methods. The difference is that this is a computer object. Yet, we will do things in ways that reflect the real world. Our product object has attributes and methods. We will map them out here below. Remember, this will all make more sense as we work through this chapter. Along the way, you will get an understanding of both how CFCs work and how to interact with a database.

...

We will modify our code just a little bit to correct the missing variable using the constructor init() method. Modify the createObject line by adding .init(); to the end as shown in the following highlighted line. You will find that you can tack on a method you want to call at the time of creating an object, all on the same line. This is a common method among developers. When you use a constructor, you should always return the this variable to the caller. this is the variable scope of an object that refers to itself and this returns a reference to the object itself. That will correctly pass the object back when you place the constructor at the end of the creation of the object. If you look at the init method in the CFC, you will find that we include it with the <cfreturn this>.

<!--- Example: 2_2b.cfm --->
<!--- Processing --->
<cfscript>
  objProduct = createObject("component","product_1").init();

You will also notice that we are pulling...

Developers used to code the data and presentation into the same file. There was no "data layer" for developing software; it was all mixed on the same page. This made the pages longer and there was much more to work through to figure out bugs or page enhancements. It was pretty much what we call "information overload". CFCs change that by encapsulating the data as a separate layer. Then the interface serves as a simpler way to push and pull data to and from your database.

Here we will create another version of our product.cfc object class. Let's name it product_2.cfc so we can keep things separate in case you want to go back and compare them later. Let's take a look at the...

Lastly we return the rsReturn variable to the caller. You will note that this has changed the variable type to a ColdFusion query which is the name for the returned recordset from <cfquery>.

Now we need to create a calling page. We have to see what is coming back from the database and how it looks inside ColdFusion. Here is the code to our calling page.

<!--- Example: 2_4.cfm --->
<!--- Processing --->
<cfscript>
  objProduct = createObject("component","product_2").init();
  rsProducts = objProduct.getRecordset();
</cfscript>
<!--- Content --->
<cfdump var="#rsProducts#">

We see something new in the recordset dump since ColdFusion version 8. This version includes the attributes for cached, execution time, and the SQL that was run to produce the query. These can be very helpful for development, debugging, and logging. You will also see that the result set displays each row in a table. Each of the fields returned from the database...

We set the default value so the page doesn't fail if there is no value for the ID variable passed in. We added the singular getProduct variable. It actually returns a recordset just like rsProducts returns a recordset. The only difference is that this will return a single record after we modify the CFC. Currently the CFC doesn't handle the where argument even though it is part of the method. We have to build in the functionality. This is what the method should look like now. Change the highlighted lines to make this method work correctly. As we are not adding the query type to the <cfoutput> tag inside the if condition where there is only one record, it will not loop through the query. It will only return the first record in the recordset. In this instance there is only one record, so that would be the same. This information is just for future reference, so we will understand why only one row appears on our web page and why we have to declare the query...

Now we create the function for assigning the encapsulated variables of the object when it is created. We are now ready to write the next version of the calling page. We are only going to change two things on that page. We will change the line where we were creating a second recordset to a call to the method for performing the assigning of the internal variable values in the object. Then we will change our content section of the code to use the object getters to pull the encapsulated variable values. The highlighted rows are the ones changed.

<!--- Example: 2_6.cfm --->
<!--- Processing --->
<cfparam name="url.id" default="0">
<cfscript>
  objProduct = createObject("component","product_2").init();
  rsProducts = objProduct.getRecordset();
  objProduct.load(url.id);
</cfscript>
<!--- Content --->
<ul><cfoutput query="rsProducts">
  <li><a href="?id=#rsProducts.id#">#rsProducts.name#</a></li&gt...

Generally, objects are not intended to create output other than returning actual variables. That is why the attributes output="false" have been added all over the CFC code. You will also notice that there is an attribute called access="public" in many of the methods. There are actually a number of settings for this. All of these indicate where the calling code must be for the method to run. Here is a list of the settings and definitions for each one:

One of the biggest advantages of CFCs is the ability to encapsulate logic. This means that we can use the same code over and over without writing it over and over. This makes initial development better. It also makes debugging and updates much more manageable. In this chapter you have just started to get a taste of the power of objects. We will be using them often throughout the rest of this book. This chapter was meant to give you a foundation to understand what follows in the remaining chapters.

Lessons learned in Chapter 2 are: