Inject Spring Boot Service Into Non-Managed Class

I have a set of classes that all extend from my ReportConfig abstract class. Once created, they are currently immutable and not managed by Spring.

However, I'm finding that sometimes I need to perform an action that requires the use of a particular service, but I'm struggling to find the best way to inject these services into my non-managed ReportConfig instances. See below:

@Service
public class ReportService() {

    @Autowired
    private SchemaService schemaService;

    @Autowired
    private ExecutionService executionService;

    @Autowired
    private ReportConfigFactory reportConfigFactory;

    public Result executeReport(ReportRequest request) {

        ReportConfig reportConfig = reportConfigFactory.getReportConfig(request);

        reportConfig.validateAgainstSchema(schemaService.getSchemaForDataset(reportConfig.getDataset()));

        executionService.execute(reportConfig.getQuery());

}

Now I have no issue with the dataService.execute() line, but I do have an issue with the reportConfig.validateAgainstSchema() line and I feel an alternative would be something like:

reportConfig.validateAgainstSchema(schemaService);

But I feel that maybe represents tight coupling.

I'm imagining there's also a way to inject SchemaService straight into ReportConfigs, but not sure if this defeats the object...

Keen to hear your thoughts.

Thanks

From what I understood from the current design of your application given in question and I am guessing the functionality and thinking about an alternative design,

reportConfig.validateAgainstSchema(schemaService.getSchemaForDataset(reportConfig.getDataset()));

What you can think of is, if reportconfig is the right place to do validateAgainstSchema if not think about changing it.
Is schemaService the right place to do validateAgainstSchema(I think not) if that is also not the right place to do it, then create a SchemaValidator or something similar.
This is something that I could think of with the information you have given me.

If validateAgainstSchema is not overridden by any child classes of ReportConfig and possibility is very rare then you should definitely think of moving it to a different class. The reason I say this is that if the schema changes then you should not have to change the reportConfig class

If its overridden and there are multiple implementations then one way would be to use a validator factory to get the validator and do validation. I don't even know if this suits your use case but this is all I can come up with the information in the question.
Hope it helps you in someway.

Why do you have to inject services into config classes ? Could you just not pass what config need directly ?

Alternatively if you must you can use setter based injection to autowire the service into ReportConfig abstract class or you can use method injection.

Something like

Setter based Injection

public abstract class ReportConfig {

   protected SchemaService schemaService;
   
   protected final setSchemaService(SchemaService schemaService) {
    this.schemaService = schemaService;
   }  
    
}

Method Injection

public class BeanUtility implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    protected SchemaService getSchemaService() {
        return this.applicationContext.getBean("schemaService", SchemaService.class);
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

Your logical is a bit strange.
The correct is another service receive ReportConfig. You doing the opposite.

You can work with bean inside another object not spring managed but you need to recreate it.

YourService container = (YourService) context.getBean("yourService");
container.load();

But it's wrong. The right way is change your logical. Create a generic service with rules to specific reportConfig. Autowire your service and pass your report config and work with that specific data inside the service. (sry my english)

You could think of wrapping your services in static holder classes

public class SchemaServiceHolder {

   private static final SchemaServiceHolder INSTANCE = new SchemaServiceHolder();

   @Autowired
   private SchemaService schemaService;

   private SchemaServiceHolder () {
   }

   public static SchemaServiceHolder instance() {
      return INSTANCE;
   }

   public SchemaService getSchemaService() {
      return schemaService;
   }
}

You then need to create a bean of this type so Spring can inject the service into the singleton SchemaServiceHolder.INSTANCE

@Configuration
public class AppConfig {
   @Bean
   public SchemaServiceHolder schemaServiceHolder () {
      return SchemaServiceHolder.instance();
   }
}

And finally, your objects can reference the schemaService statically

SchemaService schemaService = SchemaServiceHolder.instance().getSchemaService();

The simplest solution in your case to " also a way to inject SchemaService straight into ReportConfigs, but not sure if this defeats the object..." is to pass the object to the factory.

So basically this line reportConfigFactory.getReportConfig(request);
would be changed to this

reportConfigFactory.getReportConfig(request, schemaService);

It is totally fine to pass the spring managed bean in a constructor of a non managed spring class. In your case is not the constructor directly but to a factory method.