{
public abstract P createProtocol(C Configuration);
}
}}}
This factory will allow the creation of a 'Protocol' instance using a 'Configuration' instance; let's implement this for our HTTP protocol:
{{{
public class HttpProtocolFactory extends AbstractProtocolFactory
Java 5.0 Generics Tip
Submitted by hplusplus on Wed, 2006-02-08 18:27.
Java 5.0 release introduced some very interesting features. Generic programming is probably the most important addition. This tip will try to introduce a useful use case using generics.
Assume you are building a communication system, where lots of protocols are involved. Java already supports a wide group of communication protocols, but assuming you want to adapt all protocols needed by your system under a unified API, we need to do some work.
So, what would we need for such API?
Ok, a 'Protocol' contract might be useful. Oh, this 'Protocol' needs some kind of 'Configuration'. Let's start by a very simple 'Configuration' interface:
{{{
public interface Configuration{
public Properties getProperties();
public void setProperties(Properties properties);
}
}}}
This is a very simple contract that will allow you set and get some properties. But why this is needed? I can just use 'Properties' class directly. We will get to this shortly.
Now, let's write our 'Protocol' interface:
{{{
public interface Protocol{
public InputStream getInputStream();
public OutputStream getOutputStream();
public void setConfiguration(Configuration configuration);
public Configuration getConfiguration();
public void close();
}
}}}
That's it?!!
No, there is a simple enhancement that can be done with this code. Java allows you to override a method of a base class, old news. Ok, Java allows you to override a method of a base class and change the return type to a more specific one. So, when you implement the 'Protocol' interface, 'getConfiguration' method signature can specify a descendant of the 'Configuration' interface. Nice, can I do this with the parameters as well? No, you can't, but here comes the power of generics, let's enhance this code:
{{{
public interface Protocol{
public InputStream getInputStream();
public OutputStream getOutputStream();
public void setConfiguration(C configuration);
public C getConfiguration();
public void close();
}
}}}
Now, let's see a simple implementation of a protocol, let's say HTTP:
{{{
public class HttpConfiguration implements Configuration{
protected Properties properties;
public HttpConfiguration(){
properties = new Properties();
}
public String getUri(){
return properties.getProperty("uri");
}
public void setUri(String uri){
properties.setProperty("uri", uri);
}
public Properties getProperties(){
return properties;
}
public void setProperties(Properties properties){
this.properties = properties;
}
}
}}}
Notice how the getters and setters can use the properties to simplify access, for example, we can add a 'getUrl' method, which creates a URL instance from a string URI and handles the thrown exceptions for us. Ok, let's see an HTTP implementation of our 'Protocol' interface.
{{{
public class HttpProtocol implements Protocol{
protected HttpConfiguration configuration;
public InputStream getInputStream(){
InputStream in = null;
//initialize the stream, open a session with the remote server
return in;
}
public OutputStream getOutputStream(){
OutputStream out = null;
//initialize the stream, blah, blah
return out;
}
public void setConfiguration(HttpConfiguration configuration){
this.configuration = configuration;
}
public HttpConfiguration getConfiguration(){
return configuration;
}
public void close(){
// clean up
}
}
}}}
Notice how the configuration setter and getter are more specific to their related 'HttpConfiguration' implementation. Yes, we don't need to cast anymore.
Now if you start implementing lots of protocols this way, we might need a factory to support multiple implementations, let's start an abstract factory:
{{{
public abstract class AbstractProtocolFactory
Nice external comment