CODEWITHSUNDEEP
javainterface
Luca Fülbier
Luca Fülbier

Reputation: 2731

Adding functionality to implementation classes without changing the implemented Interface

I have got an interface that defines some service methods for data retrieval:

public interface DataReceiver {
    public Data getData();
}

Then i have a class that implements this interface and loads the data through a connection. I supply this connection using constructor injection:

public class ConnectionDataReceiver implements DataReceiver {
    private Connection connection;

    public ConnectionDataReceiver(Connection connection) {
        this.connection = connection;
    }

    public Data getData() {
        return connection.query("blabla");
    }
}

This works pretty nicely. I can instantiate my ConnectionDataReceiver objects using the constructor, or i could add a factory method/class that extends the usability by providing an option to select a config file for connection setup. I then use my new class through my interface, so i can easily swap out the implementation (like loading the data from a file instead of a connection).

But what if i want to change my connection during runtime, without instantiating a new ConnectionDataReceiver? I would have to add getters and setters for my class. But since they are not part of my public service definition, i can't put them in my interface. I could use the implementation object in my code to set a new connection, but it feels pretty awkward hanging onto a reference to the original object only for maybe changing the connection object:

ConnectionDataReceiver conDataRec = new ConnectionDataReceiver(myConnection);
DataReceiver dataRec = conDataRec;
// use dataRec

conDataRec.setConnection(myNewConnection);
// use dataRec again

In this example it would be the easiest way to just instantiate a new ConnectionDataReceiver and just reassign dataRec, but what if the instantiation of my object is really expensive? How do i give my implementation classes additional functionality while still being able to use my old service interface? Or is it generally frowned upon changing data at runtime, when the interface doesn't define that functionality?

Upvotes: 1

Views: 2065

Answers (2)

Fabio
Fabio

Reputation: 32455

My version:

Interface

public interface DataReceiver 
{
    public Data getData();
}

Implementation

public class ConnectionDataReceiver implements DataReceiver 
{
    private Connection connection;

    public ConnectionDataReceiver(Connection connection) 
    {
        this.connection = connection;
    }

    public Data getData() 
    {
        return connection.query("blabla");
    }
}

Interface using in business layer, here method setReceiver will assign new implementation of interface in run-time.

public class SomeBusinessLogic
{
    private DataReceiver receiver;

    public SomeBusinessLogic(DataReceiver receiver) 
    {
        this.receiver = receiver;
    }

    public void setReceiver(DataReceiver receiver) 
    {
        this.receiver = receiver;
    }
}

With this approach you can change implementation of DataReceiver in run-time

Upvotes: 1

Sanjeev Saha
Sanjeev Saha

Reputation: 2652

What you can do is that adding following two simple methods in your interface:

public void setProperty(String name, Object value);

public Object getProperty(String name);

Now with the help of these two simple methods, you may configure as many additional functionalities as you want in your implementation classes without adding a new method for a new feature (of your implementation class) in your super type.

This pattern is used in following interface:

com.ibm.msg.client.jms.JmsQueueConnectionFactory

The interface has setCharProperty, setDoubleProperty, setFloatProperty etc so that when they release a new implementation they do not have to modify the interface.

Upvotes: 1

Related Questions