3.7 Bean Factories

In many cases, you may want to make available as a bean a class that is not part of your codebase such as those provided by third-party libraries. In this case, you cannot annotate the already compiled class. Instead, you should implement a @Factory.

A factory is a class annotated with the Factory annotation that provides 1 or more methods annotated with a bean scope annotation. Which annotation you use depends on what scope you want the bean to be in. See the section on bean scopes for more information.

The return types of methods annotated with a bean scope annotation are the bean types. This is best illustrated by an example:

@Singleton
class CrankShaft {
}
class V8Engine implements Engine {
    private final int cylinders = 8;
    private final CrankShaft crankShaft;
    public V8Engine(CrankShaft crankShaft) {
        this.crankShaft = crankShaft;
    }
    public String start() {
        return "Starting V8";
    }
}
@Factory
class EngineFactory {
    @Singleton
    Engine v8Engine(CrankShaft crankShaft) {
        return new V8Engine(crankShaft);
    }
}

@Singleton
class CrankShaft {
}
class V8Engine implements Engine {
    final int cylinders = 8
    final CrankShaft crankShaft
    V8Engine(CrankShaft crankShaft) {
        this.crankShaft = crankShaft
    }
    String start() {
        "Starting V8"
    }
}
@Factory
class EngineFactory {
    @Singleton
    Engine v8Engine(CrankShaft crankShaft) {
        new V8Engine(crankShaft)
    }
}

@Singleton
internal class CrankShaft
internal class V8Engine(private val crankShaft: CrankShaft) : Engine {
    private val cylinders = 8
    override fun start(): String {
        return "Starting V8"
    }
}
@Factory
internal class EngineFactory {
    @Singleton
    fun v8Engine(crankShaft: CrankShaft): Engine {
        return V8Engine(crankShaft)
    }
}

In this case, the V8Engine is built by the EngineFactory class’ v8Engine method. Note that you can inject parameters into the method and these parameters will be resolved as beans. The resulting V8Engine bean will be a singleton.

A factory can have multiple methods annotated with bean scope annotations, each one returning a distinct bean type.

Nullability

Factory methods can return null to allow for beans to be created conditionally. The use of @Requires should always be the preferred method to conditionally create beans and returning null from a factory method should only be done if using @Requires is not possible.

For example:

public interface Engine {
    Integer getCylinders();
}
@EachProperty("engines")
public class EngineConfiguration implements Toggleable {
    private boolean enabled = true;
    private Integer cylinders;
    @NotNull
    public Integer getCylinders() {
        return cylinders;
    }
    public void setCylinders(Integer cylinders) {
        this.cylinders = cylinders;
    }
    @Override
    public boolean isEnabled() {
        return enabled;
    }
    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }
}
@Factory
public class EngineFactory {
    @EachBean(EngineConfiguration.class)
    public Engine buildEngine(EngineConfiguration engineConfiguration) {
        if (engineConfiguration.isEnabled()) {
            return engineConfiguration::getCylinders;
        } else {
            return null;
        }
    }
}

interface Engine {
    Integer getCylinders()
}
@EachProperty("engines")
class EngineConfiguration implements Toggleable {
    boolean enabled = true
    @NotNull
    Integer cylinders
}
@Factory
class EngineFactory {
    @EachBean(EngineConfiguration)
    Engine buildEngine(EngineConfiguration engineConfiguration) {
        if (engineConfiguration.enabled) {
            (Engine){ -> engineConfiguration.cylinders }
        } else {
            null
        }
    }
}

interface Engine {
    fun getCylinders(): Int
}
@EachProperty("engines")
class EngineConfiguration : Toggleable {
    val enabled = true
    @NotNull
    val cylinders: Int? = null
    override fun isEnabled(): Boolean {
        return enabled
    }
}
@Factory
class EngineFactory {
    @EachBean(EngineConfiguration::class)
    fun buildEngine(engineConfiguration: EngineConfiguration): Engine? {
        return if (engineConfiguration.isEnabled) {
            object : Engine {
                override fun getCylinders(): Int {
                    return engineConfiguration.cylinders!!
                }
            }
        } else {
            null
        }
    }
}