Spring Autowiring not working for Abstract classes

Question

I have a project where I have an interface, an Abstract class implementing the same interface and then a set of concrete classes which implement this interface and extend the Abstract Class.

public interface Invoice
{
   void process();
}

@component
public abstract class AbstractInvoice(){

    @Resource
    protected Writer writer;

    protected validateInvoice(){
        //some implementation
    }
}

@Component
public Class TypeAInvoice() extends AbstractInvoice implements Invoice{

    @Override
    public void process(){
        //... some code
        writer.write();
    }
}

public Interface Writer(){
    public void write();
}

@Component
public class CDWriter implements Writer{
    @Override 
    public void write() { /* implementation.....*/}
}

Spring file has a component scan for the package.

<context:annotation-config>
<context:component-scan base-package="com.xyz" />

I am using a factory to get an instance of TypeAInvoice invoice Now calling invoice.process() gets a NPE when getting to write.write()

I am not sure what am I missing here. I tried to see the component scan and scope and could not find anything conceptually wrong.

Remove `@component` annotation from `AbstractInvoice` and try. — Ajinkya, Jun 30 '12 at 09:40

score 5 · Accepted Answer · answered Jun 30 '12 at 09:47

I am using a factory to get an instance of TypeAInvoice invoice

Depending on what your Factory does, this may be the problem. If the Factory creates a new TypeAInvoice, Spring wiring doesn't apply. You have to query the Spring context for the Bean. One way (though not very pretty) is to use ContextLoader:

return ContextLoader.getCurrentWebApplicationContext().getBean(TypeAInvoice.class)

I'd say static Factories and Spring don't go to well together. Spring stands for the Inversion of Control pattern, while Factories stand for the Service Locator pattern. I'd suggest that you get rid of your factories and autowire your Spring Beans.

score 0 · Answer 2 · answered Jun 30 '12 at 09:48

Everything is good, except for the fact you use a factory to get the TypeAInvoice. If you create it like TypeAInvoice typer = new TypeAInvoice() then spring knows nothing of it, the Writer is not autowired, there for you get the NullPointerException. You should get the bean from the spring application context.

score -1 · Answer 3 · answered Mar 09 '18 at 23:11

In my case, inside a Spring4 Application, i had to use a classic Abstract Factory Pattern(for which i took the idea from - http://java-design-patterns.com/patterns/abstract-factory/) to create instances each and every time there was a operation to be done.So my code was to be designed like:

public abstract class EO {
    @Autowired
    protected SmsNotificationService smsNotificationService;
    @Autowired
    protected SendEmailService sendEmailService;
    ...
    protected abstract void executeOperation(GenericMessage gMessage);
}

public final class OperationsExecutor {
    public enum OperationsType {
        ENROLL, CAMPAIGN
    }

    private OperationsExecutor() {
    }

    public static Object delegateOperation(OperationsType type, Object obj) 
    {
        switch(type) {
            case ENROLL:
                if (obj == null) {
                    return new EnrollOperation();
                }
                return EnrollOperation.validateRequestParams(obj);
            case CAMPAIGN:
                if (obj == null) {
                    return new CampaignOperation();
                }
                return CampaignOperation.validateRequestParams(obj);
            default:
                throw new IllegalArgumentException("OperationsType not supported.");
        }
    }
}

@Configurable(dependencyCheck = true)
public class CampaignOperation extends EO {
    @Override
    public void executeOperation(GenericMessage genericMessage) {
        LOGGER.info("This is CAMPAIGN Operation: " + genericMessage);
    }
}

Initially to inject the dependencies in the abstract class I tried all stereotype annotations like @Component, @Service etc but even though Spring context file had ComponentScanning for the entire package, but somehow while creating instances of Subclasses like CampaignOperation, the Super Abstract class EO was having null for its properties as spring was unable to recognize and inject its dependencies.After much trial and error I used this **@Configurable(dependencyCheck = true)** annotation and finally Spring was able to inject the dependencies and I was able to use the properties in the subclass without cluttering them with too many properties.

<context:annotation-config />
<context:component-scan base-package="com.xyz" />

I also tried these other references to find a solution:

Please try using **@Configurable(dependencyCheck = true)** and update this post, I might try helping you if you face any problems.

So precisely my point here is you don't need to get a bean from spring context all the time.

... I'm not sure with whom you're communication but it appears you think you're in your own question.... if so...write a new question and link to current question if needed, but ... now it looks confusing and triggers triage review.. unnecessarily, and that's not what you want as I can see from the effort you put into it. In summary, create your-own question and delete the answer here or modify your answer such that it doens't look like a question. — ZF007, Mar 10 '18 at 00:06

Spring Autowiring not working for Abstract classes

3 Answers3

Linked