Java类设计-最佳方法的建议。 类扩展抽象类并实现接口

Question

Not sure what approach to take for design classes.

public interface AuthoringEvent {
   ProcessingResultEvent authoringEvent(Event data);
}

AbstractAuthoringEvent abstract class implements interface

public abstract class AbstractAuthoringEvent implements AuthoringEvent {

   @Override
   public ProcessingResultEvent authoringEvent(Event data) {

       ResponseEntity<Event> resultData = callService(data);
       etc...
   }

   protected abstract ResponseEntity<Event> callService(Event requestData);

}

AuthoringEventIT class extends abstract class

public class AuthoringEventIT extends AbstractAuthoringEvent {

   @Autowired
   private RESTClient restClient;

   protected ResponseEntity<Event> callService(Event requestData) {

     return restClient.callWebServiceWithAction(url, httpPostMethod, requestData, Event.class);
   }

Resource endpoint class

@Autowired
private AuthoringEventIT authoringEventIT;

@PostMapping()
public ResponseEntity<Event> authorEvent(@RequestBody final EventRequest request) {

    ProcessingResultEvent responseData = authoringEventIT.authoringEvent(request);

    return responseData.getProcessedData();
}

l have 2 more same implementations like Event for Venue and Organization model classes. l know l can remove interfaces and do all on abstract classes level which will all concrete classes implement for they own purpose as it on AuthoringEventIT.class, but my question is...

Do these abstract classes really need separate interfaces to implement? Maybe all 3 abstract classes can implement one Authoring interface some kind of generic method, but how to avoid then implementation in concrete class like AuthoringEventIT which extends abstract class and need to implement again interface method which is already implemented in abstract class? Many thanks...

Answer 1

In the Spring framework, there is no a problem to have multiple implementations of one interface. It will be not an issue if between the interface and final implementation will be an abstract class.

There are two ways how to solve the conflict in this case:

• Use @Qualifier and load all implementations to choose one in runtime
• Use one of @Condition and load one implementation which depends on some condition

In the first case it will be something like this

@Component("authoringEventIT")
public class AuthoringEventIT extends AbstractAuthoringEvent { //code }

@Autowired
@Qualifier("authoringEventIT")
private AuthoringEvent authoringEventIT;