001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.camel.util; 018 019 import java.beans.PropertyEditor; 020 import java.beans.PropertyEditorManager; 021 import java.lang.reflect.InvocationTargetException; 022 import java.lang.reflect.Method; 023 import java.lang.reflect.Proxy; 024 import java.net.URI; 025 import java.net.URISyntaxException; 026 import java.util.ArrayList; 027 import java.util.Arrays; 028 import java.util.Collection; 029 import java.util.HashSet; 030 import java.util.Iterator; 031 import java.util.LinkedHashMap; 032 import java.util.LinkedHashSet; 033 import java.util.LinkedList; 034 import java.util.List; 035 import java.util.Locale; 036 import java.util.Map; 037 import java.util.Set; 038 import java.util.regex.Pattern; 039 040 import org.apache.camel.CamelContext; 041 import org.apache.camel.NoTypeConversionAvailableException; 042 import org.apache.camel.TypeConverter; 043 import org.slf4j.Logger; 044 import org.slf4j.LoggerFactory; 045 046 /** 047 * Helper for introspections of beans. 048 * <p/> 049 * <b>Important: </b> Its recommended to call the {@link #stop()} method when 050 * {@link org.apache.camel.CamelContext} is being stopped. This allows to clear the introspection cache. 051 * <p/> 052 * This implementation will skip methods from <tt>java.lang.Object</tt> and <tt>java.lang.reflect.Proxy</tt>. 053 * <p/> 054 * This implementation will use a cache when the {@link #getProperties(Object, java.util.Map, String)} 055 * method is being used. Also the {@link #cacheClass(Class)} method gives access to the introspect cache. 056 */ 057 public final class IntrospectionSupport { 058 059 private static final Logger LOG = LoggerFactory.getLogger(IntrospectionSupport.class); 060 private static final Pattern GETTER_PATTERN = Pattern.compile("(get|is)[A-Z].*"); 061 private static final Pattern SETTER_PATTERN = Pattern.compile("set[A-Z].*"); 062 private static final List<Method> EXCLUDED_METHODS = new ArrayList<Method>(); 063 // use a cache to speedup introspecting for known classes during startup 064 // use a weak cache as we dont want the cache to keep around as it reference classes 065 // which could prevent classloader to unload classes if being referenced from this cache 066 private static final LRUCache<Class<?>, ClassInfo> CACHE = new LRUWeakCache<Class<?>, ClassInfo>(1000); 067 private static final Object LOCK = new Object(); 068 069 static { 070 // exclude all java.lang.Object methods as we dont want to invoke them 071 EXCLUDED_METHODS.addAll(Arrays.asList(Object.class.getMethods())); 072 // exclude all java.lang.reflect.Proxy methods as we dont want to invoke them 073 EXCLUDED_METHODS.addAll(Arrays.asList(Proxy.class.getMethods())); 074 } 075 076 private static final Set<Class<?>> PRIMITIVE_CLASSES = new HashSet<Class<?>>(); 077 078 static { 079 PRIMITIVE_CLASSES.add(String.class); 080 PRIMITIVE_CLASSES.add(Character.class); 081 PRIMITIVE_CLASSES.add(Boolean.class); 082 PRIMITIVE_CLASSES.add(Byte.class); 083 PRIMITIVE_CLASSES.add(Short.class); 084 PRIMITIVE_CLASSES.add(Integer.class); 085 PRIMITIVE_CLASSES.add(Long.class); 086 PRIMITIVE_CLASSES.add(Float.class); 087 PRIMITIVE_CLASSES.add(Double.class); 088 PRIMITIVE_CLASSES.add(char.class); 089 PRIMITIVE_CLASSES.add(boolean.class); 090 PRIMITIVE_CLASSES.add(byte.class); 091 PRIMITIVE_CLASSES.add(short.class); 092 PRIMITIVE_CLASSES.add(int.class); 093 PRIMITIVE_CLASSES.add(long.class); 094 PRIMITIVE_CLASSES.add(float.class); 095 PRIMITIVE_CLASSES.add(double.class); 096 } 097 098 /** 099 * Structure of an introspected class. 100 */ 101 public static final class ClassInfo { 102 public Class<?> clazz; 103 public MethodInfo[] methods; 104 } 105 106 /** 107 * Structure of an introspected method. 108 */ 109 public static final class MethodInfo { 110 public Method method; 111 public Boolean isGetter; 112 public Boolean isSetter; 113 public String getterOrSetterShorthandName; 114 public Boolean hasGetterAndSetter; 115 } 116 117 /** 118 * Utility classes should not have a public constructor. 119 */ 120 private IntrospectionSupport() { 121 } 122 123 /** 124 * {@link org.apache.camel.CamelContext} should call this stop method when its stopping. 125 * <p/> 126 * This implementation will clear its introspection cache. 127 */ 128 public static void stop() { 129 if (LOG.isDebugEnabled()) { 130 LOG.debug("Clearing cache[size={}, hits={}, misses={}, evicted={}]", new Object[]{CACHE.size(), CACHE.getHits(), CACHE.getMisses(), CACHE.getEvicted()}); 131 } 132 CACHE.clear(); 133 134 // flush java beans introspector as it may be in use by the PropertyEditor 135 java.beans.Introspector.flushCaches(); 136 } 137 138 public static boolean isGetter(Method method) { 139 String name = method.getName(); 140 Class<?> type = method.getReturnType(); 141 Class<?> params[] = method.getParameterTypes(); 142 143 if (!GETTER_PATTERN.matcher(name).matches()) { 144 return false; 145 } 146 147 // special for isXXX boolean 148 if (name.startsWith("is")) { 149 return params.length == 0 && type.getSimpleName().equalsIgnoreCase("boolean"); 150 } 151 152 return params.length == 0 && !type.equals(Void.TYPE); 153 } 154 155 public static String getGetterShorthandName(Method method) { 156 if (!isGetter(method)) { 157 return method.getName(); 158 } 159 160 String name = method.getName(); 161 if (name.startsWith("get")) { 162 name = name.substring(3); 163 name = name.substring(0, 1).toLowerCase(Locale.ENGLISH) + name.substring(1); 164 } else if (name.startsWith("is")) { 165 name = name.substring(2); 166 name = name.substring(0, 1).toLowerCase(Locale.ENGLISH) + name.substring(1); 167 } 168 169 return name; 170 } 171 172 public static String getSetterShorthandName(Method method) { 173 if (!isSetter(method)) { 174 return method.getName(); 175 } 176 177 String name = method.getName(); 178 if (name.startsWith("set")) { 179 name = name.substring(3); 180 name = name.substring(0, 1).toLowerCase(Locale.ENGLISH) + name.substring(1); 181 } 182 183 return name; 184 } 185 186 public static boolean isSetter(Method method, boolean allowBuilderPattern) { 187 String name = method.getName(); 188 Class<?> type = method.getReturnType(); 189 Class<?> params[] = method.getParameterTypes(); 190 191 if (!SETTER_PATTERN.matcher(name).matches()) { 192 return false; 193 } 194 195 return params.length == 1 && (type.equals(Void.TYPE) || (allowBuilderPattern && method.getDeclaringClass().isAssignableFrom(type))); 196 } 197 198 public static boolean isSetter(Method method) { 199 return isSetter(method, false); 200 } 201 202 203 /** 204 * Will inspect the target for properties. 205 * <p/> 206 * Notice a property must have both a getter/setter method to be included. 207 * Notice all <tt>null</tt> values will be included. 208 * 209 * @param target the target bean 210 * @param properties the map to fill in found properties 211 * @param optionPrefix an optional prefix to append the property key 212 * @return <tt>true</tt> if any properties was found, <tt>false</tt> otherwise. 213 */ 214 public static boolean getProperties(Object target, Map<String, Object> properties, String optionPrefix) { 215 return getProperties(target, properties, optionPrefix, true); 216 } 217 218 /** 219 * Will inspect the target for properties. 220 * <p/> 221 * Notice a property must have both a getter/setter method to be included. 222 * 223 * @param target the target bean 224 * @param properties the map to fill in found properties 225 * @param optionPrefix an optional prefix to append the property key 226 * @param includeNull whether to include <tt>null</tt> values 227 * @return <tt>true</tt> if any properties was found, <tt>false</tt> otherwise. 228 */ 229 public static boolean getProperties(Object target, Map<String, Object> properties, String optionPrefix, boolean includeNull) { 230 ObjectHelper.notNull(target, "target"); 231 ObjectHelper.notNull(properties, "properties"); 232 boolean rc = false; 233 if (optionPrefix == null) { 234 optionPrefix = ""; 235 } 236 237 ClassInfo cache = cacheClass(target.getClass()); 238 239 for (MethodInfo info : cache.methods) { 240 Method method = info.method; 241 // we can only get properties if we have both a getter and a setter 242 if (info.isGetter && info.hasGetterAndSetter) { 243 String name = info.getterOrSetterShorthandName; 244 try { 245 // we may want to set options on classes that has package view visibility, so override the accessible 246 method.setAccessible(true); 247 Object value = method.invoke(target); 248 if (value != null || includeNull) { 249 properties.put(optionPrefix + name, value); 250 rc = true; 251 } 252 } catch (Exception e) { 253 if (LOG.isTraceEnabled()) { 254 LOG.trace("Error invoking getter method " + method + ". This exception is ignored.", e); 255 } 256 } 257 } 258 } 259 260 return rc; 261 } 262 263 /** 264 * Introspects the given class. 265 * 266 * @param clazz the class 267 * @return the introspection result as a {@link ClassInfo} structure. 268 */ 269 public static ClassInfo cacheClass(Class<?> clazz) { 270 ClassInfo cache = CACHE.get(clazz); 271 if (cache == null) { 272 cache = doIntrospectClass(clazz); 273 CACHE.put(clazz, cache); 274 } 275 return cache; 276 } 277 278 private static ClassInfo doIntrospectClass(Class<?> clazz) { 279 ClassInfo answer = new ClassInfo(); 280 answer.clazz = clazz; 281 282 // loop each method on the class and gather details about the method 283 // especially about getter/setters 284 List<MethodInfo> found = new ArrayList<MethodInfo>(); 285 Method[] methods = clazz.getMethods(); 286 for (Method method : methods) { 287 if (EXCLUDED_METHODS.contains(method)) { 288 continue; 289 } 290 291 MethodInfo cache = new MethodInfo(); 292 cache.method = method; 293 if (isGetter(method)) { 294 cache.isGetter = true; 295 cache.isSetter = false; 296 cache.getterOrSetterShorthandName = getGetterShorthandName(method); 297 } else if (isSetter(method)) { 298 cache.isGetter = false; 299 cache.isSetter = true; 300 cache.getterOrSetterShorthandName = getSetterShorthandName(method); 301 } else { 302 cache.isGetter = false; 303 cache.isSetter = false; 304 cache.hasGetterAndSetter = false; 305 } 306 found.add(cache); 307 } 308 309 // for all getter/setter, find out if there is a corresponding getter/setter, 310 // so we have a read/write bean property. 311 for (MethodInfo info : found) { 312 info.hasGetterAndSetter = false; 313 if (info.isGetter) { 314 // loop and find the matching setter 315 for (MethodInfo info2 : found) { 316 if (info2.isSetter && info.getterOrSetterShorthandName.equals(info2.getterOrSetterShorthandName)) { 317 info.hasGetterAndSetter = true; 318 break; 319 } 320 } 321 } else if (info.isSetter) { 322 // loop and find the matching getter 323 for (MethodInfo info2 : found) { 324 if (info2.isGetter && info.getterOrSetterShorthandName.equals(info2.getterOrSetterShorthandName)) { 325 info.hasGetterAndSetter = true; 326 break; 327 } 328 } 329 } 330 } 331 332 answer.methods = found.toArray(new MethodInfo[found.size()]); 333 return answer; 334 } 335 336 public static boolean hasProperties(Map<String, Object> properties, String optionPrefix) { 337 ObjectHelper.notNull(properties, "properties"); 338 339 if (ObjectHelper.isNotEmpty(optionPrefix)) { 340 for (Object o : properties.keySet()) { 341 String name = (String) o; 342 if (name.startsWith(optionPrefix)) { 343 return true; 344 } 345 } 346 // no parameters with this prefix 347 return false; 348 } else { 349 return !properties.isEmpty(); 350 } 351 } 352 353 public static Object getProperty(Object target, String property) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { 354 ObjectHelper.notNull(target, "target"); 355 ObjectHelper.notNull(property, "property"); 356 357 property = property.substring(0, 1).toUpperCase(Locale.ENGLISH) + property.substring(1); 358 359 Class<?> clazz = target.getClass(); 360 Method method = getPropertyGetter(clazz, property); 361 return method.invoke(target); 362 } 363 364 public static Object getOrElseProperty(Object target, String property, Object defaultValue) { 365 try { 366 return getProperty(target, property); 367 } catch (Exception e) { 368 return defaultValue; 369 } 370 } 371 372 public static Method getPropertyGetter(Class<?> type, String propertyName) throws NoSuchMethodException { 373 if (isPropertyIsGetter(type, propertyName)) { 374 return type.getMethod("is" + ObjectHelper.capitalize(propertyName)); 375 } else { 376 return type.getMethod("get" + ObjectHelper.capitalize(propertyName)); 377 } 378 } 379 380 public static Method getPropertySetter(Class<?> type, String propertyName) throws NoSuchMethodException { 381 String name = "set" + ObjectHelper.capitalize(propertyName); 382 for (Method method : type.getMethods()) { 383 if (isSetter(method) && method.getName().equals(name)) { 384 return method; 385 } 386 } 387 throw new NoSuchMethodException(type.getCanonicalName() + "." + name); 388 } 389 390 public static boolean isPropertyIsGetter(Class<?> type, String propertyName) { 391 try { 392 Method method = type.getMethod("is" + ObjectHelper.capitalize(propertyName)); 393 if (method != null) { 394 return method.getReturnType().isAssignableFrom(boolean.class) || method.getReturnType().isAssignableFrom(Boolean.class); 395 } 396 } catch (NoSuchMethodException e) { 397 // ignore 398 } 399 return false; 400 } 401 402 public static boolean setProperties(Object target, Map<String, Object> properties, String optionPrefix, boolean allowBuilderPattern) throws Exception { 403 ObjectHelper.notNull(target, "target"); 404 ObjectHelper.notNull(properties, "properties"); 405 boolean rc = false; 406 407 for (Iterator<Map.Entry<String, Object>> it = properties.entrySet().iterator(); it.hasNext();) { 408 Map.Entry<String, Object> entry = it.next(); 409 String name = entry.getKey().toString(); 410 if (name.startsWith(optionPrefix)) { 411 Object value = properties.get(name); 412 name = name.substring(optionPrefix.length()); 413 if (setProperty(target, name, value, allowBuilderPattern)) { 414 it.remove(); 415 rc = true; 416 } 417 } 418 } 419 420 return rc; 421 } 422 423 public static boolean setProperties(Object target, Map<String, Object> properties, String optionPrefix) throws Exception { 424 ObjectHelper.notEmpty(optionPrefix, "optionPrefix"); 425 return setProperties(target, properties, optionPrefix, false); 426 } 427 428 public static Map<String, Object> extractProperties(Map<String, Object> properties, String optionPrefix) { 429 ObjectHelper.notNull(properties, "properties"); 430 431 Map<String, Object> rc = new LinkedHashMap<String, Object>(properties.size()); 432 433 for (Iterator<Map.Entry<String, Object>> it = properties.entrySet().iterator(); it.hasNext();) { 434 Map.Entry<String, Object> entry = it.next(); 435 String name = entry.getKey(); 436 if (name.startsWith(optionPrefix)) { 437 Object value = properties.get(name); 438 name = name.substring(optionPrefix.length()); 439 rc.put(name, value); 440 it.remove(); 441 } 442 } 443 444 return rc; 445 } 446 447 public static boolean setProperties(TypeConverter typeConverter, Object target, Map<String, Object> properties) throws Exception { 448 ObjectHelper.notNull(target, "target"); 449 ObjectHelper.notNull(properties, "properties"); 450 boolean rc = false; 451 452 for (Iterator<Map.Entry<String, Object>> iter = properties.entrySet().iterator(); iter.hasNext();) { 453 Map.Entry<String, Object> entry = iter.next(); 454 if (setProperty(typeConverter, target, entry.getKey(), entry.getValue())) { 455 iter.remove(); 456 rc = true; 457 } 458 } 459 460 return rc; 461 } 462 463 public static boolean setProperties(Object target, Map<String, Object> properties) throws Exception { 464 return setProperties(null, target, properties); 465 } 466 467 /** 468 * This method supports two modes to set a property: 469 * 470 * 1. Setting a property that has already been resolved, this is the case when {@code context} and {@code refName} are 471 * NULL and {@code value} is non-NULL. 472 * 473 * 2. Setting a property that has not yet been resolved, the property will be resolved based on the suitable methods 474 * found matching the property name on the {@code target} bean. For this mode to be triggered the parameters 475 * {@code context} and {@code refName} must NOT be NULL, and {@code value} MUST be NULL. 476 * 477 */ 478 public static boolean setProperty(CamelContext context, TypeConverter typeConverter, Object target, String name, Object value, String refName, boolean allowBuilderPattern) throws Exception { 479 Class<?> clazz = target.getClass(); 480 Collection<Method> setters; 481 482 // we need to lookup the value from the registry 483 if (context != null && refName != null && value == null) { 484 setters = findSetterMethodsOrderedByParameterType(clazz, name, allowBuilderPattern); 485 } else { 486 // find candidates of setter methods as there can be overloaded setters 487 setters = findSetterMethods(clazz, name, value, allowBuilderPattern); 488 } 489 if (setters.isEmpty()) { 490 return false; 491 } 492 493 // loop and execute the best setter method 494 Exception typeConversionFailed = null; 495 for (Method setter : setters) { 496 Class<?> parameterType = setter.getParameterTypes()[0]; 497 Object ref = value; 498 // try and lookup the reference based on the method 499 if (context != null && refName != null && ref == null) { 500 ref = CamelContextHelper.lookup(context, refName.replaceAll("#", "")); 501 if (ref == null) { 502 // try the next method if nothing was found 503 continue; 504 } else if (!parameterType.isAssignableFrom(ref.getClass())) { 505 // setter method has not the correct type 506 continue; 507 } 508 } 509 510 try { 511 try { 512 // If the type is null or it matches the needed type, just use the value directly 513 if (value == null || parameterType.isAssignableFrom(ref.getClass())) { 514 // we may want to set options on classes that has package view visibility, so override the accessible 515 setter.setAccessible(true); 516 setter.invoke(target, ref); 517 if (LOG.isDebugEnabled()) { 518 LOG.debug("Configured property: {} on bean: {} with value: {}", new Object[]{name, target, ref}); 519 } 520 return true; 521 } else { 522 // We need to convert it 523 Object convertedValue = convert(typeConverter, parameterType, ref); 524 // we may want to set options on classes that has package view visibility, so override the accessible 525 setter.setAccessible(true); 526 setter.invoke(target, convertedValue); 527 if (LOG.isDebugEnabled()) { 528 LOG.debug("Configured property: {} on bean: {} with value: {}", new Object[]{name, target, ref}); 529 } 530 return true; 531 } 532 } catch (InvocationTargetException e) { 533 // lets unwrap the exception 534 Throwable throwable = e.getCause(); 535 if (throwable instanceof Exception) { 536 Exception exception = (Exception)throwable; 537 throw exception; 538 } else { 539 Error error = (Error)throwable; 540 throw error; 541 } 542 } 543 // ignore exceptions as there could be another setter method where we could type convert successfully 544 } catch (SecurityException e) { 545 typeConversionFailed = e; 546 } catch (NoTypeConversionAvailableException e) { 547 typeConversionFailed = e; 548 } catch (IllegalArgumentException e) { 549 typeConversionFailed = e; 550 } 551 if (LOG.isTraceEnabled()) { 552 LOG.trace("Setter \"{}\" with parameter type \"{}\" could not be used for type conversions of {}", 553 new Object[]{setter, parameterType, ref}); 554 } 555 } 556 557 if (typeConversionFailed != null) { 558 // we did not find a setter method to use, and if we did try to use a type converter then throw 559 // this kind of exception as the caused by will hint this error 560 throw new IllegalArgumentException("Could not find a suitable setter for property: " + name 561 + " as there isn't a setter method with same type: " + (value != null ? value.getClass().getCanonicalName() : "[null]") 562 + " nor type conversion possible: " + typeConversionFailed.getMessage()); 563 } else { 564 return false; 565 } 566 } 567 568 public static boolean setProperty(TypeConverter typeConverter, Object target, String name, Object value) throws Exception { 569 // allow build pattern as a setter as well 570 return setProperty(null, typeConverter, target, name, value, null, true); 571 } 572 573 public static boolean setProperty(Object target, String name, Object value, boolean allowBuilderPattern) throws Exception { 574 return setProperty(null, null, target, name, value, null, allowBuilderPattern); 575 } 576 577 public static boolean setProperty(Object target, String name, Object value) throws Exception { 578 // allow build pattern as a setter as well 579 return setProperty(target, name, value, true); 580 } 581 582 private static Object convert(TypeConverter typeConverter, Class<?> type, Object value) 583 throws URISyntaxException, NoTypeConversionAvailableException { 584 if (typeConverter != null) { 585 return typeConverter.mandatoryConvertTo(type, value); 586 } 587 if (type == URI.class) { 588 return new URI(value.toString()); 589 } 590 PropertyEditor editor = PropertyEditorManager.findEditor(type); 591 if (editor != null) { 592 // property editor is not thread safe, so we need to lock 593 Object answer; 594 synchronized (LOCK) { 595 editor.setAsText(value.toString()); 596 answer = editor.getValue(); 597 } 598 return answer; 599 } 600 return null; 601 } 602 603 public static Set<Method> findSetterMethods(Class<?> clazz, String name, boolean allowBuilderPattern) { 604 Set<Method> candidates = new LinkedHashSet<Method>(); 605 606 // Build the method name. 607 name = "set" + ObjectHelper.capitalize(name); 608 while (clazz != Object.class) { 609 // Since Object.class.isInstance all the objects, 610 // here we just make sure it will be add to the bottom of the set. 611 Method objectSetMethod = null; 612 Method[] methods = clazz.getMethods(); 613 for (Method method : methods) { 614 if (method.getName().equals(name) && isSetter(method, allowBuilderPattern)) { 615 Class<?> params[] = method.getParameterTypes(); 616 if (params[0].equals(Object.class)) { 617 objectSetMethod = method; 618 } else { 619 candidates.add(method); 620 } 621 } 622 } 623 if (objectSetMethod != null) { 624 candidates.add(objectSetMethod); 625 } 626 clazz = clazz.getSuperclass(); 627 } 628 return candidates; 629 } 630 631 private static Set<Method> findSetterMethods(Class<?> clazz, String name, Object value, boolean allowBuilderPattern) { 632 Set<Method> candidates = findSetterMethods(clazz, name, allowBuilderPattern); 633 634 if (candidates.isEmpty()) { 635 return candidates; 636 } else if (candidates.size() == 1) { 637 // only one 638 return candidates; 639 } else { 640 // find the best match if possible 641 LOG.trace("Found {} suitable setter methods for setting {}", candidates.size(), name); 642 // prefer to use the one with the same instance if any exists 643 for (Method method : candidates) { 644 if (method.getParameterTypes()[0].isInstance(value)) { 645 LOG.trace("Method {} is the best candidate as it has parameter with same instance type", method); 646 // retain only this method in the answer 647 candidates.clear(); 648 candidates.add(method); 649 return candidates; 650 } 651 } 652 // fallback to return what we have found as candidates so far 653 return candidates; 654 } 655 } 656 657 protected static List<Method> findSetterMethodsOrderedByParameterType(Class<?> target, String propertyName, boolean allowBuilderPattern) { 658 List<Method> answer = new LinkedList<Method>(); 659 List<Method> primitives = new LinkedList<Method>(); 660 Set<Method> setters = findSetterMethods(target, propertyName, allowBuilderPattern); 661 for (Method setter : setters) { 662 Class<?> parameterType = setter.getParameterTypes()[0]; 663 if (PRIMITIVE_CLASSES.contains(parameterType)) { 664 primitives.add(setter); 665 } else { 666 answer.add(setter); 667 } 668 } 669 // primitives get added last 670 answer.addAll(primitives); 671 return answer; 672 } 673 674 }