September 1, 2014
Hot Topics:
RSS RSS feed Download our iPhone app

Weaving the Tapestry Framework

  • October 24, 2005
  • By Vlad Kofman
  • Send Email »
  • More Articles »

Next, create a new directory "resources." In this directory, I have placed all property and config files necessary for the sample application, including the main ".application" file. These files can be placed directly in the WEB-INF, but for convenience they have their own directory. Create a couple of empty text files with actual names such as "first-tapestry-app.application", "Home.page," and "Next.page" in that folder (you will add contents to these files later).

Create a Web Module—TapesryWebModule—in JBuilder and configure it to include all libs in the WAR file build process and these resources.



Click here for a larger image.



Click here for a larger image.

Assuming you also have downloaded MySql and installed it, this is all that is needed for the configuration of the development environment for now.

The final project should look something like this:

Main Components

Here is a very general structure of the framework.

  1. The Application Servlet is invoked by the Web container.
  2. It creates an Application Engine object on behalf of each user.
  3. The Application Engine reads the main application config file.
  4. The Application Engine reads property files.
  5. The Application Engine renders a HTML view from a template.

Look at the configuration files before continuing to see the data flow and structure. The standard web.xml file for the WAR module of the sample Tapestry application can look like a very common config file for any WAR file.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app
   PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
   "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
   <servlet>
      <servlet-name>controller</servlet-name>
      <servlet-class>com.sys.Controller</servlet-class>
   </servlet>
   <servlet-mapping>
      <servlet-name>controller</servlet-name>
      <url-pattern>/controller</url-pattern>

</servlet-mapping> </web-app>

Here, I defined a servlet called "Controller" that extends org.apache.tapestry. ApplicationServlet (note that there have been a lot of changes between Tapestry versions 2 and 3, including a package structure in version 2 ApplicationServlet was under net.sf.tapestry.ApplicationServlet), and also mapped the servlet name. A subclass servlet is needed only if you want to customize the options and path. Tapesry's main servlet has several methods, such as getApplicationSpecificationPath, that can be overwritten. If you have no need to change these settings, you can use the ApplicationServlet directly. (Also note that the setupLogging method is no longer available in version 3.)

public class Controller
      extends ApplicationServlet {
   private static Logger logger = Logger.getLogger(Controller.class);
   public Controller() {
   }
   protected String getApplicationSpecificationPath() {
      return "/resources/first-tapestry-app.application";
   }

As I mentioned, any Tapestry application also needs a main "application" config file. For example, the "first-tapestry-app.application" XML file located in the application server class path. You now can add contents to this file that is under the directory called "resources." It will end up under the "WEB-INF -> classes" directory of the WAR module.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE application PUBLIC
   "-//Howard Lewis Ship//Tapestry Specification 1.3//EN"
   "http://tapestry.sf.net/dtd/Tapestry_1_3.dtd">
<application name="first-tapestry-app"
   engine-class=" org.apache.tapestry.engine.BaseEngine">
   <property name="driverClass">com.mysql.jdbc.Driver</property>
   <property name="dbUrl">jdbc:mysql://localhost/test</property>
   <property name="user">root</property>
   <property name="password">password</property>
   <page name="Home" specification-path="/resources/Home.page"/>
</application>

The first-tapestry-app.application file is very simple; you give the application name, use the standard engine, and define a single page, named "Home." In Tapestry, pages and components are specified with the path to their specification file (a file that ends with ".page" for page specifications or ".jwc" for component specifications).

The page named "Home" has a special meaning to Tapestry: When you first launch a Tapestry application, it loads and displays the "Home" page. All Tapestry applications are required to have such a page.

Note: In previous versions of Tapestry, it was required to list all of application pages in the .application file. In Tapestry 3.0, it is necessary only to list the "Home" page.

The "JWC" stands for java Web components and "page" files are XML files that describe structure of the HTML file.

In Tapestry, every HTML page that the user sees is rendered dynamically and consists of at least three pieces. One piece is an HTML template file that is pure HTML with place holders for Tapestry components. The second piece is the XML specification "page" file that defines what will go (and be done) with the final HTML. The third piece is usually a corresponding Java Class. There could be many more "helper" files, defining individual JWC components, and so on.

The Home page specification could look like this:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE page-specification
PUBLIC "-//Apache Software Foundation//Tapestry Specification 3.0//EN"
"http://jakarta.apache.org/tapestry/dtd/Tapestry_3_0.dtd">
<page-specification class="org.apache.tapestry.html.BasePage">
   <description> Simple Home Page </description>
</page-specification>

The corresponding Home.html could look like this:

<html>
<head>
<title>Simple Home Page</title>
</head>
<body>
   Welcome to your first <b>Tapestry Application</b>.
</body>
</html>

The application will compile and run but it's not very exciting; there's no dynamic content. A very interesting observation is that there was no JavaServer page (JSP) here, and no HTML directly visible to the Web server. Tapestry assembled an application consisting of a single component on the fly and presented it to the user. This is one of the greatest differences between Tapestry and other Web development frameworks. Additionally, these created objects and pooled and reused, which makes this framework very scalable.

Conclusion

In this article, I have described the basic concepts of the Tapestry framework. I have decided to split my discussion about the framework in to two parts because I feel it's too large and complex for one article. I have shown how to create a sample project in an enterprise-scale IDE such as JBuilder and talked about framework config files and setup. In the next part of this article, I will show you how to create a real dynamic example that communicates to a RDBM source and uses more Tapestry components.

References

Online

Wikipedia online: http://en.wikipedia.org/wiki/

Tapestry (general): http://jakarta.apache.org/tapestry/

Tapestry online tutorial

Print

Neal Ford: Art of Java Web Development: Struts, Tapestry, Commons, Velocity, JUnit, Axis, Cocoon, InternetBeans, WebWork (Paperback), ISBN 1932394060

About the Author

Vlad Kofman is a Senior System Architect implementing enterprise-scale projects for the major Wall Street firms, projects under defense contracts and the U.S. government. His main interests are object-oriented programming methodologies and design patterns.





Page 2 of 2



Comment and Contribute

 


(Maximum characters: 1200). You have characters left.

 

 


Sitemap | Contact Us

Rocket Fuel