The following example uses a dynamic proxy class to keep track of how much time it takes to execute a method.

Two classes are implemented: JMSTransporter and TibcoTransporter, both implementing the interface Transporter.

interface Transporter {  
   public void sendMessage(String message);
}
 
class TibcoTransporter implements Transporter {
   public void sendMessage(String message) {
      ...
   }
}
 
class JMSTransporter implements Transporter {
   public void sendMessage(String message) {
      ...
   }
}

Suppose we need to do some performance tests to see how long each transporter takes to perform its task. The typical way of doing this is to record a timestamp in the beginning of the method and at the end and printing out the difference:

   long start = System.currentTimeMillis();
 
   .. perform job
 
   long stop = System.currentTimeMillis();
   System.out.println("Total time it took: " + (stop - start));

We would have to do that for the TibcoTransporter as well as the JMSTransporter. It also uglifies the code, makes it harder to maintain (remove when it goes in production) and may introduce bugs. You could also write a wrapper around it, but this is a tedious task and would require you to do this for every interface.

Since JDK1.3, you can simplify this task using a dynamic proxy class. A dynamic proxy class is a class that implements a list of interfaces at runtime. An instance of this class can handle method invocations of the interface(s) and dispatches them to the object that implements the interface.

Writing a proxy class is simple: implement the InvocationHandler interface and its method

   public Object invoke(Object proxy, Method method, Object[] args)            
                     throws Throwable; 

To instantiate a proxy object:

   Proxy.newProxyInstance(ClassLoader loader,
                          Class[] interfaces,
                          InvocationHandler h) 

In our example, the proxy class TimerProxy is created. All method invocations to the interfaces that were specified when instantiating the proxy object with newProxyInstance are dispatched to the TimerProxy.

Main.java:

import java.lang.reflect.*;
 
interface Transporter
{
   public void sendMessage(String message);
}
 
class TibcoTransporter implements Transporter
{
   public void sendMessage(String message) {
      // let's assume the message takes 1 second to send 
      // using Tiboc RendezVous
      try {
         Thread.sleep(1000);
      }
      catch(InterruptedException e) {
      }
      System.out.println("Message '" + message + "' sent with the TibcoTransporter");
   }
}
 
class JMSTransporter implements Transporter
{
   public void sendMessage(String message) {
      // let's assume the message takes 2 seconds to send 
      // using a JMS implementation
      try {
         Thread.sleep(2000);
      }
      catch(InterruptedException e) {
      }
      System.out.println("Message '" + message + "' sent with the JMSTransporter");
   }
}
   
public class Main
{
   public static void main(String []args) {
      TibcoTransporter tibcoTransporter = new TibcoTransporter();

      Transporter transporter1 = (Transporter) TimerProxy.newInstance(new TibcoTransporter());
      transporter1.sendMessage("Hi");

      Transporter transporter2 = (Transporter) TimerProxy.newInstance(new JMSTransporter());
      transporter2.sendMessage("Hi");
   }
}

class TimerProxy implements InvocationHandler
{
   private Object obj;
 
   public TimerProxy(Object obj) {
      this.obj = obj;
   }
  
   public static Object newInstance(Object obj) {
      return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                                    obj.getClass().getInterfaces(),
                                    new TimerProxy(obj));
   }
 
   public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
   {
      Object result = null;
      long start, stop;
      System.out.println("- Entering " + m.getName() + " in class " + obj.getClass());
      start = System.currentTimeMillis();
      try {
         result = m.invoke(obj, args);
      }
      catch(InvocationTargetException e) {
         throw e.getTargetException();
      }
      catch(Exception e) {
         throw new RuntimeException(e.getMessage());
      }
      finally {
         stop = System.currentTimeMillis();
         System.out.println("- Total time it took: " + (stop - start));
      }
      System.out.println("- Exiting " + m.getName() + " in class " + obj.getClass());
 
      return result;
   }
}

outputs:

- Entering sendMessage in class class TibcoTransporter
Message 'Hi' sent with the TibcoTransporter
- Total time it took: 1002
- Exiting sendMessage in class class TibcoTransporter
- Entering sendMessage in class class JMSTransporter
Message 'Hi' sent with the JMSTransporter
- Total time it took: 2003
- Exiting sendMessage in class class JMSTransporter

Other uses for a dynamic proxy are logging, parameter validation, access control, error handling, …

For more information on Dynamic Proxy Classes, check here

The following example will create a web application containing a jsp that will behave based on who is logged in. The possible users that can be logged in will be defined in an xml file called tomcat-users.xml located in the [TOMCAT-HOME]/conf directory.

This example will recognize two types of custom defined roles: GOLD and SILVER roles. Every user will be assigned one or both roles.

1. Create the following xml file in the [TOMCAT-HOME]/conf directory: tomcat-users.xml (or add the user tags to the existing tomcat-users.xml file):

<tomcat-users>
  <user name="gary"    password="yrag"   roles="gold"/>
  <user name="alicia"  password="aicila" roles="gold"/>
  <user name="john"    password="nhoj"   roles="silver"/>
  <user name="joris"   password="siroj"  roles="gold,silver"/>
</tomcat-users>

2. The JSP is as simple as it can be. It prints out the user that is logged in and prints out to which role it belongs.

confidential.jsp:

<html>
<body>
Hi, <%=request.getUserPrincipal().getName()%><br><br>
<%
   if (request.isUserInRole("gold")) {
%>
      You have the GOLD role<br>
<%
   }
   if (request.isUserInRole("silver")) {
%>
      You have the SILVER role<br>
<%
   }
%>
</body>
</html>

3. Create the WEB-INF/web.xml deployment descriptor.

<?xml version="1.0" encoding="ISO-8859-1"?>
 
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/j2ee/dtds/web-app_2_3.dtd">
 
<web-app>
   <security-constraint>
      <web-resource-collection>
         <web-resource-name>admin</web-resource-name>
         <url-pattern>*.jsp</url-pattern>
      </web-resource-collection>
      <auth-constraint>
         <role-name>gold</role-name>
         <role-name>silver</role-name>
      </auth-constraint>
   </security-constraint>
   <login-config>
      <auth-method>BASIC</auth-method>
      <realm-name>Log In</realm-name>
   </login-config>
</web-app>

This deployment descriptor specifies that only users with roles gold or silver are authorized to access the *.jsp resources. The method of authorization is BASIC. Other possible authorization methods are DIGEST and FORM (see other Q/A’s for examples).

4. Now package everything up in a web application loginexample1.war:

C:loginexample1>jar -cvf loginexample1.war *
added manifest
adding: confidential.jsp(in = 275) (out= 160)(deflated 41%)
adding: WEB-INF/(in = 0) (out= 0)(stored 0%)
adding: WEB-INF/web.xml(in = 673) (out= 328)(deflated 51%)

and drop loginexample1.war into the /webapps directory.

5. Start up Catalina and point your browser to http://localhost:8080/loginexample1/confidential.jsp.

Because a security constraint is defined in web.xml, specifying that only gold and silver roles can access all jsp pages, and because BASIC authentication is specified, the following window will popup to ask for the username and password:

Try one of the entries in tomcat-users.xml. Notice that you cannot log out, except by closing the browser window.

You can use the undocumented class sun.misc.Signal. But beware of using the Sun packages.

This program allows you to catch any of the following signals:

   Windows:
      	ABRT	SIGABRT
	FPE 	SIGFPE
    	SEGV	SIGSEGV
	INT	SIGINT
	TERM	SIGTERM
	ILL	SIGILL


   Solaris/Linux:
	HUP	SIGHUP
	INT	SIGINT
	QUIT	SIGQUIT
	ILL	SIGILL
	TRAP	SIGTRAP
	ABRT	SIGABRT
	IOT	SIGIOT (*)
	EMT	SIGEMT (*)
	FPE	SIGFPE
	KILL	SIGKILL
	BUS	SIGBUS
	SEGV	SIGSEGV
	SYS	SIGSYS
	PIPE	SIGPIPE
	ALRM	SIGALRM
	TERM	SIGTERM
	STKFLT	SIGSTKFLT
	USR1	SIGUSR1
	USR2	SIGUSR2
	CHLD	SIGCHLD
	PWR	SIGPWR
	WINCH	SIGWINCH
	URG	SIGURG
	POLL	SIGPOLL
	IO	SIGIO
	STOP	SIGSTOP
	TSTP	SIGTSTP
	CONT	SIGCONT
	TTIN	SIGTTIN
	TTOU	SIGTTOU
	VTALRM	SIGVTALRM
	PROF	SIGPROF
	XCPU	SIGXCPU
	XFSZ	SIGXFSZ
	UNUSED	SIGUNUSED
	SWI	SIGSWI

The example program (Linux/Solaris) demonstrates to catch and perform a System.exit only with a SIGTERM. A SIGHUP will not cause the program to exit.

Main.java:

import sun.misc.Signal;
import sun.misc.SignalHandler;
import java.lang.reflect.*;
 
public class Main
{
   public static void main(String []args) {
      DebugSignalHandler.listenTo("HUP");
      DebugSignalHandler.listenTo("INT");
      DebugSignalHandler.listenTo("KILL");
      DebugSignalHandler.listenTo("TERM");
 
      while (true) {
         try {
            Thread.sleep(1000);
         }
         catch(InterruptedException e) {
         }
      }
   }
}
 
class DebugSignalHandler implements SignalHandler
{
   public static void listenTo(String name) {
      Signal signal = new Signal(name);
      Signal.handle(signal, new DebugSignalHandler());
   }

   public void handle(Signal signal) {
      System.out.println("Signal: " + signal);
      if (signal.toString().trim().equals("SIGTERM")) {
         System.out.println("SIGTERM raised, terminating...");
         System.exit(1);
      }
   }
}

This example assumes you have the JDBC mm.mysql driver residing in an ext subdirectory.

Main.java:

import java.util.*;
import java.net.*;
import java.io.*;
import java.sql.*;
 
public class Main
{
   public static void main(String []args) throws Exception {
      ClassLoader cl = loadExt();
      if (cl != null) {
         cl.loadClass("org.gjt.mm.mysql.Driver").newInstance();
         System.out.println("mysql driver successfully loaded!");
         Connection connection = DriverManager.getConnection("jdbc:mysql://localhost/esus", "USER", "PASS");
 
         //. . .
      }
   }
 
   public static URLClassLoader loadExt() {
      try {
         Vector urls = new Vector();
         File file = new File("ext");
         String[] list = file.list();
         for (int i=0; i<list.length; i++) {
            if (list[i].endsWith(".jar")) {
               urls.add(new URL("file:" + file.getName() + "/" + list[i]));
            }
         }
         return new URLClassLoader((URL[]) urls.toArray( new URL[] { } ));
      } catch ( java.net.MalformedURLException me ) { 
         me.printStackTrace();
      }
 
      return null;
   }
}

JDK1.5 allows you to set connect and read timeouts on URLConnection (HttpURLConnection, etc.).

Here is an example:

Main.java:

import java.net.*;

public class Main
{
   public static void main(String []args) throws Exception {
      if (args.length != 1) {
         System.err.println("Usage: java Main <URL>");
         System.exit(0);
      }
          
      URL url = new URL(args[0]);
      URLConnection connection = url.openConnection();
 
      connection.setConnectTimeout(5000);
      connection.connect();
   }
}