Duplicated processing of class hierarchies java

Question

We have two similar hierarchies of classes sitting in two packages. The code is not ours, so we cannot change it. We have to process these hierarchies in a certain way. So far we end up duplicating lots of code. For instance we have two methods:

void process(pckg1.Client client){...}

and

void process(pckg2.Client client){...}

The bodies of the methods are identical except for the signature. The amount of the duplication is significant, but would not probably justify complexity of reflection. Is there a better way of doing this?

Thanks, Alex

Do they implement the same interfaces? Otherwise, you can probably use an adapter pattern. — Boris the Spider, Jan 21 '15 at 22:53
An adapter, which was proposed by Robin Khral, seems much more complicated than the duplicated code. — Alex, Jan 21 '15 at 23:01
Given any lack example code or a decent description of the problem, this is about all you are going to get. — Boris the Spider, Jan 21 '15 at 23:03
Have you considered using reflection? http://stackoverflow.com/questions/37628/what-is-reflection-and-why-is-it-useful — gknicker, Jan 21 '15 at 23:03
Alex, I would disagree. You should always look to apply the DRY principle. — JamesB, Jan 21 '15 at 23:04

Robin Krahl · Answer 1 · 2015-01-21T23:00:58.263

3

One option would be to wrap the shared methods ofpckg1.Client and pckg2.Client:

public interface ClientWrapper {
    void sharedMethod();
}

public class Packg1ClientWrapper implements ClientWrapper {
     private final pckg1.Client client;
     public Pck2ClientWrapper(final pckg1.Client client) {
         this.client = client;
     }
     public void sharedMethod() {
         client.sharedMethod();
     }
}

public class Packg2ClientWrapper implements ClientWrapper {
     private final pckg2.Client client;
     public Pck2ClientWrapper(final pckg2.Client client) {
         this.client = client;
     }
     public void sharedMethod() {
         client.sharedMethod();
     }
}

Then you can use ClientWrapper in your methods and optionally provide utility methods that create the wrapper.

public void process(final pckg1.Client client) {
    process(new Pckg1ClientWrapper(client));
}

public void process(final ClientWrapper wrapper) {
     wrapper.sharedMethod();
}

This obviously only makes sense if there are few external class and a big amount of custom code dealing with these classes.

edited Jan 21 '15 at 23:00

answered Jan 21 '15 at 22:54

Robin Krahl

5,268
19
32

The objects and their properties are rarely used more than once. The straightforward code-duplicated version will be much smaller and simpler. – Alex Jan 21 '15 at 22:59
In your second code block, you should have process(new Pckg1ClientWrapper(client)); – JamesB Jan 21 '15 at 22:59
No worries Robin, nice answer! – JamesB Jan 21 '15 at 23:02
@Alex Okay, then I don’t see a simple solution to avoid code redundancy, sorry. – Robin Krahl Jan 21 '15 at 23:02

Duplicated processing of class hierarchies java

1 Answers1