Get the full ebook with Bonus Features for a Better Reading Experience on ebookgate.

com

Java Studio Creator Field Guide Anderson

https://ebookgate.com/product/java-studio-creator-field-
guide-anderson/

OR CLICK HERE

DOWLOAD NOW

Download more ebook instantly today at https://ebookgate.com

Instant digital products (PDF, ePub, MOBI) available
Download now and explore formats that suit you...

Android Studio Bumble Bee Essentials Java Edition Neil

Smyth

https://ebookgate.com/product/android-studio-bumble-bee-essentials-
java-edition-neil-smyth/

ebookgate.com

JAVA Illuminated An Active Learning Approach 5th Edition

Julie Anderson

https://ebookgate.com/product/java-illuminated-an-active-learning-
approach-5th-edition-julie-anderson/

ebookgate.com

Field Guide to Illumination SPIE Field Guide Series Angelo

V. Arecchi

https://ebookgate.com/product/field-guide-to-illumination-spie-field-
guide-series-angelo-v-arecchi/

ebookgate.com

Field Guide to Diffractive Optics SPIE Field Guide Vol

FG21 Yakov Soskind

https://ebookgate.com/product/field-guide-to-diffractive-optics-spie-
field-guide-vol-fg21-yakov-soskind/

ebookgate.com
Java Pocket Guide 1st Edition Liguori

https://ebookgate.com/product/java-pocket-guide-1st-edition-liguori/

ebookgate.com

Microsoft XNA Game Studio Creators Guide 1st Edition

Stephen Cawood

https://ebookgate.com/product/microsoft-xna-game-studio-creators-
guide-1st-edition-stephen-cawood/

ebookgate.com

Nikon D3200 digital field guide Hess

https://ebookgate.com/product/nikon-d3200-digital-field-guide-hess/

ebookgate.com

Traditions of Gamelan Music in Java Musical Pluralism and

Regional Identity 1st Edition R. Anderson Sutton

https://ebookgate.com/product/traditions-of-gamelan-music-in-java-
musical-pluralism-and-regional-identity-1st-edition-r-anderson-sutton/

ebookgate.com

A Guide To Programming in Java Java 2 Platform Standard

Edition 5 Beth Brown

https://ebookgate.com/product/a-guide-to-programming-in-java-
java-2-platform-standard-edition-5-beth-brown/

ebookgate.com
JAVA STUDIO
TM

FIELD GUIDE
SECOND EDITION
JAVA TECHNOLOGY
OVERVIEW

Topics in This Chapter

• The Java Programming Language

• JavaBeans Components
• NetBeans Software
• The XML Language
• The J2EE Architecture
• JavaServer Faces Technology
• JDBC and Databases
• Ant Build Tool
• Web Services
• EJBs and Portlets
 Chapter

elcome to Creator! Creator is an IDE (Integrated Development

W Environment) that helps you build web applications. While many

IDEs out in the world do that, Creator is unique in that it is built on
a layered technology anchored in Java. At the core of this technol-
ogy is the Java programming language. Java includes a compiler that produces
portable bytecode and a Java Virtual Machine (JVM) that runs this byte code on
any processor. Java is an important part of Creator because it makes your web
applications portable.
But Java is more than just a programming language. It is also a technology
platform. Many large systems have been developed that use Java as their core.
These systems are highly scalable and provide services and structure that
address some of the high-volume, distributed computing environments of
today.

1.1 Introduction
Creator depends on multiple technologies, so it’s worthwhile touching on them
in this chapter. If you’re new to Java, many of its parts and acronyms can be
daunting. Java technologies are divided into related packages containing
classes and interfaces. To build an application, you might need parts of one sys-
tem and parts of another. This chapter provides you with a road map of Java

3
4 Chapter 1 Java Technology Overview

technologies and documentation sources to help you design your web applica-
tions with Creator.
We’ll begin with an overview of the Java programming language. This will
help you get comfortable writing Java code to customize your Creator applica-
tions. But before we do that, we show you how to find the documentation for
Java classes and methods. This will help you use them with confidence in your
programs.
Most of the documentation for a Java Application Program Interface (API)
can be accessed through Creator’s Help System, located under Help in the
main menu. Sometimes all you need is the name of the package or the system
to find out what API a class, interface, or method belongs to. Java consists of
the basic language (all packages under java) and Java extensions (all packages
under javax). Once you locate a package, you can explore the interfaces and
classes and learn about the methods they implement.
You can also access the Java documentation online. Here’s a good starting
point for the Java API documentation.

http://java.sun.com/docs/

This page contains links to the Java 2 Platform Standard Edition, which con-
tains the core APIs. It also has a link to all of the other Java APIs and technolo-
gies, found at

http://java.sun.com/reference/docs/index.html

Creator is also built on the technology of JavaServer Faces (JSF). You can
find the current JSF API documentation at

http://java.sun.com/j2ee/javaserverfaces/1.0/docs/api/
index.html

JSF is described as part of the J2EE Tutorial, which can be found at

http://java.sun.com/j2ee/1.4/docs/tutorial/doc/index.html

These are all important references for you. We’ve included them at the
beginning of this book so it’s easy to find them later (when you’re deep in the
challenges of web application development). For now, let’s begin with Java as a
programming language. Then we’ll look at some of the other supporting tech-
nologies on which Creator is built.
 1.2 The Java Programming Language 5

1.2 The Java Programming Language

This cursory overview of the Java programming language is for readers who
come from a non-Java programming environment. It’s not meant to be an in-
depth reference, but a starting point. Much of Creator involves manipulating
components through the design canvas and the components’ property sheets.
However, there are times when you must add code to a Java page bean (the
supporting Java code for your web application’s page) or use a JavaBeans com-
ponent in your application. You’ll want a basic understanding of Java to more
easily use Creator.

Object-Oriented Programming
Languages like C and Basic are procedure-oriented languages, which means
data and functions are separated. To write programs, you either pass data as
arguments to functions or make your data global to functions. This arrange-
ment can be problematic when you need to hide data like passwords, customer
identification codes, and network addresses. Procedure-oriented designs work
fine when you write simple programs but are often not suitable to more com-
plex tasks like distributed programming and web applications. Function librar-
ies help, but error handling can be difficult and global variables may introduce
side effects during program maintenance.
Object-oriented programming, on the other hand, combines data and func-
tions into units called objects. Languages like Java hide private data (fields) from
user programs and expose only functions (methods) as a public interface. This
concept of encapsulation allows you to control how callers access your objects. It
allows you to break up applications into groups of objects that behave in a sim-
ilar way, a concept called abstraction. In Java, you implement an object with a
Java class and your object’s public interface becomes its outside view. Java has
inheritance to create new data types as extensions of existing types. Java also
has interfaces, which allow objects to implement required behaviors of certain
classes of objects. All of these concepts help separate an object’s implementa-
tion (inside view) from its interface (outside view).
All objects created from the same class have the same data type. Java is a
strongly typed language, and all objects are implicitly derived from type
Object (except the built-in primitive types of int, boolean, char, double,
long, etc.). You can convert an object from one type to another with a converter.
Casting to a different type is only allowed if the conversion is known by the
compiler. Creator’s Java editor helps you create well-formed statements with
dynamic syntax analysis and code completion choices. You’ll see how this
works in Chapter 2.
Error handling has always been a tough problem to solve, but with web
applications error handling is even more difficult. Processing errors can occur
6 Chapter 1 Java Technology Overview

on the server but need to propagate in a well-behaved way back to the user.
Java implements exception handling to handle errors as objects and recover
gracefully. The Java compiler forces programmers to use the built-in exception
handling mechanism.
And, Java forbids global variables, a restriction that helps program mainte-
nance.

Creating Objects
Operator new creates objects in Java. You don’t have to worry about destroying
them, because Java uses a garbage collection mechanism to automatically
destroy objects which are no longer used by your program.

Point p = new Point(); // create a Point at (0, 0)

Point q = new Point(10, 20); // create a Point at (10, 20)

Operator new creates an object at run time and returns its address in memory to
the caller. In Java, you use references (p and q) to store the addresses of objects so
that you can refer to them later. Every reference has a type (Point), and objects
can be built with arguments to initialize their data. In this example, we create
two Point objects with x and y coordinates, one with a default of (0, 0) and the
other one with (10, 20).
Once you create an object, you can call its methods with a reference.

p.move(30, 30); // move object p to (30, 30)

q.up(); // move object q up in y direction
p.right(); // move object p right in x direction
int xp = p.getX(); // get x coordinate of object p
int yp = p.getY(); // get y coordinate of object p
q.setX(5); // change x coordinate in object q
p.setY(25); // change y coordinate in object p

As you can see, you can do a lot of things with Point objects. It’s possible to
move a Point object to a new location, or make it go up or to the right, all of
which affect one or more of a Point object’s coordinates. We also have getter
methods to return the x and y coordinates separately and setter methods to
change them.
Why is this all this worthwhile? Because a Point object’s data (x and y coor-
dinates) are hidden. The only way you can manipulate a Point object is through
its public methods. This makes it easier to maintain the integrity of Point
objects.
 1.2 The Java Programming Language 7

Classes
Java already has a Point class in its API, but for the purposes of this discussion,
let’s roll our own. Here’s our Java Point class, which describes the functionality
we’ve shown you.

Listing 1.1 Point class

// Point.java - Point class

class Point {
// Fields
private double x, y; // x and y coordinates

// Constructors
public Point(double x, double y) { move(x, y); }
public Point() { move(0, 0); }

// Instance Methods
public void move(double x, double y) {
this.x = x; this.y = y;
}
public void up() { y++; }
public void down() { y--; }
public void right() { x++; }
public void left() { x--; }

// getters
public double getX() { return x; }
public double getY() { return y; }

// setters
public void setX(double x) { this.x = x; }
public void setY(double y) { this.y = y; }
}

The Point class is divided into three sections: Fields, Constructors, and
Instance Methods. Fields hold internal data, constructors initialize the fields,
and instance methods are called by you with references. Note that the fields for
x and y are private. This enforces data encapsulation in object-oriented pro-
gramming, since users may not access these values directly. Everything else,
however, is declared public, making it accessible to all clients.
The Point class has two constructors to build Point objects. The first con-
structor accepts two double arguments, and the second one is a default con-
structor with no arguments. Note that both constructors call the move()
method to initialize the x and y fields. Method move() uses the Java this key-
8 Chapter 1 Java Technology Overview

word to distinguish local variable names in the method from class field names
in the object. The setX() and setY() methods use the same technique.1
Most of the Point methods use void for their return type, which means the
method does not return anything. The ++ and -- operators increment or decre-
ment their values by one, respectively. Each method has a signature, which is
another name for a function’s argument list. Note that a signature may be
empty.

Packages
The Point class definition lives in a file called Point.java. In Java, you must
name a file with the same name as your class name. This makes it convenient
for the Java run-time interpreter to find class definitions when it’s time to
instantiate (create) objects. When all classes live in the same directory, it’s easy
to compile and run Java programs.
In the real world, however, classes have to live in different places, so Java
has packages that allow you to group related classes. A package in Java is both a
directory and a library. This means a one-to-one correspondence exists between
a package hierarchy name and a file’s pathname in a directory structure.
Unique package names are typically formed by reversing Internet domain
names (com.mycompany). Java also provides access to packages from class paths
and JAR (Java Archive) files.
Suppose you want to store the Point class in a package called MyPack-
age.examples. Here’s how you do it.

package MyPackage.examples;
class Point {
. . .
}

Package names with dot (.) delimiters map directly to path names, so
Point.java lives in the examples directory under the MyPackage directory. A
Java import statement makes it easy to use class names without fully qualifying
their package names. Import statements are also applicable to class names from
any Java API.

// Another Java program

import java.util.Date;
import javax.faces.context.*;
import MyPackage.examples.Point;

1. The this reference is not necessary if you use different names for the argu-
ments.
 1.2 The Java Programming Language 9

The first import statement provides the Date class name to our Java program
from the java.util package. The second import uses a wildcard (*) to make
all class definitions available from javax.faces.context. The last import
brings our Point class into scope from package MyPackage.examples.

Exceptions
We mentioned earlier that one of the downfalls of procedure-oriented lan-
guages is that subroutine libraries don’t handle errors well. This is because
libraries can only detect problems, not fix them. Even with libraries that sup-
port elaborate error mechanisms, you cannot force someone to check a func-
tion’s return value or peek at a global error flag. For these and other reasons, it
has been difficult to write distributed software that gracefully recovers from
errors.
Object-oriented languages like Java have a built-in exception handling
mechanism that lets you handle error conditions as objects. When an error
occurs inside a try block of critical code, an exception object can be thrown
from a library method back to a catch handler. Inside user code, these catch
handlers may call methods in the exception object to do a range of different
things, like display error messages, retry, or take other actions.
The exception handling mechanism is built around three Java keywords:
throw, catch, and try. Here’s a simple example to show you how it works.

class SomeClass {
. . .
public void doSomething(String input) {
int number;
try {
number = Integer.parseInt(input);
}
catch (NumberFormatException e) {
String msg = e.getMessage();
// do something with msg
}
. . .
}
}

Suppose a method called doSomething() needs to convert a string of char-

acters (input) to an integer value in memory (number). In Java, the call to Inte-
ger.parseInt() performs the necessary conversion for you, but what about
malformed string arguments? Fortunately, the parseInt() method throws a
NumberFormatException if the input string has illegal characters. All we do is
place this call in a try block and use a catch handler to generate an error mes-
sage when the exception is caught.
10 Chapter 1 Java Technology Overview

All that’s left is to show you how the exception gets thrown. This is often
called a throw point.

class Integer {
public static int parseInt(String input)
throws NumberFormatException {
. . .
// input string has bad chars
throw new NumberFormatException("illegal chars");
}
. . .
}

The static parseInt() method2 illustrates two important points about

exceptions. First, the throws clause in the method signature announces that
parseInt() throws an exception object of type NumberFormatException. The
throws clause allows the Java compiler to enforce error handling. To call the
parseInt() method, you must put the call inside a try block or in a method
that also has the same throws clause. Second, operator new calls the Number-
FormatException constructor to build an exception object. This exception
object is built with an error string argument and thrown to a catch handler
whose signature matches the type of the exception object (NumberFormat Excep-
tion).3 As you have seen, a catch handler calls getMessage() with the excep-
tion object to access the error message.
Why are Java exceptions important? As you develop web applications with
Creator, you’ll have to deal with thrown exceptions. Fortunately, Creator has a
built-in debugger that helps you monitor exceptions. In the Chapter 14, we
show you how to set breakpoints to track exceptions in your web application
(see “Detecting Exceptions” on page 521).

Inheritance
The concept of code reuse is a major goal of object-oriented programming.
When designing a new class, you may derive it from an existing one. Inherit-
ance, therefore, implements an “is a” relationship between classes. Inheritance
also makes it easy to hook into existing frameworks so that you can take on

2. Inside class Integer, the static keyword means you don’t have to instan-
tiate an Integer object to call parseInt(). Instead, you call the static
method with a class name rather than a reference.
3. The match doesn’t have to be exact. The exception thrown can match the
catch handler’s object exactly or any exception object derived from it by
inheritance. To catch any possible exception, you can use the superclass
Exception. We discuss inheritance in the next section.
 1.2 The Java Programming Language 11

new functionalities. With inheritance, you can retain the existing structure and
behavior of an existing class and specialize certain aspects of it to suit your
needs.
In Java, inheritance is implemented by extending classes. When you extend
one class from another, the public methods of the “parent” class become part of
the public interface of the “child class.” The parent class is called a superclass
and the child class is called a subclass. Here are some examples.

class Pixel extends Point {

. . .
}

class NumberFormatException extends IllegalArgumentException {

. . .
}

In the first example, Point is a superclass and Pixel is a subclass. A Pixel

“is a” Point with, say, color. Inside the Pixel class, a color field with setter and
getter methods can assist in manipulating colors. Pixel objects, however, are
Point objects, so you can move them up, down, left or right, and you can get or
set their x and y coordinates. (You can also invoke any of Point’s public meth-
ods with a reference to a Pixel object.) Note that you don’t have to write any
code in the Pixel class to do these things because they have been inherited
from the Point class. Likewise, in NumberFormatException, you may intro-
duce new methods but inherit the functionality of IllegalArgumentExcep-
tion.
Another point about inheritance. You can write your own version of a
method in a subclass that has the same name and signature as the method in
the superclass. Suppose, for instance, we add a clear() method in our Point
class to reset Point objects back to (0, 0). In the Pixel class that extends from
Point, we may override the clear() method.4 This new version could move a
Pixel object to (0, 0) and reset its color. Note that clear() in class Point is
called for Point objects, but clear() in class Pixel will be called for Pixel
objects. With a Point reference set to either type of object, different behaviors
happen when you call this method.
It’s important to understand that these kinds of method calls in Java are
resolved at run time. This is called dynamic binding. In the object-oriented para-
digm, dynamic binding means that the resolution of method calls with objects

4. Creator uses this same feature by providing methods that are called at dif-
ferent points in the JSF page request life cycle. You can override any of these
methods and thus provide your own code, “hooking” into the page request
life cycle. We show you how to do this in Chapter 6 (see “The Creator-JSF
Life Cycle” on page 151).
12 Chapter 1 Java Technology Overview

is delayed until you run a program. In web applications and other types of dis-
tributed software, dynamic binding plays a key role in how objects call meth-
ods from different machines across a network or from different processes in a
multitasking system.

Interfaces
In Java, a method with a signature and no code body is called an abstract
method. Abstract methods must be overridden in subclasses and help define
interfaces. A Java interface is like a class but has no fields and only abstract pub-
lic methods. Interfaces are important because they specify a contract. Any new
class that implements an interface must provide code for the interface’s meth-
ods.
Here’s an example of an interface.

interface Encryptable {
void encode(String key);
String decode();
}

class Password implements Encryptable {

. . .
void encode(String key) { . . . }
String decode() { . . . }
}

The Encryptable interface contains only the abstract public methods

encode() and decode(). Class Password implements the Encryptable inter-
face and must provide implementations for these methods. Remember, inter-
faces are types, just like classes. This means you can implement the same
interface with other classes and treat them all as Encryptable types.
Java prohibits a class from inheriting from more than one superclass, but it
does allow classes to implement multiple interfaces. Interfaces, therefore, allow
arbitrary classes to “take on” the characteristics of any given interface.
One of the most common interfaces implemented by classes in Java is the
Serializable interface. When an object implements Serializable, you can
use it in a networked environment or make it persistent (this means the state of
an object can be saved and restored by different clients). There are methods to
serialize the object (before sending it over the network or storing it) and to
deserialize it (after retrieving it from the network or reading it from storage).
 1.3 JavaBeans Components 13

1.3 JavaBeans Components

A JavaBeans component is a Java class with certain structure requirements. Jav-
abeans components define and manipulate properties, which are objects of a
certain type. A JavaBeans component must have a default constructor so that it
can be instantiated when needed. Beans also have getter and setter methods
that manipulate a bean property and conform to a specific naming convention.
These structural requirements make it possible for development tools and
other programs to create JavaBeans components and manipulate their proper-
ties.
Here’s a simple example of a JavaBeans component.

public class Book {

private String title;
private String author;
public Book() { setTitle(""); setAuthor(""); }
public void setTitle(String t) { title = t; }
public String getTitle() { return title; }
public void setAuthor(String a) { author = a; }
public String getAuthor() { return author; }
}

Why are JavaBeans components important? First and most important, they
are accessible to Creator. When you write a JavaBeans component that con-
forms to the specified design convention, you may use it with Creator and bind
JSF components to bean properties. Second, JavaBeans components can encap-
sulate business logic. This helps separate your design presentation (GUI com-
ponents) from the business data model.
In subsequent chapters, we show you several examples of JavaBeans compo-
nents. We’ll use a LoginBean to handle users that login with names and pass-
words and show you a LoanBean that calculates mortgage payments for loans.
The Point class in Listing 1.1 on page 7 is another example of a JavaBeans com-
ponent.

1.4 NetBeans Software

NetBeans software is an open source IDE written in the Java programming lan-
guage. It also includes an API that supports building any type of application.
The IDE has support for Java, but its architecture is flexible and extensible,
making support for other languages possible.
14 Chapter 1 Java Technology Overview

NetBeans is an Open Source project. You can view more information on its
history, structure, and relationship with Sun Microsystems at its web site

http://www.netbeans.org/

NetBeans and Creator are related because Creator is based on the NetBeans
platform. In building Creator, Sun is offering an IDE aimed specifically at cre-
ating web-based applications. Thus, the IDE integrates page design with gener-
ated JSP source and page bean components. NetBeans provides features such
as source code completion, workspace manipulation of windows, expandable
tree views of files and components, and debugging facilities. Because NetBeans
is extensible, the Creator architects included Java language features such as
inheritance to adapt components from NetBeans into Creator applications with
the necessary IDE functions.

1.5 The XML Language

XML is a metalanguage that dictates how to define custom languages and
describe data. The name is an acronym for Extensible Markup Language. XML
is not a programming language, however. In fact, it’s based on simple character
text in which the data are surrounded by text markup that documents data.
This means you can use XML to describe almost anything. Since XML is self-
describing, it’s easy to read with tools and other programs to decide what
actions to take. You can transport XML documents easily between systems or
across the Internet, and virtually any type of data can be expressed and vali-
dated in an XML document. Furthermore, XML is portable because it’s lan-
guage and system independent.
Creator uses XML to define several configuration files as well as the source
for the JSP web pages. Here’s an example XML file (managed-beans.xml) that
Creator generates for managing a JavaBeans component in a web application.

<faces-config>
<managed-bean>
<managed-bean-name>LoanBean</managed-bean-name>
<managed-bean-class>asg.bean_examples.LoanBean
</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>
</faces-config>

Every XML file has opening tags (<tag>) and closing tags (</tag>) that
define self-describing information. Here, we specify a managed-bean element
 1.6 The J2EE Architecture 15

to tell Creator what it needs to know about the LoanBean component. This
includes its name (LoanBean), class name and package (asg.bean-
_examples.LoanBean), and the scope of the bean (session). When you add your
own JavaBeans components to Creator as managed beans, Creator generates
this configuration information for you.
Creator maintains and updates its XML files for you, but it’s a good idea to
be familiar with XML syntax. This will allow you to customize the Creator
XML files if necessary.

1.6 The J2EE Architecture

The J2EE platform gives you a multitiered application model to develop dis-
tributed components. Although any number of tiers is possible, we’ll use a
three-tier architecture for the applications in this book. Figure 1–1 shows the
approach.
The client machine supports web browsers, applets, and stand-alone appli-
cations. A client application may be as simple as a command-line program run-
ning as an administrator client or a graphical user interface created from Java
Swing or Abstract Window Toolkit (AWT) components. Regardless, the J2EE
specification encourages thin clients in the presentation tier. A thin client is a
lightweight interface that does not perform database queries, implement busi-
ness logic, or connect to legacy code. These types of “heavyweight” operations
preferably belong to other tiers.

Web
Presentation Tier Database
Tier Tier
Business
Tier

Client J2EE Server Database

Machine Machine Server Machine

Figure 1–1 Three-tier J2EE architecture

16 Chapter 1 Java Technology Overview

The J2EE server machine is the center of the architecture. This middle tier
contains web components and business objects managed by the application
server. The web components dynamically process user requests and construct
responses to client applications. The business objects implement the logic of a
business domain. Both components are managed by a J2EE application server
that provides these components with important system services, such as secu-
rity, transaction management, naming and directory lookups, and remote con-
nectivity. By placing these services under control of the J2EE application server,
client components focus on either presentation logic or business logic. And,
business objects are easier for developers to write. Furthermore, the architec-
ture encourages the separation of business logic from presentation logic (or
model from view).
The database server machine handles the database back end. This includes
mainframe transactions, databases, Enterprise Resource Planning (ERP) sys-
tems, and legacy code. Another advantage of the three-tier architecture is that
older systems can take on a whole new “look” by using the J2EE platform. This
is the approach many businesses are taking as they integrate legacy systems
into a modern distributed computing environment and expose application ser-
vices and data to the web.

1.7 Java Servlet Technology

The Java Servlet component technology presents a request-response program-
ming model in the middle tier. Servlets let you define HTTP-specific servlet
classes that accept data from clients and pass them on to business objects for
processing. Servlets run under the control of the J2EE application server and
often extend applications hosted by web servers. Servlet code is written in Java
and compiled. It is particularly suited to server-side processing for web appli-
cations since each Servlet session is handled in its own thread.

1.8 JavaServer Pages Technology

A JavaServer Pages (JSP) page is a text-based document interspersed with Java
code. A JSP engine translates JSP text into Java Servlet code. It is then dynami-
cally compiled and executed. This component technology lets you create
dynamic web pages in the middle tier. JSP pages contain static template data
(HTML, WML, and XML) and JSP elements that determine how a page con-
structs dynamic content. The JSP API provides an efficient, thread-based mech-
anism to create dynamic page content.
 1.9 JDBC API and Database Access 17

Creator uses JavaServer Faces (JSF), which is built on both the servlet and
JSP technologies. However, by using Creator, you are shielded from much of
the details of not only JSP and servlet programming, but JSF details as well.

1.9 JDBC API and Database Access

Java Data Base Connectivity (JDBC) is an API that lets you invoke SQL com-
mands from Java methods in the middle tier. Typically, you use the JDBC API
to access a database from servlets or JSP pages. The JDBC API has an applica-
tion-level interface for database access and a service provider interface to
attach JDBC drivers to the J2EE platform. In support of JDBC, J2EE application
servers manage a pool of database connections. This pool provides business
objects efficient access to database servers.
The JDBC CachedRowSet API is a newer technology that makes database
access more flexible. Creator accesses configured data sources using a Cached-
RowSet object, a JavaBeans component that is scrollable, updatable, and serial-
izable. These components are disconnected from the database, caching its rows
into memory. When web applications modify data in the cached rowset object,
the result propagates back to the data source through a subsequent connection.
By default, Creator instantiates a cached rowset object in session scope.
The concept of data providers is also important because it produces a level of
abstraction for data flow within Creator’s application environment. Creator’s
data providers allow you to change the source of data (say, from a database
table to a web services call or an EJB method) by hooking the data provider to a
different data source.
We introduce data providers in Chapter 8 and show how to use them with
databases in Chapter 9.

1.10 JavaServer Faces Technology

The JavaServer Faces (JSF) technology helps you develop web applications
using a server-side user interface (UI) component framework. The JSF API
gives you a rich set of UI components and lets you handle events, validate and
convert user input, define page navigation, and support internationalization.
JSF has custom tag libraries for connecting components to server-side objects.
We show you these components and tag libraries in Chapter 3.
JSF incorporates many of the lower level tasks that JSP developers are used
to doing. Unlike JSP applications, however, applications developed with JSF
can map HTTP requests to component-specific event handlers and manage UI
elements as stateful objects on the server. This means JSF offers a better separa-
18 Chapter 1 Java Technology Overview

tion of model and presentation. The JSF API is also layered directly on top of
the Servlet API.

1.11 Ant Build Tool

Ant is a tool from the Apache Software Foundation (www.apache.org) that
helps you manage the “build” of a software application. The name is an acro-
nym for “Another Neat Tool” and is similar in concept to older build tools like
make under Unix and gmake under Linux. However, Ant is XML-based, it’s eas-
ier to use, and it’s platform independent.
Ant is written in Java and accepts instructions from XML documents. Ant is
well suited for performing complicated and repetitive tasks. Creator uses Ant
to compile and deploy your web applications. Ant gets its instructions for
building a system from the configuration file, build.xml. You won’t have to
know too much about Ant to use Creator, but you should be aware that it’s
behind the scenes doing a lot of work for you.

1.12 Web Services

Web services are software APIs that are accessible over a network in a hetero-
geneous environment. Network accessibility is achieved by means of a set of
XML-based open standards such as the Web Services Description Language
(WSDL), the Simple Object Access Protocol (SOAP), and Universal Description,
Discovery, and Integration (UDDI). Web service providers and clients use these
standards to define, publish, and access web services.
Creator’s application server (J2EE 1.4) provides support for web services. In
Creator, you can access methods of a web service by dragging its node onto the
design canvas. We show you web services with Creator in Chapter 10.

1.13 Enterprise JavaBeans (EJB)

EJB is a component technology that helps developers create business objects in
the middle tier. These business objects (enterprise beans) consist of fields and
methods that implement business logic. EJBs are server-side components writ-
ten in Java that serve as building blocks for enterprise systems. They perform
specific tasks by themselves, or forward operations to other enterprise beans.
EJBs are under control of the J2EE application server. We show you how to
access an EJB from a Creator application in Chapter 11.
 1.14 Portlets 19

1.14 Portlets
A portlet is an application that runs on a web site managed by a server called a
portal. A portal server manages multiple portlet applications, displaying them
on the web page together. Each portlet consumes a fragment of the page and
manages its own information and user interaction. Portlet application develop-
ers will typically target portlets to run under portals provided by various por-
tal vendors.
You can use Creator to develop portlets. Creator builds JSF portlets. This
means your design-time experience in building portlet web application using
the visual, drag-and-drop features of Creator will be familiar. Most of the inter-
action with the IDE is exactly the same as it is for non-portlet JSF projects. We
show you how to create portlets in Chapter 12.

1.15 Key Point Summary

• Creator is an IDE built on layered Java technologies that helps you build
web applications.
• Procedure-oriented languages separate data and functions, whereas object-
oriented languages combine them.
• Encapsulation enforces data hiding and allows you to control access to your
objects.
• Java is a strongly typed object-oriented language with a large set of APIs
that help you develop portable web applications.
• In Java, operator new returns a reference to a newly created object so that
you can call methods with the reference.
• Java classes have fields, constructors, and instance methods. The private
keyword is used for encapsulation, and the public keyword grants access to
clients.
• Java packages allow you to store class files and retrieve them with import
statements in Java programs.
• Java uses try, catch, and throw to handle error conditions with a built-in
exception handling mechanism.
• Inheritance is a code reuse mechanism that implements an “is a”
relationship between classes.
• Dynamically bound method calls are resolved at run time in Java. Dynamic
binding is essential with distributed web applications.
• An interface has no fields and only abstract public methods. A class that
implements an interface must provide code for the interface’s methods.
• The J2EE architecture is a multitiered application model to develop
distributed components.
20 Chapter 1 Java Technology Overview

• Java Servlets let you define HTTP-specific servlet classes that accept data
from clients and pass them on to business objects for processing.
• A JSP page is a text-based document interspersed with Java code that allows
you to create dynamic web pages.
• JDBC is an API for database access from servlets, JSP pages, or JSF. Creator
uses data providers to introduce a level of abstraction between Creator UI
components and sources of data.
• JavaServer Faces (JSF) helps you develop web applications using a server-
side user interface component framework. Creator generates and manages
all of the configuration files required by JSF.
• A JavaBeans component is a Java class with a default constructor and setter
and getter methods to manipulate its properties.
• NetBeans is a standards-based IDE and platform written in the Java
programming language. Java Studio Creator is based on the NetBeans
platform.
• XML is a self-describing, text-based language that documents data and
makes it easy to transport between systems.
• Ant is a Java build tool that helps you compile and deploy web applications.
• Web services are software APIs that are accessible over a network in a
heterogeneous environment.
• EJBs are server-side components written in Java that implement business
logic and serve as building blocks for enterprise systems.
• Portlets are applications that consume a portion of a web page. They run on
web sites managed by a portal server and execute along with other portlets
on the page.
• Portlets help divide web pages into smaller, more manageable fragments.
CREATOR BASICS

Topics in This Chapter

• Creator Window Layout

• Visual Design Editor
• Components and Clips Palette
• Source Editors/Code Completion
• Page Navigation Editor
• Outline Window
• Projects Window
• Servers and Resources
• Creator Help System
• Basic Project Building
 Chapter

un Java Studio Creator makes it easy to work with web applications

S from multiple points of view. This chapter explores some of Creator’s

basic capabilities, the different windows (views) and the way in which
you use them to build your application. We show you how to manipu-
late your application through the drag-and-drop mechanism for placing com-
ponents, configuring components in the Properties window, controlling page
flow with the Page Navigation editor, and selecting services from the Servers
window.

2.1 Examples Installation

We assume that you’ve successfully installed Creator. The best source of infor-
mation for installing Creator is Sun’s product information page at the following
URL.

http://developers.sun.com/prodtech/javatools/jscreator/

Creator runs on a variety of platforms and can be configured with different

application servers and JDBC database drivers. However, to run all our exam-
ples we’ve used the bundled application server (Sun Java System Application
Server 8.2) and the bundled database server (Derby). Once you’ve configured

23
24 Chapter 2 Creator Basics

Creator for your system, the examples you build here should run the same on
your system.

Download Examples
You can download the examples for this book at the Sun Creator web site. The
examples are packed in a zip file. When you unzip the file, you’ll see the
FieldGuide2/Examples directory and subdirectories for the various chapters
and projects. As each chapter references the examples, you will be instructed
on how to access the files.
You’re now ready to start the tour of Creator.

2.2 Creator Views

Figure 2–1 shows Creator’s initial window layout in its default configuration.
When you first bring it up, no projects are open and Creator displays its Wel-
come window.
There are other windows besides those shown in the initial window layout.
As you’ll see, you can hide and display windows, as well as move them
around. As we begin this tour of Creator, you’ll probably want to run Creator
while reading the text.

Welcome Window
The Welcome window lets you create new projects or work on existing ones.
Figure 2–2 shows the Welcome window in more detail. It lists the projects
you’ve worked on recently and offers selection buttons for opening existing
projects or creating new projects. If you hover with the mouse over a recently
opened project name, Creator displays the full pathname of the project in a
tooltip.
To demonstrate Creator, let’s open a project that we’ve already built. The
project is included in the book’s download bundle, in directory FieldGuide2/
Examples/Navigation/Projects/Login1.

Creator Tip

We show you how to build this project from scratch in Chapter 5 (see
“Dynamic Navigation” on page 206). For our tour of the IDE, however, we’ll
use the pre-built project from the examples download.
 2.2 Creator Views 25

Main Menu Servers View Properties Window

Bar Palette
Tool Icons Files View

Outline View Welcome Window Projects View

Status Bar
Navigator View
Dynamic Help

Figure 2–1 Creator’s initial window layout

1. Select the Open Existing Project button and browse to the FieldGuide2/
Examples/Navigation/Projects directory.
2. Select Login1 (look for the projects icon) and click Open Project Folder. This
opens the Login1 project in the Creator IDE.
3. Page1 should display in the visual editor, as shown in Figure 2–3. If Page1
does not open in the design editor, find the Projects view (its default posi-
tion is on the right, under the Properties view).
4. In the Projects view, expand node Login1, then Web Pages. Double-click
Page1.jsp. Page1 should now appear in the design editor.
26 Chapter 2 Creator Basics

Figure 2–2 Creator’s Welcome window

Design Editor
Figure 2–3 shows a close-up of the design canvas (the visual design editor) of
Page1. You see the design grid and the components we’ve placed on the can-
vas. The design editor lets you visually populate the page with components.
Page1 contains a “virtual form.” Virtual forms are accessible on a page by
selecting the Show Virtual Forms icon on the editing toolbar, as shown in
Figure 2–3. Virtual forms let you assign different components to different
actions on the page. We show you how to use virtual forms in “Configure Vir-
tual Forms” on page 216 (for project Login1 in Chapter 5) and in “Virtual
Forms” on page 419 (for project MusicAdd in Chapter 9).
Select the text field component. The design canvas marks the component
with selection and resizing handles. Now move the text field component
around on the grid. You’ll note that it snaps to the gird marks automatically
when you release the mouse. You can temporarily disable the snap to grid fea-
ture by moving the component and pressing the <Shift> key at the same time.
You can also select more than one component at a time (use <Shift-Click>) and
 2.2 Creator Views 27

Editing Toolbar File Tab Design Grid

Show Virtual
Forms Toggle

Label Text Field

Message
Password Field

Button Virtual Form

Designation

Design Canvas

Figure 2–3 Creator’s design canvas showing project Login1

Creator provides options to align components. We cover the mechanics of page

design in Chapter 7 (see “Using the Visual Design Editor” on page 273).
Note that when you make modifications to a page, Creator indicates that
changes have been made to the project by appending an asterisk to the file
name tab. Once you save your project by clicking the Save All icon in the tool-
bar (or selecting File > Save All from the main menu), the Save All icon is dis-
abled and the asterisk is cleared from the file name tab.
Typically applications consist of more than one page. You can have more
than one of your project’s pages open at a time (currently, there’s just one page
open). When you open other files, a file tab appears at the top of the editor
pane. The file tab lets you select other files to display in the editor pane.
Creator lets you configure your display’s workspace to suit the tasks you’re
working on. All the windows can be hidden when not needed (click the small x
in a window’s title bar to close it) and moved (grab the window’s title bar and
move it to a new location). To view a hidden window, select View from the
menu bar and then the window name. Figure 2–4 shows the View menu with
the various windows you can open, along with a key stroke shortcut for open-
ing each window.
You can also dock Creator windows by selecting the pushpin in the window
title bar. This action minimizes the window along the left or right side of the
28 Chapter 2 Creator Basics

Figure 2–4 Creator’s View Menu allows you to select specific views of your project

workspace. Make it visible again by moving the cursor over its docked posi-
tion. Toggling the pushpin icon undocks the window. Figure 2–5 shows the
Properties view with both the Projects and Files windows docked.

Properties
As you select individual components, their properties appear in the Properties
window. Select the text field component on the design canvas. This brings up
its Properties window, as shown in Figure 2–5.
Creator lets you configure the components you use by manipulating their
properties. When you change a component’s properties, Creator automatically
updates the underlying JSP source for you. Let’s look at several properties of
the text field component. If you hold the cursor over any property value, Cre-
ator displays its setting in a tooltip.
Components have many properties in common; other properties are unique
to the specific component type. The id property uniquely identifies the compo-
nent on the page. Creator generates the name for you, but you can change it (as
we have in this example) to more easily work with generated code. The label
property enables you to specify a textual label associated with the text field.
The red asterisk next to the label in the design view indicates that input is
 2.2 Creator Views 29

Component label text

Identifier (id)

Files and Projects

views docked

Style Attributes
Property Customizer
Box

input is required

Event Handler
Method

toolTip text

JavaScript
Settings

Figure 2–5 Properties window for text field component “userName”

required for this component. Property text holds the text that the user sub-
mits. You can use the style property to change a component’s appearance. The
style property’s position tag reflects the component’s position on the page.
When you move the component in the design view, Creator updates this for
you.
Property styleClass takes previously defined CSS style classes (you can
apply more than one). File stylesheet.css (under Web Pages > resources in the
Projects window) is the default style sheet for your projects. We cover style,
styleClass and using Creator’s preconfigured Themes in Chapter 7.
Text field components can take a converter (specified in property con-
verter) and a validator (property validator). The validate and valueChange
properties (under Events) expect method names and are used to provide cus-
tom validation or to process input when the component’s text value changes.
30 Chapter 2 Creator Basics

Click on the text field component (again) in the design canvas until Creator
displays a gray outline around the component. Now type in some text and fin-
ish editing with <Enter>. The text you type appears opposite property text in
the Properties window. To reset the property, click the customizer box opposite
property text. Creator pops up a Property Customizer dialog, as shown in
Figure 2–6. Select Unset Property. This is a handy way to return a property
value to its unset state.

Figure 2–6 Property customizer dialog for property text

Each property’s customizer is tailored to the specific property. For example,

select the Login button on the design canvas. In the Properties window, click
the property customizer box opposite property style. Creator pops up an
elaborate style editor. Experiment with some of the settings (change the font
style or color, for example) and see how the button changes in the design view.
You can also preview the look. Right-click inside the design view and select
Preview in Browser. Figure 2–7 shows a preview of Login1 with a different
appearance for the Login button.

Palette
Creator provides a rich set of basic components, as well as special-function
components such as Calendar, File Upload, Tab Set, and Tree. The palette is
divided into sections that can be expanded or collapsed. Figure 2–8 shows the
Basic Components palette, which includes all of the components on Page1 of
project Login1. In Figure 2–8 you also see the Layout and Composite Compo-
nents palette.
The palette lets you drag and drop components on the page of your applica-
tion. Once a component is on a page, you can reposition it with the mouse or
configure it with the Properties window.
Figure 2–9 shows the Validators and Converters palette. Creator’s converters
and validators let you specify how to convert and validate input. Because con-
 2.2 Creator Views 31

Figure 2–7 Preview in Browser for Login1

Figure 2–8 Basic, Layout and Composite Components palette

32 Chapter 2 Creator Basics

version and validation are built into the JSF application model, developers can
concentrate on providing event handling code for valid input.

Figure 2–9 Creator Validators and Converters Components palette

You select converters and validators just like the UI components. When you
drag one to the canvas and drop it on top of a component, the validator or con-
verter binds to that component. To test this, select the Length Validator and
drop it on top of the userName text field component. You’ll see a length valida-
tor lengthValidator1 defined for the text field’s validator property in the
Properties window.
Note that components, validators, and converters all have associated icons
in the palette. Creator uses these icons consistently so you can easily spot what
kind of component you’re working with. For example, select the Login button
component on the design canvas and examine the Outline view. You’ll see that
the icon next to the button components (Login and Reset) matches component
Button in the Basic Components palette.

Outline
Figure 2–10 is the Page1 Outline view for project Login1. (Its default placement
is in the lower-left portion of the display.) The Outline window is handy for
showing both visual and nonvisual components for the page that’s currently
 2.2 Creator Views 33

displayed in the design canvas. You can select the preconfigured managed
beans, RequestBean1, SessionBean1 and ApplicationBean1. These JavaBeans
components hold your project’s data that belong in either request (page), ses-
sion or application scope, respectively. (We discuss scope issues for web appli-
cation objects in “Scope of Web Applications” on page 224.)

Text Field Component “userName”

Length Validator “lengthValidator1”

Managed Bean RequestBean1

Managed Bean SessionBean1
Managed Bean ApplicationBean1

Figure 2–10 Creator’s Outline window for project Login1

Some components are composite components (they contain nested ele-

ments). The Outline window shows composite components as nodes that you
can expand and compress with ‘+’ and ‘-’ as needed. Suppose, for example, you
select grid panel for layout. When you add components to this grid panel, they
appear nested underneath the panel component in the Outline view.
The length validator component on the userName text field appears as com-
ponent lengthValidator1 in the Outline view. Select the length validator and
examine it in the Properties view. Specify values for properties maximum (use
10) and minimum (use 3). This limits input for the userName text field compo-
nent to a string that is between 3 and 10 characters long.
Now let’s look at the Projects window.

Projects
Figure 2–11 shows the Projects window for project Login1. Its default location
is in the lower-right corner. Whereas the Outline view displays components for
individual pages and managed beans, the Projects window displays your
entire project, organized in a logical hierarchy. (Since Creator lets you open
more than one project at a time, the Projects window displays all currently
opened projects.) Project Login1 contains three JSP pages under the Web Pages
node: Page1.jsp, LoginGood.jsp, and LoginBad.jsp. Double-click any one of
34 Chapter 2 Creator Basics

them to bring it up in the design canvas. When the page opens, Creator dis-
plays a file name tab so you can easily switch among different open files in the
design canvas.

Figure 2–11 Creator’s Project Navigator window for project Login1

When you create your own projects, each page has its own Java component
“page bean.” These are Java classes that conform to the JavaBeans structure we
mention in Chapter 1 (see “JavaBeans Components” on page 13). To see the
Java files in this project, expand the Source Packages node (click on the ‘+’),
then the login1 folder. When you double-click on any of the Java files, Creator
brings it up in the Java source editor. (We’ll examine the Java source editor
shortly.) Without going to the editor, you can also see Java classes, fields, con-
structors, and methods by expanding the ‘+’ next to each level of the Java file.
The Projects view displays Creator’s “scoped beans.” These are pre-config-
ured JavaBeans components that store data for your project in different scopes.
You can use request scope (Request Bean), application scope (Application
Bean), or session scope (Session Bean). Many of the projects in this text add
properties to these beans. We discuss JSF scoping issues in Chapter 6 (see “Pre-
defined Creator Java Objects” on page 226).
 2.2 Creator Views 35

The Projects view also lists the resources node, which lives under the Web
Pages node. The resources node typically holds file stylesheet.css and any
image files. Creator uses the libraries listed in the Libraries node to display,
build, and deploy your application. These class files (compiled Java classes) are
stored in special archive files called JAR (Java Archive) files. You can see the
name, as well as the contents (down to the field and method names) of any JAR
file by expanding the nodes under Libraries. We show you how to add a JAR
file to your project in Chapter 13 (see “Add the asg.jar Jar File” on page 595).

Files
The Projects window shows you a logical view of your project. Sometimes you
may need to access a configuration file that is not included in the Projects view.
In such a case, use the Files view, as shown in Figure 2–12.

Figure 2–12 Files view for project Login1

The Files view shows all of the files in your project. For example, expand
node web > WEB-INF and double-click file web.xml. Creator brings up file
web.xml in a specialized Creator-configuration XML editor, as shown in
Figure 2–13.
36 Chapter 2 Creator Basics

Figure 2–13 Editing file web.xml

File web.xml lets you set various project-level configuration parameters,

such as Session Timeout, Filters, or special error pages. Close this file by click-
ing the small x in the web.xml file tab.

JSP Editor
As you drop components on the page and configure them with the Properties
window, Creator generates JSP source code for your application. You can view
the JSP representation of a page by clicking the JSP button in the editing tool-
bar, as shown in Figure 2–14.
Normally, you will not need to edit this page directly, but studying it is a
good way to understand how Creator UI components work and how to man-
age their properties. You’ll see a close correspondence between the JSP tags
and the components’ properties as shown in the Properties window. If you do
edit the JSP source directly, you can easily return to the design view. Creator
always keeps the design view synchronized with the JSP source.
Tags in the JSP source use a JSF Expression Language (EL) to refer to meth-
ods and properties in the Java page bean. For example, the login button’s
action property is set to #{Page1.login_action}, which references method
login_action() in class Page1.java.
Creator also generates and maintains code for the “page bean,” the Java
backing code generated for each page. Let’s look at the Java source for
Page1.java now.
 2.2 Creator Views 37

JSP
button

Creator
UI
Components

Figure 2–14 Page1.jsp XML Editor

Java Source Editor

Click the Design button and return to the Page1 design view. As you build your
application, not only does Creator generate JSP source that defines and config-
ures your component, but it also maintains the page bean. For example, Cre-
ator makes it easy for you to code event handlers (methods that perform
customized tasks when the user selects an option from a drop down list or
clicks a button). Double-click button Login in the design view. Creator gener-
ates a default event handler for this button and puts the cursor at the method in
the Java source editor. If this method was previously generated (as it was here),
Creator brings up the editor and puts the cursor at the method, as shown in
Figure 2–15. Here you see method login_action() in file Page1.java.
You can always bring up a page’s Java code by selecting the Java button in
the editing toolbar. This Java file is a bean (conforming to a JavaBeans struc-
ture) and its properties consist of the components you place on the page. Each
38 Chapter 2 Creator Basics

Java
Button

Login
Button
Event
Handler

Reset
Button
Event
Handler

Code
Folding
Handle

Figure 2–15 Page1.java in Java source editor

component corresponds to a private variable and has a getter and setter. This
allows the JSF EL expression to access properties of the page bean.
All of Creator’s editors are based on NetBeans. The Editor Module is a full-
featured source editor and provides code completion (we show an example
shortly), a set of abbreviations, and fast import with <Alt-Shift-I>. The editor
also has several useful commands: Reformat Code (handy when pasting code
from an external source), Fix Imports (adds needed import statements as well
as removes unused ones), and Show Javadoc (displays documentation for
classes and methods). There are more selections in the context menu (right-
click inside the editor to see the menu). Sections of the Creator-generated code
are folded by default to help keep the editing pane uncluttered. You can unfold
(select ‘+’) or fold (select ‘-’) sections as you work with the source code.
To see the set of abbreviations for the Java editor, select Tools > Options from
the main menu bar. The Options dialog pops up. Under Options, select Editing
> Editor Settings > Java Editor. On the right side of the display, click the small
 2.2 Creator Views 39

editing box next to Abbreviations. Creator pops up the window shown in

Figure 2–16.

Figure 2–16 Java source editor list of abbreviations

The window lists the abbreviations in effect for your Java editor. (You can
edit, add, or remove any item.) For example, to place a for loop in your Java
source file, type the sequence fora (for array) followed by <Space>. The editor
generates

for (int i = 0; i < .length; i++) {

}

and places the cursor in front of .length so that you can add an array name.
(.length refers to the length of the array object. This code snippet lets you eas-
ily loop through the elements of the array.)
The Java source editor also helps you with Java syntax and code completion.
All Java keywords are bold, and variables and literal Strings have unique col-
ors.
40 Chapter 2 Creator Basics

When you add statements to your Java source code, the editor dynamically
marks syntax errors (in red, of course). The editor also pops up windows to
help with code completion and package location for classes you need to refer-
ence (press <Ctrl-Space> to activate the code completion window). If available,
code completion includes Javadoc help. For example, Figure 2–17 shows the
code completion mechanism as you highlight method equals() and press
<Ctrl-Space>.

Figure 2–17 Java source editor code completion

When you use the down-arrow to select the second method, equalsIgnore-
Case(), the help mechanism displays its Javadoc documentation. (To retrieve
Javadoc documentation on any class in your source file, select it and press
<Ctrl-Shift-Space>.) The Java Source editor is discussed in more detail in Chap-
ter 4 (see “Using the Java Source Editor” on page 136).
When the Java source editor is active, Creator also activates the Navigator
window, as shown in Figure 2–18. The Navigator window lets you go to a
method or field within the Java source editor by clicking its name in the win-
dow. In Figure 2–18, the cursor hovers over method destroy(), displaying
help in a tooltip.
 2.2 Creator Views 41

Figure 2–18 Navigator view and help for method destroy() displayed

Code Clips Palette

When the Java Source editor is displayed, Creator replaces the Components
palette with the Code Clips palette, as shown in Figure 2–19. Here we show
several sections, including the code clips for Application Data. Highlight clip
Store Value in Session in this section. If you hold the cursor over the clip name,
Creator displays a snippet window. You can drag and drop the clip directly
into your Java source file.
To view or edit a clip, select it, right-click, and choose Edit Code Clip.
Figure 2–20 shows the Store Value in Session code clip.
The Code Clips palette is divided into categories to show sample code for
different programming tasks. For example, if you click Application Data, you’ll
see a listing of clips that let you access application data from different scopes in
your web application.
42 Chapter 2 Creator Basics

Figure 2–19 Java Clips Palette

Figure 2–20 Code Clips Editor

 2.2 Creator Views 43

Page Navigation Editor

Return to the Java Source window and examine method login_action().
You’ll see that login_action() returns one of two Strings (either "loginFail"
or "loginSuccess") to the action event handler. The action event handler then
passes the String on to the navigation handler to determine page flow. Let’s
look at the Page Navigation editor now.

1. From the top of the Java source window, select the Design button. This
returns you to the design canvas for this page.
2. Now right-click in the design canvas and select Page Navigation from the
context menu. Creator brings up the Page Navigation editor for project
Login1, as shown in Figure 2–21.

Figure 2–21 Page navigation editor for project Login1

There are three pages in this project. The Page Navigation editor displays
each page and indicates page flow logic with labeled arrows. The two labels
originating from page Page1.jsp correspond to the return Strings in action
method login_action().
Chapter 5 shows you how to specify navigation in your applications (see
“Page Navigation” on page 188). The Page Navigation editor is also a handy
way to bring up any of the project’s pages: just double-click inside the page.
Once you’ve visited the Page Navigation editor, Creator displays a file tab
called Page Navigation so you can easily return to it.
44 Chapter 2 Creator Basics

Before we explore our project any further, let’s have you deploy and run the
application. From the menu bar, select Run > Run Main Project. (Or, click the
green Run arrow on the icon toolbar, which also builds and runs your project.)

Output Window
Figure 2–22 shows the output window after building and deploying project
Login1. Creator uses the Ant build tool to control project builds. This Ant build
process requires compiling Java source files and assembling resources used by
the project into an archive file called a WAR (Web Archive) file. Ant reads its
instructions from a Creator-generated XML configuration file, called
build.xml, in the project’s directory structure.

Figure 2–22 Output window after building and deploying project Login1

If problems occur during the build process, Creator displays messages in the
Output window. A compilation error with the Java source is the type of error
that causes the build to fail. When a build succeeds (the window shows BUILD
SUCCESSFUL, as you see Figure 2–22), Creator tells the application server to
deploy the application. If the application server is not running, Creator starts it
for you. If errors occur in this step, messages appear in the Outline window
from the application server.
Finally, it’s possible that the deployment is successful but a runtime error
occurs. In this situation, the system throws an exception and displays a stack
trace on the browser’s web page. Likely sources for these errors are problems
with JSF tags on the JSP page, resources that are not available for the runtime
class loader, or objects that have not been properly initialized.
 2.2 Creator Views 45

When the build/deployment process is complete, Creator brings up your

browser with the correct URL. (Here the status window displays “Browsing:
http://localhost:28080/Login1/.”) To run project Login1 with the Sun
bundled Application Server, Creator generates this web address.

http://localhost:28080/Login1/

You use localhost if you’re running the application server on your own
machine; otherwise, use the Internet address or host name where the server is
running. The port number 28080 is unique to Sun’s bundled J2EE application
server. Other servers will use a different port number here.
Note that the Context Root is /Login1 for this application. The application
server builds a directory structure for each deployed application; the context
root is the “base address” for all the resources that your application uses.
Figure 2–23 shows the Login1 project deployed and running in a browser.
The Password field’s tooltip is displayed. Both the User Name and Password
input fields have asterisks, indicating required input. Type in some values for
User Name and Password. If you leave the User Name field empty or type less
than 3 characters or more than 10, you’ll get a validation error. (The minimum
and maximum number of characters only apply if you added a length validator
earlier.) The correct User Name and Password is “rave4u” for both fields.

Figure 2–23 Project Login1 running in a browser

If you supply the correct values and click the Login button, the program dis-
plays page LoginGood.jsp. Incorrect values display LoginBad.jsp.
46 Chapter 2 Creator Basics

It’s time now to explore the Servers window, located in the upper-left por-
tion of your Creator display. Click the tab labeled Servers to see this window.

Servers
Figure 2–24 shows the Servers window after you’ve deployed project Login1.
Various categories of servers are listed here, including Data Sources, Enterprise
JavaBeans, Web Services, Deployment Server, Remote Deployment Servers,
and Bundled Database Server.

Deployed project Login1

Figure 2–24 Servers window

The Data Sources node is a JDBC database connection. Creator bundles a

database server and the Data Sources node connects to the bundled database
by default. You can configure a different database. Creator comes configured
with several sample databases, which are visible if you expand the Data
Sources node.
 2.2 Creator Views 47

Creator Tip

The Database Server must be running to inspect the sample database tables.
If the Bundled Database Server is not running, right-click node Bundled
Database Server and select Start Bundled Database.

Let’s expand the Travel > Tables node and view the database tables. As you
select different tables, Creator displays their properties in the Properties win-
dow. Expand a table further to examine its database table field names, as
shown in Figure 2–25. Here, we expand table PERSON, displaying field names
PERSONID, NAME, JOBTITLE, and FREQUENTFLYER.

Figure 2–25 Inspecting the Travel Database tables (Person)

When you double-click a table name, Creator displays the data in the editor
pane with a default query, as shown in Figure 2–26. You can close the table
view by clicking the small x on the Query 1 tab. We discuss creating web appli-
cations that access databases in Chapter 9 (see “Accessing Databases” on
page 374).
The second resource in the Servers window is the Enterprise JavaBeans
node. Creator has a few sample EJBs deployed on the bundled Application
Server, which you can access within your projects. Expand node Enterprise Jav-
aBeans > Travel Center > TravelEJB, as shown in Figure 2–27. The TravelEJB
provides some of the same data as the Travel database. With Creator, you can
bind data to components exactly the same with EJBs as you can with data
source tables. We show you how to use EJBs in Chapter 11.
48 Chapter 2 Creator Basics

Figure 2–26 Display data from the Person table

Figure 2–27 EJB and Web Services resources shown in the Servers window

Another server resource is Web Services, which provides access to remote

APIs from Creator applications. This requires the cooperation of several Java
technologies, which we discussed in Chapter 1. The Creator installation
 2.2 Creator Views 49

includes a client to access the Google Web Services. In Chapter 10 we show you
how to create an application with the Google web service API. The Google
Search web service methods are shown in Figure 2–27.
The bundled Deployment Server allows you to deploy and run Creator
applications on your machine. The Deployed Components node shows you the
currently deployed components (including the Login1 application you just
deployed). From the Deployment Server node, you can start and stop the
server, access the Administrative Console, or view the server’s log (right-click
Deployment Server to view the context menu with these options).

Creator Tip

The application server must be running for access to the administration

console. Use user name admin and password adminadmin.

Debugging Windows
Creator has a debugger that lets you perform typical debugging tasks, such as
setting breakpoints, tracing the call stack, tracking local variables, and setting
watches. Use the View > Debugging menu to choose which debugging win-
dows to enable, as shown in Figure 2–28.

Figure 2–28 View > Debugging Menu Choices

To run your application in “debug mode,” click on Run > Debug Main
Project from the menu bar. The application server has to stop and restart if it’s
not already in debug mode. In Chapter 14 we walk you through the debugger
options, setting breakpoints, stepping through code, and other debugging
activities.
50 Chapter 2 Creator Basics

Creator Help System

The Creator Help System is probably the most useful window for readers new
to Creator. This help system includes a Dynamic Help display, search capabil-
ity, contents, and an index. The easiest way to access the help system is to select
Help > Dynamic Help from the main menu. The selections displayed are con-
text sensitive.
As an example, in the Page1 design view, select one of the Message compo-
nents and choose Help > Dynamic Help. Creator displays a help window with
topics relating to the message component as shown in Figure 2–29.

Figure 2–29 Dynamic Help window

When you double-click a selection, Creator displays the help information (see
Figure 2–30).
 2.3 Sample Application 51

Figure 2–30 Creator Help system

2.3 Sample Application

Now that you’re comfortable with Creator, let’s create a simple web applica-
tion. Even though this application is simplistic, it shows some of the power in
Creator. Figure 2–31 provides a preview of this web application.

Create a Project
Close project Login1 if it’s open.

1. From the Projects window, right-click the project node Login1 and select
Close Project from the context menu.
2. From Creator’s Welcome Page, select Create New Project. From the New
Project dialog, under Categories select Web and under Projects select JSF
Web Application. Click Next.
Exploring the Variety of Random
Documents with Different Content
 The Project Gutenberg eBook of The Sexual
Life of Our Time in Its Relations to Modern
Civilization
This ebook is for the use of anyone anywhere in the United
States and most other parts of the world at no cost and with
almost no restrictions whatsoever. You may copy it, give it away
or re-use it under the terms of the Project Gutenberg License
included with this ebook or online at www.gutenberg.org. If you
are not located in the United States, you will have to check the
laws of the country where you are located before using this
eBook.

Title: The Sexual Life of Our Time in Its Relations to Modern

Civilization

Author: Iwan Bloch

Translator: Eden Paul

Release date: December 19, 2019 [eBook #60968]

Most recently updated: October 17, 2024

Language: English

Credits: Produced by Turgut Dincer, Harry Lamé and the Online

Distributed Proofreading Team at http://www.pgdp.net
(This book was produced from images made available
by the HathiTrust Digital Library.)

*** START OF THE PROJECT GUTENBERG EBOOK THE SEXUAL LIFE

OF OUR TIME IN ITS RELATIONS TO MODERN CIVILIZATION ***
Please see the Transcriber’s Notes at
the end of this text.
THE SEXUAL LIFE OF OUR

TIME
 THE SEXUAL LIFE OF

OUR TIME

IN ITS RELATIONS TO MODERN

CIVILIZATION

BY
IWAN BLOCH, M.D.
PHYSICIAN FOR DISEASES OF THE SKIN, AND FOR DISEASES OF THE SEXUAL SYSTEM
IN CHARLOTTENBURG, BERLIN

AUTHOR OF “THE ORIGIN OF SYPHILIS,” ETC.

 TRANSLATED FROM THE SIXTH GERMAN EDITION
BY
M. EDEN PAUL, M.D.

LONDON
REBMAN LIMITED, 129, SHAFTESBURY AVENUE, W.C.
1909

Entered at Stationers’ Hall, 1908

All rights reserved
 PUBLISHERS’ NOTE TO THE ENGLISH EDITION
The author’s aim in writing this book was to write a complete
Encyclopædia on the sexual sciences, and it will probably be
acknowledged by all who study its pages that the author has
accomplished his intention in a very scholarly manner, and in such
form as to be of great value to the professions for whom this
translation is intended. The subject is no doubt one which appeals to
and affects the interests of all adult persons, but the publishers
have, after very serious and careful consideration, come to the
conclusion that the sale of the English translation of the book shall
be limited to members of the legal and medical professions.
To both these professions it is essential that a knowledge of the
science of Sex and the various causes for the existence of
“abnormals” should be ascertained, so that they may be guided in
the future in their investigations into, and the practice of attempts to
mitigate, the evil which undoubtedly exists, and to bring about a
more healthy class of beings. It is the first time that the subject has
been so carefully and fully gone into in the English language, and it
is believed that the very exhaustive examination which the author
has made into the matter, and the various cases to which he has
called attention, will be of considerable use to the medical
practitioner, and also to the lawyer in criminal and quasi-criminal
matters, and probably in matrimonial disputes and cases of insanity.
 CONTENTS

PAGE
INTRODUCTION 1

CHAPTER I
THE ELEMENTARY PHENOMENA OF HUMAN LOVE 7

CHAPTER II
THE SECONDARY PHENOMENA OF HUMAN LOVE
(BRAIN AND SENSES) 19

CHAPTER III
THE SECONDARY PHENOMENA OF HUMAN LOVE
(REPRODUCTIVE ORGANS, SEXUAL IMPULSE,
SEXUAL ACT) 37

CHAPTER IV
PHYSICAL DIFFERENTIAL SEXUAL CHARACTERS 53

CHAPTER V
PSYCHICAL DIFFERENTIAL SEXUAL CHARACTERS—THE
WOMAN’S QUESTION. APPENDIX: SEXUAL
SENSIBILITY IN WOMEN 67

CHAPTER VI
THE WAY OF THE SPIRIT IN LOVE—RELIGION AND
SEXUALITY 87

CHAPTER VII
THE WAY OF THE SPIRIT IN LOVE—THE EROTIC SENSE
OF SHAME (NAKEDNESS AND CLOTHING) 125

CHAPTER VIII
THE WAY OF THE SPIRIT IN LOVE—THE
INDIVIDUALIZATION OF LOVE 159

CHAPTER IX
THE ARTISTIC ELEMENT IN MODERN LOVE 177

CHAPTER X
THE SOCIAL FORMS OF THE SEXUAL RELATIONSHIP—
MARRIAGE 185

CHAPTER XI
FREE LOVE 233

CHAPTER XII
SEDUCTION, THE SENSUAL LIFE, AND WILD LOVE 279

CHAPTER XIII
PROSTITUTION—APPENDIX: THE HALF-WORLD 303

CHAPTER XIV
VENEREAL DISEASES—APPENDIX: VENEREAL DISEASES
IN THE HOMOSEXUAL 349

CHAPTER XV
PROPHYLAXIS, TREATMENT, AND SUPPRESSION OF
VENEREAL DISEASES 371

CHAPTER XVI
STATES OF SEXUAL IRRITABILITY AND SEXUAL
WEAKNESS (AUTO-EROTISM, MASTURBATION,
SEXUAL HYPERÆSTHESIA AND SEXUAL
ANÆSTHESIA, SEMINAL EMISSIONS, IMPOTENCE,
AND SEXUAL NEURASTHENIA) 407

CHAPTER XVII
THE ANTHROPOLOGICAL ASPECT OF PSYCHOPATHIA
SEXUALIS—APPENDIX: SEXUAL PERVERSIONS DUE
TO DISEASE 453

CHAPTER XVIII
MISOGYNY 479

CHAPTER XIX
THE RIDDLE OF HOMOSEXUALITY—APPENDIX: THEORY
OF HOMOSEXUALITY 487

CHAPTER XX
PSEUDO-HOMOSEXUALITY (GREEK AND ORIENTAL
PÆDERASTY, HERMAPHRODITISM, BISEXUAL
VARIETIES) 537

CHAPTER XXI
ALGOLAGNIA (SADISM AND MASOCHISM)—APPENDIX:
A CONTRIBUTION TO THE PSYCHOLOGY OF THE
RUSSIAN REVOLUTION (HISTORY OF THE
DEVELOPMENT OF AN ALGOLAGNISTIC
REVOLUTIONIST) 555

CHAPTER XXII
SEXUAL FETICHISM 609

CHAPTER XXIII
Welcome to Our Bookstore - The Ultimate Destination for Book Lovers
Are you passionate about books and eager to explore new worlds of
knowledge? At our website, we offer a vast collection of books that
cater to every interest and age group. From classic literature to
specialized publications, self-help books, and children’s stories, we
have it all! Each book is a gateway to new adventures, helping you
expand your knowledge and nourish your soul
Experience Convenient and Enjoyable Book Shopping Our website is more
than just an online bookstore—it’s a bridge connecting readers to the
timeless values of culture and wisdom. With a sleek and user-friendly
interface and a smart search system, you can find your favorite books
quickly and easily. Enjoy special promotions, fast home delivery, and
a seamless shopping experience that saves you time and enhances your
love for reading.
Let us accompany you on the journey of exploring knowledge and
personal growth!

ebookgate.com