@Test
public void acceptedCommandsCanBeSerializedTest() throws Exception {
Field commandsField = JaxbCommandsRequest.class.getDeclaredField("commands");
XmlElements xmlElemsAnno = (XmlElements) commandsField.getAnnotations()[0];
XmlElement[] xmlElems = xmlElemsAnno.value();
Set<Class> cmdSet = new HashSet<Class>(AcceptedCommands.getSet());
assertEquals(cmdSet.size(), xmlElems.length);
Set<String> xmlElemNameSet = new HashSet<String>();
for (XmlElement xmlElemAnno : xmlElems) {
Class cmdClass = xmlElemAnno.type();
String name = xmlElemAnno.name();
assertTrue(name + " is used twice as a name.", xmlElemNameSet.add(name));
assertTrue(
cmdClass.getSimpleName()
+ " is present in "
+ JaxbCommandsRequest.class.getSimpleName()
+ " but not in "
+ AcceptedCommands.class.getSimpleName(),
cmdSet.remove(cmdClass));
}
for (Class cmdClass : cmdSet) {
System.out.println("Missing: " + cmdClass.getSimpleName());
}
assertTrue(
"See output for classes in "
+ AcceptedCommands.class.getSimpleName()
+ " that are not in "
+ JaxbCommandsRequest.class.getSimpleName(),
cmdSet.size() == 0);
}
/**
* The default value, or null if none exists.
*
* @return The default value, or null if none exists.
*/
public String getDefaultValue() {
String defaultValue = null;
if ((xmlElement != null) && (!"\u0000".equals(xmlElement.defaultValue()))) {
defaultValue = xmlElement.defaultValue();
}
return defaultValue;
}
// Inherited.
public String getName() {
String propertyName = getSimpleName().toString();
if ((xmlElement != null) && (!"##default".equals(xmlElement.name()))) {
propertyName = xmlElement.name();
}
return propertyName;
}
// Inherited.
public String getNamespace() {
String namespace = null;
if (getForm() == XmlNsForm.QUALIFIED) {
namespace = getTypeDefinition().getNamespace();
}
if ((xmlElement != null) && (!"##default".equals(xmlElement.namespace()))) {
namespace = xmlElement.namespace();
}
return namespace;
}
private static Field getElField(String partName, final Class<?> wrapperType) {
String fieldName = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.VARIABLE);
Field[] fields = ReflectionUtil.getDeclaredFields(wrapperType);
for (Field field : fields) {
XmlElement el = field.getAnnotation(XmlElement.class);
if (el != null && partName.equals(el.name())) {
return field;
}
if (field.getName().equals(fieldName)) {
return field;
}
}
return null;
}
/**
* Whether this element is required.
*
* @return Whether this element is required.
*/
public boolean isRequired() {
boolean required = BeanValidationUtils.isNotNull(this);
if (xmlElement != null && !required) {
required = xmlElement.required();
}
return required;
}
/**
* Whether this element is nillable.
*
* @return Whether this element is nillable.
*/
public boolean isNillable() {
boolean nillable = false;
if (xmlElement != null) {
nillable = xmlElement.nillable();
}
return nillable;
}
protected boolean isMandatory(Object bean, String propertyName) {
// lets look at the setter method and see if its got a @Required
// annotation
if (bean instanceof AbstractNode) {
AbstractNode node = (AbstractNode) bean;
Class<?> camelClass = node.getCamelDefinitionClass();
if (camelClass != null) {
XmlAccessorType accessorType = camelClass.getAnnotation(XmlAccessorType.class);
boolean useMethods = true;
if (accessorType != null) {
if (accessorType.value().equals(XmlAccessType.FIELD)) {
useMethods = false;
}
}
try {
BeanInfo beanInfo = Introspector.getBeanInfo(camelClass);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
if (propertyDescriptors != null) {
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
if (propertyName.equals(propertyDescriptor.getName())) {
Method writeMethod = propertyDescriptor.getWriteMethod();
if (writeMethod != null) {
Required annotation = writeMethod.getAnnotation(Required.class);
if (annotation != null) {
return true;
}
if (useMethods) {
XmlElement element = writeMethod.getAnnotation(XmlElement.class);
if (element != null && element.required()) {
return true;
}
XmlAttribute attribute = writeMethod.getAnnotation(XmlAttribute.class);
if (attribute != null && attribute.required()) {
return true;
}
}
}
break;
}
}
}
if (!useMethods) {
Field[] fields = camelClass.getDeclaredFields();
for (Field field : fields) {
if (propertyName.equals(field.getName())) {
Required annotation = field.getAnnotation(Required.class);
if (annotation != null) {
return true;
}
XmlElement element = field.getAnnotation(XmlElement.class);
if (element != null && element.required()) {
return true;
}
XmlAttribute attribute = field.getAnnotation(XmlAttribute.class);
if (attribute != null && attribute.required()) {
return true;
}
}
}
}
} catch (IntrospectionException e) {
// ignore
}
}
}
// expression is mandatory on resequence
if (node instanceof Resequence && "expression".equals(propertyName)) {
return true;
}
// lets make all URI properties mandatory by default to avoid complex
// validation with ref v uri
boolean answer =
("uri".equals(propertyName) || propertyName.endsWith("Uri"))
|| (bean instanceof Aggregate && "strategyRef".equals(propertyName))
|| (bean instanceof ConvertBody && "type".equals(propertyName))
|| (bean instanceof ExpressionDefinition && isMandatoryExpression())
|| (bean instanceof Log && "message".equals(propertyName))
|| (bean instanceof Process && "ref".equals(propertyName))
|| (bean instanceof RemoveHeader && "headerName".equals(propertyName))
|| (bean instanceof RemoveProperty && "propertyName".equals(propertyName))
|| (bean instanceof SetHeader && "headerName".equals(propertyName))
|| (bean instanceof SetOutHeader && "headerName".equals(propertyName))
|| (bean instanceof SetProperty && "propertyName".equals(propertyName));
return answer;
}
public WrapperHelper createWrapperHelper(
Class<?> wrapperType,
QName wrapperName,
List<String> partNames,
List<String> elTypeNames,
List<Class<?>> partClasses) {
List<Method> getMethods = new ArrayList<Method>(partNames.size());
List<Method> setMethods = new ArrayList<Method>(partNames.size());
List<Method> jaxbMethods = new ArrayList<Method>(partNames.size());
List<Field> fields = new ArrayList<Field>(partNames.size());
Method allMethods[] = wrapperType.getMethods();
String packageName = PackageUtils.getPackageName(wrapperType);
// if wrappertype class is generated by ASM,getPackage() always return null
if (wrapperType.getPackage() != null) {
packageName = wrapperType.getPackage().getName();
}
String objectFactoryClassName = packageName + ".ObjectFactory";
Object objectFactory = null;
try {
objectFactory = wrapperType.getClassLoader().loadClass(objectFactoryClassName).newInstance();
} catch (Exception e) {
// ignore, probably won't need it
}
Method allOFMethods[];
if (objectFactory != null) {
allOFMethods = objectFactory.getClass().getMethods();
} else {
allOFMethods = new Method[0];
}
for (int x = 0; x < partNames.size(); x++) {
String partName = partNames.get(x);
if (partName == null) {
getMethods.add(null);
setMethods.add(null);
fields.add(null);
jaxbMethods.add(null);
continue;
}
String elementType = elTypeNames.get(x);
String getAccessor = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.GETTER);
String setAccessor = JAXBUtils.nameToIdentifier(partName, JAXBUtils.IdentifierType.SETTER);
Method getMethod = null;
Method setMethod = null;
Class<?> valueClass = wrapperType;
try {
getMethod = valueClass.getMethod(getAccessor, AbstractWrapperHelper.NO_CLASSES);
} catch (NoSuchMethodException ex) {
// ignore for now
}
Field elField = getElField(partName, valueClass);
if (getMethod == null
&& elementType != null
&& "boolean".equals(elementType.toLowerCase())
&& (elField == null
|| (!Collection.class.isAssignableFrom(elField.getType())
&& !elField.getType().isArray()))) {
try {
String newAcc = getAccessor.replaceFirst("get", "is");
getMethod = wrapperType.getMethod(newAcc, AbstractWrapperHelper.NO_CLASSES);
} catch (NoSuchMethodException ex) {
// ignore for now
}
}
if (getMethod == null && "return".equals(partName)) {
// RI generated code uses this
try {
getMethod = valueClass.getMethod("get_return", AbstractWrapperHelper.NO_CLASSES);
} catch (NoSuchMethodException ex) {
try {
getMethod = valueClass.getMethod("is_return", new Class[0]);
} catch (NoSuchMethodException ex2) {
// ignore for now
}
}
}
if (getMethod == null && elField != null) {
getAccessor =
JAXBUtils.nameToIdentifier(elField.getName(), JAXBUtils.IdentifierType.GETTER);
setAccessor =
JAXBUtils.nameToIdentifier(elField.getName(), JAXBUtils.IdentifierType.SETTER);
try {
getMethod = valueClass.getMethod(getAccessor, AbstractWrapperHelper.NO_CLASSES);
} catch (NoSuchMethodException ex) {
// ignore for now
}
}
String setAccessor2 = setAccessor;
if ("return".equals(partName)) {
// some versions of jaxb map "return" to "set_return" instead of "setReturn"
setAccessor2 = "set_return";
}
for (Method method : allMethods) {
if (method.getParameterTypes() != null
&& method.getParameterTypes().length == 1
&& (setAccessor.equals(method.getName()) || setAccessor2.equals(method.getName()))) {
setMethod = method;
break;
}
}
getMethods.add(getMethod);
setMethods.add(setMethod);
if (setMethod != null
&& JAXBElement.class.isAssignableFrom(setMethod.getParameterTypes()[0])) {
Type t = setMethod.getGenericParameterTypes()[0];
Class<?> pcls = null;
if (t instanceof ParameterizedType) {
t = ((ParameterizedType) t).getActualTypeArguments()[0];
}
if (t instanceof Class) {
pcls = (Class<?>) t;
}
String methodName =
"create" + wrapperType.getSimpleName() + setMethod.getName().substring(3);
for (Method m : allOFMethods) {
if (m.getName().equals(methodName)
&& m.getParameterTypes().length == 1
&& (pcls == null || pcls.equals(m.getParameterTypes()[0]))) {
jaxbMethods.add(m);
}
}
} else {
jaxbMethods.add(null);
}
if (elField != null) {
// JAXB Type get XmlElement Annotation
XmlElement el = elField.getAnnotation(XmlElement.class);
if (el != null && (partName.equals(el.name()) || "##default".equals(el.name()))) {
ReflectionUtil.setAccessible(elField);
fields.add(elField);
} else {
if (getMethod == null && setMethod == null) {
if (el != null) {
LOG.warning(
"Could not create accessor for property "
+ partName
+ " of type "
+ wrapperType.getName()
+ " as the @XmlElement "
+ "defines the name as "
+ el.name());
} else {
LOG.warning(
"Could not create accessor for property "
+ partName
+ " of type "
+ wrapperType.getName());
}
}
fields.add(null);
}
} else {
fields.add(null);
}
}
return createWrapperHelper(
wrapperType,
setMethods.toArray(new Method[setMethods.size()]),
getMethods.toArray(new Method[getMethods.size()]),
jaxbMethods.toArray(new Method[jaxbMethods.size()]),
fields.toArray(new Field[fields.size()]),
objectFactory);
}
