Strategy within Spring boot

Make your StrategyFactory another Spring bean, and inject all the strategies in the factory:

@Component
public class StrategyFactory {
    private final List<Strategy> strategies;

    @Autowired
    public StrategyFactory(List<Strategy> strategies) {
        this.strategies = strategies;
    }

    public Strategy getStrategy(String strategyName) {
        // iterate through the strategies to find the right one, and return it.
    }
}

I usually use an enum rather than a String to identify the stratehy, and I make each Strategy return the enum value that it handles, so the iteration can be as simple as

return strategies.stream().filter(strategy -> strategy.getType() == type).findAny().orElseThrow(
    () -> new IllegalStateException("No strategy found for type " + type));

Of course, you can also store the strategies in a Map inside the constructor, to make the lookup O(1).

All the previous answers are using a pretty straight forward usage of spring DI. However it's also possible to use ServiceLocatorFactoryBean in order to create a factory without having to specify any bean in the factory. First define a interface for your factory:

public interface MyFactory {
    Strategy get(String type);
}

// Could be an abstract class
public interface Strategy {
    void doStuff();
}

Then in your application:

@Configuration
public class AppConfiguration {
    @Autowired
    private BeanFactory beanFactory;

    public ServiceLocatorFactoryBean myFactoryLocator() {
        final ServiceLocatorFactoryBean locator = new ServiceLocatorFactoryBean();
        locator.setServiceLocatorInterface(MyFactory.class);
        locator.setBeanFactory(beanFactory);
        return locator;
    }

    @Bean
    public MyFactory myFactory() {
        final ServiceLocatorFactoryBean locator = myFactoryLocator();
        locator.afterPropertiesSet();
        return (MyFactory) locator.getObject();
    }
}

Now you can define bean (using annotation @Service, @Component or @Bean) that implements/extends and they are automatically registered into the MyFactory bean and can be created with:

myFactory.get("beanName");

The best part is you can register the Strategy bean as lazy and with different scopes.

I would suggest you to make your StrategyFactory a bean and inject into it a Map<String, Strategy>. Spring fill it with the name of the strategy bean as a key and a value will be a strategy itself. Then all you'll need to do is to call get on that Map.

Here is an example:

@SpringBootApplication
public class So44761709Application {

    public static void main(String[] args) {
        SpringApplication.run(So44761709Application.class, args);
    }

    public interface Strategy { }

    @Component
    public static class DependencyA {}
    @Component
    public static class DependencyB {}

    @Component("StrategyA")
    public static class StrategyA implements Strategy {
        private DependencyA depA;
        private DependencyB depB;
        @Autowired
        public StrategyA(DependencyA depA, DependencyB depB) {
            this.depA = depA;
            this.depB = depB;
        }
    }

    @Component("StrategyB")
    public class StrategyB implements Strategy {
        private DependencyA depA;
        private DependencyB depB;
        @Autowired
        public StrategyB(DependencyA depA, DependencyB depB) {
            this.depA = depA;
            this.depB = depB;
        }
    }

    @Component
    public class StrategyFactory {
        @Autowired
        private Map<String, Strategy> strategies;

        public Strategy getStrategy(String strategyName) {
            return strategies.get(strategyName);
        }
    }

    @Bean
    CommandLineRunner run(StrategyFactory strategyFactory) {
        return args -> {
            System.out.println(strategyFactory.getStrategy("StrategyB").getClass().getSimpleName());
            System.out.println(strategyFactory.getStrategy("StrategyA").getClass().getSimpleName());
        };
    }
}

Prints:

StrategyB
StrategyA