1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package info.magnolia.objectfactory.guice;
35
36 import info.magnolia.objectfactory.CandidateParameterResolver;
37 import info.magnolia.objectfactory.ComponentFactory;
38 import info.magnolia.objectfactory.ComponentProvider;
39 import info.magnolia.objectfactory.NoSuchComponentException;
40 import info.magnolia.objectfactory.ObjectManufacturer;
41 import info.magnolia.objectfactory.ParameterResolver;
42
43 import java.util.Arrays;
44 import java.util.Map;
45
46 import javax.inject.Inject;
47 import javax.inject.Provider;
48
49 import org.slf4j.Logger;
50 import org.slf4j.LoggerFactory;
51
52 import com.google.inject.Injector;
53
54
55
56
57
58
59
60
61
62 public class GuiceComponentProvider implements ComponentProvider {
63
64 private static Logger logger = LoggerFactory.getLogger(GuiceComponentProvider.class);
65
66 @Inject
67 private Injector injector;
68 private ObjectManufacturer manufacturer;
69 private final Map<Class<?>, Class<?>> typeMappings;
70 private final GuiceComponentProvider parentComponentProvider;
71
72 public GuiceComponentProvider(Map<Class<?>, Class<?>> typeMappings, GuiceComponentProvider parentComponentProvider) {
73 this.parentComponentProvider = parentComponentProvider;
74 this.typeMappings = typeMappings;
75 }
76
77 @Override
78 public <T> Class<? extends T> getImplementation(Class<T> type) {
79 Class<?> implementation = typeMappings.get(type);
80 if (implementation == null) {
81 if (parentComponentProvider != null) {
82 return parentComponentProvider.getImplementation(type);
83 }
84 return type;
85 }
86 if (ComponentFactory.class.isAssignableFrom(implementation)) {
87 return type;
88 }
89 return (Class<? extends T>) implementation;
90 }
91
92 @Override
93 @Deprecated
94 public <T> T getSingleton(Class<T> type) {
95 return getComponent(type);
96 }
97
98 @Override
99 public <T> T getComponent(Class<T> type) throws NoSuchComponentException{
100 if (!GuiceUtils.hasExplicitBindingFor(injector, type)) {
101 throw new NoSuchComponentException("No component configuration for type [" + type.getName() + "] found. Please add a configuration to your module descriptor.");
102 }
103 return injector.getInstance(type);
104 }
105
106 @Override
107 public <T> T newInstance(Class<T> type, Object... parameters) {
108 return newInstanceWithParameterResolvers(type, new CandidateParameterResolver(parameters));
109 }
110
111 @Override
112 public <T> T newInstanceWithParameterResolvers(Class<T> type, ParameterResolver... parameterResolvers) {
113 if (this.manufacturer == null) {
114 this.manufacturer = new ObjectManufacturer();
115 }
116 Class<? extends T> implementation = getImplementation(type);
117 parameterResolvers = concat(parameterResolvers, new GuiceParameterResolver(injector));
118 T instance = (T) manufacturer.newInstance(implementation, parameterResolvers);
119 injectMembers(instance);
120 return instance;
121 }
122
123 private ParameterResolver[] concat(ParameterResolver[] array, ParameterResolver extra) {
124 ParameterResolver[] newArray = Arrays.copyOf(array, array.length + 1);
125 newArray[array.length] = extra;
126 return newArray;
127 }
128
129 public Injector getInjector() {
130 return injector;
131 }
132
133 public <T> Provider<T> getProvider(Class<T> type) {
134 if (!GuiceUtils.hasExplicitBindingFor(injector, type)) {
135 return null;
136 }
137 return injector.getProvider(type);
138 }
139
140 public void injectMembers(Object instance) {
141 injector.injectMembers(instance);
142 }
143
144 public void destroy() {
145
146
147
148
149
150
151
152
153
154 }
155
156 @Override
157 public GuiceComponentProvider getParent() {
158 return parentComponentProvider;
159 }
160 }