Java

Signing Classes

2009-10-03T18:44:00.000-07:00

Web browsers that run Java applets start by defining a few rules and some coarse levels of security that restrict where applets may come from and what system resources they may access. These rules are sufficient to keep a malicious applet from attacking you, but they aren't sufficient for applications you'd like to trust with sensitive information. To fully exploit the power of Java, we need to have some nontechnical basis on which to make reasonable decisions about what a program can be allowed to do. This nontechnical basis is trust; basically, you trust certain entities not to do anything that's harmful to you. For a home user, this may mean that you trust the "Bank of Boofa" to distribute applets that let you transfer funds between your accounts, or you may trust L.L. Bean to distribute an applet that debits your Visa account. For a company, this may mean you trust applets originating behind your firewall and perhaps applets from a few high-priority customers to modify internal databases. In all these cases, you don't need to know in detail what the program is going to do and give it permission for each operation. You only need to know that you trust the source.

This doesn't mean that there isn't a technical aspect to the problem of trust. Trusting your local bank when you walk up to the ATM means one thing; trusting some web page that claims to come from your local bank means something else entirely. It would be very difficult to impersonate the ATM two blocks down the street (though it has been known to happen), but, depending on your position on the Net, it's not all that difficult to impersonate a web site or to intercept data coming from a legitimate web site and substitute your own.

That's where cryptography comes in. Digital signatures, together with certificates, are techniques for verifying that data truly comes from the source it claims to have come from and hasn't been modified en route. If the Bank of Boofa signs its checkbook applet, your browser can verify that the applet actually came from the bank, not an imposter, and hasn't been modified. Therefore, you can tell your browser to trust applets that have the Bank of Boofa's signature. Java supports digital signatures;

Application and User-Level Security

2009-10-02T18:43:00.001-07:00

There's a fine line between having enough power to do something useful and having all the power to do anything you want. Java provides the foundation for a secure environment in which untrusted code can be quarantined, managed, and safely executed. However, unless you are content with keeping that code in a little black box and running it just for its own benefit, you will have to grant it access to at least some system resources so that it can be useful. Every kind of access carries with it certain risks and benefits. For example, in the web browser environment, the advantages of granting an untrusted (unknown) applet access to your windowing system are that it can display information and let you interact in a useful way. The associated risks are that the applet may instead display something worthless, annoying, or offensive. Since most people can accept that level of risk, graphical applets and the Web in general are possible.

At one extreme, the simple act of running an application gives it a resourcecomputation timethat it may put to good use or burn frivolously. It's difficult to prevent an untrusted application from wasting your time or even attempting a "denial of service" attack. At the other extreme, a powerful, trusted application may justifiably deserve access to all sorts of system resources (e.g., the filesystem, process creation, network interfaces); a malicious application could wreak havoc with these resources. The message here is that important and sometimes complex security issues have to be addressed.

In some situations, it may be acceptable to simply ask the user to "okay" requests. With Sun's Java plug-in, web browsers can pop up a dialog box and ask the user's permission for an applet to access an otherwise restricted file. However, we can put only so much burden on our users. An experienced person will quickly grow tired of answering questions; an inexperienced user may not be able to answer the questions correctly. Is it okay for me to grant an applet access to something if I don't understand what that is?

Making decisions about what is dangerous and what is not can be difficult. Even ostensibly harmless access, such as displaying a window, can become a threat when paired with the ability of an untrusted application to communicate from your host. The Java Security Manager provides an option to flag windows created by an untrusted application with a special, recognizable border to prevent it from impersonating another application and perhaps tricking you into revealing your password or your secret recipe collection. There is also a grey area, in which an application can do devious things that aren't quite destructive. An applet that can mail a bug report can also mail-bomb your boss. The Java language provides the tools to implement whatever security policies you want. However, what these policies will be ultimately depends on who you are, what you are doing, and where you are doing it.

Java Compared with Other Languages

2009-06-18T19:13:00.000-07:00

Java is a relatively new language, but it draws on many years of programming experience with other languages in its choice of features. It is worth taking a moment to compare Java at a high level with some other popular languages today, both for the benefit of those of you with other programming experience and for the newcomers who need to put things in context. We do not expect you to have a knowledge of any particular programming language in this book and when we refer to other languages by way of comparison we hope that the comments are self-explanatory.

At least three pillars are necessary to support a universal programming language today: portability, speed, and security. Figure 1-2 shows how Java compares to a couple of other languages.

Figure 1-2. Programming languages compared

You may have heard that Java is a lot like C or C++, but that's really not true, except at a superficial level. When you first look at Java code, you'll see that the basic syntax looks like C or C++. But that's where the similarities end. Java is by no means a direct descendant of C or a next-generation C++. If you compare language features, you'll see that Java actually has more in common with highly dynamic languages such as Smalltalk and Lisp. In fact, Java's implementation is about as far from native C as you can imagine.

The surface-level similarities to these languages are worth noting, however. Java borrows heavily from C and C++ syntax, so you'll see terse language constructs, including an abundance of curly braces and semicolons. Java subscribes to the C philosophy that a good language should be compact; in other words, it should be sufficiently small and regular so a programmer can hold all the language's capabilities in his or her head at once. Just as C is extensible with libraries, packages of Java classes can be added to the core language components to extend its vocabulary.

C has been successful because it provides a reasonably feature-packed programming environment, with high performance and an acceptable degree of portability. Java also tries to balance functionality, speed, and portability, but it does so in a very different way. C trades functionality for portability; Java initially traded speed for portability. Java also addresses security issues while C doesn't.

In the early days before JIT and adaptive compilation, Java was slower than statically compiled languages and there was a constant refrain from detractors that it would never catch up. But as we described in the previous section, Java's performance is now comparable to C or C++ for equivalent tasks and those criticisms have generally fallen quiet. In fact, in 2004, ID Software's open source Quake2 video game engine was ported to Java. If Java is fast enough for first-person-shooter video games, it's certainly fast enough for business applications.

Scripting languages, such as Perl, Python, and Ruby, are very popular, and for good reason. There's no reason a scripting language can't be suitable for safe, networked applications. But most scripting languages are not designed for serious, large-scale programming. The attraction to scripting languages is that they are dynamic; they are powerful tools for rapid development. Some scripting languages such as Perl also provide powerful tools for text-processing tasks that more general-purpose languages find unwieldy. Scripting languages are also highly portable, albeit at the source-code level.

Not to be confused with Java, JavaScript is an object-based scripting language originally developed by Netscape for the web browser. It serves as a glue and an "in the document" language for dynamic, interactive HTML-based applications. JavaScript takes its name from its intended integration with Java applets and some similarity in syntax, but the comparison really ends there. While there have been applications of JavaScript outside of the browser, it has never really caught on as a general scripting language. For more information on JavaScript, check out JavaScript: The Definitive Guide by David Flanagan (O'Reilly).

The problem with scripting languages is that they are rather casual about program structure and data typing. Most scripting languages (with a hesitant exception for Python and later versions of Perl) are not object-oriented. They also have vastly simplified type systems and generally don't provide for sophisticated scoping of variables and functions. These characteristics make them unsuitable for building large, modular applications. Speed is another problem with scripting languages; the high-level, fully interpreted nature of these languages often makes them quite slow.

Advocates of individual scripting languages would take issue with some of these generalizations and no doubt they'd be right in some casesscripting languages are growing up. But the fundamental tradeoff is undeniable: scripting languages were born as loose, less structured alternatives to systems programming languages and are generally not as suitable for large or complex projects for a variety of reasons, at least not today.

Java offers some of the essential advantages of a scripting language (it is highly dynamic), along with the added benefits of a lower-level language. Java 1.4 added a powerful Regular Expression API that competes with Perl for working with text and Java 5.0 has introduced new language features that streamline coding, such as "foreach"-style iteration over collections, variable argument lists, autoboxing and unboxing of primitives, and static imports of methods.

Incremental development with object-oriented components, combined with Java's simplicity, make it possible to develop applications rapidly and change them easily. Studies have found that development in Java is faster than in C or C++, strictly based on language features.^[*] Java also comes with a large base of standard core classes for common tasks such as building GUIs and handling network communications. But along with these features, Java has the scalability and software-engineering advantages of more static languages. It provides a safe structure on which to build higher-level frameworks (and even other languages).

^[*] See, for example, G. Phipps, "Comparing Observed Bug and Productivity Rates for Java and C++," SoftwarePractice & Experience, Volume 29, 1999 (http://www.spirus.com.au/papersAndTalks/javaVsC++.pdf).

As we've already said, Java is similar in design to languages such as Smalltalk and Lisp. However, these languages are currently used mostly as research vehicles rather than for development of large-scale systems. One reason is that these languages never developed a standard portable binding to operating-system services, such as the C standard library or the Java core classes. Smalltalk is compiled to an interpreted bytecode format, and it can be dynamically compiled to native code on the fly, just like Java. But Java improves on the design by using a bytecode verifier to ensure the correctness of compiled Java code. This verifier gives Java a performance advantage over Smalltalk because Java code requires fewer runtime checks. Java's bytecode verifier also helps with security issues, something that Smalltalk doesn't address. Smalltalk is a mature language, though, and Java's designers took lessons from many of its features.

Throughout the rest of this chapter, we'll present a bird's-eye view of the Java language. We'll explain what's new and what's not-so-new about Java and why.

Objects

2009-06-05T20:28:00.000-07:00

Class Instantiation

The process of creating objects from a class is called instantiation. An object is an instance of a class. The object is constructed using the class as a blueprint and is a concrete instance of the abstraction that the class represents. An object must be created before it can be used in a program. In Java, objects are manipulated through object references (also called reference values or simply references). The process of creating objects usually involves the following steps:

Declaration of a variable to store the object reference.

This involves declaring a reference variable of the appropriate class to store the reference to the object.
```
// Declaration of two reference variables that will denote
// two distinct objects, namely two stacks of characters, respectively.
CharStack stack1, stack2;
```
Creating an object.

This involves using the new operator in conjunction with a call to a constructor, to create an instance of the class.
```
// Create two distinct stacks of chars.
stack1 = new CharStack(10); // Stack length: 10 chars
stack2 = new CharStack(5);  // Stack length: 5 chars
```
The new operator returns a reference to a new instance of the CharStack class. This reference can be assigned to a reference variable of the appropriate class.

Each object has a unique identity and has its own copy of the fields declared in the class definition. The two stacks, denoted by stack1 and stack2, will have their own stackArray and topOfStack fields.

The purpose of the constructor call on the right side of the new operator is to initialize the newly created object. In this particular case, for each new CharStack instance created using the new operator, the constructor creates an array of characters. The length of this array is given by the value of the argument to the constructor. The constructor also initializes the topOfStack field.

The declaration and the instantiation can also be combined:

CharStack stack1 = new CharStack(10),
         stack2 = new CharStack(5);

Figure 1.2 shows the UML notation for objects. The graphical representation of an object is very similar to that of a class. Figure 1.2 shows the canonical notation, where the name of the reference variable denoting the object is prefixed to the class name with a colon ':'. If the name of the reference variable is omitted, as in Figure 1.2b, this denotes an anonymous object. Since objects in Java do not have names, but are denoted by references, a more elaborate notation is shown in Figure 1.2c, where objects representing references of CharStack class explicitly refer to CharStack objects. In most cases, the more compact notation will suffice.

Figure 1.2. UML Notation for Objects

Object References

A reference provides a handle to an object that is created and stored in memory. In Java, objects can only be manipulated via references, which can be stored in variables. An object can have several references, often called its aliases. The object can be manipulated via any one of its aliases.

// Create two distinct stacks of chars.
CharStack stackA = new CharStack(12); // Stack length: 12 chars
CharStack stackB = new CharStack(6);  // Stack length: 6 chars

stackB = stackA;                      // (1) aliases after assignment
// Stack previously referenced by stackB can now be garbage collected.

Two stacks are created in the code above. Before the assignment at (1), the situation is as depicted in Figure 1.3a. After the assignment at (1), reference variables stackA and stackB will denote the same stack, as depicted in Figure 1.3b. Reference variables stackA and stackB are aliases after the assignment, as they refer to the same object. What happens to the stack object that was denoted by the reference variable stackB before the assignment? When objects are no longer in use, their memory is, if necessary, reclaimed and reallocated for other objects. This is called automatic garbage collection. Garbage collection in Java is taken care of by the runtime system.

Figure 1.3. Aliases

Classes

2009-06-04T20:20:00.000-07:00

One of the fundamental ways in which we handle complexity is abstractions. An abstraction denotes the essential properties and behaviors of an object that differentiate it from other objects. The essence of OOP is modelling abstractions, using classes and objects. The hard part in this endeavour is finding the right abstractions.

A class denotes a category of objects, and acts as a blueprint for creating such objects. A class models an abstraction by defining the properties and behaviors for the objects representing the abstraction. An object exhibits the properties and behaviors defined by its class. The properties of an object of a class are also called attributes, and are defined by fields in Java. A field in a class definition is a variable which can store a value that represents a particular property. The behaviors of an object of a class are also known as operations, and are defined using methods in Java. Fields and methods in a class definition are collectively called members.

An important distinction is made between the contract and the implementation that a class provides for its objects. The contract defines what services, and the implementation defines how these services are provided by the class. Clients (i.e., other objects) only need to know the contract of an object, and not its implementation, in order to avail themselves of the object's services.

As an example, we will implement different versions of a class that models the abstraction of a stack that can push and pop characters. The stack will use an array of characters to store the characters, and a field to indicate the top element in the stack. Using Unified Modeling Language (UML) notation, a class called CharStack is graphically depicted in Figure 1.1, which models the abstraction. Both fields and method names are shown in Figure 1.1a.

Figure 1.1. UML Notation for Classes

Declaring Members: Fields and Methods

Example 1.1 shows the definition of the class CharStack depicted in Figure 1.1. Its intention is to illustrate the salient features of a class definition in Java, and not effective implementation of stacks.

A class definition consists of a series of member declarations. In the case of the class CharStack, it has two fields:

stackArray, which is an array to hold the elements of the stack (in this case characters)
topOfStack, which denotes the top element of the stack (i.e., index of the last character stored in the array)

The class CharStack has five methods that implement the essential operations on a stack:

push() pushes a character on to the stack
pop() removes and returns the top element of the stack
peek() returns the top element of the stack for inspection
isEmpty() determines whether the stack is empty
isFull() determines whether the stack is full

The class definition also has a method-like declaration with the same name as the class, (2). Such declarations are called constructors. As we shall see, a constructor is executed when an object is created from the class. However, the implementation details in the example are not important for the present discussion.

Example 1.1 Basic Elements of a Class Definition

// Source Filename: CharStack.java
public class CharStack {          // Class name
  // Class Declarations:

  // (1) Fields:
  private char[] stackArray;    // The array implementing the stack.
  private int    topOfStack;    // The top of the stack.

  // (2) Constructor:
  public CharStack(int n) { stackArray = new char[n]; topOfStack = -1; }

  // (3) Methods:
  public void push(char element) { stackArray[++topOfStack] = element; }
  public char pop()              { return stackArray[topOfStack--]; }
  public char peek()             { return stackArray[topOfStack]; }
  public boolean isEmpty()       { return topOfStack < topofstack ="=""> }
public boolean isFull()        { return topOfStack == stackArray.length - 1; }
}

To pass the Sun Certified Programmer for Java 2 Platform 1.4 exam (SCPJ2 1.4)

2009-06-03T20:11:00.001-07:00

Before embarking on the road to Java programmer certification, it is important to understand the basic terminology and concepts in object-oriented programming (OOP). In this chapter, the emphasis is on providing an introduction rather than an exhaustive coverage. In-depth coverage of the concepts follows in due course in subsequent chapters of the book.

Java supports the writing of many different kinds of executables: applications, applets, and servlets. The basic elements of a Java application are introduced in this chapter. The old adage that practice makes perfect is certainly true when learning a programming language. To encourage programming on the computer, the mechanics of compiling and running a Java application are outlined.

Safety of Design

2009-05-19T19:03:00.000-07:00

You have no doubt heard a lot about the fact that Java is designed to be a safe language. But what do we mean by safe? Safe from what or whom? The security features that attract the most attention for Java are those features that make possible new types of dynamically portable software. Java provides several layers of protection from dangerously flawed code as well as more mischievous things such as viruses and Trojan horses. In the next section, we'll take a look at how the Java virtual machine architecture assesses the safety of code before it's run and how the Java class loader (the bytecode loading mechanism of the Java interpreter) builds a wall around untrusted classes. These features provide the foundation for high-level security policies that can allow or disallow various kinds of activities on an application-by-application basis.

In this section, though, we'll look at some general features of the Java programming language. Perhaps more important than the specific security features, although often overlooked in the security din, is the safety that Java provides by addressing common design and programming problems. Java is intended to be as safe as possible from the simple mistakes we make ourselves as well as those we inherit from legacy software. The goal with Java has been to keep the language simple, provide tools that have demonstrated their usefulness, and let users build more complicated facilities on top of the language when needed.

Simplify, Simplify, Simplify...

With Java, simplicity rules. Since Java started with a clean slate, it was able to avoid features that proved to be messy or controversial in other languages. For example, Java doesn't allow programmer-defined operator overloading (which in some languages allows programmers to redefine the meaning of basic symbols like + and -). Java doesn't have a source code preprocessor, so it doesn't have things like macros, #define statements, or conditional source compilation. These constructs exist in other languages primarily to support platform dependencies, so in that sense, they should not be needed in Java. Conditional compilation is also commonly used for debugging, but Java's sophisticated runtime optimizations and features such as assertions solve the problem more elegantly (we'll cover these in Chapter 4).

Java provides a well-defined package structure for organizing class files. The package system allows the compiler to handle some of the functionality of the traditional make utility (a tool for building executables from source code). The compiler can also work with compiled Java classes directly because all type information is preserved; there is no need for extraneous source "header" files, as in C/C++. All this means that Java code requires less context to read. Indeed, you may sometimes find it faster to look at the Java source code than to refer to class documentation.

Java also takes a different approach to some structural features that have been troublesome in other languages. For example, Java supports only a single inheritance class hierarchy (each class may have only one "parent" class) but allows multiple inheritance of interfaces. An interface, like an abstract class in C++, specifies the behavior of an object without defining its implementation. It is a very powerful mechanism that allows the developer to define a "contract" for object behavior that can be used and referred to independently of any particular object implementation. Interfaces in Java eliminate the need for multiple inheritance of classes and the associated problems.

It is only after many years of debate that, in Java 5.0, some major new language features have been added to the language. The latest release of Java added generics, which are an abstraction that allows Java classes to work with different types in a safe way that the compiler can understand. While generics can hardly be considered simple, their common usage and effect on the language will make code more maintainable and easier to read. Providing this without a major complication of the language has been an accomplishment.

As you'll seein Chapter 4, Java is a fairly simple and elegant programming language and that is still a large part of its appeal.

Type Safety and Method Binding

One attribute of a language is the kind of type checking it uses. Generally, languages are categorized as static or dynamic, which refers to the amount of information about variables known at compile time versus what is known while the application is running.

In a strictly statically typed language such as C or C++, data types are etched in stone when the source code is compiled. The compiler benefits from this by having enough information to catch many kinds of errors before the code is executed. For example, the compiler would not allow you to store a floating-point value in an integer variable. The code then doesn't require runtime type checking, so it can be compiled to be small and fast. But statically typed languages are inflexible. They don't support high-level constructs such as lists and collections as naturally as languages with dynamic type checking, and they make it impossible for an application to safely import new data types while it's running.

In contrast, a dynamic language such as Smalltalk or Lisp has a runtime system that manages the types of objects and performs necessary type checking while an application is executing. These kinds of languages allow for more complex behavior and are in many respects more powerful. However, they are also generally slower, less safe, and harder to debug.

The differences in languages have been likened to the differences among kinds of automobiles.^[*] Statically typed languages such as C++ are analogous to a sports carreasonably safe and fastbut useful only if you're driving on a nicely paved road. Highly dynamic languages such as Smalltalk are more like an off-road vehicle: they afford you more freedom but can be somewhat unwieldy. It can be fun (and sometimes faster) to go roaring through the back woods, but you might also get stuck in a ditch or mauled by bears.

^[*] The credit for the car analogy goes to Marshall P. Cline, author of the C++ FAQ.

Another attribute of a language is the way it binds method calls to their definitions. In a static language such as C or C++, the definitions of methods are normally bound at compile time, unless the programmer specifies otherwise. Languages like Smalltalk, on the other hand, are called "late binding" because they locate the definitions of methods dynamically at runtime. Early binding is important for performance reasons; an application can run without the overhead incurred by searching for methods at runtime. But late binding is more flexible. It's also necessary in an object-oriented language where new types can be loaded dynamically and only the runtime system can determine which method to run.

Java provides some of the benefits of both C++ and Smalltalk; it's a statically typed, late-binding language. Every object in Java has a well-defined type that is known at compile time. This means the Java compiler can do the same kind of static type checking and usage analysis as C++. As a result, you can't assign an object to the wrong type of variable or call nonexistent methods on an object. The Java compiler goes even further and prevents you from using uninitialized variables and creating unreachable statements (see Chapter 4).

However, Java is fully runtime-typed as well. The Java runtime system keeps track of all objects and makes it possible to determine their types and relationships during execution. This means you can inspect an object at runtime to determine what it is. Unlike C or C++, casts from one type of object to another are checked by the runtime system, and it's possible to use new kinds of dynamically loaded objects with a level of type safety. And since Java is a late-binding language, it's always possible for a subclass to override methods in its superclass, even a subclass loaded at runtime.

Incremental Development

Java carries all data-type and method-signature information with it from its source code to its compiled bytecode form. This means that Java classes can be developed incrementally. Your own Java source code can also be compiled safely with classes from other sources your compiler has never seen. In other words, you can write new code that references binary class files without losing the type safety you gain from having the source code.

Java does not suffer from the "fragile base class" problem. In languages such as C++, the implementation of a base class can be effectively frozen because it has many derived classes; changing the base class may require recompilation of all of the derived classes. This is an especially difficult problem for developers of class libraries. Java avoids this problem by dynamically locating fields within classes. As long as a class maintains a valid form of its original structure, it can evolve without breaking other classes that are derived from it or that make use of it.

Dynamic Memory Management

Some of the most important differences between Java and lower-level languages such as C and C++ involve how Java manages memory. Java eliminates ad hoc "pointers" that can reference arbitrary areas of memory and adds object garbage collection and high-level arrays to the language. These features eliminate many otherwise insurmountable problems with safety, portability, and optimization.

Garbage collection alone has saved countless programmers from the single largest source of programming errors in C or C++: explicit memory allocation and deallocation. In addition to maintaining objects in memory, the Java runtime system keeps track of all references to those objects. When an object is no longer in use, Java automatically removes it from memory. You can, for the most part, simply ignore objects you no longer use, with confidence that the interpreter will clean them up at an appropriate time.

Java uses a sophisticated garbage collector that runs intermittently in the background, which means that most garbage collecting takes place during idle times, between I/O pauses, mouse clicks, or keyboard hits. Advanced runtime systems, such as HotSpot, have more advanced garbage collection that can differentiate the usage patterns of objects (such as short-lived versus long-lived) and optimize their collection. The Java runtime can now tune itself automatically for the optimal distribution of memory for different kinds of applications, based on their behavior. With this kind of runtime profiling, automatic memory management can be much faster than the most diligently programmer-managed resources, something that some people still find hard to believe.

We've said that Java doesn't have pointers. Strictly speaking, this statement is true, but it's also misleading. What Java provides are referencesa safe kind of pointerand Java is rife with them. A reference is a strongly typed handle for an object. All objects in Java, with the exception of primitive numeric types, are accessed through references. You can use references to build all the normal kinds of data structures a C programmer would be accustomed to building with pointers, such as linked lists, trees, and so forth. The only difference is that with references you have to do so in a typesafe way.

Another important difference between a reference and a pointer is that you can't play games (pointer arithmetic) with references to change their values; they can point only to specific objects or elements of an array. A reference is an atomic thing; you can't manipulate the value of a reference except by assigning it to an object. References are passed by value, and you can't reference an object through more than a single level of indirection. The protection of references is one of the most fundamental aspects of Java security. It means that Java code has to play by the rules; it can't peek into places it shouldn't.

Java references can point only to class types. There are no pointers to methods. People sometimes complain about this missing feature, but you will find that tasks that call for pointers to methods can be accomplished more cleanly using interfaces and adapter classes instead. We should also mention that Java has a sophisticated Reflection API that actually allows you to reference and invoke individual methods. However this is not the normal way of doing things. We discuss reflection in Chapter 7.

Finally, we should mention that arrays in Java are true, first-class objects. They can be dynamically allocated and assigned like other objects. Arrays know their own size and type, and although you can't directly define or subclass array classes, they do have a well-defined inheritance relationship based on the relationship of their base types. Having true arrays in the language alleviates much of the need for pointer arithmetic, such as that used in C or C++.

Error Handling

Java's roots are in networked devices and embedded systems. For these applications, it's important to have robust and intelligent error management. Java has a powerful exception-handling mechanism, somewhat like that in newer implementations of C++. Exceptions provide a more natural and elegant way to handle errors. Exceptions allow you to separate error-handling code from normal code, which makes for cleaner, more readable applications.

When an exception occurs, it causes the flow of program execution to be transferred to a predesignated "catcher" block of code. The exception carries with it an object that contains information about the situation that caused the exception. The Java compiler requires that a method either declare the exceptions it can generate or catch and deal with them itself. This promotes error information to the same level of importance as argument and return types for methods. As a Java programmer, you know precisely what exceptional conditions you must deal with, and you have help from the compiler in writing correct software that doesn't leave them unhandled.

Threads

Today's applications require a high degree of parallelism. Even a very single-minded application can have a complex user interfacewhich requires concurrent activities. As machines get faster, users become more sensitive to waiting for unrelated tasks that seize control of their time. Threads provide efficient multiprocessing and distribution of tasks for both client and server applications. Java makes threads easy to use because support for them is built into the language.

Concurrency is nice, but there's more to programming with threads than just performing multiple tasks simultaneously. In most cases, threads need to be synchronized, which can be tricky without explicit language support. Java supports synchronization based on the monitor and condition modela sort of lock and key system for accessing resources. The keyword synchronized designates methods and blocks of code for safe, serialized access within an object. There are also simple, primitive methods for explicit waiting and signaling between threads interested in the same object.

Java 5.0 introduced a new high-level concurrency package. This package provides powerful utilities that address common patterns in multithreaded programming, such as thread pools, coordination of tasks, and sophisticated locking. With the addition of the concurrency package, Java now provides some of the most advanced thread-related utilities of any language.

Although some developers may never have to write multithreaded code, learning to program with threads is an important part of mastering programming in Java and something all developers should grasp. See Chapter 9 for a discussion of this topic. For complete coverage of threads, refer to Java Threads by Scott Oaks and Henry Wong (O'Reilly).

Scalability

At the lowest level, Java programs consist of classes. Classes are intended to be small, modular components. They can be separated physically on different systems, retrieved dynamically, stored in a compressed format, and even cached in various distribution schemes. Over classes, Java provides packages, a layer of structure that groups classes into functional units. Packages provide a naming convention for organizing classes and a second tier of organizational control over the visibility of variables and methods in Java applications.

Within a package, a class is either publicly visible or protected from outside access. Packages form another type of scope that is closer to the application level. This lends itself to building reusable components that work together in a system. Packages also help in designing a scalable application that can grow without becoming a bird's nest of tightly coupled code.

Online Resources

2009-05-15T20:02:00.000-07:00

There are many online sources for information about Java. Sun Microsystems's official web site for Java topics is http://java.sun.com; look here for the software, updates, and Java releases. This is where you'll find the JDK, which includes the compiler, the interpreter, and other tools (the JDK is also on the CD-ROM that comes with this book; view the CD content online at http://examples.oreilly.com/learnjava3/CD-ROM/).

You should also visit O'Reilly Media's Java site at http://java.oreilly.com. There you'll find information about other O'Reilly Java books, and a pointer to the home page for Learning Java, http://www.oreilly.com/catalog/learnjava3/, where you'll find the source code examples for this book.

Introduction to the JDeveloper IDE - Managing Files

2009-01-05T19:13:00.001-08:00

Managing Files

The integrated JDeveloper tool allows search functionalities on files belonging to your current application or across multiple applications. To experiment these functionalities perform the following steps:

1.
From the menu, select Search | Find Application Files.

2.
In the File List tab, use the Look in field to select the scope of your search. Keep the All Projects choice.

3.
Select File Extension and type .java to retrieve all files of this type, then click Search.

4.
The Results window returns the file names corresponding to your criteria.
Note that clicking on one of the file name from the list opens the file in the editor.

5.
You can indicate complex search criteria using the sign combined with the logical Match operators.

6.
You can also retrieve files recently used from the Application Navigator, click the Recently Opened Files to deploy the accordion.

7.
To retrieve a Java class, click [Ctrl] + [-] key to open a dialog.

8.
In the Name field, type Int, then select the IntAnimal.java from the list, then Enter.

9.
To retrieve a file, click [Ctrl] + [Alt] + [-] key stroke to open a dialog. In the File Name field, type D, then select the Dog.java from the list, then Enter.

Introduction to the JDeveloper IDE - Debugging Java Programs

2009-01-05T19:12:00.001-08:00

Debugging Java Programs

The integrated JDeveloper debugger enables you to debug Java programs in the source editor. This topic shows
you how to control the execution of a program by setting breakpoints. When program execution encounters a
breakpoint, the program pauses, and the debugger displays the line containing the breakpoint in the source editor. You
can then use the debugger to view the state of the program.

1.
Set a breakpoint in the Dog.java file. To do this, click in the margin to the left of the line:
System.out.println(count + myDog.sayHowDoYouDo("Kate"));
The breakpoint icon, which looks like a red ball, is displayed in the margin.

2.
Right-click in the source editor and select Debug from the context menu.

3.
Program execution proceeds up to the breakpoint. The red arrow in the left margin of the source editor indicates where the break is occurring. The debugger window opens and displays the debugging trace.

4.
Click the Step Over icon in the toolbar to execute the first iteration of the myDog.sayHowDoYouDo() method.

5.
Click the Debugging: MyProject.jpr tab at the bottom of the log window and then click the Log tab in the debugger window. Note that the log window displays the first woof Kate message.

6
Notice the Smart Data window to the right of the Debugging Log tab. Select the count variable, and double-click in the Value column to display the Modify Value dialog.

7.
Type 2 as the new value. Click OK.

8.
In the toolbar, click Resume to continue program execution.

9.
The count variable is incremented and exceeds its limit, so the program terminates, and the debugger disconnects.

Introduction to the JDeveloper IDE - Navigating through code

2009-01-05T19:11:00.001-08:00

Navigating through code

JDeveloper provides easy ways to navigate to related code and to Javadoc, and the ability to expand or contract sections of code, improving navigability in large programs. To explore these features, perform the following steps:

1.
Click the Source tab for the Dog.java file in the editor.
You can navigate from one part of the code to another related part. One example of this is navigating from a method to its declaration in an interface.
A method that implements a declaration from an interface displays a callout icon in the left-hand margin. Clicking this icon takes you to where the method is declared.
Click the arrow icon next to the sayHowDoYouDo() method in the Dog.java file.

2.
JDeveloper takes you to the IntAnimal interface where the method is declared and highlights the appropriate line for you.

3.
To return to where you were in the Dog class, click the green Back button in the toolbar.
You can also Navigate backward or forward using the [Alt] + [left] or [right] arrow key.

4.
You can also navigate to the Javadoc for a given element. In the Dog.java file in the editor, right-click within the sayHowDoYouDo() method. From the context menu, choose Quick Javadoc.

5.
The Javadoc popup window displays additional information about the selected method.

6.
Click the String link to get more info about the String class.
Click within the code editor window to remove the doc 'ghost' window.

7.
Click [Ctrl]+[-] (minus) key to popup the Go to Java Class dialog. It allows you to display Source or Javadoc information of the selected class.
In the Name field type String then Enter on the java.lang.String highlighted suggestion.

8.
The source code for the String class opens in the editor.
Close the String.java tab.

9.
Code folding enables you to expand and contract sections of code, making large programs more manageable.
Place your mouse in the space between the dotted and solid lines to the left of the Cat line.
Notice that a blue vertical line displays beside the main method body.

10.
Click the minus (-) sign at the top of the vertical blue line to contract this section of code.

11.
Hover over the plus (+) sign next to the contracted section of code. The contracted lines of code display in a blue shaded box.

12.
The new Quick Outline Navigator enables you to quickly navigate to methods and fields of a class and its super classes.
In the code editor toolbar click the Quick Outline icon.
The Quick Outline 'ghost' window displays.

13.
Click the Show Methods icon (first icon from the left) to see all the methods in the Dog class.

14.
Filter by typing ge in the field.

15.
Use the down arrow key to select the getName() method, then Enter.
That's a new feature that provides built-in navigation in the class you are looking at.

16.
Back in the code editor, double-click within the ellipses of the main() {...} method. JDeveloper expands the collapsed code.

Back to Topic

Introduction to the JDeveloper IDE - Viewing code modification history

2009-01-05T19:05:00.000-08:00

Viewing code modification history

JDeveloper has a built-in history feature. This local history does not require a version control system to provide a recent change record and visual "diff" between versions. Versions are automatically created based on user interactions such as Save, Compile, Rename, and so on.

1.
Notice the three tabs at the foot of the editor window. Click the History tab.

2.
The History window displays. The top part of the window contains a list of revisions and dates, while a list of changes to the code displays in the bottom part of the window. The two windows are synchronized, so that the detail in the bottom part of the window matches the selection in the top part.
The revisions for the selected date and time are summarized in the status line at the bottom of the IDE, in this case 6 differences: 3 added, 0 removed, 3 changed.

3.
The lilac-colored boxes indicate changes to the code.
In the top portion of the window, select Introduce Parameter near the top of the list.
In the bottom left portion of the editor, position your mouse over the green right-pointing arrow in the lilac box that contains the sayHi() method declaration. Notice that a message displays, indicating that clicking the green arrow enables you to replace the adjacent difference. In this case, clicking the green arrow would revert the sayHowDoYouDo() method to sayHi(). Don't revert now.

4.
The green boxes indicate additions to the code.
In the top portion of the window, select Load External State near the bottom of the list.
In the bottom of the window, select the //Cat myCat = new Cat(); line in the green box in the right hand window. Hover over the red X with your mouse. Notice the message indicating that to delete the addition(s), you click the X.

Introduction to the JDeveloper IDE - Refactoring code

2009-01-05T19:01:00.000-08:00

Refactoring code

Refactoring is an editing technique that modifies code structure without altering program behavior. A refactoring operation
is a sequence of simple edits that transforms a program's code but keeps it in a state where it compiles and runs correctly.
JDeveloper provides a collection of refactoring operations.

1.	One example of a refactoring operation is replacing a constant expression in a method body by a parameter for the method. The expression is replaced by the parameter name. The new parameter is added to the method's parameter list and to all invocations of the method. To do this in the Dog class, right-click the literal, 'Kate' in the sayHi() method code and select Refactor --> Introduce Parameter...from the context menu
2.	In the Introduce Parameter dialog, type name in the Name field, and click OK.
3.	Examine the code to see the results of the refactor operation. The method declaration now contains String name in its parameter list; the parameter name has replaced the literal 'Kate' in the method return value, and the literal 'Kate' has been inserted as a parameter in the method call.
4.	Another refactoring operation is to derive a new interface from selected methods in an existing class. To do this in the Dog class, right-click the Dog class declaration method, and from the context menu, choose Refactor --> Extract Interface...
5.	In the Extract Interface dialog, type IntAnimal as the name of the interface, and select the sayHi(String) method in the Extract Interface list. Click OK.
6.	The IntAnimal interface is created and opens in the source editor.
7.	Another simple refactoring operation is to rename a method, whereby every occurrence of the method name is replaced by the new name. To do this in the IntAnimal interface, right-click in the sayHi() method, and from the context menu, choose Refactor --> Rename.
8.	In the Rename Method dialog, change the sayHi method name to sayHowDoYouDo. Select the Preview check box to see all the usages that are affected by the name change. Click OK.
9.	The log window lists all usages of the sayHi() method. You should examine each usage to check that you want each occurrence of sayHi()to be changed to sayHowDoYouDo(). If so, click Do Refactoring in the log window toolbar.
10.	Note that the name change has taken place in the IntAnimal interface......
11.	.....and in the Dog class.
12.	Select the Navigate menu option. The Back option allows you to return to the previous location. This option is also available from the toolbar, using the Back button. Clicking the down arrow next to the Back button, shows the history of the navigation.
13.	From the menu select Search \| Auto Code Highlight to turn off this option, and in the code editor toolbar click the Clear All Highlighting icon.

Introduction to the JDeveloper IDE - Searching and Highlighting code

2009-01-05T18:55:00.001-08:00

Searching and Highlighting code

Using the code editor, you can search for text and display all occurrences of the search criteria. You can also use a highlighting facility that retrieves all occurrences of an object.

1.	Use the Search/Code highlight feature. In the Search box on the left of the code editor toolbar, type name. The first instance of name found is highlighted in the code editor.
2.	Click the 'down' arrow to move to the next occurrence of the string.
3.	Click the binocular icon to have access to additional options and check the Highlight Occurrences option. Click the down arrow to highlight all Occurrences. Notice that the search function retrieves all Occurrences of a string in the code.
4.	Click the Clear All Highlighting icon in the editor toolbar.
5.	Remove name from the Search field.
6.	From the menu, choose Search \| Auto Code Highlight.
7.	In the code editor select the age parameter of the setAge method. Notice that then the highlighted occurrences are restricted to occurrences of the same semantic object. The age variable being excluded.
8.	Now select the age variable in the setAge method to highlight all Occurrences of that variable.
9.	In the right margin, hover over the top yellow marker with the mouse to display the code.
10.	Double click this yellow marker. This moves you to the corresponding location in the source editor.
11.	Configure JDeveloper to allow a 'ghost' window to display additional information. From the main menu, select Tools \| Preferences.
12.	In the Preferences dialog, select Accelerators and from the All Category, select Quick Peek. The assigned accelerator is [Ctrl]+[1]. Click OK.
13.	You can view the definition of a variable or method without navigating to a different file or opening a new editor. JDeveloper uses a 'ghost' window to overlay your code in the code editor, or the structure pane, enabling you to discover the information you need without having your attention drawn away to a separate dialog interaction. In the structure pane, move your mouse over one of the nodes and click the [Ctrl]+[1] keys. This way you can also display the code front structure from the class structure. The ghost window closes as you release the shortcut keys.
14.	Now back in the source editor window, hover your mouse over the sayHi method in the System.out.println(count + myDog.sayHi()); and press the [Ctrl]+[1] keys. This displays the method definition.
15.	Reformat your code by clicking the Reformat icon in the code editor toolbar.

Introduction to the JDeveloper IDE - Working with Code Assist

2009-01-05T18:52:00.000-08:00

Working with Code Assist

Code Assist examines your code in the editor and provides assistance to fix common problems. Here you use the Dog class to explore some examples of the suggestions that are offered.

1.
Create a Cat object.
At the start of the main method, just after the first curly brace, press [Enter] to create a new line. In the new line, enter the following code:
Cat myCat = new Cat();

2.
Notice that the red wavy lines and margin indicators have again appeared. Place the mouse over a margin indicator to see what the problem is from the code popup window.
Notice that the popup box displays the problematic lines as well as telling you what the problem is.

3.
Hover your mouse over the light bulb icon in the left hand margin of the 'cat' line. A message tells you that 'quick fixes and code assists' are available for this line.

4.
Click the icon to see what they are.
You need a Cat class to instantiate a Cat object. If you click on the first suggestion in the list offered, JDeveloper creates a class called Cat.
On this occasion you don't want to create the Cat class immediately, so you remind yourself to do it later by setting yourself a task: press [Enter] after new Cat(); to open a new line and in the new line enter the following code:
//TODO create a Cat class

5.
Select View | Tasks to see a list of tasks that you have created.

6.
The Tasks window displays a list of the tasks you have created (in this case, it is your only task).

7.
If you double-click a task in the list, JDeveloper takes you to the relevant task, inserting the cursor at the start of the line.

8.
Notice the pink marker at the top right margin of the editor. It indicates where you have created a task. Hover over the marker with the mouse to see what the task is.

9.
Comment out the line that creates the Cat object. Notice that the red markers have now disappeared, to be replaced by a green marker indicating that there are no errors in your code.

10.
Check out the new toolbar in the code editor.
Add two variables to the class. Hit [Enter] to create a new line after the class declaration. Declare two variables as follows:
String name;
int age;

11.
In the code editor, right click and select the Generate Accessors option from context.

The generate accessor option is also available from the code editor toolbar using the Generate Accessors icon.

12.
In the Generate Accessors dialog, check the Dog box to generate Getter and Setter methods for both variables.
Notice that you can define the scope for the methods, and define other properties to be implemented in the setter methods such as involving listeners and verifying the new value.
Click OK. Getter and Setter methods are generated into the Dog class.

13.
Right click within the code editor and from context select Source --> Generate Constructor from fields.

14.
In the Generate Constructor from Fields dialog, select both fields and click OK.

15.
The new constructor method is added to your code.

16.
Click the Undo button since we don't need this constructor method.

Introduction to the JDeveloper IDE - Compiling and running your Java class

2009-01-05T18:10:00.000-08:00

Compiling and running your Java class

When you successfully compile a .java file, you create a .class file in the \src directory of the project. Compiling a class in JDeveloper automatically saves the .java file as well. When you run a class, it is automatically compiled and saved.

1.	In the Application Navigator or in the source editor, right-click Dog.java and select Make from the context menu.
2.	At the bottom right of the JDeveloper IDE, the log window should show successful compilation. If the log window does not display, use View \| Log to display it ( or press [Ctrl]+[Shift]+[L]). Notice that when using the Make option to compile your class, JDeveloper saves all the files in your project.
3.	In the Application Navigator or in the source editor, right-click Dog.java again, and this time select Run from the context menu. .
4.	The log window displays 3 counts of the ' woof Kate' message.

Introduction to the JDeveloper IDE - Using the Source Editor with Your Java Class

2009-01-05T18:04:00.000-08:00

Using the Source Editor with Your Java Class

Editors are where most of the application development work takes place; this is where you write code and design user interfaces. In this topic you explore some of the features of the Java Source Editor.

	Using code templates
	Compiling and running your Java class
	Working with Code Assist
	Searching and Highlighting Code
	Refactoring code
	Viewing code modification history
	Navigating through code

Using code templates

Code templates assist you in writing code more quickly and efficiently while you are in the source editor. You can edit existing templates or create your own. This topic shows you how to use some of the existing code templates in the Dog class.

1.	There is a code template for adding a main method to a Java class. Press [Enter] to create a new line after the sayHi() method. Type the letter m, and press [Ctrl]+[Enter] to invoke code templates. The main method template is suggested.
2.	Press Enter again to accept the suggestion and incorporate the template.
3.	Create a Dog object in the main method by adding the following code: Dog myDog = new Dog(); If you mouse over the myDog variable, a tooltip displays to tell you that the variable has not been used. You see other examples like this in Working with Code Assist later in this tutorial.
4.	Add a new line and press [Ctrl]+[Enter] to see the list of code templates that are available.
5.	You decide to create an integer-based loop using a for type code template. Type fo to restrict the list. Three templates are suggested.
6.	Double-click the second of the three suggestions, the fori integer based loop, to select it. The template code is incorporated into the file.
7.	Modify the template code. Replace i with count. Notice that changing the first i variable name in the loop changes all subsequent references. Limit the loop to 3 iterations.
8.	Enter a System.out.println statement. Place the cursor on the blank line inside the curly braces of the for loop, and type System. (be sure to include the dot at the end of the word.) A list of suggested code appears. Type the letter o and press [Enter] to select the suggested out code. Type . (dot), and when the list of suggested code appears, type the letter p and double-click the println() suggested code. Note: An even quicker way to enter a System.out.println() statement is to enter sop and then press [Ctrl]+[Enter]. The technique above is given to illustrate how to use code completion.
9.	Add code to use the loop to display the sayHi message. Inside the parentheses after println, you want to enter the following code: count + myDog.sayHi(). Start typing count + myDog. and select the sayHi method from the list. The complete line should read: System.out.println(count + myDog.sayHi());
10.	Right-click within the editor view and select Reformat to have JDeveloper restructure your code.
11.	Your code should now look like this:
12.	Save your work. Go to File-->Save All, or click the Save All button in the toolbar.

Introduction to the JDeveloper IDE

2009-01-05T17:57:00.001-08:00

Introduction to the JDeveloper IDE

Purpose

This tutorial provides a tour of the major components in the Oracle JDeveloper 11g IDE, and shows you how they can be used to build a basic application.

Time to Complete

Approximately 45 minutes.

Topics

This tutorial covers the following topics:

	Overview
	Prerequisites
	Launching JDeveloper 11g
	Creating Your First Application
	Creating Your First Java Class
	Using the Source Editor with Your Java Class
	Debugging Java Programs
	Managing Files
	Summary

Viewing Screenshots

Place the cursor over this icon to load and view all the screenshots for this tutorial. (Caution: This action loads all screenshots simultaneously, so response time may be slow depending on your Internet connection.)

Note: Alternatively, you can place the cursor over an individual icon in the following steps to load and view only the screenshot associated with that step. You can hide an individual screenshot by clicking it.

Overview

In the tutorial, you learn how to create a simple Java class. Using your new class, you then explore some of the features of the JDeveloper IDE, including Code Assist and the Debugger.

Back to Topic List

Prerequisites

Before you begin this tutorial, you should:

Have access to or have installed Oracle JDeveloper 11g Production. You can download it from Oracle Technology Network.

Launching JDeveloper 11g

Start JDeveloper by selecting Start > All Programs > Oracle WebLogic > JDeveloper Studio 11.1.1.0.0

If a dialog box opens asking if you would like to migrate from a previous version of JDeveloper, click NO.

In the Select Role dialog, choose Default Role and click OK.

Note: Shaping, which is based on the role of the user, allows the JDeveloper environment to tailor itself. It does this by removing unneeded items from the menus, preferences, new gallery, and even individual fields on dialogs. Shaping can even control the default values for fields on dialogs within the tool. When you first start JDeveloper, you are prompted to choose a role that describes how you use JDeveloper. If you choose a role of "Java Developer" versus "CRM Applications Developer" versus "Default Role" you will get a totally different experience!

Close the Tip of the Day window.

Once loaded, the JDeveloper IDE appears. The very first time you open JDeveloper, the Start Page displays. You can re-invoke the Start Page later by choosing Help | Start Page.

Notice the various options available to help you learn about JDeveloper. After exploring these options, close the Start Page by clicking the X on its tab (the X appears when you mouse over the tab).

Back to Topic List

Creating Your First Application

The application is the highest level in the control structure. It is a view of all the objects you need while you are working. An application keeps track of all your projects while you are developing your Java programs.

Applications are stored in files with the extension .jws. When you open JDeveloper, the last application used is opened by default, so that you can resume where you left off.

When creating a new application you have the option to base it on a template. The application template you select determines the initial project structure, that is, the named project folders within the application.

In JDeveloper you always work with projects contained within an application. A JDeveloper project is a logical grouping of related files. You can add multiple projects to an application to easily access, modify and reuse your source code.

The Application Navigator is the main JDeveloper window from which you access the components of your application. The structure of the Application Navigator is hierarchical and supports, for a given application, projects, images, .html files, and many more. By default the Application Navigator displays on the left side of the IDE.

To create an application, perform the following steps:

1.	Click the New Application link in the Application Navigator.
2.	In the Create Application dialog, modify the default application name to MyFirstApp. Note that the Directory Name changes accordingly.
3.	Scroll down the Application Template pane to review the list of available templates. Select the Generic Application to configure this application with a single project that has access to all JDeveloper technologies. Click Next.
4.	In this new step, change the default Project Name to MyProject, and then click Finish.
5.	In the Application Navigator, projects are displayed as the second level in the hierarchy under the application. The Application Navigator should look like this: Note that the project folder is a child of the application folder.
6.	The Visual Editor displays information about the various categories of JDeveloper, and at the bottom of each category, provides links to enable you to discover more information about that category.
7.	Within the Application Navigator, notice the three titles corresponding to accordion type of panes.
8.	Click in the accordion title to expand it.
9.	Click in the title of an expanded accordion to collapse it.
10.	Accordions are also available in other panes of JDeveloper such as the Structure pane or Resources Palette.

Creating Your First Java Class

To create a new Java class, perform the following steps:

1.	Right-click the MyProject node in the Application Navigator and select New... from the context menu.
2.	The New Gallery displays. By default, the first category, General, is highlighted in the Categories list. The other categories enable you to work with different technologies to build the various tiers of an application. Click the + sign to the left of the General category to expand it, and take note of the sub-categories that are available. Select the Java node, and then select Java Class in the Items list in the right portion of the window. Click OK.
3.	In the Create Java Class dialog, change the default name to Dog. Because you did not specify a package name when creating the application, the package name defaults to the project name in lowercase. You could change this if desired, but you do not need to do so for this tutorial. Accept all other defaults and click OK.
4.	The new class opens automatically in the source editor, where you see the skeleton class definition. Add a method to the class. After the constructor, press [Enter] to create a new line, and type the following code: public String sayHi() Notice that the line that you just entered has a wavy red line under it, indicating a problem with the syntax. There are also red boxes in the right margin of the source editor. If you mouse over these boxes or over the wavy red line, a tooltip displays information about the error or errors. You see other examples like this in Working with Code Assist later in this tutorial.
5.	At the end of the line, press [Ctrl]+[Shift] [Enter] and JDeveloper provides auto-completion of the method structure, and some of the error indicators disappear. However some indicators remain, showing that the syntax is still not complete. Notice that auto-completion is also accessible from the Source \| Complete Statement menu option.
6.	Add code to provide the missing return statement. In the blank line between the two curly braces that were added to the method, add the following code: return " woof " + "Kate"; Notice that when you type the first double quote symbol ("), JDeveloper automatically provides you with the second double quote, enclosing the cursor between them, so that you can easily type the literal. Notice also that a green box has appeared in the upper right margin to indicate that there are now no syntax errors.

Oracle JDeveloper 11g Tutorials - Oracle by Example Series: JDeveloper 11g Production

2009-01-05T17:33:00.000-08:00

Oracle by Example Series: JDeveloper 11g Production

The Oracle by Example series provides step-by-step instructions on how to perform a variety of common tasks using Oracle JDeveloper. These short tutorials allow you to gain valuable hands-on experience, and then use the lessons as the foundation for your own implementation.
	Generic IDE and Java EE
	Introduction to the JDeveloper IDE
	Build a Web Application with JDeveloper 11g Using EJB, JPA, and JavaServer Faces
	Database Development with JDeveloper
	Build Web Services with Oracle JDeveloper
	Oracle ADF Tutorials
	Developing Business Services with ADF Business Components
	Developing a User Interface with ADF Faces
	Examining ADF Business Components New Features
	Developing Ajax-Based User Interfaces with JSF: An Introduction to ADF Faces Rich Client Components
	Introduction to ADF Data Visualization Components - Graphs, Gauge, Maps, Pivot Table and Gantt
	Use JDeveloper 11g to Create a Data Control From a Web Service
	Build a Bookmarkable JSF Page with JDeveloper 11g
	Extending the JSF Controller - Working with Bounded Task Flows, Regions and Routers

Additional Cue Card Tutorials for JDeveloper 11g

OBEs for JDeveloper 10.1.3.
Additional Tutorials and Collateral for Forms Developers

Oracle JDeveloper Downloads

2009-01-05T16:41:00.000-08:00

Oracle JDeveloper Downloads

Oracle JDeveloper 11g New December 2008
Certified on Windows NT/2000/XP/Vista, Linux, and Macintosh. Supported on any platform that runs JDK 6.

	Oracle JDeveloper (10.1.3.4) July 2008 Certified on Windows NT/2000/XP, Linux, and Macintosh. Supported on any platform that runs JDK 5.0.
	Oracle ADF Installer (10.1.3.4) July 2008 Certified on Windows NT/2000/XP, Linux, and Macintosh. Supported on any platform that runs JDK 5.0.

Oracle JDeveloper Archives

	Archives


	Related Products
	Oracle Database XE - The Free Oracle Database Version
	Oracle Containers for J2EE
	Oracle SOA Suite
	Oracle WebCenter Suite

Oracle ADF Faces Documentation

2009-01-05T15:10:00.000-08:00

Oracle ADF Faces Documentation

API documentation

ADF Faces Tag Enhanced Documentation
ADF Faces Tag Documentation
Rich API Javadoc
Apache Trinidad API Javadoc
JavaScript Doc (Note: While JS APIs can now be used, they are still subject to change. Component APIs are generally stable - it is the non-component classes that are at issue.)
ADF Faces Skinning Selectors definitions
ADF Faces Data Visualization Tags
ADF Faces Runtime Demo Installation

Supported Platforms

ADF Faces is currently supported in the following user agents (i.e. browsing platforms):

User Agent	Windows	Solaris	Mac OS X	Red Hat Linux
Internet Explorer	7.0	-	-	-
Firefox	2.0.0.2+	2.0.0.2+	2.0.0.2+	2.0.0.2+

Developing Ajax-Based User Interfaces with JSF: An Introduction to ADF Faces Rich Client Components

2009-01-05T15:06:00.000-08:00

Developing Ajax-Based User Interfaces with JSF: An Introduction to ADF Faces Rich Client Components

Purpose

In this tutorial, you learn how to create JSF pages using Oracle ADF Faces Rich Client (RC). Oracle ADF Faces Rich Client is a set of standard JSF components that include built-in Ajax functionality. While Ajax allows rich client-like applications to run on standard internet technologies, JSF provides server-side control, which reduces the dependency on an abundance of JavaScript often found in typical Ajax applications.

Time to Complete

60 minutes

Topics

The tutorial covers the following topics:

	Overview
	Scenario
	Prerequisites
	Open the Startup Application
	Create the Page Flow
	Use Layout Components to Design the Page
	ADF Table Component and ADF Binding
	Test the Main Page
	Work with the Image and Gauge components
	Work with Menus
	Work with Input Components
	Implement Partial Page Rendering
	Add Pop up Functionality to the Main Page
	Add Drag and Drop Functionality to the Main Page
	Use Skins to Change the Look and Feel of the Application
	Summary

Enter to Java

2009-01-01T20:05:00.000-08:00

Enter Java

The Java programming language, developed at Sun Microsystems under the guidance of Net luminaries James Gosling and Bill Joy, is designed to be a machine-independent programming language that is both safe enough to traverse networks and powerful enough to replace native executable code. Java addresses the issues raised here and helps us start building the kinds of applications we want.

Initially, most of the enthusiasm for Java centered on its capabilities for building embedded applications for the Web called applets. But in the early days, applets and other client-side GUI applications written in Java were limited. Today, Java has Swing, one of the most sophisticated toolkits for building graphical user interfaces (GUIs) in any language. This development has allowed Java to become a popular platform for developing traditional client-side application software.

Of even more importance in the past few years, Java has become the premier platform for web-based applications and web services. These applications use technologies including the Java Servlet API, Enterprise JavaBeans?, and many popular open source and commercial Java application servers and frameworks. Java's portability and speed make it the platform of choice for modern business applications.

This book will show you how to use Java to accomplish all of these real-world programming tasks. In the coming chapters we'll cover everything from text processing to networking, building rich client-side GUI applications with Swing and lightweight web-based applications with XML.

Java's Origins

The seeds of Java were planted in 1990 by Sun Microsystems patriarch and chief researcher, Bill Joy. At the time, Sun was competing in a relatively small workstation market while Microsoft was beginning its domination of the more mainstream, Intel-based PC world. When Sun missed the boat on the PC revolution, Joy retreated to Aspen, Colorado to work on advanced research. He was committed to the idea of accomplishing complex tasks with simple software and founded the aptly named Sun Aspen Smallworks.

Of the original members of the small team of programmers assembled in Aspen, James Gosling will be remembered as the father of Java. Gosling first made a name for himself in the early 80s as the author of Gosling Emacs, the first version of the popular Emacs editor that was written in C and ran under Unix. Gosling Emacs became popular but was soon eclipsed by a free version, GNU Emacs, written by Emacs's original designer. By that time, Gosling had moved on to design Sun's NeWS, which briefly contended with the X Window System for control of the Unix GUI desktop in 1987. Although some people would argue that NeWS was superior to X, NeWS lost because Sun kept it proprietary and didn't publish source code while the primary developers of X formed the X Consortium and took the opposite approach.

Designing NeWS taught Gosling the power of integrating an expressive language with a network-aware windowing GUI. It also taught Sun that the Internet programming community will ultimately refuse to accept proprietary standards, no matter how good they may be. The seeds of Java's licensing scheme and open (if not quite "open source") code were sown by NeWS's failure. Gosling brought what he had learned to Bill Joy's nascent Aspen project. In 1992, work on the project led to the founding of the Sun subsidiary, FirstPerson, Inc. Its mission was to lead Sun into the world of consumer electronics.

The FirstPerson team worked on developing software for information appliances, such as cellular phones and personal digital assistants (PDAs). The goal was to enable the transfer of information and real-time applications over cheap infrared and packet-based networks. Memory and bandwidth limitations dictated small, efficient code. The nature of the applications also demanded they be safe and robust. Gosling and his teammates began programming in C++, but they soon found themselves confounded by a language that was too complex, unwieldy, and insecure for the task. They decided to start from scratch, and Gosling began working on something he dubbed "C++ minus minus."

With the foundering of the Apple Newton, it became apparent that the PDA's ship had not yet come in, so Sun shifted FirstPerson's efforts to interactive TV (ITV). The programming language of choice for ITV set-top boxes was to be the near ancestor of Java, a language called Oak. Even with its elegance and ability to provide safe interactivity, Oak could not salvage the lost cause of ITV at that time. Customers didn't want it, and Sun soon abandoned the concept.

At that time, Joy and Gosling got together to decide on a new strategy for their innovative language. It was 1993, and the explosion of interest in the Web presented a new opportunity. Oak was small, safe, architecture-independent, and object-oriented. As it happens, these are also some of the requirements for a universal, Internet-savvy programming language. Sun quickly changed focus, and, with a little retooling, Oak became Java.

Growing Up

It would not be overdoing it to say that Java caught on like wildfire. Even before its first official release when Java was still a nonproduct, nearly every major industry player had jumped on the Java bandwagon. Java licensees included Microsoft, Intel, IBM, and virtually all major hardware and software vendors. That's not to say that everything was easy. Even with all this support, Java took a lot of knocks and had some growing pains during its first few years.

A series of breech of contract and antitrust lawsuits between Sun and Microsoft over the distribution of Java and its use in Internet Explorer has hampered its deployment on the world's most common desktop operating systemWindows. Microsoft's involvement with Java also become one focus of a larger federal lawsuit over serious anticompetitive practices at the company, with court testimony revealing concerted efforts by the software giant to undermine Java by introducing incompatibilities in its version of the language. Meanwhile, Microsoft introduced its own Java-like language called C# (C-sharp) as part of its .NET initiative and dropped Java from inclusion in the latest versions of Windows.

But Java continues to spread on both high- and low-end platforms. As we begin looking at the Java architecture, you'll see that much of what is exciting about Java comes from the self-contained, virtual machine environment in which Java applications run. Java has been carefully designed so that this supporting architecture can be implemented either in software, for existing computer platforms, or in customized hardware, for new kinds of devices. Sun and other industry giants are producing fast Java chips and microprocessors tailored to run media-rich Java applications. Hardware implementations of Java are currently used in smart cards and other embedded systems. Today you can buy "wearable" devices, such as rings and dog tags, that have Java interpreters embedded in them. Software implementations of Java are available for all modern computer platforms down to portable computing devices, such as the popular Palm PDA. Java is also becoming standard equipment on many new cell phones.

Simple MDB with Oracle Database JMS Provider

2008-12-23T22:33:00.000-08:00

Continuing in my JMS explorations of late I was asked about clustering MDB on top of a simple topic backended by AQ. My first problem was I could not find a quick and dirty example of an MDB (EJB 3.0) using a JMS topic, the recommended JMS resource adapter approach of OracleAS 10.1.3 and on top of AQ. A simple hello world was all I was after.

Give me something very simple and I can go miles because the doc for JMS (http://download-west.oracle.com/docs/cd/B25221_04/web.1013/b14427/jms.htm#i1085966) and MDB (http://download-west.oracle.com/docs/cd/B25221_04/web.1013/b14428/mdb30cfg.htm#BCGFGDAI) explains all the advanced stuff and this OTN how-to (http://www.oracle.com/technology/tech/java/oc4j/1013/how_to/how-to-connect-to-oemsjmsd/doc/how-to-connect-to-oemsjmsd.html) gives a pretty rich example with a lot of detail on what the idiosyncracies are with setup.

However, despite this being easy, I also wanted quick set up using the tools provided by Oracle that combined setting up the resource adapter, configuring a topic and writing an MDB to process messages into one sequence of steps rather than 3 different tasks. This entry is devoted to getting going fast with such a sample - cobbled together from other similar examples, a bit of new stuff and a bit of begging and pleading from various people who built it all - thanks to Demed Lher (JMS PM), Debu Panda (EJB PM) and the ASControl 10.1.3 folks who made this possible.

Here goes:

1. Create a JMS user on your database and grant them AQ rights. I am using XE and you can tell I have a tough password policy:

sqlplus sys/welcome1@xe as sysdba

grant connect, resource, aq_administrator_role to jmsuser identified by jmsuser;
grant execute on sys.dbms_aqadm to jmsuser;
grant execute on sys.dbms_aq to jmsuser;
grant execute on sys.dbms_aqin to jmsuser;
grant execute on sys.dbms_aqjms to jmsuser;
exec dbms_aqadm.grant_system_privilege('ENQUEUE_ANY','jmsuser');
exec dbms_aqadm.grant_system_privilege('DEQUEUE_ANY','jmsuser');

2. Create a AQ topic - in this case JMSDEMO_TOPIC:

sqlplus jmsuser/jmsuser@xe
exec dbms_aqadm.create_queue_table(queue_table=>'JMSDEMO_QUEUE_TABLE', queue_payload_type=>'sys.aq$_jms_text_message',multiple_consumers=>true);
exec dbms_aqadm.create_queue(queue_name=>'JMSDEMO_TOPIC', queue_table=>'JMSDEMO_QUEUE_TABLE');
exec dbms_aqadm.start_queue(queue_name=>'JMSDEMO_TOPIC');
commit;

3. Create a data-source in OracleAS to point to the database user JMSUSER. I used Application Server Control to do this here by creating a connection pool called oemsdbPool and a data source called oemsdbDS:

Which could also be put directly into your data-sources.xml using this snippet:

4. In order to use the resource provider approach for my MDB, I need to configure up the OEMS Database provider. Unlike 10.1.3.0 where this was a manual and configuration process, it is a nicely automated procedure in OracleAS 10.1.3.1 (I am using the Developer Preview).

The following 3 screen shots show how trivial the Application Server Control team have made this.

a. In the administration tab, click on the OEMS database persistence configuration

b. Click on the deploy button to deploy it

c. Name the resource adapter/provider and hook it up to the data source created previously. When you click on finish, you will be asked to restart the default application. Mine never came back so I ended up using opmnctl to do a full OC4J instance re-start ... I believe this is a bug in the developer preview that was fixed after its August release.

You can then see and do further configuration of the adapter on the adapters page. From a lot of doc to about a 4 click operation, I have to say the ASControls folks who I have the luck to know reasonably well, did a great simplification job of a complex area!

5. Now for my application clients using the OEMS Database provider, I need to surface my topic with some logical names. This I found this confusing though correctly documented but again ASControl made short work of exactly the things I needed to do:

a. Make sure an appropriate connection factory is available by going to the connection factory tab of my newly created resource adapter (picture below), name it (I gave it the adapter name - simpleOemsRA/MyTCF) and give it a private connection pool for simplicity.

b. Name my administered topic object (oracle.j2ee.ra.jms.generic.AdminObjectTopicImpl from the drop down list box) to provide a JNDI mapping to the physical database topic JMSDEMO_TOPIC and finally hook it up to the resource provider created during deployment.

This has two parts so here are they are in detail:

b1. Unlike the OracleAS JMS screen you will see that you do *not* have to provide the JNDI location and JNDI name for the Topic. You just give a JNDI location. You can provide a JNDI name but you would have to manually edit the underlying oc4j-connectors.xml. What this is "encouraging" is the use of autowrapping of the destinations. So enter your JNDI name - I chose simpleOemsRA/AutoWrap because this JNDI name will be the "automatic" wrapper for all my topics. See later for some details on this.

b2. Second the screen asks for the resource provider name and defaults it to ojmsrp when you should be using the resource provider name you used when deploying the resource adapter - in our case simpleOemsRP - both b1 and b2 are shown in the screen sequence below.

To get a sense of some comfort that things are working at this stage, if you go back to the Administer OEMS tab of the Application Server Control you should be able to see the physical AQ JMSDEMO_TOPIC in the list of available topics that are hooked up to the environment like below with a JNDI URL of something like java:comp/resource/simpleOemsRP/Topics/JMSDEMO_TOPIC:

What's up here? I can see that from my configuration of my resource provider having a database connection we created earlier it automatically discovered my topic. That's cool! But what is also interesting is the resolution of the physical JNDI name - java:comp/resource/simpleOemsRP/Topics/JMSDEMO_TOPIC - where did that /Topics/ come from?

It turns out that is part of how OEMS Database provider queues and topics are surfaced through the resource provider - the prefix /Topics/ and /Queues/ are prefixed on the database queue/topic name. As such, taking an example, a database topic named JMSDEMO_TOPIC will have the physical suffix of Topics/JMSDEMO_TOPIC. Likewise with queues, a database queue named JMSDEMO_QUEUE will have a physical suffix of Queues/JMSDEMO_QUEUE. This is doc'd more formally just under the table this URL points at:

http://download-east.oracle.com/docs/cd/B25221_04/web.1013/b14427/jms.htm#sthref295

The end result when working with MDBs and clients, the JNDI location you will use for this example is going to have the logical name of (using my example): simpleOemsRA/Autowrap/Topics/JMSDEMO_TOPIC which in turn will resolve to the physical name java:comp/resource/simpleOemsRP/Topics/JMSDEMO_TOPIC. Check out my MDB at the end of this blog where I provide this setting in the destination name. If you want to manually wrap this in order to obfusticate the JMSDEMO_TOPIC name you can as well but this is not avialable from the ASControl screen.

5. With that, everything - at least the minimal - is done and it is possible to write an MDB. Again following the lazy man's approach I will use EJB 3.0 so I can do it all in as little configuration as possible. Mucking around my MDB pretty much wires up to the configuration done above and does a simple printout of the message off the queue. It looks like the following code at the end of this [1] blog - code liberally stolen from Debu Panda's EJB 3.0 MDB samples at http://otn.oracle.com/ejb3.

6. As I was doing this in JDeveloper, I simply packaged this guy up in an ear and then used the admin_client deployment tool to deploy it as follows:

SET JAVA_HOME=d:\jdk150
SET PATH=d:\jdk150\bin
SET ORACLE_HOME=d:\soasuite
java -jar %ORACLE_HOME%\j2ee\home\admin_client.jar deployer:oc4j:opmn://127.0.0.1:6003/home oc4jadmin welcome1 -deploy -file D:\mywork\oemsMDB\deploy\myMDB.ear -deploymentName myMDB

7. Then of course we need a client to throw messages on the queue. The easiest way is to write a simple Java client. Again in the spirit of begging and borrowing code, I have taken a sample from the JMS product manager, Demed LHer and slimmed it down to the bare essentials so it just does that one thing in [2].

To run that client you simply have to compile it with the right classpath:

set AS_HOME=D:\soasuite
set DB_HOME=D:\oraclexe\app\oracle\product\10.2.0\server
set JAVA_HOME=D:\jdk150 CLASSPATH=.;%DB_HOME%/RDBMS/jlib/aqapi13.jar;%DB_HOME%/RDBMS/jlib/jmscommon.jar;%DB_HOME%/RDBMS/jlib/xdb.jar;%DB_HOME%/lib/xmlparserv2.jar;%DB_HOME%/jdbc/lib/ojdbc14.jar;%DB_HOME%/jlib/orai18n.jar;%DB_HOME%/jlib/jndi.jar;%J2EE_HOME%/lib/jta.jar
javac -classpath %CLASSPATH% Send.java
java Send "JMSDEMO_TOPIC"

And there you go. If you look in your ORACLE_HOME\opmn\logs you should see the MDB sucking the above message off the topic and spitting out the results using its System.out.println.

I can't say it was trivial, but broken down to its simplest form, hopefully it is a building block that can be generalized for others!

[1] My MDB:

package demo.mdb;

import java.util.Date;

import javax.ejb.MessageDriven;
import oracle.j2ee.ejb.MessageDrivenDeployment;
import javax.ejb.ActivationConfigProperty;
import javax.jms.Message;
import javax.jms.MessageListener;

import javax.jms.Message;

@MessageDriven(
activationConfig = {
@ActivationConfigProperty(
propertyName="ConnectionFactoryJndiName", propertyValue="simpleOemsRA/MyTCF"),
@ActivationConfigProperty(
propertyName="DestinationName", propertyValue="simpleOemsRA/AutoWrap/Topics/JMSDEMO_TOPIC"),
@ActivationConfigProperty(
propertyName="DestinationType", propertyValue="javax.jms.Topic"),
@ActivationConfigProperty(
propertyName="SubscriptionDurability", propertyValue="Durable"),
@ActivationConfigProperty(
propertyName="SubscriptionName", propertyValue="MySubscription"),
@ActivationConfigProperty(
propertyName="messageSelector", propertyValue="RECIPIENT = 'MDB'")
})

// associate MDB with the database JMS resource adapter
@MessageDrivenDeployment(resourceAdapter = "simpleOemsRA")
/**
* This is a very simple example of a Message-Driven Bean configured to listen
* on an AQ Topic using the generic resource adapter for JMS. It listens to the
* configured Topic and gets notified via an invocation of it's
* onMessage() method when a message has been posted to the Topic. This
* bean simply prints out the contents of the message.
*/
public class MessageTopicProcessor {

public void onMessage(Message message) {
System.out.println("onMessage() - " + message);
try {

String subject = message.getStringProperty("subject");
String inmessage = message.getStringProperty("message");
System.out.println("Message received\n\tDate: "
+ new java.util.Date() + "\n\tSubject: " + subject
+ "\n\tMessage: " + inmessage + "\n");
}

catch (Throwable ex) {
ex.printStackTrace();
}
}

}

[2] Sample Database JMS Client

/*
*
* If using Oracle XE, the following jar files are required in your classpath to
* run this example:
*
* .;%DB_HOME%/RDBMS/jlib/aqapi13.jar;%DB_HOME%/RDBMS/jlib/jmscommon.jar;
* %DB_HOME%/RDBMS/jlib/xdb.jar;%DB_HOME%/lib/xmlparserv2.jar;
* %DB_HOME%/jdbc/lib/ojdbc14.jar;%DB_HOME%/jlib/orai18n.jar;%DB_HOME%/jlib/jndi.jar;%J2EE_HOME%/lib/jta.jar
*
*/

// Java infrastructure packages
import java.lang.*;
import java.util.Properties;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

// JMS packages
import oracle.AQ.*;
import oracle.jms.*;
import javax.jms.*;

/* -------------------------------------------------------
* Send
* ------------------------------------------------------- */
public class Send
{

// Here's the XML payload to put in a text message
private final static String SOME_XML =
"\n" +
"\n" +
" \n" +
" John\n" +
" W\n" +
" Doe\n" +
" \n"+
"";

public static void main (String args [])
throws java.sql.SQLException, ClassNotFoundException, JMSException
{

TopicConnectionFactory tcfact =null;
TopicConnection tconn =null;
Topic topic =null;
TopicSession tsess =null;
TopicPublisher publisher = null;
TopicSubscriber subscriber = null;
TextMessage txtmsg, dtxtmsg;
String destName = "JMSDEMO_TOPIC";
String dbHost = "127.0.0.1";
String dbPort = "1521";
String dbSid = "XE";
String dbDriver = "thin";
String dbUser = "jmsuser";
String dbPassword = "jmsuser";

System.out.println("\n-------------------------------------------------------------");
System.out.println("OEMS.155 - simple JMS Send / JMS 1.02 / Database AQ / no JNDI");
System.out.println("-------------------------------------------------------------");

// get destination to Send on from command-line
try {
destName = args[0];
} catch (Exception e) {
System.out.println("** please provide a destination to send on [" + args.length + "]");
usage();
System.exit(0);
}

try {
// get connection factory - we are not going through JNDI here
tcfact = AQjmsFactory.getTopicConnectionFactory(dbHost, dbSid, Integer.parseInt(dbPort), dbDriver);
System.out.println("Connection factory = " + tcfact.toString());
// create connection
tconn = tcfact.createTopicConnection(dbUser,dbPassword);
System.out.println("Created connection = " + tconn.toString());
// create session
tsess = tconn.createTopicSession(true, Session.CLIENT_ACKNOWLEDGE);
System.out.println("Created session = " + tsess.toString());
// start connection
tconn.start() ;
System.out.println("started connection");
// get topic
topic = ((AQjmsSession)tsess).getTopic(dbUser,destName) ;
System.out.println("Got topic = " + topic.toString());
System.out.println("started session = " + tsess.toString());

} catch (JMSException e) {
System.err.println("** JMS: failed starting session. Do not forget to run the SQL scripts to create necessary tables in RDBMS.\n");
e.printStackTrace();
System.exit(-1);
}

try {
publisher = tsess.createPublisher(topic);
txtmsg = tsess.createTextMessage(SOME_XML) ;
System.out.println("\ndestination: " + topic + "\nmessage :\n\n" + SOME_XML);
publisher.publish(topic, txtmsg) ;
tsess.commit() ;
System.out.println("\nmessage was sent with ID="+txtmsg.getJMSMessageID());
} catch (Exception e) {
System.err.println("** Problem publishing messaging:\n");
e.printStackTrace();
}

// Cleaning up before exiting
try {
//((AQjmsDestination)topic).stop(tsess, true, true, false);
tsess.close() ;
tconn.close() ;
} catch (Exception e) {
System.err.println("** Problem terminating session and connection:\n");
e.printStackTrace();
}

}

/*-----------------------------------------------------------------------
* usage
* prints program usage
*----------------------------------------------------------------------*/

private static void usage() {
System.err.println("\nUsage: Send ");
System.err.println("Ex : Send JMSDEMO_TOPIC");
}
}

Using HTTPS with Web Services

2008-12-23T22:17:00.001-08:00

Using HTTPS with Web Services

Prerequisites:
In this article you have

already a Web Service deployed in OC4J that is running on the default HTTP port. The WSDL and Endpoint are available. In my sample the non secure Web Service endpoint is: http://127.0.0.1:8888/math-service/MathServiceSoapHttpPort

Add HTTPS to OC4J

Creating of the Keystore

The first thing to do to secure OC4J would be to create a new keystore that will contain the different certificates. The easiest way to do that for a Java developer is to use SUN's keytool:

keytool -genkey -alias oracle-server -dname "CN=Tug Grall, OU=Blog O=Grall And Co L=Redwood Shores, S=CA, C=US" -keyalg RSA -keypass welcome -storepass welcome -keystore server.keystore

You can copy the server.keystore into the $ORACLE_HOME/j2ee/home/config to simplify the next steps.

Configuring OC4J

OC4J stand alone is using the notion of Web-Site to expose HTTP resources (Web Applications). The default-web-site is define is he $ORACLE_HOME/j2ee/home/config/default-web-site.xml. To secure an OC4J you can follow the steps describe in the OC4J Security guide that I have summarized in the following section.

What we want to achieve for the purpose of the demonstration is to have OC4J using HTTP and HTTPS, on port 8888 and 4443 for example.

1. Copy default-web-site.xml to secure-web-site.xml

2. Edit the secure-web-site.xml:

2.1. Change the web-site tag by changing the port to 4443 and adding the element secure="true"

2.1. Add the ssl-config element and point this to the new created keystore.
The file looks like:

xsi:noNamespaceSchemaLocation="http://xmlns.oracle.com/oracleas/schema/web-site-10_0.xsd"
port="4443"
secure="true"
display-name="OC4J 10g (10.1.3) Default Web Site"
schema-major-version="10"
schema-minor-version="0" >
...

...

3. Import the new Web site in your OC4J instance by editing the $ORACLE_HOME/j2ee/home/server.xml file. You need to add or replace the web-site tag. In my case I want to add the secure web site to my instance so the configuration looks like:

...

...

Since we have copied the file from the default-web-site, all applications are available using HTTP and HTTPS

Start OC4J and test the HTTPS port

Start OC4J using the standard Java command or shell script, I am adding the Java Network debug flag that would help you to see what is happening at the SSL level.

java -Djavax.net.debug=ssl -jar oc4j.jar

You should be able to access the service WSDL using the HTTPS port for example in my case:

https://127.0.0.1:4443/math-service/MathServiceSoapHttpPort?WSDL

Consuming the Service using HTTPS

Generate and configure a client Keystore

Event if this is possible to use the same keystore for the server and the client, I will guide you in the steps to create a client certificate and import the certificate from the existing -server- one. Here the command to create a new keystore:

keytool -genkey -alias oracle-client -dname "CN=John Doe, OU=Blog O=MyDummyClient, S=CA, C=US" -keyalg RSA -keypass welcomeClient -storepass welcomeClient -keystore client.keystore

The next step is to export the certificate from the server keystore to be able to import it in the client:

keytool -keystore server.keystore -export -alias oracle-server -file server.cer

You can now import the cerificate in the client keystore:

keytool -keystore client.keystore -import -file server.cer

Generate the proxy

You have now the client certificate so you can use the Oracle Web Service Assembler to generate the proxy. The only specific thing you have to do is to specify which key store to use when running the tool. The command to use when generating the proxy is:

java -Djavax.net.ssl.trustStore=/Users/tgrall/ssl/client.keystore
-Djavax.net.ssl.keyStore=/Users/tgrall/ssl/client.keystore
-Djavax.net.ssl.trustStorePassword=welcomeClient
-Djavax.net.ssl.keyStorePassword=welcomeClient
-jar $ORACLE_HOME/webservices/lib/wsa.jar
-genProxy
-wsdl https://127.0.0.1:4443/math-service/MathServiceSoapHttpPort?WSDL

Calling the Service using secure endpoint

Configure the Java Environment to use the client store is made using the following System properties:

javax.net.ssl.trustStore
javax.net.ssl.keyStore
javax.net.ssl.trustStorePassword
javax.net.ssl.keyStorePassword

This could be done using different approach, property file, -D command line parameter or programmatically. To simply the example I am using the programmatic approach, the following code is part of the main method of the Client class:

...
System.setProperty("javax.net.ssl.trustStore", "/Users/tgrall/ssl/client.keystore");
System.setProperty("javax.net.ssl.keyStore", "/Users/tgrall/ssl/client.keystore");
System.setProperty("javax.net.ssl.trustStorePassword", "welcomeClient");
System.setProperty("javax.net.ssl.keyStorePassword", "welcomeClient");
...
// Adding Debug information
System.setProperty("javax.net.debug", "ssl");
...

It is possible to change the Endpoint dynamically in the Proxy using the setEndpoint method.

...
democlient.proxy.MathServiceSoapHttpPortClient myPort = new democlient.proxy.MathServiceSoapHttpPortClient();
...
String ep = "https://127.0.0.1:4443/math-service/MathServiceSoapHttpPort";
myPort.setEndpoint(ep);
System.out.println("Result of the operation is "+ myPort.add(2,2));
...

You should now be able to run the client and call the service using HTTPS. This would look like:

by: Tugdual Grall

Enhanced Graphics, Text, and Imaging

2008-12-18T14:29:00.000-08:00

Early versions of the AWT provided a simple rendering package suitable for rendering
common HTML pages, but not full-featured enough for complex graphics,
text, or imaging. As a simplified rendering package, the early AWT embodied
specific cases of more general rendering concepts. The Java 2D™ API provides a
more flexible, full-featured rendering package by expanding the AWT to support
more general graphics and rendering operations.
For example, through the Graphics class you can draw rectangles, ovals, and
polygons. Graphics2D enhances the concept of geometric rendering by providing
a mechanism for rendering virtually any geometric shape. Similarly, with the Java
2D API you can draw styled lines of any width and fill geometric shapes with virtually
any texture.
Geometric shapes are provided through implementations of the Shape interface,
for example Rectangle2D and Ellipse2D. Curves and arcs are also specific
implementations of Shape.
Fill and pen styles are provided through implementations of the Paint and
Stroke interfaces, for example BasicStroke, GradientPaint, TexturePaint,
and Color.
AffineTransform defines linear transformations of 2D coordinates, including
scale, translate, rotate, and shear.
Clip regions are defined by the same implementations of the Shape interface that
are used to define general clipping regions, for example Rectangle2D and GeneralPath.
Color composition is provided by implementations of the Composite interface,
for example AlphaComposite.
A Font is defined by collections of Glyphs, which are in turn defined by individual
Shapes.

JAVA PROGRAMMING EXAMPLE BASIC CONCEPTS

2008-12-14T01:05:00.000-08:00

This program illustrates the basic concepts of java programming. ARRAY is use to list months, weekdays and days; SCANNER is use to input the year; the COUNTER starts New Years Day on the correct weekday; NESTED for LOOP is
JAVA PROGRAMMING EXAMPLE BASIC CONCEPTS

Publish at Scribd or explore others: Cheat Sheets Reference java break

1.	From the menu, select Search \| Find Application Files.
2.	In the File List tab, use the Look in field to select the scope of your search. Keep the All Projects choice.
3.	Select File Extension and type .java to retrieve all files of this type, then click Search.
4.	The Results window returns the file names corresponding to your criteria. Note that clicking on one of the file name from the list opens the file in the editor.
5.	You can indicate complex search criteria using the sign combined with the logical Match operators.
6.	You can also retrieve files recently used from the Application Navigator, click the Recently Opened Files to deploy the accordion.
7.	To retrieve a Java class, click [Ctrl] + [-] key to open a dialog.
8.	In the Name field, type Int, then select the IntAnimal.java from the list, then Enter.
9.	To retrieve a file, click [Ctrl] + [Alt] + [-] key stroke to open a dialog. In the File Name field, type D, then select the Dog.java from the list, then Enter.

1.	Set a breakpoint in the Dog.java file. To do this, click in the margin to the left of the line: System.out.println(count + myDog.sayHowDoYouDo("Kate")); The breakpoint icon, which looks like a red ball, is displayed in the margin.
2.	Right-click in the source editor and select Debug from the context menu.
3.	Program execution proceeds up to the breakpoint. The red arrow in the left margin of the source editor indicates where the break is occurring. The debugger window opens and displays the debugging trace.
4.	Click the Step Over icon in the toolbar to execute the first iteration of the myDog.sayHowDoYouDo() method.
5.	Click the Debugging: MyProject.jpr tab at the bottom of the log window and then click the Log tab in the debugger window. Note that the log window displays the first woof Kate message.
6	Notice the Smart Data window to the right of the Debugging Log tab. Select the count variable, and double-click in the Value column to display the Modify Value dialog.
7.	Type 2 as the new value. Click OK.
8.	In the toolbar, click Resume to continue program execution.
9.	The count variable is incremented and exceeds its limit, so the program terminates, and the debugger disconnects.

1.	Click the Source tab for the Dog.java file in the editor. You can navigate from one part of the code to another related part. One example of this is navigating from a method to its declaration in an interface. A method that implements a declaration from an interface displays a callout icon in the left-hand margin. Clicking this icon takes you to where the method is declared. Click the arrow icon next to the sayHowDoYouDo() method in the Dog.java file.
2.	JDeveloper takes you to the IntAnimal interface where the method is declared and highlights the appropriate line for you.
3.	To return to where you were in the Dog class, click the green Back button in the toolbar. You can also Navigate backward or forward using the [Alt] + [left] or [right] arrow key.
4.	You can also navigate to the Javadoc for a given element. In the Dog.java file in the editor, right-click within the sayHowDoYouDo() method. From the context menu, choose Quick Javadoc.
5.	The Javadoc popup window displays additional information about the selected method.
6.	Click the String link to get more info about the String class. Click within the code editor window to remove the doc 'ghost' window.
7.	Click [Ctrl]+[-] (minus) key to popup the Go to Java Class dialog. It allows you to display Source or Javadoc information of the selected class. In the Name field type String then Enter on the java.lang.String highlighted suggestion.
8.	The source code for the String class opens in the editor. Close the String.java tab.
9.	Code folding enables you to expand and contract sections of code, making large programs more manageable. Place your mouse in the space between the dotted and solid lines to the left of the Cat line. Notice that a blue vertical line displays beside the main method body.
10.	Click the minus (-) sign at the top of the vertical blue line to contract this section of code.
11.	Hover over the plus (+) sign next to the contracted section of code. The contracted lines of code display in a blue shaded box.
12.	The new Quick Outline Navigator enables you to quickly navigate to methods and fields of a class and its super classes. In the code editor toolbar click the Quick Outline icon. The Quick Outline 'ghost' window displays.
13.	Click the Show Methods icon (first icon from the left) to see all the methods in the Dog class.
14.	Filter by typing ge in the field.
15.	Use the down arrow key to select the getName() method, then Enter. That's a new feature that provides built-in navigation in the class you are looking at.
16.	Back in the code editor, double-click within the ellipses of the main() {...} method. JDeveloper expands the collapsed code.

1.	Notice the three tabs at the foot of the editor window. Click the History tab.
2.	The History window displays. The top part of the window contains a list of revisions and dates, while a list of changes to the code displays in the bottom part of the window. The two windows are synchronized, so that the detail in the bottom part of the window matches the selection in the top part. The revisions for the selected date and time are summarized in the status line at the bottom of the IDE, in this case 6 differences: 3 added, 0 removed, 3 changed.
3.	The lilac-colored boxes indicate changes to the code. In the top portion of the window, select Introduce Parameter near the top of the list. In the bottom left portion of the editor, position your mouse over the green right-pointing arrow in the lilac box that contains the sayHi() method declaration. Notice that a message displays, indicating that clicking the green arrow enables you to replace the adjacent difference. In this case, clicking the green arrow would revert the sayHowDoYouDo() method to sayHi(). Don't revert now.
4.	The green boxes indicate additions to the code. In the top portion of the window, select Load External State near the bottom of the list. In the bottom of the window, select the //Cat myCat = new Cat(); line in the green box in the right hand window. Hover over the red X with your mouse. Notice the message indicating that to delete the addition(s), you click the X.

1.	Create a Cat object. At the start of the main method, just after the first curly brace, press [Enter] to create a new line. In the new line, enter the following code: Cat myCat = new Cat();
2.	Notice that the red wavy lines and margin indicators have again appeared. Place the mouse over a margin indicator to see what the problem is from the code popup window. Notice that the popup box displays the problematic lines as well as telling you what the problem is.
3.	Hover your mouse over the light bulb icon in the left hand margin of the 'cat' line. A message tells you that 'quick fixes and code assists' are available for this line.
4.	Click the icon to see what they are. You need a Cat class to instantiate a Cat object. If you click on the first suggestion in the list offered, JDeveloper creates a class called Cat. On this occasion you don't want to create the Cat class immediately, so you remind yourself to do it later by setting yourself a task: press [Enter] after new Cat(); to open a new line and in the new line enter the following code: //TODO create a Cat class
5.	Select View \| Tasks to see a list of tasks that you have created.
6.	The Tasks window displays a list of the tasks you have created (in this case, it is your only task).
7.	If you double-click a task in the list, JDeveloper takes you to the relevant task, inserting the cursor at the start of the line.
8.	Notice the pink marker at the top right margin of the editor. It indicates where you have created a task. Hover over the marker with the mouse to see what the task is.
9.	Comment out the line that creates the Cat object. Notice that the red markers have now disappeared, to be replaced by a green marker indicating that there are no errors in your code.
10.	Check out the new toolbar in the code editor. Add two variables to the class. Hit [Enter] to create a new line after the class declaration. Declare two variables as follows: String name; int age;
11.	In the code editor, right click and select the Generate Accessors option from context. The generate accessor option is also available from the code editor toolbar using the Generate Accessors icon.
12.	In the Generate Accessors dialog, check the Dog box to generate Getter and Setter methods for both variables. Notice that you can define the scope for the methods, and define other properties to be implemented in the setter methods such as involving listeners and verifying the new value. Click OK. Getter and Setter methods are generated into the Dog class.
13.	Right click within the code editor and from context select Source --> Generate Constructor from fields.
14.	In the Generate Constructor from Fields dialog, select both fields and click OK.
15.	The new constructor method is added to your code.
16.	Click the Undo button since we don't need this constructor method.