Corporate Info | News | Solutions | Products | Partners | Services | Events | Download | How To Buy

# Using WebLogic JHTML I. Introduction What is JHTML? How it works II. Converting between JHTML and JSP III. Setting up WebLogic for JHTML Register the PageCompileServlet Related properties IV. Implementing with WebLogic JHTML Quick reference JHTML tags supported in WebLogic Reserved words in JHTML A simple example How JHTML relates to Java Importing packages Defining the body of the service method Declaring class scope objects Embedding a Java method in a JHTML file Using the backtick Using session tracking Getting data with JDBC IV. Using the WebLogic JHTML compiler V. Change history Other related documents Installing WebLogic (non-Windows) Installing WebLogic (Windows) Developers Guides API Reference Manual Glossary # I. Introduction Note: For future HTTP servlet projects, we recommend you use JSP instead of the older JHTML standard. ## What is JHTML? JHTML is a JavaSoft standard for combining Java with HTML pages. In particular, JHTML makes it easy to intersperse dynamic data within your HTML pages. If you understand HTML and you know a little about Java, you can learn how to use JHTML very quickly. If you are just beginning with Java, check out the Java tutorial at Sun. WebLogic offers support for the Java specification for JHTML, which is part of the Java WebServer API (Page Compilation technology) recently introduced by JavaSoft. JHTML allows you to embed Java into a standard web page. You -- or your marketing department -- can create a web page in any HTML editor, and then you -- or your engineering team -- can add Java to the HTML page. The WebLogic Server interprets your JHTML and will send a web page to your client's browser. The ability to combine Java with HTML makes it easy to design the layout of your web page using HTML, whilst embedding dynamic data that can be retrieved from a database or derived from user input, using Java. WebLogic's implementation of JHTML is very similar to that used in JavaSoft's WebServer. You can find good documentation for new-comers to HTML and Java at their website on Introducing Page Compilation. This document assumes you have some experience with Java and that you are very familiar with HTML. To get started with JHTML, you need to add a few properties to your weblogic.properties file. Check the section below on Setting up WebLogic. ## How it works JHTML is implemented using a special HTML servlet that comes as standard with the WebLogic Server, called the PageCompileServlet. The PageCompileServlet is set up by default to handle all HTTP requests for files ending in ".jhtml". The PageCompileServlet calls upon the JHTML compiler to compile the JHTML file into a standard Java HTTP servlet , and executes the new servlet on the fly. The resulting HTTP servlet delivers a web page in response to the client browser. The JHTML file is only compiled when it is visited for the first time, or when the JHTML file has been changed since it was last compiled. Otherwise, the previously compiled JHTML servlet class is used, making subsequent responses much quicker. It is possible to use the JHTML Compiler stand alone. You can look at the ".java" files it produces, or just register the HTML servlet ".class" files. # II. Converting between JHTML and JSP This guide will help you convert your legacy JHTML pages into JSP format. The first step to convert your JHTML pages by hand is to copy the file to a similarly named file, but using the extension .jsp in place of .jhtml. You will need to open the copied JSP file in a text editor and start making changes by hand. ## Mapping JHTML syntax to JSP This table shows the corresponding JSP tags to use in place of JHTML tags in your converted JSP. JHTML tag | JSP tag
    <java>
      java_code
    <java>
...or...
    <java type=code>
      java_code
    </java>
    <%
        java_code
    %>
...or use XML equivalent...
    <jsp:scriplet>
      java_code
    </jsp:scriplet>
    <java type=package>
      package.name
    </java>
| There is no equivalent tag you can use in a JSP file. You can configure the package name of the generated HTTP servlets with the packagePrefix initArg in the JSPServlet registration in the weblogic.properties file.
    <java type=import>
      import mypackage.one.*;
      import mypackage.two.*;
    </java>
    <%@ page
        import="mypackage.one.*,
                mypackage.two.*"
    %>
    <java type=extends>
      extended.class
    </java>
    <%@ page
        extends="extended.class" %>
    <java type=implements>
    </java>
| There is no equivalent tag in JSP.
    <java type=class>
      ...define class-scope
      variables or
      methods here...
    </java>
    <%!
      ...define class-scope
      variables or
      methods here...
    %>
    <java type=method>
      new_method_name
    </java>
| There is no equivalent capability in JSP.
    <java type=print>
      java-expression
    </java>
    ...and...
    ` (backtick)
    <%=
      java-expression
    %>

## Referencing HTTPServlet variables

One of the biggest obstacles faced when converting from JHTML to JSP are the changes required to cope with the different underlying architectures. Often, JHTML pages may presume that the generated servlet class implementation extends an HTTPServlet, and may reference the inherited methods and member variables of the presumed super-classes. The generated JSP servlets do not extend HTTPServlet, but do provide a number of implicit objects that represent all of the HTTP servlet facilities your JSP page requires.

Declaring custom variables with the same names as JSP implicit objects will cause a translation-time error, so you will need to replace such variable names in your JHTML pages with another name.

JSP and JHTML share the same implicit object names and types for request and response. You may refer to both as you would in a JHTML page. However, in JSP, there are other ways in which you may set attributes of the response object. The page directive allows you to set the content type of the response and the character set. The <jsp:useBean> tag provides a clean way to add variables to various levels of scope, including the HTTPSession, and the JSP implicit object session represents the HTTPSession in the HTTPResponse.

# III. Setting up WebLogic for JHTML

Before you can request a .jhtml file, you must set up the WebLogic Server with the following properties in your weblogic.properties file.

### Register the PageCompileServlet

The PageCompileServlet is a standard HTTP servlet included with the WebLogic Server. You must register it to handle all HTTP requests for files ending with the suffix ".jhtml" using the line:

    weblogic.httpd.register.*.jhtml=\
      weblogic.servlet.jhtmlc.PageCompileServlet

You can add additional registrations to instruct the PageCompileServlet to handle other file suffixes (such as "*.htm", "*.html", and "*.txt") using a similar syntax to that above. The use of an extension takes precedence over any default servlet registration.

You set up initialization arguments for the PageCompileServlet using the standard servlet initArgs property as shown here:

    weblogic.httpd.initArgs.*.jhtml=\
      compileCommand=path to compiler,\
      workingDir=path to directory of compiled .jhtml classes,\
      verbose=[true | false],\
      pageCheckSeconds=interval WebLogic checks for re-compilation,\
      packagePrefix=package name of files (default: "jhtmlc")

Where the argument names are defined as:

compileCommand
  (Required)
  Specifies the Java compiler to be used by the PageCompileServlet. For example, to use the Symantec Java compiler:

       compileCommand=/VisualCafe/bin/sj.exe

workingDir
  (Required)
  Specifies the absolute path of a local directory where the compiled ".class" and ".java" files from the JHTML compiler are placed. For example,

        workingDir=/weblogic/myserver/compiled

  This directory will contain the ".java" and ".class" files generated from all JHTML pages.

  Note: The workingDir should not point to a directory in the system classpath, otherwise this may result in a ClassCastException when invoking the generated HTTP servlet.

verbose
  (Optional) default value is false.
  When set to true debugging information is printed out to the console and the WebLogic Server log file.

keepgenerated
  (Optional) default is false.
  When set to true, the generated ".java" source files are stored with the class files in the directory specified by the workingDir parameter.

pageCheckSeconds
  (Optional) default value is 0.
  Sets the interval at which WebLogic checks to see if JHTML files have been changed and need recompiling. Dependencies are checked and recursively reloaded if changed. If pageCheckSeconds is -1, pages are not checked after they are compiled.

packagePrefix
  (Optional) default value is "jhtmlc".
  Sets a package name for automatically compiled pages. This should prevent class name clashes with your other servlets and applets, so long as you do not also compile them into a package of the same name.

## Related properties

The following are related properties that you may need to set in your weblogic.properties file. These properties are used by other services of the WebLogic Server. When changing their settings you should consider the impact on other services.

### Setting the Document Root

This is the directory where you publish your ".jhtml" files on the WebLogic Server. You set this using the property:

    weblogic.httpd.documentRoot=path

where path is an absolute directory path, or a relative directory path from the myserver/ directory under your WebLogic installation. For example, if you set the property to:

    weblogic.httpd.documentRoot=jhtml

You would publish your JHTML files in the directory: $WEBLOGICROOT/myserver/public_html/jhtml.

If you do not set this property, it will default to the $WEBLOGICROOT/myserver/public_html directory. The document root is the top level directory where the WebLogic Server searches for all published web pages. This property is also used by the FileServlet, which is registered by default to deliver all other types of HTTP media.

### Setting up session tracking

To enable session tracking, set this property to "true":

    weblogic.httpd.session.enable=true

Other properties related to session tracking can be found in the "Using WebLogic HTTP Servlets" developer's guide.

### Other properties

Other useful related properties include:

- Setting up a server-side connection pool.

- Registering a servlet and setting up its access control list , see the Developers Guide, Using WebLogic HTTP Servlets.

# IV. Implementing with WebLogic JHTML

Quick reference
  JHTML tags supported in WebLogic
  Reserved words in JHTML
A simple example
How JHTML relates to Java
  Importing packages
  Defining the body of the service method
  Declaring class scope objects
  Embedding a Java method in a JHTML file
Using the backtick
Using session tracking
Getting data with JDBC

## Quick Reference

If you are familiar with JHTML, this quick reference should help refresh your memory, and bring you up to speed with WebLogic JHTML. Follow the steps in Setting up Weblogic for JHTML to enable the server. The following tables give a brief description of the JHTML tags and reserved words. If you are new to JHTML, you may skip to "A simple example".

### JHTML tags supported in WebLogic

Here is a quick reference list of the tags used in WebLogic JHTML. Note that all of these <java> tags require an ending </java> tag. All of these tags can be included inside, or combined with, java comments. For example, the tags:

      <java>
      .
      .
      .
      </java>

can also be written as:

      <!--java>
      .
      .
      .
      </java-->

JHTML tag | Description
<java> or <java type=code> </java> | Delimits Java source code from HTML page code. The last two variations can be used to hide Java code in a comment block from visual page editors. See "Defining the body of the service method".
<java type=package> </java> | Assigns a package name for the class into which this file will eventually be compiled, for example: <java type=package>tutorial.servlet.jhtml</java>
<java type=import> </java> | Designates a package or class to import. Use regular import statements for all packages within only one set of tags per JHTML file, separated by semi-colons. See "Importing Packages".
<java type=extends> <java type=implements> </java> | Designates the name of a class to extend or a list of interfaces to implement. The servlet that results from compiling the JHTML file will extend this class or implement the interface(s).
<java type=class> </java> | Allows adding class variables and defining class methods for a page. See "Declaring class scope objects".
<java type=method> </java> | Overrides the service() method name; the superclass method can then be used for pre- and post-processing of the user-specified method.
<java type=print> </java> | Prints the enclosed Java expression to the output stream. This is very similar to the use of the backtick.
` (backtick) | Operator. You can embed a Java expression in any arbitrary HTML tag by enclosing it in backticks. The expression is evaluated and then converted to a string. See "Using the backtick".

Note: WebLogic does not currently support the <servlet> tag.

### Reserved words in JHTML

JHTML reserves the use of these words within embedded Java code. In this case, you use these words as objects in your Java code.

out
  out represents the HTTP response output stream, through which your JHTML servlet sends the response to the browser. It is technically a subclass of java.io.OutputStream object, an abstract class that defines how to handle streams of bytes. The out object has several methods you can use, including write(), which takes a String value and prints it to a page, and flush() which lets you clear the stream before printing something new.

request
  request is the HttpServletRequest object. It contains information about the request from the browser, and has several useful methods for getting cookie, header, and session data.

response
  response represents the HttpServletResponse object. The response object is used to deliver the servlet output back to the web browser. It has several useful methods for setting cookies, and obtaining an output stream.

  For more about the request and response objects, read the related Developers Guide, Using WebLogic HTTP Servlets.

## A simple example

Using the <JAVA> tag

Here is a very simple page that mixes HTML with embedded Java. Notice these basics:

- You can have multiple blocks of Java code. The page will be read sequentially; that means that each block of Java code -- and its resulting display -- will occur in the normal sequence of the HTML page, just as you have written it.
- You can switch between HTML and Java code anywhere, even within Java constructs and blocks. Note in the loop shown here that we declare a Java loop, switch to HTML, then switch back to Java to close the loop. The HTML is output multiple times as the loop iterates.
- You can use the class variable out to print things directly to the servlet output stream from your Java code. Here we call the write() method to print a string.
- You can also use the shortcut html() method within a Java tag to insert an arbitrary string.
- The Java tag is an "inline" tag; it doesn't force a paragraph.

    <html>
    <head><title>Hello World Test</title></head>
    <body>

    <h1> <font color=#DB1260> Hello World Test </font></h1>

    <java>
    out.print("Java-generated Hello World");
    </java>

    <p> This is not Java!
    <p><i>Middle stuff on page</i>

    <p>
    <java>
    for (int i = 1; i<=5; i++) {
      out.print("This is a Java loop! " + i + "<p>");
    }
    </java>

    </body>
    </html>

Here is what the resulting page will look like after it is compiled:

# Hello World Test Java-generated Hello World This is not Java! Middle stuff on page This is a Java loop! 1 This is a Java loop! 2 This is a Java loop! 3 This is a Java loop! 4 This is a Java loop! 5

## How JHTML relates to Java

In this section, we describe how the Java in your JHTML page relates to a regular Java class, and how it is compiled into an HTTP servlet.

The JTHML compiler turns your JHTML file into an HTTP servlet ".java" file. The resulting file must be a legal ".java" file so it may be compiled by a regular java compiler. In effect, all of your plain HTML is turned into Java write() statements that send the HTML to the HTTPServletResponse output stream. You include Java code in your HTML page by wrapping it in special <java> tags. The order of the HTML print statements and the Java code are preserved, and essentially make up the body of the HTTP servlet's 'service' method. For more details on the structure of an HTTP servlet, see the "Using WebLogic HTTP Servlets" developer's guide.

Since your JHTML is ultimately translated into plain Java, you can use any Java constructs, classes or WebLogic services within your JHTML page, just as you would for writing a regular servlet. For more details on using WebLogic services from server-side Java see "Using WebLogic services from an HTTP servlet" in the HTTP servlet developer's Guide.

Note: Make sure that the names of your .jhtml files do not collide with any of your other servlet or applet classes. All the .jhtml files are eventually compiled into .class files, and so you should not use any names that conflict with any existing servlet or applet class that may be in your WebLogic Server's CLASSPATH .

Other types of tags allow you to define and declare other sections of the generated servlet class from the JHTML file.

In this section, we build upon an example that illustrates a simple database login, interrogates a database, and displays the results in a web page.

### Importing packages

You must import other java packages into your JHTML using the special <java type=import> tag type. Here, we import the java.sql.* package, which contains the JDBC interfaces. (There is more on using JDBC in any of the JDBC Developer Guides.) You can only have one <java type=import> tag in a JHTML file, but you can have many import statements within that one tag. Although you can place the import tag anywhere in your JHTML file, we recommend that you place it at the top of the file, as you would for a regular ".java" file.

    <java type=import>
    import java.io.*;
    import java.sql.*;
    </java>

### Defining the body of the service method

As we described above, your JHTML is first compiled into a standard HTTP servlet Java file, then compiled using a standard java compiler. The order of the HTML and the Java in the JHTML page is preserved when translated into Java source code. For instance, you might:

1. Use HTML to define the beginning of a page and the start of a table block
2. Switch to Java to interrogate a database and output the table data
3. Switch back to HTML to end the table and the page.

You can use any Java construct in your JHTML, such as loops or conditional statements. You may switch between Java and HTML in order to embed HTML output within a Java construct. The following JHTML is quite legal:

      <html><body>
      <java>
        for (int i=0; i<10 ; i++) {
      </java>
      <h1>Hello World!</h1>
      <P>
      <java>
        } // End of for loop
      </java></body></html>

This will result in "Hello World!" being written 10 times in an HTML page.

### Declaring class scope objects

You may declare class scope objects such as variables, methods, and inner classes between the <java type=class> tags in a JHTML file. You may use any number of this type of java tags in your JHTML, but we recommend that you group related variables together at the start of your JHTML for maintainability reasons. In the following example, we set up some variables that are used by the HTTP servlet class. We have taken these out of the above <java> tag so that they may be accessed from other methods, and they are not instantiated on every call. The new variable declarations now look like this:

    <java type=class>
    String jdbcClass = "weblogic.jdbc.oci.Driver";
    String jdbcURL   = "jdbc:weblogic:oracle:goldengate";
    String user = "scott";
    String password = "";
    </java>

In most situations it is better to use method scoped variables due to servlet threading issues. This means either declaring the variables in other methods, or directly in the body of the service method (that is, just within plain <java> tags). For more details on threading and servlets, see Threading issues in HTTP servlets in the servlet developer's guide.

#### Embedding a Java method in a JHTML file

This example illustrates how to define a class method in your JHTML file that is called from the main <java> block.

The short method getCon() initializes a JDBC Connection object that is used elsewhere in the servlet. Note that we wrap the work of the method in a try block so a failure will not break the servlet.

    <java type=class>
      static final String jdbcClass =
            "weblogic.jdbc.oci.Driver";
      static final String jdbcURL   =
            "jdbc:weblogic:oracle:goldengate";
      static final String user      = "scott";
      static final String password  = "tiger";

      protected Connection getCon() {
        Connection conn  = null;
        try {
          Class.forName(jdbcClass).newInstance();
          conn = DriverManager.getConnection(jdbcURL,
                                             user, password);
        }
        catch (Exception f) {
        }
        return conn;
      }
    </java>

You can call this method from any other Java code in your JHTML. Notice that the other variables declared in this block are at class scope, so they also can be referenced from any <java> block in your JHTML.

## Using the backtick

By default, WebLogic supports the use of the backtick in Java tags. You can insert arbitrary backticks anywhere in your HTML. A Java statement within a backtick is evaluated, converted to a string, and sent to the servlet output stream. Backticks are essential for inserting dynamic content within HTML tags, such as a link to another document, based on some variable value.

### The backtick in WebLogic

Under the Java WebServer, you can embed a Java expression in any arbitrary HTML tag by enclosing it in backticks. We take this functionality one step further in WebLogic JHTML, and backticks are valid inside and outside of java tags. This is very convenient for embedding small pieces of java in your HTML to generate dynamic content since it keeps the HTML in a readable format.

Using the backtick in this manner means that you can no longer use a backtick character directly in your HTML code. The workaround is to print a backtick to the output stream within <java> tags. Since the backtick is rarely used, the convenience of using backtick-java-expressions in your HTML far outweighs this drawback.

You can enable and disable the extended use of backticks by setting the following property in the weblogic.properties file:

     weblogic.httpd.initArgs.*.jhtml=backtick=true|false

Look for these initial arguments in your weblogic.properties file and append to them if they exist, separating each name=value pair with a comma. They may already be in your properties file, but commented out.

### A simple example

Here is a line from an example we use later in this document:

      <td>`ds.getString("empno") != null ?
                ds.getString("empno") : "&nbsp;"`</td>

Where ds is a Java class that we have initialized elsewhere in our JHTML file. Here, we use the backtick to insert the result of a Java expression -- the employee number, or a non-breaking-whitespace character -- into an HTML table element.

Note that within the Java method out.print, backticks are treated as characters and do not end the Java code.

## Using session tracking

WebLogic's HTTP server also supports session tracking, which allows you to track information about a user as they progress through your web application. For example, an online auction or trading application might use session tracking to keep up with what a user has added to a shopping basket or the bids a user is making on an item for sale.

You access a session from the request keyword, with the getSession() method, which returns an HttpSession object. You can add data to or retrieve data from the HttpSession object using arbitrary name=value pairs. The following example illustrates how you would include the contents of a session in the HTML response to a request.

    <html>
    <head>
    <title>Using session tracking</title>
    <java type=package>tutorial.servlets.jhtml</java>
    </head>
    <body bgcolor=#FFFFFF>

    <h3>Values already in Session:</h3>

    <table border=1 width="100%">

    <java>
        HttpSession session = request.getSession(true);

        String[] valueNames = session.getValueNames();
        for (int i = 0; i < valueNames.length; i++) {
          String name = valueNames[i];
          String value = session.getValue(name).toString();
          out.print("<tr><td>" + name + "</td><td>" +
                    value + "</td></tr>");
        }
    </java>

    </table>

You add data to a session in a similar way, but using the putValue() method. This example retrieves all parameter name=value pairs from the query data of the request and stores them in a session.

    <h3>Values to add to Session:</h3>

    <table border=1 width="100%">

    <java>
        Enumeration paramNames = request.getParameterNames();
        while (paramNames.hasMoreElements()) {
          String name  = (String)paramNames.nextElement();
          String[] values = request.getParameterValues(name);
          session.putValue(name,
                           (values!=null ? values[0] : "null"));
          out.print("<tr><td>" + name + "</td><td>" +
                    value + "</td></tr>");
        }
    </java>
    </table>

    </body>
    </html>

Note that to use session tracking with WebLogic, you will need to add a property to the weblogic.properties file for WebLogic.

There is more information on using session tracking and cookies in the Developers Guide Using WebLogic HTTP Servlets.

## Getting data with JDBC

This example demonstrates how you should access a database from JHTML to include dynamic content in your web pages.

    <java>
    try {
      String jdbcClass = "weblogic.jdbc.oci.Driver";
      String jdbcURL   = "jdbc:weblogic:oracle:goldengate";
      String user = "scott";
      String password = "";

      password = "tiger";
      Class.forName(jdbcClass).newInstance();
      Connection conn =
        DriverManager.getConnection(jdbcURL, user, password);
      out.print("&lt;p&gt;First " +
                "login attempt was successful for ");
      out.print(user + "/" + password);

      password = "tigger";
      Class.forName(jdbcClass).newInstance();
      Connection conn2 =
        DriverManager.getConnection(jdbcURL, user, password);
      out.print("&lt;p&gt;Second login attempt " +
                "was successful for ");
      out.print(user + "/" + password);
      }

    catch (Exception f) {
      out.print("&lt;p&gt;Login failed for " +
                user + "/" + password);
      out.print("&gt;p&gt;");
      f.printStackTrace(new PrintStream(out));
      }

    finally {
      try {conn.close();}
      catch (Exception g) {}
      try {conn2.close();}
      catch (Exception h) {}
      }
    </java>

Let's look at the interesting parts of this example.

- This servlet prints HTML "inline" within the Java code with the out.print() method. Note that the contents of out.print() -- what's in the parentheses -- must not evaluate to null.

- Notice how we print the stack trace. You can find out more about the printStackTrace() method in the java.lang.Exception class. A stack trace must always be passed an output stream of type PrintStream. In this example we use the out object -- it contains the bytes that will eventually paint the browser page -- in the constructor for a new PrintStream, which prints the stack trace to the page.

- We wrap our code in a try {} block to catch any potential exceptions and handle them appropriately. This is especially important when accessing a remote resource such as a database.

- We use a finally{} block to close any connections to the database that have been opened. Even if there is an error, and the Java program does not complete, we are still assured that these expensive resources are cleaned up.

# IV. Using the WebLogic JHTML compiler

Since the PageCompileServlet automatically calls the WebLogic JHTML compiler as required, you generally do not need to directly access it. However, there may be situations (such as debugging) where accessing the compiler directly can be useful. This section is provided as reference for the compiler.

The WebLogic JHTML compiler parses the .jhtml file that you produce into a Java file and then compiles the Java file into a class file, all in a single step.

#### Syntax

The JHTML compiler works in much the same way that other WebLogic compilers work (including the RMI and EJB compilers). Here is the pattern:

    $ java weblogic.jhtmlc -options fileName

where fileName is the name of the .jhtml file that you want to compile. The options may be before or after the target filename. Here is an example that compiles "myFile" into the destination directory (one of the options) "weblogic/classes".

    $ java weblogic.jhtmlc -d /weblogic/classes-jdk110 \
      myFile.jhtml

#### Arguments

The options available are:

-help
  Outputs a list of all the available flags.

-backticks
  Parses text anywhere in the .jhtml file as Java, rather than exclusively inside tags. This allows you to embed things like table and column names within your HTML. True by default.

-verbose
  Prints debugging information to the shell window when the flag is present. Default is turned off.

-classpath
  Add a semicolon-delimited list of directories that make up the desired CLASSPATH. For example (to be entered on one line):

      $ java weblogic.jhtmlc \
          -classpath java/classes.zip;/weblogic/classes.zip \
          myFile.jhtml

-d
  Destination of the compiled output (the class file). Use this as a shortcut to place the compiled classes in a directory that is already in your CLASSPATH.

-keepgenerated
  Keeps the Java files that are created as an intermediary step in the compilation process.

-compiler
  Substitutes another compiler for javac for the Java-to-class compilation.

-nowarn
  Turns off warning messages from the Java compiler.

-nowrite
  Runs the compilation process without actually producing a .class file. If you combine this with the -keepgenerated flag, the compiler will create only the intermediate .java file. This can be useful for debugging.

-deprecation
  Causes the Java compiler to print a notice about any deprecated classes or methods called or used by your .jhtml file.

-J
  Use the -J option to add other options that your specific compiler will parse.

# V. Change history

Release 4.0.3

  Enhanced the JHTML PageCompileServlet to use the servlet classpath (specified by the property weblogic.httpd.servlet.classpath in the weblogic.properties file).

Release 4.0.2

  Fixed a problem with using JHTML under Java 1.2 and setting the PageCompileServlet argument verbose=true.

  Fixed a problem with compilation failures for JHTML pages with frames.

Release 4.0.1

  Made the JHTML page compiler smarter so it properly handles spaces in the CLASSPATH on UNIX.

Release 4.0.0

  The PageCompileServlet (JHTML) now passes through untouched quoted paths for setting the CLASSPATH.

Release 3.1

  Fixed bug that was preventing JHTML-file parsing past an empty <java></java> block.

  out.write() has been replaced by out.print().
  The shortcut method html() has been replaced with out.print().

  First released.

Copyright © 2000 BEA Systems, Inc. All rights reserved. Required browser: Netscape 4.0 or higher, or Microsoft Internet Explorer 4.0 or higher. Last updated 01/13/1999