DI：依存性注入ライブラリを自分で作ろう（短板）

DI は便利だけど、@Injectはどこに付けたらいい？どの場合に付けたらいい？@Singletonは？
それから、うまく行かなかった場合は調査するの大変？
Dependency Injection はブラックボックスにみえるかもしれないけどやっている事はシンプル。
ステップ・バイ・ステップ、依存性注入ライブラリをどうやって作るかをみましょう。

Transcript

1. DI：依存性注入ライブラリを 自分で作ろう Benoît Quenaudon @oldergod
2. public class VisitHandler { private final Counter counter; private final Logger logger; public VisitHandler(Counter counter, Logger logger) { this.counter = counter; this.logger = logger; } public void visit() { counter.increment(); logger.log("Visits increased: " + counter.getCount()); } }
3. public class Counter { private int count; void increment() { count++; } int getCount() { return count; } } public class Logger { private final PrintStream printStream; public Logger(PrintStream printStream) { this.printStream = printStream; } public void log(String log) { printStream.println(log); } }
4. public static void main(String... args) { Counter counter = new Counter(); PrintStream printStream = System.out; Logger logger = new Logger(printStream); VisitHandler visitHandler = new VisitHandler(counter, logger); visitHandler.visit(); }
5. public static void main(String... args) { ObjectGraph objectGraph = buildObjectGraph(); VisitHandler visitHandler = objectGraph.get(VisitHandler.class); visitHandler.visit(); }
6. public class ObjectGraph { public <T> T get(Class<T> key) { throw new UnsupportedOperationException("Not implemented"); } }
7. public interface Factory<T> { T get(Linker linker); } public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { return (Factory<T>) factories.get(key); } }
8. public interface Factory<T> { T get(Linker linker); } public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { return (Factory<T>) factories.get(key); } }
9. public interface Factory<T> { T get(Linker linker); } public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { return (Factory<T>) factories.get(key); } }
10. public interface Factory<T> { T get(Linker linker); } public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { return (Factory<T>) factories.get(key); } }
11. public interface Factory<T> { T get(Linker linker); } public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { return (Factory<T>) factories.get(key); } }
12. public class ObjectGraph { private final Linker linker; public ObjectGraph(Linker linker) { this.linker = linker; } public <T> T get(Class<T> key) { Factory<T> factory = linker.factoryFor(key); return factory.get(linker); } }
13. public class ObjectGraph { private final Linker linker; public ObjectGraph(Linker linker) { this.linker = linker; } public <T> T get(Class<T> key) { Factory<T> factory = linker.factoryFor(key); return factory.get(linker); } }
14. public static void main(String... args) { ObjectGraph objectGraph = buildObjectGraph(); VisitHandler visitHandler = objectGraph.get(VisitHandler.class); visitHandler.visit(); }
15. private static ObjectGraph buildObjectGraph() { Linker linker = new Linker(); installFactories(linker); return new ObjectGraph(linker); }
16. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, ...); }
17. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { @Override public VisitHandler get(Linker linker) { Factory<Counter> counterFactory = linker.factoryFor(Counter.class); Factory<Logger> loggerFactory = linker.factoryFor(Logger.class); Counter counter = counterFactory.get(linker); Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); }
18. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { @Override public VisitHandler get(Linker linker) { Factory<Counter> counterFactory = linker.factoryFor(Counter.class); Factory<Logger> loggerFactory = linker.factoryFor(Logger.class); Counter counter = counterFactory.get(linker); Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); }
19. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { @Override public VisitHandler get(Linker linker) { Factory<Counter> counterFactory = linker.factoryFor(Counter.class); Factory<Logger> loggerFactory = linker.factoryFor(Logger.class); Counter counter = counterFactory.get(linker); Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStreamFactory.get(linker)); } }); linker.install(PrintStream.class, new Factory<PrintStream>() {
20. Factory<Logger> loggerFactory = linker.factoryFor(Logger.class); Counter counter = counterFactory.get(linker); Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStreamFactory.get(linker)); } }); linker.install(PrintStream.class, new Factory<PrintStream>() { @Override public PrintStream get(Linker linker) { return System.out; } }); linker.install(Counter.class, new Factory<Counter>() {
21. Factory<Logger> loggerFactory = linker.factoryFor(Logger.class); Counter counter = counterFactory.get(linker); Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStreamFactory.get(linker)); } }); linker.install(PrintStream.class, new Factory<PrintStream>() { @Override public PrintStream get(Linker linker) { return System.out; } }); linker.install(Counter.class, new Factory<Counter>() {
22. Factory<Logger> loggerFactory = linker.factoryFor(Logger.class); Counter counter = counterFactory.get(linker); Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStreamFactory.get(linker)); } }); linker.install(PrintStream.class, new Factory<PrintStream>() { @Override public PrintStream get(Linker linker) { return System.out; } }); linker.install(Counter.class, new Factory<Counter>() {
23. linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStreamFactory.get(linker)); } }); linker.install(PrintStream.class, new Factory<PrintStream>() { @Override public PrintStream get(Linker linker) { return System.out; } }); linker.install(Counter.class, new Factory<Counter>() { @Override public Counter get(Linker linker) { return new Counter(); } }); }
24. linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStreamFactory.get(linker)); } }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, new Factory<Counter>() { @Override public Counter get(Linker linker) { return new Counter(); } }); }
25. public class ValueFactory<T> implements Factory<T> { public static <T> Factory<T> of(T instance) { return new ValueFactory<>(instance); } private final T value; public ValueFactory(T value) { this.value = value; } @Override public T get(Linker linker) { return value; } }
26. Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStreamFactory.get(linker)); } }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, new Factory<Counter>() { @Override public Counter get(Linker linker) { return new Counter(); } }); }
27. Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStreamFactory.get(linker)); } }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, new Factory<Counter>() { @Override public Counter get(Linker linker) { return new Counter(); } }); }
28. Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStreamFactory.get(linker)); } }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, SingletonFactory.of(new Factory<Counter>() { @Override public Counter get(Linker linker) { return new Counter(); } })); }
29. public class SingletonFactory<T> implements Factory<T> { public static <T> Factory<T> of(Factory<T> factory) { return new SingletonFactory<>(factory); } private final Factory<T> factory; private T instance; public SingletonFactory(Factory<T> factory) { this.factory = factory; } @Override public T get(Linker linker) { if (instance == null) { instance = factory.get(linker); } return instance; } }
30. public class SingletonFactory<T> implements Factory<T> { public static <T> Factory<T> of(Factory<T> factory) { return new SingletonFactory<>(factory); } private final Factory<T> factory; private T instance; public SingletonFactory(Factory<T> factory) { this.factory = factory; } @Override public T get(Linker linker) { if (instance == null) { instance = factory.get(linker); } return instance; } }
31. Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStreamFactory.get(linker)); } }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, SingletonFactory.of(new Factory<Counter>() { @Override public Counter get(Linker linker) { return new Counter(); } })); }
32. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { @Override public VisitHandler get(Linker linker) { Factory<Counter> counterFactory = linker.factoryFor(Counter.class); Factory<Logger> loggerFactory = linker.factoryFor(Logger.class); Counter counter = counterFactory.get(linker); Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStream); } }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, SingletonFactory.of(new Factory<Counter>() { @Override public Counter get(Linker linker) { return new Counter(); } })); }
33. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { System.out.println("Get factory for " + key); return (Factory<T>) factories.get(key); } }
34. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { System.out.println("Get factory for " + key); return (Factory<T>) factories.get(key); } }
35. public static void main(String... args) { ObjectGraph objectGraph = buildObjectGraph(); VisitHandler visitHandler = objectGraph.get(VisitHandler.class); visitHandler.visit(); } Get factory for class VisitHandler Get factory for class Counter Get factory for class Logger Get factory for class java.io.PrintStream Visits increased: 1
36. So far • Instantiation and its order automated
37. Good job ?
38. public static void main(String... args) { ObjectGraph objectGraph = buildObjectGraph(); VisitHandler visitHandler = objectGraph.get(VisitHandler.class); visitHandler.visit(); VisitHandler visitHandler2 = objectGraph.get(VisitHandler.class); visitHandler2.visit(); } Get factory for class VisitHandler Get factory for class Counter Get factory for class Logger Get factory for class java.io.PrintStream Visits increased: 1 Get factory for class VisitHandler Get factory for class Counter Get factory for class Logger Get factory for class java.io.PrintStream Visits increased: 2
39. public interface Factory<T> { T get(Linker linker); }
40. public abstract class Factory<T> { public void link(Linker linker) { } public abstract T get(); }
41. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { return (Factory<T>) factories.get(key); } }
42. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); private final Map<Class<?>, Factory<?>> linkedFactories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { Factory<?> factory = linkedFactories.get(key); if (factory == null) { factory = factories.get(key); factory.link(this); linkedFactories.put(key, factory); } return (Factory<T>) factory; } }
43. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); private final Map<Class<?>, Factory<?>> linkedFactories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { Factory<?> factory = linkedFactories.get(key); if (factory == null) { factory = factories.get(key); factory.link(this); linkedFactories.put(key, factory); } return (Factory<T>) factory; } }
44. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); private final Map<Class<?>, Factory<?>> linkedFactories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { Factory<?> factory = linkedFactories.get(key); if (factory == null) { factory = factories.get(key); factory.link(this); linkedFactories.put(key, factory); } return (Factory<T>) factory; } }
45. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); private final Map<Class<?>, Factory<?>> linkedFactories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { Factory<?> factory = linkedFactories.get(key); if (factory == null) { factory = factories.get(key); factory.link(this); linkedFactories.put(key, factory); } return (Factory<T>) factory; } }
46. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); private final Map<Class<?>, Factory<?>> linkedFactories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { Factory<?> factory = linkedFactories.get(key); if (factory == null) { factory = factories.get(key); factory.link(this); linkedFactories.put(key, factory); } return (Factory<T>) factory; } }
47. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); private final Map<Class<?>, Factory<?>> linkedFactories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { Factory<?> factory = linkedFactories.get(key); if (factory == null) { factory = factories.get(key); factory.link(this); linkedFactories.put(key, factory); } return (Factory<T>) factory; } }
48. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { @Override public VisitHandler get(Linker linker) { Factory<Counter> counterFactory = linker.factoryFor(Counter.class); Factory<Logger> loggerFactory = linker.factoryFor(Logger.class); Counter counter = counterFactory.get(linker); Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStream); } }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, SingletonFactory.of(new Factory<Counter>() { @Override public Counter get(Linker linker) { return new Counter(); } })); }
49. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { @Override public VisitHandler get(Linker linker) { Factory<Counter> counterFactory = linker.factoryFor(Counter.class); Factory<Logger> loggerFactory = linker.factoryFor(Logger.class); Counter counter = counterFactory.get(linker); Logger logger = loggerFactory.get(linker); return new VisitHandler(counter, logger); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker); return new Logger(printStream); } }); linker.install(PrintStream.class, ValueFactory.of(System.out));
50. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { Factory<Logger> loggerFactory; Factory<Counter> counterFactory; @Override public void link(Linker linker) { counterFactory = linker.factoryFor(Counter.class); loggerFactory = linker.factoryFor(Logger.class); } @Override public VisitHandler get() { return new VisitHandler(counterFactory.get(), loggerFactory.get()); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker);
51. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { Factory<Logger> loggerFactory; Factory<Counter> counterFactory; @Override public void link(Linker linker) { counterFactory = linker.factoryFor(Counter.class); loggerFactory = linker.factoryFor(Logger.class); } @Override public VisitHandler get() { return new VisitHandler(counterFactory.get(), loggerFactory.get()); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker);
52. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { Factory<Logger> loggerFactory; Factory<Counter> counterFactory; @Override public void link(Linker linker) { counterFactory = linker.factoryFor(Counter.class); loggerFactory = linker.factoryFor(Logger.class); } @Override public VisitHandler get() { return new VisitHandler(counterFactory.get(), loggerFactory.get()); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker);
53. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { Factory<Logger> loggerFactory; Factory<Counter> counterFactory; @Override public void link(Linker linker) { counterFactory = linker.factoryFor(Counter.class); loggerFactory = linker.factoryFor(Logger.class); } @Override public VisitHandler get() { return new VisitHandler(counterFactory.get(), loggerFactory.get()); } }); linker.install(Logger.class, new Factory<Logger>() { @Override public Logger get(Linker linker) { Factory<PrintStream> printStreamFactory = linker.factoryFor(PrintStream.class); PrintStream printStream = printStreamFactory.get(linker);
54. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); private final Map<Class<?>, Factory<?>> linkedFactories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { System.out.println("Get factory for " + key); Factory<?> factory = linkedFactories.get(key); if (factory == null) { System.out.println("Link factory for " + key); factory = factories.get(key); factory.link(this); linkedFactories.put(key, factory); } return (Factory<T>) factory; } }
55. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); private final Map<Class<?>, Factory<?>> linkedFactories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { System.out.println("Get factory for " + key); Factory<?> factory = linkedFactories.get(key); if (factory == null) { System.out.println("Link factory for " + key); factory = factories.get(key); factory.link(this); linkedFactories.put(key, factory); } return (Factory<T>) factory; } }
56. Get factory for class VisitHandler Link factory for class VisitHandler Get factory for class Counter Link factory for class Counter Get factory for class Logger Link factory for class Logger Get factory for class java.io.PrintStream Link factory for class java.io.PrintStream Visits increased: 1 Get factory for class VisitHandler Visits increased: 2 public static void main(String... args) { ObjectGraph objectGraph = buildObjectGraph(); VisitHandler visitHandler = objectGraph.get(VisitHandler.class); visitHandler.visit(); VisitHandler visitHandler2 = objectGraph.get(VisitHandler.class); visitHandler2.visit(); }
57. So far • Instantiation and its order automated • Caching
58. Good job ?
59. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { Factory<Logger> loggerFactory; Factory<Counter> counterFactory; @Override public void link(Linker linker) { counterFactory = linker.factoryFor(Counter.class); loggerFactory = linker.factoryFor(Logger.class); } @Override public VisitHandler get() { return new VisitHandler(counterFactory.get(), loggerFactory.get()); } }); linker.install(Logger.class, new Factory<Logger>() { Factory<PrintStream> printStreamFactory; @Override public void link(Linker linker) { printStreamFactory = linker.factoryFor(PrintStream.class); } @Override public Logger get() { return new Logger(printStreamFactory.get()); } }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, SingletonFactory.of(new Factory<Counter>() { @Override public Counter get() { return new Counter(); } })); }
60. public class VisitHandler { private final Counter counter; private final Logger logger; @Inject public VisitHandler(Counter counter, Logger logger) { this.counter = counter; this.logger = logger; } public void visit() { counter.increment(); logger.log("Visits increased: " + counter.getCount()); } }
61. public class VisitHandler { private final Counter counter; private final Logger logger; @Inject public VisitHandler(Counter counter, Logger logger) { this.counter = counter; this.logger = logger; } public void visit() { counter.increment(); logger.log("Visits increased: " + counter.getCount()); } }
62. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); private final Map<Class<?>, Factory<?>> linkedFactories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { Factory<?> factory = linkedFactories.get(key); if (factory == null) { factory = factories.get(key); factory.link(this); linkedFactories.put(key, factory); } return (Factory<T>) factory; } }
63. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); private final Map<Class<?>, Factory<?>> linkedFactories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { Factory<?> factory = linkedFactories.get(key); if (factory == null) { factory = factories.get(key); factory.link(this); linkedFactories.put(key, factory); } return (Factory<T>) factory; } }
64. public class Linker { private final Map<Class<?>, Factory<?>> factories = new HashMap<>(); private final Map<Class<?>, Factory<?>> linkedFactories = new HashMap<>(); public <T> void install(Class<T> key, Factory<T> factory) { factories.put(key, factory); } public <T> Factory<T> factoryFor(Class<T> key) { Factory<?> factory = linkedFactories.get(key); if (factory == null) { factory = loadFactory(key); factory.link(this); linkedFactories.put(key, factory); } return (Factory<T>) factory; } }
65. private <T> Factory<?> loadFactory(Class<T> key) { Factory<?> factory = factories.get(key); if (factory != null) { return factory; } Constructor<T> constructor = findAtInjectConstructor(key); if (constructor != null) { factory = new ReflectiveFactory(constructor); if (key.isAnnotationPresent(Singleton.class)) { factory = SingletonFactory.of(factory); } return factory; } throw new IllegalStateException("No factory for " + key); } private <T> Constructor<T> findAtInjectConstructor(Class<T> type) { for (Constructor<?> constructor : type.getConstructors()) { if (constructor.isAnnotationPresent(Inject.class)) { return (Constructor<T>) constructor; } } return null; }
66. private <T> Factory<?> loadFactory(Class<T> key) { Factory<?> factory = factories.get(key); if (factory != null) { return factory; } Constructor<T> constructor = findAtInjectConstructor(key); if (constructor != null) { factory = new ReflectiveFactory(constructor); if (key.isAnnotationPresent(Singleton.class)) { factory = SingletonFactory.of(factory); } return factory; } throw new IllegalStateException("No factory for " + key); } private <T> Constructor<T> findAtInjectConstructor(Class<T> type) { for (Constructor<?> constructor : type.getConstructors()) { if (constructor.isAnnotationPresent(Inject.class)) { return (Constructor<T>) constructor; } } return null; }
67. private <T> Factory<?> loadFactory(Class<T> key) { Factory<?> factory = factories.get(key); if (factory != null) { return factory; } Constructor<T> constructor = findAtInjectConstructor(key); if (constructor != null) { factory = new ReflectiveFactory(constructor); if (key.isAnnotationPresent(Singleton.class)) { factory = SingletonFactory.of(factory); } return factory; } throw new IllegalStateException("No factory for " + key); } private <T> Constructor<T> findAtInjectConstructor(Class<T> type) { for (Constructor<?> constructor : type.getConstructors()) { if (constructor.isAnnotationPresent(Inject.class)) { return (Constructor<T>) constructor; } } return null; }
68. private <T> Factory<?> loadFactory(Class<T> key) { Factory<?> factory = factories.get(key); if (factory != null) { return factory; } Constructor<T> constructor = findAtInjectConstructor(key); if (constructor != null) { factory = new ReflectiveFactory(constructor); if (key.isAnnotationPresent(Singleton.class)) { factory = SingletonFactory.of(factory); } return factory; } throw new IllegalStateException("No factory for " + key); } private <T> Constructor<T> findAtInjectConstructor(Class<T> type) { for (Constructor<?> constructor : type.getConstructors()) { if (constructor.isAnnotationPresent(Inject.class)) { return (Constructor<T>) constructor; } } return null; }
69. private <T> Factory<?> loadFactory(Class<T> key) { Factory<?> factory = factories.get(key); if (factory != null) { return factory; } Constructor<T> constructor = findAtInjectConstructor(key); if (constructor != null) { factory = new ReflectiveFactory(constructor); if (key.isAnnotationPresent(Singleton.class)) { factory = SingletonFactory.of(factory); } return factory; } throw new IllegalStateException("No factory for " + key); } private <T> Constructor<T> findAtInjectConstructor(Class<T> type) { for (Constructor<?> constructor : type.getConstructors()) { if (constructor.isAnnotationPresent(Inject.class)) { return (Constructor<T>) constructor; } } return null; }
70. private <T> Factory<?> loadFactory(Class<T> key) { Factory<?> factory = factories.get(key); if (factory != null) { return factory; } Constructor<T> constructor = findAtInjectConstructor(key); if (constructor != null) { factory = new ReflectiveFactory(constructor); if (key.isAnnotationPresent(Singleton.class)) { factory = SingletonFactory.of(factory); } return factory; } throw new IllegalStateException("No factory for " + key); } private <T> Constructor<T> findAtInjectConstructor(Class<T> type) { for (Constructor<?> constructor : type.getConstructors()) { if (constructor.isAnnotationPresent(Inject.class)) { return (Constructor<T>) constructor; } } return null; }
71. private <T> Factory<?> loadFactory(Class<T> key) { Factory<?> factory = factories.get(key); if (factory != null) { return factory; } Constructor<T> constructor = findAtInjectConstructor(key); if (constructor != null) { factory = new ReflectiveFactory(constructor); if (key.isAnnotationPresent(Singleton.class)) { factory = SingletonFactory.of(factory); } return factory; } throw new IllegalStateException("No factory for " + key); } private <T> Constructor<T> findAtInjectConstructor(Class<T> type) { for (Constructor<?> constructor : type.getConstructors()) { if (constructor.isAnnotationPresent(Inject.class)) { return (Constructor<T>) constructor; } } return null; }
72. public class ReflectiveFactory<T> extends Factory<T> { private final Constructor<T> constructor; private final ArrayList<Factory<?>> factories = new ArrayList<>(); public ReflectiveFactory(Constructor<T> constructor) { this.constructor = constructor; } @Override public void link(Linker linker) { for (Class<?> parameterType : constructor.getParameterTypes()) { factories.add(linker.factoryFor(parameterType)); } } @Override public T get() { Object[] dependencies = new Object[factories.size()]; for (int i = 0; i < dependencies.length; i++) { Factory<?> factory = factories.get(i); dependencies[i] = factory.get(); } try { return constructor.newInstance(dependencies); } catch (Exception e) { throw new RuntimeException(e); } } }
73. public class ReflectiveFactory<T> extends Factory<T> { private final Constructor<T> constructor; private final ArrayList<Factory<?>> factories = new ArrayList<>(); public ReflectiveFactory(Constructor<T> constructor) { this.constructor = constructor; } @Override public void link(Linker linker) { for (Class<?> parameterType : constructor.getParameterTypes()) { factories.add(linker.factoryFor(parameterType)); } } @Override public T get() { Object[] dependencies = new Object[factories.size()]; for (int i = 0; i < dependencies.length; i++) { Factory<?> factory = factories.get(i); dependencies[i] = factory.get(); } try { return constructor.newInstance(dependencies); } catch (Exception e) { throw new RuntimeException(e); } } }
74. public class ReflectiveFactory<T> extends Factory<T> { private final Constructor<T> constructor; private final ArrayList<Factory<?>> factories = new ArrayList<>(); public ReflectiveFactory(Constructor<T> constructor) { this.constructor = constructor; } @Override public void link(Linker linker) { for (Class<?> parameterType : constructor.getParameterTypes()) { factories.add(linker.factoryFor(parameterType)); } } @Override public T get() { Object[] dependencies = new Object[factories.size()]; for (int i = 0; i < dependencies.length; i++) { Factory<?> factory = factories.get(i); dependencies[i] = factory.get(); } try { return constructor.newInstance(dependencies); } catch (Exception e) { throw new RuntimeException(e); } } }
75. public class ReflectiveFactory<T> extends Factory<T> { private final Constructor<T> constructor; private final ArrayList<Factory<?>> factories = new ArrayList<>(); public ReflectiveFactory(Constructor<T> constructor) { this.constructor = constructor; } @Override public void link(Linker linker) { for (Class<?> parameterType : constructor.getParameterTypes()) { factories.add(linker.factoryFor(parameterType)); } } @Override public T get() { Object[] dependencies = new Object[factories.size()]; for (int i = 0; i < dependencies.length; i++) { Factory<?> factory = factories.get(i); dependencies[i] = factory.get(); } try { return constructor.newInstance(dependencies); } catch (Exception e) { throw new RuntimeException(e); } } }
76. public class ReflectiveFactory<T> extends Factory<T> { private final Constructor<T> constructor; private final ArrayList<Factory<?>> factories = new ArrayList<>(); public ReflectiveFactory(Constructor<T> constructor) { this.constructor = constructor; } @Override public void link(Linker linker) { for (Class<?> parameterType : constructor.getParameterTypes()) { factories.add(linker.factoryFor(parameterType)); } } @Override public T get() { Object[] dependencies = new Object[factories.size()]; for (int i = 0; i < dependencies.length; i++) { Factory<?> factory = factories.get(i); dependencies[i] = factory.get(); } try { return constructor.newInstance(dependencies); } catch (Exception e) { throw new RuntimeException(e); } } }
77. public class VisitHandler { @Inject public VisitHandler(Counter counter, Logger logger) { this.counter = counter; this.logger = logger; } } public class Logger { @Inject public Logger(PrintStream printStream) { this.printStream = printStream; } } @Singleton public class Counter { @Inject public Counter() {} }
78. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { Factory<Logger> loggerFactory; Factory<Counter> counterFactory; @Override public void link(Linker linker) { counterFactory = linker.factoryFor(Counter.class); loggerFactory = linker.factoryFor(Logger.class); } @Override public VisitHandler get() { return new VisitHandler(counterFactory.get(), loggerFactory.get()); } }); linker.install(Logger.class, new Factory<Logger>() { Factory<PrintStream> printStreamFactory; @Override public void link(Linker linker) { printStreamFactory = linker.factoryFor(PrintStream.class); } @Override public Logger get() { return new Logger(printStreamFactory.get()); } }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, SingletonFactory.of(new Factory<Counter>() { @Override public Counter get() { return new Counter(); } })); }
79. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { ... }); linker.install(Logger.class, new Factory<Logger>() { ... }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, SingletonFactory.of(new Factory<Counter>() { ... })); }
80. private static void installFactories(Linker linker) { linker.install(Logger.class, new Factory<Logger>() { ... }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, SingletonFactory.of(new Factory<Counter>() { ... })); }
81. private static void installFactories(Linker linker) { linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, SingletonFactory.of(new Factory<Counter>() { ... })); }
82. private static void installFactories(Linker linker) { linker.install(PrintStream.class, ValueFactory.of(System.out)); }
83. private static void installFactories(Linker linker) { linker.install(VisitHandler.class, new Factory<VisitHandler>() { Factory<Logger> loggerFactory; Factory<Counter> counterFactory; @Override public void link(Linker linker) { counterFactory = linker.factoryFor(Counter.class); loggerFactory = linker.factoryFor(Logger.class); } @Override public VisitHandler get() { return new VisitHandler(counterFactory.get(), loggerFactory.get()); } }); linker.install(Logger.class, new Factory<Logger>() { Factory<PrintStream> printStreamFactory; @Override public void link(Linker linker) { printStreamFactory = linker.factoryFor(PrintStream.class); } @Override public Logger get() { return new Logger(printStreamFactory.get()); } }); linker.install(PrintStream.class, ValueFactory.of(System.out)); linker.install(Counter.class, SingletonFactory.of(new Factory<Counter>() { @Override public Counter get() { return new Counter(); } })); } private static void installFactories(Linker linker) { linker.install(PrintStream.class, ValueFactory.of(System.out)); }
84. So far • Instantiation and its order automated • Caching • No boilerplate
86. Good job ?
88. linker.install(VisitHandler.class, new Factory<Logger>() { Factory<PrintStream> printStreamFactory; @Override public void link(Linker linker) { printStreamFactory = linker.factoryFor(PrintStream.class); } @Override public Logger get() { return new Logger(printStreamFactory.get()); } });
89. Annotation Processing
90. public class Logger$$Factory extends Factory<Logger> { Factory<PrintStream> printStreamFactory; @Override public void link(Linker linker) { printStreamFactory = linker.factoryFor(PrintStream.class); } @Override public Logger get() { return new Logger(printStreamFactory.get()); } }
91. public abstract class GeneratedFactory<T> extends Factory<T> { private final boolean singleton; public GeneratedFactory(boolean singleton) { this.singleton = singleton; } } public class Logger$$Factory extends GeneratedFactory<Logger> { public Logger$$Factory() { super(false); } }
92. private <T> Factory<?> loadFactory(Class<T> key) { Factory<?> factory = factories.get(key); if (factory != null) { return factory; } Constructor<T> constructor = findAtInjectConstructor(key); if (constructor != null) { factory = new ReflectiveFactory(constructor); if (key.isAnnotationPresent(Singleton.class)) { factory = SingletonFactory.of(factory); } return factory; } throw new IllegalStateException("No factory for " + key); }
93. public class Linker { private <T> Factory<?> loadFactory(Class<T> key) { Factory<?> factory = factories.get(key); if (factory != null) { return factory; } factory = GeneratedFactory.loadFactory(key); if (factory != null) { return factory; } throw new IllegalStateException("No factory for " + key); } }
94. public class Linker { private <T> Factory<?> loadFactory(Class<T> key) { Factory<?> factory = factories.get(key); if (factory != null) { return factory; } factory = GeneratedFactory.loadFactory(key); if (factory != null) { return factory; } throw new IllegalStateException("No factory for " + key); } }
95. public abstract class GeneratedFactory<T> extends Factory<T> { public static <T> Factory<T> loadFactory(Class<T> key) { String generatedClass = key.getName() + "$$Factory"; try { Class<GeneratedFactory<T>> factoryClass = (Class<GeneratedFactory<T>>) Class.forName(generatedClass); GeneratedFactory<T> factory = factoryClass.newInstance(); if (factory.singleton) { return SingletonFactory.of(factory); } else { return factory; } } catch (Exception e) { System.err.println("Error for " + key); e.printStackTrace(); return null; } } private final boolean singleton; public GeneratedFactory(boolean singleton) { this.singleton = singleton; } }
96. public abstract class GeneratedFactory<T> extends Factory<T> { public static <T> Factory<T> loadFactory(Class<T> key) { String generatedClass = key.getName() + "$$Factory"; try { Class<GeneratedFactory<T>> factoryClass = (Class<GeneratedFactory<T>>) Class.forName(generatedClass); GeneratedFactory<T> factory = factoryClass.newInstance(); if (factory.singleton) { return SingletonFactory.of(factory); } else { return factory; } } catch (Exception e) { System.err.println("Error for " + key); e.printStackTrace(); return null; } } private final boolean singleton; public GeneratedFactory(boolean singleton) { this.singleton = singleton; } }
97. public abstract class GeneratedFactory<T> extends Factory<T> { public static <T> Factory<T> loadFactory(Class<T> key) { String generatedClass = key.getName() + "$$Factory"; try { Class<GeneratedFactory<T>> factoryClass = (Class<GeneratedFactory<T>>) Class.forName(generatedClass); GeneratedFactory<T> factory = factoryClass.newInstance(); if (factory.singleton) { return SingletonFactory.of(factory); } else { return factory; } } catch (Exception e) { System.err.println("Error for " + key); e.printStackTrace(); return null; } } private final boolean singleton; public GeneratedFactory(boolean singleton) { this.singleton = singleton; } }
98. So far • Instantiation and its order automated • Caching • No boilerplate • No reflection
99. BETA
100. Good job ?
101. public class DatabaseManager { private final Database database; @Inject public DatabaseManager(Database database) { this.database = database; } public void updateVisits(int count) { database.execute("UPDATE count_table SET count = " + count); } }
102. public static void main(String... args) { ObjectGraph objectGraph = buildObjectGraph(); DatabaseManager databaseManager = objectGraph.get(DatabaseManager.class); databaseManager.updateVisits(3); } Exception in thread "main" java.lang.IllegalStateException: No factory for interface app.db.Database at injection.Linker.loadFactory(Linker.java:41) at injection.Linker.factoryFor(Linker.java:21) at app.db.DatabaseManager$$Factory.link(DatabaseManager$$Factory.java:17) at injection.factory.SingletonFactory.link(SingletonFactory.java:20) at injection.Linker.factoryFor(Linker.java:22) at injection.ObjectGraph.get(ObjectGraph.java:13) at Main.main(Main.java:11)
103. public static void main(String... args) { ObjectGraph objectGraph = buildObjectGraph(); objectGraph.validate(DatabaseManager.class); DatabaseManager databaseManager = objectGraph.get(DatabaseManager.class); databaseManager.updateVisits(3); } public class ObjectGraph { private final Linker linker; public <T> T get(Class<T> key) { Factory<T> factory = linker.factoryFor(key); return factory.get(); } public <T> void validate(Class<T> key) { linker.factoryFor(key); } }
104. public static void main(String... args) { ObjectGraph objectGraph = buildObjectGraph(); objectGraph.validate(DatabaseManager.class); DatabaseManager databaseManager = objectGraph.get(DatabaseManager.class); databaseManager.updateVisits(3); } public class ObjectGraph { private final Linker linker; public <T> T get(Class<T> key) { Factory<T> factory = linker.factoryFor(key); return factory.get(); } public <T> void validate(Class<T> key) { linker.factoryFor(key); } }
105. static void installFactories(Linker linker) { linker.install(PrintStream.class, ValueFactory.of(System.out)); }
106. public static void main(String... args) { ObjectGraph objectGraph = buildObjectGraph(); objectGraph.validate(DatabaseManager.class); // … } public static void installFactories(Linker linker) { linker.install(PrintStream.class, ValueFactory.of(System.out)); }
107. Annotation Processing
108. public static void main(String... args) { ObjectGraph objectGraph = buildObjectGraph(); objectGraph.validate(DatabaseManager.class); // … } public static void installFactories(Linker linker) { linker.install(PrintStream.class, ValueFactory.of(System.out)); }
109. public class Module { @Provides public Database provideDatabase(DatabaseImpl database) { return database; } @Provides public PrintStream providePrintStream() { return System.out; } }
110. public class Module { @Provides public Database provideDatabase(DatabaseImpl database) { return database; } @Provides public PrintStream providePrintStream() { return System.out; } }
111. @Module public class MainModule { @Provides public Database provideDatabase(DatabaseImpl database) { return database; } @Provides public PrintStream providePrintStream() { return System.out; } }
112. private static ObjectGraph buildObjectGraph() { Linker linker = new Linker(); installFactories(linker); return new ObjectGraph(linker); } private static void installFactories(Linker linker) { linker.install(PrintStream.class, ValueFactory.of(System.out)); }
113. private static ObjectGraph buildObjectGraph(List<Class> moduleClasses) { Linker linker = new Linker(); linker.loadModuleBindings(moduleClasses); return new ObjectGraph(linker); } private static void installFactories(Linker linker) { linker.install(PrintStream.class, ValueFactory.of(System.out)); }
114. public static void main(String... args) { ObjectGraph objectGraph = buildObjectGraph(); objectGraph.validate(DatabaseManager.class); // … }
115. @Module public class MainModule { @Provides public Database provideDatabase(DatabaseImpl database) { return database; } @Provides public PrintStream providePrintStream() { return System.out; } }
116. @Module public class MainModule { @Provides public Database provideDatabase(DatabaseImpl database) { return database; } @Provides public PrintStream providePrintStream() { return System.out; } }
117. @Module(injects = DatabaseManager.class) public class MainModule { @Provides public Database provideDatabase(DatabaseImpl database) { return database; } @Provides public PrintStream providePrintStream() { return System.out; } }
118. So far • Instantiation and its order automated • Caching • No boilerplate • No reflection • Verification at compile time
120. Good job ?
121. So far • Instantiation and its order automated • Caching • No boilerplate • No reflection • Verification at compile time • Scope? • Great performance? • Lazy computation?
123. Fin Slides: goo.gl/nceQmc Benoît Quenaudon @oldergod
124. Reference • DIY: Build Your Own Dependency Injection Library ◦ https://news.realm.io/news/android-pierre-yves-ricau-build-own-dependency-injection/ • Dagger ◦ https://google.github.io/dagger