|
1
16 package org.springframework.webflow.core.collection;
17
18 import java.io.IOException  ;
19 import java.io.ObjectInputStream ;
20 import java.io.ObjectOutputStream ;
21 import java.io.Serializable ;
22 import java.lang.reflect.Array ;
23 import java.util.ArrayList ;
24 import java.util.Collections ;
25 import java.util.List ;
26 import java.util.Map ;
27
28 import org.springframework.binding.collection.MapAccessor;
29 import org.springframework.binding.convert.ConversionException;
30 import org.springframework.binding.convert.ConversionExecutor;
31 import org.springframework.binding.convert.ConversionService;
32 import org.springframework.binding.convert.support.DefaultConversionService;
33 import org.springframework.core.style.StylerUtils;
34 import org.springframework.util.Assert;
35 import org.springframework.web.multipart.MultipartFile;
36
37
44 public class LocalParameterMap implements ParameterMap, Serializable {
45
46
49 private Map parameters;
50
51
55 private transient MapAccessor parameterAccessor;
56
57
61 private transient ConversionService conversionService;
62
63
71 public LocalParameterMap(Map parameters) {
72 this(parameters, new DefaultConversionService());
73 }
74
75
85 public LocalParameterMap(Map parameters, ConversionService conversionService) {
86 initParameters(parameters);
87 this.conversionService = conversionService;
88 }
89
90 public boolean equals(Object o) {
91 if (!(o instanceof LocalParameterMap)) {
92 return false;
93 }
94 LocalParameterMap other = (LocalParameterMap)o;
95 return parameters.equals(other.parameters);
96 }
97
98 public int hashCode() {
99 return parameters.hashCode();
100 }
101
102 public Map asMap() {
103 return Collections.unmodifiableMap(parameterAccessor.asMap());
104 }
105
106 public boolean isEmpty() {
107 return parameters.isEmpty();
108 }
109
110 public int size() {
111 return parameters.size();
112 }
113
114 public boolean contains(String parameterName) {
115 return parameters.containsKey(parameterName);
116 }
117
118 public String get(String parameterName) {
119 return get(parameterName, (String )null);
120 }
121
122 public String get(String parameterName, String defaultValue) {
123 if (!parameters.containsKey(parameterName)) {
124 return defaultValue;
125 }
126 Object value = parameters.get(parameterName);
127 if (value.getClass().isArray()) {
128 parameterAccessor.assertKeyValueInstanceOf(parameterName, value, String [].class);
129 String [] array = (String [])value;
130 if (array.length == 0) {
131 return null;
132 }
133 else {
134 Object first = ((String [])value)[0];
135 parameterAccessor.assertKeyValueInstanceOf(parameterName, first, String .class);
136 return (String )first;
137 }
138
139 }
140 else {
141 parameterAccessor.assertKeyValueInstanceOf(parameterName, value, String .class);
142 return (String )value;
143 }
144 }
145
146 public String [] getArray(String parameterName) {
147 if (!parameters.containsKey(parameterName)) {
148 return null;
149 }
150 Object value = parameters.get(parameterName);
151 if (value.getClass().isArray()) {
152 parameterAccessor.assertKeyValueInstanceOf(parameterName, value, String [].class);
153 return (String [])value;
154 }
155 else {
156 parameterAccessor.assertKeyValueInstanceOf(parameterName, value, String .class);
157 return new String [] { (String )value };
158 }
159 }
160
161 public Object [] getArray(String parameterName, Class targetElementType) throws ConversionException {
162 String [] parameters = getArray(parameterName);
163 return parameters != null ? convert(parameters, targetElementType) : null;
164 }
165
166 public Object get(String parameterName, Class targetType) throws ConversionException {
167 return get(parameterName, targetType, null);
168 }
169
170 public Object get(String parameterName, Class targetType, Object defaultValue) throws ConversionException {
171 if (defaultValue != null) {
172 assertAssignableTo(targetType, defaultValue.getClass());
173 }
174 String parameter = get(parameterName);
175 return parameter != null ? convert(parameter, targetType) : defaultValue;
176 }
177
178 public String getRequired(String parameterName) throws IllegalArgumentException {
179 parameterAccessor.assertContainsKey(parameterName);
180 return get(parameterName);
181 }
182
183 public String [] getRequiredArray(String parameterName) throws IllegalArgumentException {
184 parameterAccessor.assertContainsKey(parameterName);
185 return getArray(parameterName);
186 }
187
188 public Object [] getRequiredArray(String parameterName, Class targetElementType) throws IllegalArgumentException ,
189 ConversionException {
190 String [] parameters = getRequiredArray(parameterName);
191 return convert(parameters, targetElementType);
192 }
193
194 public Object getRequired(String parameterName, Class targetType) throws IllegalArgumentException ,
195 ConversionException {
196 return convert(getRequired(parameterName), targetType);
197 }
198
199 public Number getNumber(String parameterName, Class targetType) throws ConversionException {
200 assertAssignableTo(Number .class, targetType);
201 return (Number )get(parameterName, targetType);
202 }
203
204 public Number getNumber(String parameterName, Class targetType, Number defaultValue) throws ConversionException {
205 assertAssignableTo(Number .class, targetType);
206 return (Number )get(parameterName, targetType, defaultValue);
207 }
208
209 public Number getRequiredNumber(String parameterName, Class targetType) throws IllegalArgumentException ,
210 ConversionException {
211 assertAssignableTo(Number .class, targetType);
212 return (Number )getRequired(parameterName, targetType);
213 }
214
215 public Integer getInteger(String parameterName) throws ConversionException {
216 return (Integer )get(parameterName, Integer .class);
217 }
218
219 public Integer getInteger(String parameterName, Integer defaultValue) throws ConversionException {
220 return (Integer )get(parameterName, Integer .class, defaultValue);
221 }
222
223 public Integer getRequiredInteger(String parameterName) throws IllegalArgumentException , ConversionException {
224 return (Integer )getRequired(parameterName, Integer .class);
225 }
226
227 public Long getLong(String parameterName) throws ConversionException {
228 return (Long )get(parameterName, Long .class);
229 }
230
231 public Long getLong(String parameterName, Long defaultValue) throws ConversionException {
232 return (Long )get(parameterName, Long .class, defaultValue);
233 }
234
235 public Long getRequiredLong(String parameterName) throws IllegalArgumentException , ConversionException {
236 return (Long )getRequired(parameterName, Long .class);
237 }
238
239 public Boolean getBoolean(String parameterName) throws ConversionException {
240 return (Boolean )get(parameterName, Boolean .class);
241 }
242
243 public Boolean getBoolean(String parameterName, Boolean defaultValue) throws ConversionException {
244 return (Boolean )get(parameterName, Boolean .class, defaultValue);
245 }
246
247 public Boolean getRequiredBoolean(String parameterName) throws IllegalArgumentException , ConversionException {
248 return (Boolean )getRequired(parameterName, Boolean .class);
249 }
250
251 public MultipartFile getMultipartFile(String parameterName) {
252 return (MultipartFile)parameterAccessor.get(parameterName, MultipartFile.class);
253 }
254
255 public MultipartFile getRequiredMultipartFile(String parameterName) throws IllegalArgumentException {
256 return (MultipartFile)parameterAccessor.getRequired(parameterName, MultipartFile.class);
257 }
258
259 public AttributeMap asAttributeMap() {
260 return new LocalAttributeMap(getMapInternal());
261 }
262
263
267 protected void initParameters(Map parameters) {
268 this.parameters = parameters;
269 parameterAccessor = new MapAccessor(this.parameters);
270 }
271
272
275 protected Map getMapInternal() {
276 return parameters;
277 }
278
279
281
284 private Object convert(String parameter, Class targetType) throws ConversionException {
285 return conversionService.getConversionExecutor(String .class, targetType).execute(parameter);
286 }
287
288
292 private Object [] convert(String [] parameters, Class targetElementType) throws ConversionException {
293 List list = new ArrayList (parameters.length);
294 ConversionExecutor converter = conversionService.getConversionExecutor(String .class, targetElementType);
295 for (int i = 0; i < parameters.length; i++) {
296 list.add(converter.execute(parameters[i]));
297 }
298 return list.toArray((Object [])Array.newInstance(targetElementType, parameters.length));
299 }
300
301
304 private void assertAssignableTo(Class clazz, Class requiredType) {
305 Assert.isTrue(clazz.isAssignableFrom(requiredType), "The provided required type must be assignable to ["
306 + clazz + "]");
307 }
308
309
311 private void writeObject(ObjectOutputStream out) throws IOException {
312 out.defaultWriteObject();
313 }
314
315 private void readObject(ObjectInputStream in) throws IOException , ClassNotFoundException {
316 in.defaultReadObject();
317 parameterAccessor = new MapAccessor(parameters);
318 conversionService = new DefaultConversionService();
319 }
320
321 public String toString() {
322 return StylerUtils.style(parameters);
323 }
324 } |
Popular Tags |
Java API By Example, From Geeks To Geeks.