Our implementation begins with the definition of an interface--called ServiceInterface (ServiceInterface.class)--for all of our Services:

   public interface ServiceInterface
   {  //++ Public Methods
      public void      StartUp();
      public void      ShutDown();
      public void      Activate();
      public void      Deactivate();
      public boolean   IsActive();
   }//end interface ServiceInterface

This interface is implemented by the class GenericService, which is defined as abstract, which of course means that you are not allowed to create an instance of this class directly. But you can create a class that is inherited from the abstract base class, which is generally a good technique, because it documents what is generic in your class hierarchy:

   public abstract class GenericService implements Runnable, 
        Cloneable, ServiceInterface

GenericService creates a thread, which manages a ServerSocket class. This class is used by calling its Accept() method, which blocks until it receives a connection and returns the socket that is used to communicate with your client:

   final public void run()
   {    
      Socket ns = serverSocket.accept();
      GenericService n = (GenericService)clone();
   }   

Once we have our abstract service class, we need only write some specific services. To do this, all we have to specify is the method that processes a service request. Here our CapService takes the input String and calls .toUpperCase:

   public class CapService extends GenericService implements 
      PortInterface

   public void serviceRequest() throws IOException
   {  
      try
      {    System.out.println("in serviceRequest for server " +
                    getClass().getName() + "\n");
           String foo = null;
           while ( (foo = clientInput.readLine()) != null)
              clientOutput.print("server: " + foo.toUpperCase() + "
                    :server\r\n")
              clientOutput.flush();
      } //end try
      catch (Exception e)
      { 
         e.printStackTrace();
      }//end catch
    } //end serviceRequest()

   public static int GetPort()
   { 
      return ClassPort;
   }  //end getPort();

   class ServiceDef (ServiceDef.class)
   {   
       public ServiceDef (String ClassName, String ClassPath)
       {   
           mstrClassName = ClassName;
           mstrClassPath = ClassPath;
       }//end constructor

       public String ClassPath ()
       {   
           return mstrClassPath;
       }//end ClassPath()

       public String ClassName ()
       {   
           return mstrClassName;
       }//end ClassName()

       public  ServiceInterface ServiceObj ()
       {   
           return mService;
       }//end ServiceObj()

       protected void Load ()
       {   
           try
           {   
               ClassoClass = Class.forName (mstrClassPath);
               mService = (ServiceInterface) oClass.newInstance ();
           }//end try
           catch (Exception e)
           { 
               e.printStackTrace();
           }//end catch
       }//end Load()

    //protected data members
    
       protected String mstrClassName;
       protected String mstrClassPath;
       private ServiceInterface mService;
   }//end class ServiceDef

The last two classes-- ServiceLoader and GenericClient-- show how to use this system. ServiceLoader first constructs a vector of class names and class paths called mServiceList. (It is important to specify the full package path when calling Class.forName(). If CapService were in the package util.serviceloader, you would have needed to specify util.serviceloader.CapService as its classpath name.) The second step is to useLoad() on each object in the vector to create the service. Then make the call to Activate() and StartUp():

   private void LoadServiceClasses()
   {    
       try
       {   
           int iCount = mServiceList.size();
           for (int i = 0; i < iCount; i++)
           {   
               ServiceDef oServiceDef = (ServiceDef)
                            mServiceList.elementAt(i);
               oServiceDef.Load();
               ServiceInterface oServiceObj = 
                            oServiceDef.ServiceObj();
               String strKey = oServiceDef.ClassName ();
               System.out.println("Starting: " + strKey + " ...");
               oServiceObj.Activate ();
               oServiceObj.StartUp ();
           }//end for
       }//end try
       catch (Exception e)
       {   
           e.printStackTrace();
       }//end catch
   }//end LoadServiceClasses

   //example use of Dynamic Service Loading
   public class GenericClient 
   {
      public static void main(String[] args)
      {   
          try
          {   
              //Load and Start all Service Classes
              new ServiceLoader(); 

   //Create Input and Output Sockets for Service1 - CAPS
   //Get port for Service Type
   int iServerPort = CapService.GetPort(); 
   //Create Socket
   Socket CapSocket = new Socket("localhost", iServerPort );

   //Create Input and Output Sockets for Service2 - Reverse
   int iServerPort2 = ReverseService.GetPort();
   Socket ReverseSocket = new Socket("localhost", iServerPort2 );

   //Use Caps Service
   PushToService("This is a fine class", CapSocket);
   //Use Reverse Service
   PushToService("This is a fine class", ReverseSocket);

By building up a library of services, you provide a solution that is dynamically configurable at runtime for each user environment. Java's ability to create a class by name makes this easy. And Java applets require sophisticated, dynamic class loading, Java comes with some very powerful capabilities for client/server design built right into it. This program is an interesting example that shows you how to take advantage of these powers.

Download the zipped file which contains the necessary files for Stefanini's generic service loader.

What You Can Learn From Tim Stefanini About Threads, Efficiency, and Understanding Java

Sliding Buffers