in modules/kernel/src/org/apache/axis2/description/java2wsdl/DefaultSchemaGenerator.java [603:763]
protected QName generateSchema(Class<?> javaType) throws Exception {
String name = getClassName(javaType);
QName schemaTypeName = typeTable.getComplexSchemaType(name);
if (schemaTypeName == null) {
String simpleName = getSimpleClassName(javaType);
String packageName = getQualifiedName(javaType.getPackage());
String targetNameSpace = resolveSchemaNamespace(packageName);
XmlSchema xmlSchema = getXmlSchema(targetNameSpace);
String targetNamespacePrefix = targetNamespacePrefixMap.get(targetNameSpace);
if (targetNamespacePrefix == null) {
targetNamespacePrefix = generatePrefix();
targetNamespacePrefixMap.put(targetNameSpace, targetNamespacePrefix);
}
XmlSchemaComplexType complexType = new XmlSchemaComplexType(xmlSchema, false);
XmlSchemaSequence sequence = new XmlSchemaSequence();
XmlSchemaComplexContentExtension complexExtension =
new XmlSchemaComplexContentExtension();
schemaTypeName = new QName(targetNameSpace, simpleName, targetNamespacePrefix);
Class<?> sup = javaType.getSuperclass();
if ((sup != null)
&& (!"java.lang.Object".equals(sup.getName()))
&& (!"java.lang.Exception".equals(sup.getName()))
&& !getQualifiedName(sup.getPackage()).startsWith("org.apache.axis2")
&& !getQualifiedName(sup.getPackage()).startsWith("java.util")){
String superClassName = sup.getName();
String superclassname = getSimpleClassName(sup);
String tgtNamespace;
String tgtNamespacepfx;
QName qName = typeTable.getSimpleSchemaTypeName(superClassName);
if (qName != null) {
tgtNamespace = qName.getNamespaceURI();
tgtNamespacepfx = qName.getPrefix();
} else {
tgtNamespace = resolveSchemaNamespace(getQualifiedName(sup.getPackage()));
tgtNamespacepfx = targetNamespacePrefixMap.get(tgtNamespace);
QName superClassQname = generateSchema(sup);
if (superClassQname != null) {
tgtNamespacepfx = superClassQname.getPrefix();
tgtNamespace = superClassQname.getNamespaceURI();
}
}
if (tgtNamespacepfx == null) {
tgtNamespacepfx = generatePrefix();
targetNamespacePrefixMap.put(tgtNamespace, tgtNamespacepfx);
}
//if the parent class package name is differ from the child
if (!((NamespaceMap) xmlSchema.getNamespaceContext()).values().
contains(tgtNamespace)) {
XmlSchemaImport importElement = new XmlSchemaImport(xmlSchema);
importElement.setNamespace(tgtNamespace);
xmlSchema.getItems().add(importElement);
((NamespaceMap) xmlSchema.getNamespaceContext()).
put(generatePrefix(), tgtNamespace);
}
QName basetype = new QName(tgtNamespace, superclassname, tgtNamespacepfx);
complexExtension.setBaseTypeName(basetype);
complexExtension.setParticle(sequence);
XmlSchemaComplexContent contentModel = new XmlSchemaComplexContent();
contentModel.setContent(complexExtension);
complexType.setContentModel(contentModel);
} else {
complexType.setParticle(sequence);
}
complexType.setName(simpleName);
if (Modifier.isAbstract(javaType.getModifiers())) {
complexType.setAbstract(true);
}
xmlSchema.getItems().add(complexType);
xmlSchema.getSchemaTypes().put(schemaTypeName, complexType);
// adding this type to the table
typeTable.addComplexSchema(name, schemaTypeName);
// adding this type's package to the table, to support inheritance.
typeTable.addComplexSchema(getQualifiedName(javaType.getPackage()), schemaTypeName);
typeTable.addClassNameForQName(schemaTypeName, name);
BeanExcludeInfo beanExcludeInfo = null;
if (service.getExcludeInfo() != null) {
beanExcludeInfo = service.getExcludeInfo().getBeanExcludeInfoForClass(getClassName(javaType));
}
// we need to get properties only for this bean. hence ignore the super
// class properties
BeanInfo beanInfo = Introspector.getBeanInfo(javaType, javaType.getSuperclass());
for (PropertyDescriptor property : beanInfo.getPropertyDescriptors()) {
String propertyName = property.getName();
if (!property.getName().equals("class") && (property.getPropertyType() != null)) {
if (property.getReadMethod()!= null && ((beanExcludeInfo == null) || !beanExcludeInfo.isExcludedProperty(propertyName))) {
Type genericFieldType = property.getReadMethod().getGenericReturnType();
if(genericFieldType instanceof ParameterizedType){
ParameterizedType aType = (ParameterizedType) genericFieldType;
Type[] fieldArgTypes = aType.getActualTypeArguments();
if(Map.class.isAssignableFrom((Class)((ParameterizedType)aType).getRawType())){
generateWrappedSchemaTypeForMap(sequence, aType, propertyName);
} else if (Collection.class
.isAssignableFrom((Class) ((ParameterizedType) aType)
.getRawType())) {
generateWrappedSchemaTypeForCollection(
sequence, aType, propertyName);
} else {
try {
generateSchemaforGenericFields(xmlSchema,
sequence,
fieldArgTypes[0],
propertyName);
} catch (Exception e) {
generateSchemaforFieldsandProperties(xmlSchema,
sequence,
property.getPropertyType(),
propertyName,
property.getPropertyType().isArray());
}
}
} else if (genericFieldType != null && !(genericFieldType instanceof ParameterizedType)
&& Document.class
.isAssignableFrom((Class) genericFieldType)) {
generateSchemaTypeForDocument(sequence,
propertyName);
} else {
if(genericFieldType != null && Map.class.isAssignableFrom((Class) genericFieldType)){
generateWrappedSchemaTypeForMap(sequence, genericFieldType, propertyName);
} else if (genericFieldType != null
&& Collection.class
.isAssignableFrom((Class) genericFieldType)) {
generateWrappedSchemaTypeForCollection(
sequence, genericFieldType,
propertyName);
}else if (genericFieldType!=null && Enum.class.isAssignableFrom((Class)genericFieldType)) {
generateWrappedSchemaTypeForEnum(sequence , propertyName ,(Class)genericFieldType , false );
}else {
generateSchemaforFieldsandProperties(xmlSchema,
sequence,
property.getPropertyType(),
propertyName,
property.getPropertyType().isArray());
}
}
}
}
}
}
return schemaTypeName;
}