What is the best architecture for this case?

[apurav]

I have a controller C. In that controller i injected a Service class S.
like:

class C extends SimpleFormController{
private S service;

onSubmit{
service.doSomeOperation();
service.anotherOperation();

}

}

NOw i have got a requirement that, depending on a condition at the the time of context startup, i have to call another implementation of the service.anotherOperation().

So nw i have created an interface and Service S implements it. And also created one more Service P where i have changed the implementation of anotherOperation().

Now My question is : for the remaining methods whose implemenation is same as that of class S, should i make P as subclass of S as well.
LIke:

Interface A;
S implements A;
P extends S implements A;
class C{
private A a;
}
------OR--------
class S;
P extends S;
class C{
private S s;
}

Which design is the best ?

[dr_pompeii]

Hello

Use code tags, is more readable for us

class S;
P extends S;
class C{
private S s;
}

Absolutely not, Spring work with Interfaces since it works with the Proxy Pattern and furthermore interfaces offer a level of loose coupling

Interface A;
S implements A;
P extends S implements A;
class C{
private A a;
}

I think is fine, but you must consider for this situation use @Service("p") and @Service("s") for each class implementation, therefore when you inject the interface into the controller with @Autowired you must now use and add the @Qualifier("p")

Let me know your advance

[apurav]

Hi Dr pompeii,

I had also decided to go with the design you suggested. But my confusion is:

P is extending S to share common implemenation. But doesnt it then conflict with the spring's advice of loose coupling. Should we not separate the common implemenation into some another class and inject that in P and S? So that it looks like this:

Design 2

Interface A;
S implements A;
P implements A;
class C{
private A a;
}

In terms of this, when and how to decide what design we should go for? And why we should go which design?
Plz put some expert light on this?

[dr_pompeii]

P is extending S to share common implemenation

With such context, is correct

Should we not separate the common implemenation into some another class and inject that in P and S

If is common not, it is used when is uncommon for example you have a interface DAO and you have 3 implementations of such interface, one with Hibernate, other with JPA and the last with MyBatis (known as Ibatis), with my previous explanation

Interface A;
S implements A;
P implements A;
class C{
private A a;
}

YOur code has more sense now

In terms of this, when and how to decide what design we should go for? And why we should go which design?

It depends if has common methods inplementations or not

HTH