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 import com.mycila.inject.jsr250.Jsr250Injector;
54
55
56
57
58
59
60
61
62
63 public class GuiceComponentProvider implements ComponentProvider {
64
65 private static Logger logger = LoggerFactory.getLogger(GuiceComponentProvider.class);
66
67 @Inject
68 private Jsr250Injector injector;
69 private ObjectManufacturer manufacturer;
70 private final Map<Class<?>, Class<?>> typeMappings;
71 private final GuiceComponentProvider parentComponentProvider;
72
73 public GuiceComponentProvider(Map<Class<?>, Class<?>> typeMappings, GuiceComponentProvider parentComponentProvider) {
74 this.parentComponentProvider = parentComponentProvider;
75 this.typeMappings = typeMappings;
76 }
77
78 @Override
79 public <T> Class<? extends T> getImplementation(Class<T> type) {
80 Class<?> implementation = typeMappings.get(type);
81 if (implementation == null) {
82 if (parentComponentProvider != null) {
83 return parentComponentProvider.getImplementation(type);
84 }
85 return type;
86 }
87 if (ComponentFactory.class.isAssignableFrom(implementation)) {
88 return type;
89 }
90 return (Class<? extends T>) implementation;
91 }
92
93 @Override
94 @Deprecated
95 public <T> T getSingleton(Class<T> type) {
96 return getComponent(type);
97 }
98
99 @Override
100 public <T> T getComponent(Class<T> type) throws NoSuchComponentException{
101 if (!GuiceUtils.hasExplicitBindingFor(injector, type)) {
102 throw new NoSuchComponentException("No component configuration for type [" + type.getName() + "] found. Please add a configuration to your module descriptor.");
103 }
104 return injector.getInstance(type);
105 }
106
107 @Override
108 public <T> T newInstance(Class<T> type, Object... parameters) {
109 return newInstanceWithParameterResolvers(type, new CandidateParameterResolver(parameters));
110 }
111
112 @Override
113 public <T> T newInstanceWithParameterResolvers(Class<T> type, ParameterResolver... parameterResolvers) {
114 if (this.manufacturer == null) {
115 this.manufacturer = new ObjectManufacturer();
116 }
117 Class<? extends T> implementation = getImplementation(type);
118 parameterResolvers = concat(parameterResolvers, new GuiceParameterResolver(injector));
119 T instance = (T) manufacturer.newInstance(implementation, parameterResolvers);
120 injectMembers(instance);
121 return instance;
122 }
123
124 private ParameterResolver[] concat(ParameterResolver[] array, ParameterResolver extra) {
125 ParameterResolver[] newArray = Arrays.copyOf(array, array.length + 1);
126 newArray[array.length] = extra;
127 return newArray;
128 }
129
130 public Injector getInjector() {
131 return injector;
132 }
133
134 public <T> Provider<T> getProvider(Class<T> type) {
135 if (!GuiceUtils.hasExplicitBindingFor(injector, type)) {
136 return null;
137 }
138 return injector.getProvider(type);
139 }
140
141 public void injectMembers(Object instance) {
142 injector.injectMembers(instance);
143 }
144
145 public void destroy() {
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160 }
161
162 @Override
163 public GuiceComponentProvider getParent() {
164 return parentComponentProvider;
165 }
166 }