A Better way to learning Java

RESTRICTING ACCESS TO AJAX SERVICES

2007-10-26T04:11:00.000-07:00

Mashups are appearing on the web at an extremely fast rate. It's estimated that three new mashups appear on the web each day. As a service provider, you know that exposing your service so that it can be used in mashups can benefit you in a number of ways. Among other things, mashups can advertise the existence of your services to a constantly growing audience. However, there are some things you should consider when you make a service available for mashups. One of them is the possibility of security exposures. You want people to use your service but not abuse it.

If you're a service provider, you can take actions that protect your service such as limiting or restricting access. This article highlights some techniques for restricting access to a service. It then focuses on using API keys, which gives you finer-grained protection than the other techniques covered in this article. It allows you to restrict access to your service to users in specific host domains. You can also use API keys to identify who is using your service or meter usage, that is, regulate how much your service is used during a given period of time. However, the focus of this article is primarily on how to limit or restrict access to your service.

Here are some approaches that you can take to restrict access to your service:

Token-Based Restriction
Application key-based Restriction
Session-based Restriction
Content type restriction
Authentication-based restriction
URL based API key restriction

JAVA BEANS

2007-10-26T04:09:00.001-07:00

Rapid application development tools are great. Visual Basic, Delphi, etc. are great at cutting development time for complex applications through their use of reusable components.

Reusable components (I will refer to them as "controls" from here on) are simply pre-built pieces of programming code designed to perform a specific function. When designing an application in a visual environment, controls can be quickly dropped into the design, and modified to fit the task at hand. Most of the controls you'll find are designed to handle such tasks as pushbuttons, menus, text labels, and so forth. As a developer, you only need to write code to "glue" them into your application, and develop the interactions between controls.

Recently, programmers have been searching for some way to create and reuse components in the Java language. Java holds great promise, but the early releases lacked any method for creating reusable controls, and thus caused extended development times for applications. Sun Microsystems, the creators of the Java language, have at last recognized this need, and have released the Java Beans Component Architecture. Java Beans are, quite simply, reusable controls written in Java, for Java application development.

Beans are "capsules" of code, each designed for a specific purpose. The advantage of Java Beans over standard programming controls is that Beans are independent. They are not specific to operating systems or development environments. A Bean created in one development environment can be easily copied and modified by another. This allows Java Beans greater flexibility in enterprise computing, as components are easily shared between developers.

Java Beans are best put to use by visual developers. In a visual design environment (for example, Symantec's Visual Cafe Pro, this author's current tool of choice), an application interface is developed on a "form" or client window. A toolbox contains all the controls (Beans) which are dropped onto the form through simple drag and drop procedures. As the controls are dropped onto the form, the development environment grinds out the necessary code, When the interface is finished, the developer can set about creating the actual interactions between controls and the application as a whole. An exciting concept behind Beans springs from the fact that an application created in Java can be used as a Bean, which can be used to build other applications. As you can imagine, this circle of application to Bean and back can make developing large-scale applications much easier.

Some may wonder why anyone would use a Bean over a Java Class file. The strongest argument for a Bean over a Class is that Beans support introspection. That is, they allow the development environment to analyze the Bean, determine its properties and methods, and manipulate the Bean at design time instead of at run time.

The newest use of Beans is to create a bridge between Java and ActiveX. Several software companies are working on methods of quickly converting ActiveX controls to Java Beans (IBM's Visual Age, for example, is leading the pack in this area). Whereas Microsoft hoped to encompass Java into ActiveX, it appears that developers have different ideas and are churning out a wide variety of conversion tools to pull ActiveX into Java.

Java Beans are not a cure for all your programming ills, though. Beans are great for developing interfaces and basic applications, but for working with JDBC and SQL, text-based hand coding is your best bet.

If you're a visual developer looking to migrate to Java, you'll find that Java Beans will make the transition much easier. With Java Beans, Sun is proving that Java is poised to grow and become a powerful force in application development.

For more information about Java and Beans on the Web, try:
http://java.sun.com
http://www.javasoft.com
http://splash.java.com
http://www.developer.com
http://www.javology.com/javology

Applets - An applet is a mini-application developed in the Java language. Applets are commonly downloaded from the Internet and run on the user's machine. Lately, even full-scale Java applications have been referred to as applets.

IDE - Integrated Development Environment. Usually a visual-style programming application. Common IDE's include Visual Basic, Delphi, and Symantec's Visual Café

Java - A programming language, developed by Sun Microsystems, which is designed to be run on any type of operating system. Applications developed in Java are "Written once, run anywhere".

JDBC - Java Database Connectivity. This allows Java applets/applications to read/write/modify data in any of the supported JDBC database formats.
SQL - Structured Query Language (or Standard Query Language, depending on who you ask). SQL is a language used to "ask questions of" a database. Through SQL, an application makes specific requests for information, and the database relays that information back to the application.

NAMED PARAMETERS FOR PREPARED STATEMENT

2007-10-26T04:05:00.000-07:00

In past if you have worked with JDBC than you may know that keeping track of the indices of PreparedStatement is very difficult for larger queries having tens of parameters.

If you needs to insert or delete a parameter in the middle of a query, you must renumber all the parameters following it.

To make writing parameterized query easier, Adam has created NamedParameterStatement.
With NamedParameterStatement, instead of question marks, parameters are represented as a colon followed by an identifier.

So developer don't need to remember index of a parameters, insted parameters can be set using identifier.

Internally NamedParameterStatement uses PreparedStatement and replaces parameter identifiers with question marks.

Here is an example of how NamedParameterStatement can make developers life easier.

String query = "select * from users where userid = :userid; NamedParameterStatement p = new NamedParameterStatement(con, query); p.setString("userid", userid);

Look at following insert query.
StringBuffer query = new StringBuffer("INSERT INTO users (userid, first_name, last_name, street, city, country, zip_code)); query.append("VALUES (:userid, :fname, :lname, :street, :city, :country)"); NamedParameterStatement statement= new NamedParameterStatement(conn,query.toString()); statement.setString("userid", userid); statement.setString("fname", fname ); statement.setString("lname", ;name ); statement.setString("street", street ); statement.setString("city", city); statement.setString("country", country); statement.executeUpdate();

Now if you want to insert a new parameter 'middle_initial' at third position, it can be done as in the following.
StringBuffer query = new StringBuffer("INSERT INTO users (userid, first_name,middle_initial, last_name, street, city,country, zip_code)); query.append("VALUES (:userid, :fname, :middleinitial, :lname, :street, :city, :country)"); NamedParameterStatement statement= new NamedParameterStatement(conn,query.toString()); statement.setString("userid", userID); statement.setString("fname", firstName); statement.setString("lname", lastName); statement.setString("street", street ); statement.setString("city", city); statement.setString("country", country); statement.setString("middleinitial", middleInitial); statement.executeUpdate();

You don't need to renumber parameters following middle_initial, insted new parameter is added at the end.

This code is not only flexible but it is more understandable also.

2007-10-26T04:03:00.000-07:00

A Command pattern for Ajax?

In the canonical example, the Gand of Four Command pattern is used by a toolkit developer to enable future users to specify actions within the toolkit. Not knowing how the toolkit will be used, the developer codes to an interface, leaving the implementation details abstract.

The average enterprise Web application involves a similar scenario, where one person or group provides the tools to another. Although the typical Web application probably doesn't need to provide such complete autonomy between teams, other factors at work in a JSF-Ajax call suggest the use of the Command pattern; namely the layered architecture, the intermediary of HTTP, and JSF's component model.

Now, let's say you're working on a Web application where you need to do the following:

Handle commands arriving as Ajax requests without isolating the logic in a component.
Make it easy to add new commands.
Delegate the business logic to the business layer.

We'll start by taking a look at how you would set up the server side of the request, based on the AjaxCommand strategy. After that we'll look at the front-end design, and I'll conclude by comparing the original Command pattern with the AjaxCommand variation.

THE AJAX COMMAND STRATEGY FOR JSF

2007-10-26T04:01:00.000-07:00

As Java Server Faces continues to mature and its component libraries grow more robust, it becomes an ever more compelling option for enterprise Web application development. Ajax has passed the stage of being the hot new thing to become an expected aspect of competitive Web applications. Marrying the two isn't necessarily difficult, but it does present some interesting puzzles. In this article, Java developer Matthew Tyson tackles one such puzzle: how to handle a single (or similar) Ajax request action across multiple JSF components, without duplicating code in the components.

I recently encountered a problem at work that had me delving into the Gang of four design patterns for a solution. I was working on a tree component that rendered its nodes according to nested facets. The user could delete a node by clicking on a Delete button or by right-clicking and selecting Delete. The delete was to be carried out via an Ajax call.

Coding all this was relatively easy, but for one problem: I needed to delete objects outside the tree, for instance, from the item detail page and from the toolbar. I didn't want to embed the deletion request logic in the tree component's renderer. I needed the logic to be accessible anywhere; from links, buttons and images, anything that could handle an onClick.

Describing my solution to a colleague the next day took quite a while. Once I had successfully conveyed the design, my coworker paused for a moment and said, "Oh, you mean it's a Command?"

The Command pattern is a convenient way to express the intention of the AjaxCommand strategy, though there are some differences. I'll focus on the AjaxCommand strategy in this article, but use the Command pattern as a point of reference.

Note that I assume you are familiar with JSF and Ajax development in general. I've used the Dojo Library for my example, but the idea applies regardless of how you accomplish your Ajax calls.

LAUNCH JAVA APPLICATIONS FROM ASSEMBLY LANGUAGE PROGRAMS

2007-10-26T03:58:00.000-07:00

Java Native Interface (JNI) is a mechanism that can be used to establish communication between native language programs and the Java virtual machine. The documentation for JNI and the technical literature on JNI deal extensively with interactions between the JVM and C/C++ code. The Java SDK even provides a utility to generate a header file to facilitate calling C/C++ programs from Java code. However, there is hardly any mention of Java and assembly earlier language showed how assembly language programs can be called from Java applications. Here I deal with the technique for invoking Java programs from an ASM process through a demo application that calls a Java method from assembly language code. The Java method brings up a Swing `JDialog` to show that it has, indeed, been launched.

PREVENTING THREAD PROBLEMS WITH YOUR SINGLETON

2007-10-26T03:56:00.000-07:00

We need to make sure that threads calling the getSingletonObject() method don't cause problems, so it's advisable to mark the method as synchronized. This prevents two threads from calling the getSingletonObject() method at the same time. If one thread entered the method just after the other, you could end up calling the SingletonObject constructor twice and returning different values. To change the method, just add the synchronized keyword as follows to the method declaration :-

public static synchronized
  SingletonObject getSingletonObject()

Are we finished yet?

There, finished. A singleton object that guarantees one instance of the class, and never more than one. Right? Well.... not quite. Where there's a will, there's a way - it is still possible to evade all our defensive programming and create more than one instance of the singleton class defined above. Here's where most articles on singletons fall down, because they forget about cloning. Examine the following code snippet, which clones a singleton object.

public class Clone
{
 public static void main(String args[])
   throws Exception
 {
   // Get a singleton
   SingletonObject obj =
   SingletonObject.getSingletonObject();

   // Buahahaha. Let's clone the object
   SingletonObject clone =
  (SingletonObject) obj.clone();
 }
}

Okay, we're cheating a little here. There isn't a clone() method defined in SingletonObject, but there is in the java.lang.Object class which it is inherited from. By default, the clone() method is marked as protected, but if your SingletonObject extends another class that does support cloning, it is possible to violate the design principles of the singleton. So, to be absolutely positively 100% certain that a singleton really is a singleton, we must add a clone() method of our own, and throw a CloneNotSupportedException if anyone dares try!

Here's the final source code for a SingletonObject, which you can use as a template for your own singletons.

public class SingletonObject
{
 private SingletonObject()
 {
   // no code req'd
 }

 public static SingletonObject getSingletonObject()
 {
   if (ref == null)
       // it's ok, we can call this constructor
       ref = new SingletonObject();  
   return ref;
 }

 public Object clone()
 throws CloneNotSupportedException
 {
   throw new CloneNotSupportedException();
   // that'll teach 'em
 }

 private static SingletonObject ref;
}

GETTING AN INSTANCE OF THE SINGLETON

2007-10-26T03:55:00.000-07:00

We need to provide an accessor method, that returns an instance of the SingletonObject class but doesn't allow more than one copy to be accessed. We can manually instantiate an object, but we need to keep a reference to the singleton so that subsequent calls to the accessor method can return the singleton (rather than creating a new one). To do this, provide a public static method called getSingletonObject(), and store a copy of the singleton in a private member variable.

public class SingletonObject
{
   private SingletonObject()
   {
       // no code req'd
   }

   public static SingletonObject getSingletonObject()
   {
     if (ref == null)
         // it's ok, we can call this constructor
         ref = new SingletonObject();
     return ref;
   }

   private static SingletonObject ref;
}

So far, so good. When first called, the getSingletonObject() method creates a singleton instance, assigns it to a member variable, and returns the singleton. Subsequent calls will return the same singleton, and all is well with the world. You could extend the functionality of the singleton object by adding new methods, to perform the types of tasks your singleton needs. So the singleton is done, right? Well almost.....

PREVENTING DIRECT INSTANTIATION

2007-10-26T03:54:00.000-07:00

We all know how objects are instantiated right? Maybe not everyone? Let's go through a quick refresher.

Objects are instantiated by using the new keyword. The new keyword allows you to create a new instance of an object, and to specify parameters to the class's constructor. You can specify no parameters, in which case the blank constructor (also known as the default constructor) is invoked. Constructors can have access modifiers, like public and private, which allow you to control which classes have access to a constructor. So to prevent direct instantiation, we create a private default constructor, so that other classes can't create a new instance.

We'll start with the class definition, for a SingletonObject class. Next, we provide a default constructor that is marked as private. No actual code needs to be written, but you're free to add some initialization code if you'd like.

public class SingletonObject
{
 private SingletonObject()
 {
  // no code req'd
 }
}

So far so good. But unless we add some further code, there'll be absolutely no way to use the class. We want to prevent direct instantiation, but we still need to allow a way to get a reference to an instance of the singleton object.

Introducing the Single Java Object

2007-10-26T03:50:00.000-07:00

For those who haven't heard of design patterns before, or who are familiar with the term but not its meaning, a design pattern is a template for software development. The purpose of the template is to define a particular behavior or technique that can be used as a building block for the construction of software - to solve universal problems that commonly face developers. Think of design code as a way of passing on some nifty piece of advice, just like your mother used to give. "Never wear your socks for more than one day" might be an old family adage, passed down from generation to generation. It's common sense solutions that are passed on to others. Consider a design pattern as a useful piece of advice for designing software.

Design patterns out of the way, let's look at the singleton. By now, you're probably wondering what a singleton is - isn't jargon terrible? A singleton is an object that cannot be instantiated. At first, that might seem counterintuitive - after all, we need an instance of an object before we can use it. Well yes a singleton can be created, but it can't be instantiated by developers - meaning that the singleton class has control over how it is created. The restriction on the singleton is that there can be only one instance of a singleton created by the Java Virtual Machine (JVM) - by prevent direct instantiation we can ensure that developers don't create a second copy.

So why would this be useful? Often in designing a system, we want to control how an object is used, and prevent others (ourselves included) from making copies of it or creating new instances. For example, a central configuration object that stores setup information should have one and one only instance - a global copy accessible from any part of the application, including any threads that are running. Creating a new configuration object and using it would be fairly useless, as other parts of the application might be looking at the old configuration object, and changes to application settings wouldn't always be acted upon. I'm sure you can think of a other situations where a singleton would be useful - perhaps you've even used one before without giving it a name. It's a common enough design criteria (not used everyday, but you'll come across it from time to time). The singleton pattern can be applied in any language, but since we're all Java programmers here (if you're not, shame!) let's look at how to implement the pattern using Java.

About the Java Technology

2007-09-04T22:24:00.000-07:00

Java technology is both a programming language and a platform.

The Java Programming Language

The Java programming language is a high-level language that can be characterized by all of the following buzzwords:

Simple	Architecture neutral
Object oriented	Portable
Distributed	High performance
Multithreaded	Robust
Dynamic	Secure

Each of the preceding buzzwords is explained in The Java Language Environment , a white paper written by James Gosling and Henry McGilton.

In the Java programming language, all source code is first written in plain text files ending with the .java extension. Those source files are then compiled into .class files by the javac compiler. A .class file does not contain code that is native to your processor; it instead contains bytecodes — the machine language of the Java Virtual Machine¹ (Java VM). The java launcher tool then runs your application with an instance of the Java Virtual Machine.

An overview of the software development process.

Because the Java VM is available on many different operating systems, the same .class files are capable of running on Microsoft Windows, the Solaris ^TM Operating System (Solaris OS), Linux, or Mac OS. Some virtual machines, such as the Java HotSpot virtual machine, perform additional steps at runtime to give your application a performance boost. This include various tasks such as finding performance bottlenecks and recompiling (to native code) frequently used sections of code.

Through the Java VM, the same application is capable of running on multiple platforms.

The Java Platform

A platform is the hardware or software environment in which a program runs. We've already mentioned some of the most popular platforms like Microsoft Windows, Linux, Solaris OS, and Mac OS. Most platforms can be described as a combination of the operating system and underlying hardware. The Java platform differs from most other platforms in that it's a software-only platform that runs on top of other hardware-based platforms.

The Java platform has two components:

The Java Virtual Machine
The Java Application Programming Interface (API)

You've already been introduced to the Java Virtual Machine; it's the base for the Java platform and is ported onto various hardware-based platforms.

The API is a large collection of ready-made software components that provide many useful capabilities. It is grouped into libraries of related classes and interfaces; these libraries are known as packages. The next section, What Can Java Technology Do? highlights some of the functionality provided by the API.

The API and Java Virtual Machine insulate the program from the underlying hardware.

As a platform-independent environment, the Java platform can be a bit slower than native code. However, advances in compiler and virtual machine technologies are bringing performance close to that of native code without threatening portability.

The terms"Java Virtual Machine" and "JVM" mean a Virtual Machine for the Java platform.

« Previous • Trail • Next »

What Can Java Technology Do?

The general-purpose, high-level Java programming language is a powerful software platform. Every full implementation of the Java platform gives you the following features:

Development Tools: The development tools provide everything you'll need for compiling, running, monitoring, debugging, and documenting your applications. As a new developer, the main tools you'll be using are the javac compiler, the java launcher, and the javadoc documentation tool.
Application Programming Interface (API): The API provides the core functionality of the Java programming language. It offers a wide array of useful classes ready for use in your own applications. It spans everything from basic objects, to networking and security, to XML generation and database access, and more. The core API is very large; to get an overview of what it contains, consult the Java SE Development Kit 6 (JDK^TM 6) documentation.
Deployment Technologies: The JDK software provides standard mechanisms such as the Java Web Start software and Java Plug-In software for deploying your applications to end users.
User Interface Toolkits: The Swing and Java 2D toolkits make it possible to create sophisticated Graphical User Interfaces (GUIs).
Integration Libraries: Integration libraries such as the Java IDL API, JDBC^TM API, Java Naming and Directory Interface^TM ("J.N.D.I.") API, Java RMI, and Java Remote Method Invocation over Internet Inter-ORB Protocol Technology (Java RMI-IIOP Technology) enable database access and manipulation of remote objects.

We can't promise you fame, fortune, or even a job if you learn the Java programming language. Still, it is likely to make your programs better and requires less effort than other languages. We believe that Java technology will help you do the following:

Get started quickly: Although the Java programming language is a powerful object-oriented language, it's easy to learn, especially for programmers already familiar with C or C++.
Write less code: Comparisons of program metrics (class counts, method counts, and so on) suggest that a program written in the Java programming language can be four times smaller than the same program written in C++.
Write better code: The Java programming language encourages good coding practices, and automatic garbage collection helps you avoid memory leaks. Its object orientation, its JavaBeans^TM component architecture, and its wide-ranging, easily extendible API let you reuse existing, tested code and introduce fewer bugs.
Develop programs more quickly: The Java programming language is simpler than C++, and as such, your development time could be up to twice as fast when writing in it. Your programs will also require fewer lines of code.
Avoid platform dependencies: You can keep your program portable by avoiding the use of libraries written in other languages.
Write once, run anywhere: Because applications written in the Java programming language are compiled into machine-independent bytecodes, they run consistently on any Java platform.
Distribute software more easily: With Java Web Start software, users will be able to launch your applications with a single click of the mouse. An automatic version check at startup ensures that users are always up to date with the latest version of your software. If an update is available, the Java Web Start software will automatically update their installation.