1. Introduction
In this tutorial, we’ll give a brief introduction to AutoFactory, from by Google.
This is a source-level code generator that helps generate factories.
2. Maven Setup
Before we begin, let’s add the following dependency to the pom.xml:
<dependency>
<groupId>com.google.auto.factory</groupId>
<artifactId>auto-factory</artifactId>
<version>1.0-beta5</version>
</dependency>
The latest version can be found here.
3. Quickstart
Let’s now take a quick look at what AutoFactory can do and create a simple Phone class.
So, when we annotate the Phone class with @AutoFactory and its constructor parameter with @Provided, we get:
@AutoFactory
public class Phone {
private final Camera camera;
private final String otherParts;
PhoneAssembler(@Provided Camera camera, String otherParts) {
this.camera = camera;
this.otherParts = otherParts;
}
//...
}
We only used two annotations: @AutoFactory and @Provided. When we need a factory generated for our class, we can annotate it with @AutoFactory, whereas @Provided applies to constructor parameters of this class, and it means that the annotated parameter should be provided by an injected Provider.
In the snippet above, we expect the Camera to be provided by any camera producer and AutoFactory will help generate the following code:
@Generated("com.google.auto.factory.processor.AutoFactoryProcessor")
public final class PhoneFactory {
private final Provider<Camera> cameraProvider;
@Inject
PhoneAssemblerFactory(Provider<Camera> cameraProvider) {
this.cameraProvider = checkNotNull(cameraProvider, 1);
}
PhoneAssembler create(String otherParts) {
return new PhoneAssembler(
checkNotNull(cameraProvider.get(), 1),
checkNotNull(otherParts, 2));
}
// ...
}
Now we have a PhoneFactory generated automatically by AutoFactory at compile time, and we can use it to produce phone instances:
PhoneFactory phoneFactory = new PhoneFactory(
() -> new Camera("Unknown", "XXX"));
Phone simplePhone = phoneFactory.create("other parts");
The @AutoFactory annotation can be applied to constructors as well:
public class ClassicPhone {
private final String dialpad;
private final String ringer;
private String otherParts;
@AutoFactory
public ClassicPhone(
@Provided String dialpad, @Provided String ringer) {
this.dialpad = dialpad;
this.ringer = ringer;
}
@AutoFactory
public ClassicPhone(String otherParts) {
this("defaultDialPad", "defaultRinger");
this.otherParts = otherParts;
}
//...
}
In the snippet above, we applied @AutoFactory to both constructors. AutoFactory will simply generate two creation methods for us accordingly:
@Generated(value = "com.google.auto.factory.processor.AutoFactoryProcessor")
public final class ClassicPhoneFactory {
private final Provider<String> java_lang_StringProvider;
@Inject
public ClassicPhoneFactory(Provider<String> java_lang_StringProvider) {
this.java_lang_StringProvider =
checkNotNull(java_lang_StringProvider, 1);
}
public ClassicPhone create() {
return new ClassicPhone(
checkNotNull(java_lang_StringProvider.get(), 1),
checkNotNull(java_lang_StringProvider.get(), 2));
}
public ClassicPhone create(String otherParts) {
return new ClassicPhone(checkNotNull(otherParts, 1));
}
//...
}
AutoFactory also supports parameters annotated with @Provided, but only for JSR-330 annotations.
For example, if we want the cameraProvider to be “Sony”, we can change the Phone class to:
@AutoFactory
public class Phone {
PhoneAssembler(
@Provided @Named("Sony") Camera camera, String otherParts) {
this.camera = camera;
this.otherParts = otherParts;
}
//...
}
AutoFactory will retain the @Named @Qualifier so that we can make use of it, for example, when using Dependency Injection frameworks:
@Generated("com.google.auto.factory.processor.AutoFactoryProcessor")
public final class PhoneFactory {
private final Provider<Camera> cameraProvider;
@Inject
PhoneAssemblerFactory(@Named("Sony") Provider<Camera> cameraProvider) {
this.cameraProvider = checkNotNull(cameraProvider, 1);
}
//...
}
4. Customized Code Generation
There are several attributes we can use with the @AutoFactory annotation to customize the generated code.
4.1. Custom Class Name
The name of the generated factory class can be set with className:
@AutoFactory(className = "SamsungFactory")
public class SmartPhone {
//...
}
With the configuration above, we’ll create a class named SamsungFactory:
@Generated("com.google.auto.factory.processor.AutoFactoryProcessor")
public final class SamsungFactory {
//...
}
4.2. non-final Factories
Note that the generated factory class is marked final by default, so we can alter this behavior by setting the allowSubclasses attribute to false:
@AutoFactory(
className = "SamsungFactory",
allowSubclasses = true)
public class SmartPhone {
//...
}
Now we have:
@Generated("com.google.auto.factory.processor.AutoFactoryProcessor")
public class SamsungFactory {
//...
}
4.3. More Capabilities
Additionally, we can specify a list of interfaces for the generated factory to implement using the “implementing” parameter.
Here we need the SamsungFactory to produce smartphones with customizable storage:
public interface CustomStorage {
SmartPhone customROMInGB(int romSize);
}
Note that methods in the interface should return instances of the base class SmartPhone.
Then, to generate a factory class with the interface above implemented, AutoFactory requires relevant constructors in the base class:
@AutoFactory(
className = "SamsungFactory",
allowSubclasses = true,
implementing = CustomStorage.class)
public class SmartPhone {
public SmartPhone(int romSize){
//...
}
//...
}
Thus, AutoFactory will generate the following code:
@Generated("com.google.auto.factory.processor.AutoFactoryProcessor")
public class SamsungFactory implements CustomStorage {
//...
public SmartPhone create(int romSize) {
return new SmartPhone(romSize);
}
@Override
public SmartPhone customROMInGB(int romSize) {
return create(romSize);
}
}
4.4. Factories with Extensions
Since AutoFactory can generate interface implementations, it’s natural to expect it to be able to extend classes as well and this is possible indeed:
public abstract class AbstractFactory {
abstract CustomPhone newInstance(String brand);
}
@AutoFactory(extending = AbstractFactory.class)
public class CustomPhone {
private final String brand;
public CustomPhone(String brand) {
this.brand = brand;
}
}
Here, we extended the AbstractFactory class using extending. Also, we should note that each abstract method in the base abstract class (AbstractFactory) should have a corresponding constructor in the concrete class (CustomPhone).
Finally, we can see the following generated code:
@Generated("com.google.auto.factory.processor.AutoFactoryProcessor")
public final class CustomPhoneFactory extends AbstractFactory {
@Inject
public CustomPhoneFactory() {
}
public CustomPhone create(String brand) {
return new CustomPhone(checkNotNull(brand, 1));
}
@Override
public CustomPhone newInstance(String brand) {
return create(brand);
}
//...
}
We can see that AutoFactory is smart enough to make use of the constructor to implement the corresponding abstract method – great features like this in AutoFactory surely will save us lots of time and code.
5. AutoFactory with Guice
As we mentioned earlier in this article, AutoFactory supports JSR-330 annotations, so we can integrate existing dependency injection framework with it.
First, let’s add Guice to the pom.xml:
<dependency>
<groupId>com.google.inject</groupId>
<artifactId>guice</artifactId>
<version>4.2.0</version>
</dependency>
The latest version of Guice can be found here.
Now, we’ll demonstrate how well AutoFactory integrates with Guice.
As we expect “Sony” to be the camera provider, we need to inject a SonyCameraProvider to PhoneFactory‘s constructor:
@Generated("com.google.auto.factory.processor.AutoFactoryProcessor")
public final class PhoneFactory {
private final Provider<Camera> cameraProvider;
@Inject
public PhoneFactory(@Named("Sony") Provider<Camera> cameraProvider) {
this.cameraProvider = checkNotNull(cameraProvider, 1);
}
//...
}
Finally, we’ll make the binding in a Guice module:
public class SonyCameraModule extends AbstractModule {
private static int SONY_CAMERA_SERIAL = 1;
@Named("Sony")
@Provides
Camera cameraProvider() {
return new Camera(
"Sony", String.format("%03d", SONY_CAMERA_SERIAL++));
}
}
And we set the camera provider annotated with @Named(“Sony”) in SonyCameraModule to match PhoneFactory‘s constructor parameter.
Now we can see that Guice is managing dependency injection for our generated factory:
Injector injector = Guice.createInjector(new SonyCameraModule());
PhoneFactory injectedFactory = injector.getInstance(PhoneFactory.class);
Phone xperia = injectedFactory.create("Xperia");
6. Under the Hood
All annotations provided by AutoFactory are processed in the compilation stage, as we have explained in detail in the article: how the source-level annotation processing works.
7. Conclusion
In this article, we’ve introduced how to use AutoFactory, and how to integrate it with Guice – writing factories can be repetitive and error-prone – code generation tools like AutoFactory and AutoValue can save us lots of time and free us from subtle bugs.
As always, the full implementation of the code samples can be found over on Github.