cfinterface

Defines an interface that consists of a set of signatures for functions. The interface does not include the full function definitions; instead, you implement the functions in a ColdFusion component (CFC). The interfaces that you define by using this tag can make up the structure of a reusable application framework.

History

ColdFusion 8: Added this tag.

Category

Application framework tags, Extensibility tags

Syntax

See also

cfargument, cfcomponent, cffunction, GetComponentMetaData, IsInstanceOf

Attributes

Usage

The cfinterface tag declares a set of related functions that any ColdFusion component (CFC) that implements the interface must define. The interface specifies function signatures, but does not implement the functions; instead, the CFC that implements the interface must contain the full function definitions.
For example, you could create a create, read, update, and delete (CRUD) interface that defines the basic signatures of the four operations. All components that implement the interface must then conform to the interface signatures. You can then implement the interface in different components to manage different types of data sources. Because all the components implement the same interface, you can ensure that you can easily replace one component with another, depending on the specific data source that an individual application requires.
You define an interface by creating a ColdFusion file with a .cfc extension and specifying the cfinterface tag as the first and only top-level tag in the file. The filename determines the interface name, so myInterface.cfc defines the myInterface interface. You can specify any attributes in the cfinterface tag; however, only the names listed in the Attributes table are meaningful to ColdFusion. The filename must not contain commas, or any periods except for the separator before the .cfc extension. Inside the cfinterface tag body, you specify the interface by declaring the functions of the interface. The interface definition must follow these basic rules:

• The cfinterface tag body can contain only cffunction tags and comments.
• The cffunction tag bodies can contain only cfargument tags, which declare the function arguments, and comments.

• The cffunction tag body is optional.
  The following example shows the general format of an interface definition:

This interface extends the IBasicInterface interface, so any component that implements this interface must also implement the methods of the IBasicInterface interface. This interface requires the component to implement the following three functions:

• A hello function that can optionally take a single string argument, which has a default value of "world".
• A calculateTwo function that takes one required numeric argument, has an optional numeric argument with a default value of 0, and must return a number.
• A disclaimer function that takes no arguments and returns any type.
  The CFC that implements an interface specifies the interface name in the cfcomponent tag's implements attribute. It must implement all of the interface's methods as specified in the interface cffunction tags. The order of function arguments in the interface definition and the component definition must be identical.
  The following table lists the attributes that you can use in the cffunction and cfargument tags, and describes the requirements and limitations on how you can use them in the interface definition and the component implementation:

A CFC can implement multiple interfaces.

ColdFusion uses the same rules to locate interfaces as it does to locate components. You can use the GetComponentMetaData function to get information about an interface.Adobe recommends that you use a consistent technique for identifying interface names, for example, by always starting the file (and therefore interface) name with a capital I. Any component that implements only that single interface could have a similar name, for example the same root prefixed by a capital C. You could have an IresourceInfo.cfc interface file and a corresponding CresourceInfo.cfc component file, for example.

Example

The following example defines an IBasicMath interface with add, subtract, multiply, and divide operations. The integerMath CFC implements this interface by defining integer arithmetic versions of the operations. The testMath.cfm application uses the integerMath functions to do arithmetic calculations on two decimal numbers (using the values of pi and e). As an exercise, consider modifying the interface definition to take and return values of any type, and then implement a second CFC that uses the PrecisionEvaluate function to calculate arbitrary precision arithmetic and return the results. (These versions are omitted for brevity.)The IBasicMath.cfc file defines the interface as follows:

The integerMath.cfc file defines the integerMath component, which implements the IBasicMath interface, as follows:

The testMath.cfm file uses the integerMath component methods to calculate integer values, as follows: