ColdFusion pages and JSP pages can interoperate in several ways:
The following sections show how you can use these techniques.
You can integrate JSP pages and servlets in your ColdFusion application. For example, you can write some application pages in JSP and write others in CFML. ColdFusion pages can access JSP pages by using the JSP include
and forward
methods to call the page. As with any web application, you can use href
links in ColdFusion pages to open JSP pages.
The ability to use JSP lets you incorporate legacy JSP pages in your ColdFusion application, or conversely, use CFML to expand an existing JSP application using ColdFusion pages.
If you have a JSP page that must call a ColdFusion page, you also use a jsp:forward
or jsp:include
tag to call the ColdFusion page. For an example of calling a ColdFusion page from a JSP page, see "Calling a JSP page from a ColdFusion page".
To access a JSP page or servlet from a ColdFusion page, you use the getPageContext
function with the forward
or the include
method. For example, to include a JSP "Hello World" page in your ColdFusion application, use the following line:
GetPageContext().include("hello.jsp");
To pass parameters to the JSP page, include the parameters in the page URL.
For example, you might want to integrate an existing JSP customer response component into a new ColdFusion order processing application. The order processing application provides the order number, total cost, and expected shipping date, and the customer response component sends the response to the e-mail address on file for the particular customer number. The ColdFusion application might use the following CFScript code to call the response JSP page:
urlParams = "UID=#order.uid#&cost=#order.total#&orderNo=#order.orderNo# &shipDate=#order.shipDateNo#"
getPageContext().forward(URLEncodedFormat("/responsegen/responsegen.jsp ?#urlParams#"));
To access a servlet that exposes the same functionality, you use the same code, although the URL would change. For example, to run a servlet called HelloWorldServlet, you put the servlet .java or .class file in the serverroot/WEB-INF/classes directory and refer to the servlet with the URL /servlet/HelloWorldServlet.
If an application includes ColdFusion pages and JSP pages or servlets, they can share data in the Request, Session and Application scopes. The following table lists the ways that you can access JSP pages with which you want to share the scope data:
Scope |
Can share data using |
---|---|
Request |
forward, include |
Session |
href, cfhttp, forward, include |
Application |
href, cfhttp, forward, include |
Note: When you share data between ColdFusion pages and JSP pages, you must be careful about data type conversion issues. For more information, see "Java and ColdFusion Data Type Conversions".
To share session variables, you must specify J2EE session management in the ColdFusion Administrator. For more information on configuring and using J2EE Session scope management, see "ColdFusion and J2EE session management," in Chapter 15.
For example, you could put the customer order structure used in the previous example in the Session scope. Then, you would not have to pass the order values as a set of parameters. Instead, the JSP pages could access the Session scope variables directly, and the ColdFusion page would only require a line like the following to call the JSP page:
getPageContext().forward(URLEncodedFormat("/responsegen/responsegen.jsp"));
For examples of using the Request, Session, and Application scopes to share data between ColdFusion pages and JSP pages, including samples of the appropriate JSP code, see the following section, "Examples: using JSP with CFML" .
ColdFusion runs as a J2EE application on the J2EE application server. The J2EE application ServletContext is a data structure that stores objects as attributes. A ColdFusion Application scope is represented as an attribute named by the Application scope name. The attribute contains the scope values as a hash table. Therefore, you access ColdFusion Application scope variable in a JSP page or servlet using the following format:
((Map)application.getAttribute("CFApplicationName"))).get("appVarName")
Similarly, the ColdFusion Session scope is a structure within the J2EE session. Because ColdFusion identifies sessions by the application name. the session structure is contained in an attribute of the J2EE session that is identified by the application name. Therefore, you access ColdFusion session variables as follows:
((Map)(session.getAttribute("CFApplicationName"))).get("sessionVarName")
If you do not specify an application name in the ColdFusion cfapplication
tag, the application is unnamed. ColdFusion supports only a single unnamed application, so if multiple cfapplication
tags do not specify an application name, all pages affected by the tags share the single unnamed application Scope. This scope maps directly to the J2EE application scope. Similarly, all sessions of unnamed applications correspond directly to the J2EE application server's session scope.
You access an Application scope variable from a ColdFusion unnamed application in a JSP page using the following format:
application.getAttribute("applicationVariableName")
You access Session scope variables in a ColdFusion unnamed application as follows:
session.getAttribute("sessionVariableName")
Note: When you use application and session variables for the unnamed ColdFusion application in JSP pages and servlets, the variable names must be case-correct. That is, the characters in the variable name must have the same case as you used when you created the variable in ColdFusion. You do not have to use case-correct application and session variable names for named ColdFusion applications.
The following simple examples show how you can integrate JSP pages, servlets, and ColdFusion pages. They also show how you can use the Request, Application, and Session scopes to share data between ColdFusion pages, JSP pages, and servlets.
The following page sets Request, Session, and application variables and calls a JSP page, passing it a name parameter:
<cfapplication name="myApp" sessionmanagement="yes">
<cfscript> Request.myVariable = "This"; Session.myVariable = "is a"; Application.myVariable = "test."; GetPageContext().include("hello.jsp?name=Bobby"); </cfscript>
The following table describes the CFML code and its function:
The hello.jsp page is called by the CFML. It displays the Name parameter in a header and the three variables in the remainder of the body.
<%@page import="java.util.*" %>
<h2>Hello <%= request.getParameter("Name")%>!</h2> <br>Request.myVariable: <%= request.getAttribute("myvariable")%> <br>session.myVariable: <%= ((Map)(session.getAttribute("myApp"))) .get("myVariable")%> <br>Application.myVariable: <%= ((Map)(application.getAttribute("myApp"))) .get("myVariable")%>
The following table describes the JSP code and its function:
The following JSP page sets Request, Session, and application variables and calls a ColdFusion page, passing it a name parameter:
<%@page import="java.util.*" %>
<% request.setAttribute("myvariable", "This");%> <% ((Map)session.getAttribute("myApp")).put("myVariable", "is a");%> <% application.setAttribute("myApp.myvariable", "test.");%> <jsp:include page="hello.cfm"> <jsp:param name="name" value="Robert" /> </jsp:include>
The following table describes the JSP code and its function:
The following hello.cfm page is called by the JSP page. It displays the Name parameter in a heading and the three variables in the remainder of the body.
<cfapplication name="myApp" sessionmanagement="yes">
<cfoutput> <h2>Hello #URL.name#!</h2> Request.myVariable: #Request.myVariable#<br> Session.myVariable: #Session.myVariable#<br> Application.myVariable: #Application.myVariable#<br> </cfoutput>
The following table describes the CFML code and its function: