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.jcr.node2bean.impl;
35
36 import info.magnolia.jcr.node2bean.Node2BeanTransformer;
37 import info.magnolia.jcr.node2bean.PropertyTypeDescriptor;
38 import info.magnolia.jcr.node2bean.TypeDescriptor;
39 import info.magnolia.jcr.node2bean.TypeMapping;
40 import info.magnolia.objectfactory.Components;
41
42 import java.beans.PropertyDescriptor;
43 import java.lang.reflect.Method;
44 import java.lang.reflect.ParameterizedType;
45 import java.lang.reflect.Type;
46 import java.util.Collection;
47 import java.util.HashMap;
48 import java.util.Map;
49
50 import org.apache.commons.beanutils.PropertyUtils;
51 import org.apache.commons.lang.ArrayUtils;
52 import org.apache.commons.lang.StringUtils;
53 import org.slf4j.Logger;
54 import org.slf4j.LoggerFactory;
55
56
57
58
59 public class TypeMappingImpl implements TypeMapping {
60
61 private static Logger log = LoggerFactory.getLogger(TypeMappingImpl.class);
62
63 private final Map<String, PropertyTypeDescriptor> propertyTypes = new HashMap<String, PropertyTypeDescriptor>();
64 private final Map<Class<?>, TypeDescriptor> types = new HashMap<Class<?>, TypeDescriptor>();
65
66 @Override
67 public PropertyTypeDescriptor getPropertyTypeDescriptor(Class<?> beanClass, String propName) {
68 PropertyTypeDescriptor dscr = null;
69 String key = beanClass.getName() + "." + propName;
70
71 dscr = propertyTypes.get(key);
72
73 if (dscr != null) {
74 return dscr;
75 }
76
77 dscr = new PropertyTypeDescriptor();
78 dscr.setName(propName);
79
80 PropertyDescriptor[] descriptors = PropertyUtils.getPropertyDescriptors(beanClass);
81 for (PropertyDescriptor descriptor : descriptors) {
82 if (descriptor.getName().equals(propName)) {
83
84 Class<?> propertyType = descriptor.getPropertyType();
85 if (propertyType != null) {
86 dscr.setType(getTypeDescriptor(propertyType));
87 }
88
89 dscr.setWriteMethod(descriptor.getWriteMethod());
90
91 int numberOfParameters = dscr.isMap() ? 2 : 1;
92 dscr.setAddMethod(getAddMethod(beanClass, propName, numberOfParameters));
93
94 break;
95 }
96 }
97
98 if (dscr.getType() != null) {
99
100 if (dscr.isMap() || dscr.isCollection()) {
101 Type[] typeArgs = new Type[] {};
102 if (dscr.getWriteMethod() != null) {
103
104 Type[] parameterTypes = dscr.getWriteMethod().getGenericParameterTypes();
105 if (parameterTypes.length > 0) {
106
107 for (Type genericParameterType : parameterTypes) {
108
109 if (genericParameterType instanceof ParameterizedType) {
110 ParameterizedType type = (ParameterizedType) genericParameterType;
111 for (Type t : type.getActualTypeArguments()) {
112 if (t instanceof ParameterizedType) {
113
114
115 typeArgs = (Type[]) ArrayUtils.add(typeArgs, ((ParameterizedType) t).getRawType());
116 } else {
117 typeArgs = (Type[]) ArrayUtils.add(typeArgs, t);
118 }
119 }
120 }
121 }
122 }
123 }
124 if (dscr.getAddMethod() != null && typeArgs.length == 0) {
125
126
127 typeArgs = dscr.getAddMethod().getParameterTypes();
128
129 dscr.setWriteMethod(null);
130 }
131 if (typeArgs.length > 0) {
132
133 if (dscr.isMap()) {
134 dscr.setCollectionKeyType(getTypeDescriptor((Class<?>) typeArgs[0]));
135 dscr.setCollectionEntryType(getTypeDescriptor((Class<?>) typeArgs[1]));
136 } else {
137
138 dscr.setCollectionEntryType(getTypeDescriptor((Class<?>) typeArgs[0]));
139 }
140 }
141 } else if (dscr.isArray()) {
142
143
144 dscr.setCollectionEntryType(getTypeDescriptor(dscr.getType().getType().getComponentType()));
145 }
146 }
147 propertyTypes.put(key, dscr);
148
149 return dscr;
150 }
151
152 @Override
153 public TypeDescriptor getTypeDescriptor(Class<?> beanClass) {
154 TypeDescriptor dscr = types.get(beanClass);
155
156 if(dscr != null){
157 return dscr;
158 }
159 dscr = new TypeDescriptor();
160 dscr.setType(beanClass);
161 dscr.setMap(Map.class.isAssignableFrom(beanClass));
162 dscr.setCollection(Collection.class.isAssignableFrom(beanClass));
163 dscr.setArray(beanClass.isArray());
164 types.put(beanClass, dscr);
165
166 if (!beanClass.isArray() && !beanClass.isPrimitive()) {
167 Node2BeanTransformer transformer = null;
168 try {
169 @SuppressWarnings("unchecked")
170 Class<Node2BeanTransformer> clazz = (Class<Node2BeanTransformer>) Class.forName(beanClass.getName() + "Transformer");
171 transformer = Components.getComponent(clazz);
172 } catch (Exception e) {
173 log.debug("No custom transformer class {}Transformer class found", beanClass.getName());
174 }
175 dscr.setTransformer(transformer);
176 }
177 return dscr;
178 }
179
180
181
182
183
184 public Method getAddMethod(Class<?> type, String name, int numberOfParameters) {
185 name = StringUtils.capitalize(name);
186 Method method = getExactMethod(type, "add" + name, numberOfParameters);
187 if (method == null) {
188 method = getExactMethod(type, "add" + StringUtils.removeEnd(name, "s"), numberOfParameters);
189 }
190
191 if (method == null) {
192 method = getExactMethod(type, "add" + StringUtils.removeEnd(name, "es"), numberOfParameters);
193 }
194
195 if (method == null) {
196 method = getExactMethod(type, "add" + StringUtils.removeEnd(name, "ren"), numberOfParameters);
197 }
198
199 if (method == null) {
200 method = getExactMethod(type, "add" + StringUtils.removeEnd(name, "ies") + "y", numberOfParameters);
201 }
202 return method;
203 }
204
205
206
207
208
209
210
211 protected Method getExactMethod(Class<?> type, String name, int numberOfParameters) {
212 Method[] methods = type.getMethods();
213 for (int i = 0; i < methods.length; i++) {
214 Method method = methods[i];
215 if (method.getName().equals(name)) {
216
217
218
219
220
221 if (method.getParameterTypes().length == numberOfParameters) {
222 return method;
223 }
224 }
225 }
226 return null;
227 }
228
229 }