title: Autowiring in concrete classes of an abstract class than implements an interface
body: <p>I am using Spring boot and I have the following Task model</p>
  
  <pre><code>public class Task {
      private String name;
      private TaskType type; // ManualTask, AutomatedTask
      private boolean completed;
      //....other fields
  
      //getters and setters
  }
  </code></pre>
  
  <p>A controller</p>
  
  <pre><code>@Controller
  @RequestMapping("/api/task")
  public class TaskController {
  
      @Autowired
      private TaskService taskService;
  
      @GetMapping("/{taskId}/handle")
      public String handle(Model model, @PathVariable("taskId") Long taskId) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
          try {
              Task task = taskService.handle(taskId);
              model.addAttribute("task", task);
          } catch (Exception e) {
              return "errorpage";
          }
          return "successpage";
      }
  }
  </code></pre>
  
  <p>I have an interface</p>
  
  <pre><code>public interface TaskService {
  
      Task findById(Long taskId);
  
      Task handleTask(Long taskId) throws ClassNotFoundException, InstantiationException, IllegalAccessException;
  
  }
  </code></pre>
  
  <p>An abstract class implements the interface:</p>
  
  <pre><code>@Service
  public abstract class TaskServiceImpl implements TaskService {
  
      @Autowired
      private TaskRepository taskRepository;
  
      private static final String PATH_OF_CLASS = "com.task.service.impl";
  
      protected abstract Task doTypeSpecificTask(Long taskId);
  
      @Override
      public Task findById(Long taskId) {
          return taskRepository.findById(taskId).get();
      }
  
      @Override
      public Task handleTask(Long taskId) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
          Task task = findById(taskId);
          TaskServiceImpl service = getHandlerService(task);
          return service.doTypeSpecificTask(taskId);
      }
  
      private TaskServiceImpl getHandlerService(Task task) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
          String serviceClassName = PATH_OF_CLASS.concat(".").concat(task.getTaskType().getName()).concat("Service");
          Class&lt;?&gt; serviceClass = Class.forName(serviceClassName);
          if (!TaskServiceImpl.class.isAssignableFrom(serviceClass)) {
              throw new RuntimeException("Service class " + serviceClassName + " did not implements " + TaskServiceImpl.class.getName());
          }
          Object serviceObject = serviceClass.newInstance();
          TaskServiceImpl service = (TaskServiceImpl) serviceObject;
          return service;
      }
  
  
  }
  </code></pre>
  
  <p>And concrete services that extend the abstract class</p>
  
  <pre><code>@Service
  @Primary
  public class ManualTaskService extends TaskServiceImpl {
  
      @Autowired
      private TaskRepository taskRepository;
  
      @Autowired
      private ManualTaskHandlerService manualTaskHandlerService;
  
      @Override
      protected Task doTypeSpecificTask(Long taskId) {
          Task task = findById(taskId);
          manualTaskHandlerService.handleManualTask(task);
          task.setCompleted(true);
          return taskRepository.save(task);
      }
  }
  
  @Service
  public class AutomatedTaskService extends TaskServiceImpl {
  
      @Autowired
      private TaskRepository taskRepository;
  
      @Autowired
      private AutomatedTaskHandlerService automatedTaskHandlerService;
  
      @Override
      protected Task doTypeSpecificTask(Long taskId) {
          Task task = findById(taskId);
          automatedTaskHandlerService.handleAutomatedTask(task);
          task.setCompleted(true);
          return taskRepository.save(task);
      }
  }
  
  public interface TaskRepository extends JpaRepository&lt;Task, Long&gt; {
  
  }
  </code></pre>
  
  <p>The <code>ManualTaskService</code> or <code>AutomatedTaskService</code> is selected dynamically based on the type of task on runtime.</p>
  
  <p>Now, without the <code>@Primary</code>, I get the following error:</p>
  
  <pre><code>Field taskService in com.test.controller.TaskController required a single bean, but 2 were found:
  - manualTaskService
  - automatedTaskService
  
  Action:
  
  Consider marking one of the beans as @Primary, updating the consumer to accept multiple beans, or using @Qualifier to identify the bean that should be consumed
  </code></pre>
  
  <p>With <code>@Primary</code> set in ManualTaskService, <code>doTypeSpecificTask</code> in ManualTaskService works but in AutomatedTaskService it fails because of <code>automatedTaskHandlerService.handleAutomatedTask(task)</code>. Also calls to taskRepository from AutomatedTaskService fail.</p>
  
  <p>I've tried using <code>@Qualifier</code> as well as defining all <code>@Autowired</code> in the abstract class as protected but nothing works. What am I doing wrong?</p>