jaxbtype.java

Xfire文件 用于开发web service 的一个开源工具 很好用的

package org.codehaus.xfire.jaxb2;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import javax.xml.XMLConstants;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.SchemaOutputResolver;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.annotation.XmlEnum;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlSchema;
import javax.xml.bind.annotation.XmlType;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
import javax.xml.transform.Result;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.codehaus.xfire.MessageContext;
import org.codehaus.xfire.XFireRuntimeException;
import org.codehaus.xfire.aegis.AegisBindingProvider;
import org.codehaus.xfire.aegis.MessageReader;
import org.codehaus.xfire.aegis.MessageWriter;
import org.codehaus.xfire.aegis.stax.ElementWriter;
import org.codehaus.xfire.aegis.type.Type;
import org.codehaus.xfire.fault.XFireFault;
import org.codehaus.xfire.service.MessagePartInfo;
import org.codehaus.xfire.service.binding.ObjectServiceFactory;
import org.codehaus.xfire.soap.SoapConstants;
import org.codehaus.xfire.transport.Channel;
import org.codehaus.xfire.util.Resolver;
import org.codehaus.xfire.util.stax.DOMStreamWriter;
import org.jdom.Element;
import org.xml.sax.SAXException;


public class JaxbType
    extends Type
{
	
	private static final Log LOG = LogFactory.getLog(JaxbType.class);
	public static final String SEARCH_PACKAGES = "jaxb.search.packages";
    public static final String ENABLE_VALIDATION = "jaxb.validation.enabled";
    public static final String ENABLE_RESPONSE_VALIDATION = "jaxb.validation.response.enabled";
    public static final String ENABLE_REQUEST_VALIDATION = "jaxb.validation.request.enabled";
    public static final String VALIDATION_SCHEMA = "jaxb.validation.schema";
    public static final String GENERATED_VALIDATION_SCHEMA = "jaxb.generated.validation.schema";
    
    private Class actualTypeClass;
    private static final QName XSI_TYPE = new QName(SoapConstants.XSI_NS, "type");
    private JAXBContext context;
    private Class< ? extends XmlAdapter> adapterClz;

    public JaxbType(Class clazz)
    {
        this(clazz, null);
    }
    
    public JaxbType(Class clazz, JAXBContext jaxbContext)
    {
        setTypeClass(clazz);

        initType();
        
        this.context = jaxbContext;
    }

     private Schema setupValidationSchema(Collection<String> schemaLocations) throws IOException, SAXException {
        
        SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
        StreamSource[] schemaSources = new StreamSource[schemaLocations.size()];
        Schema schema;

        try {
            int i = 0;
            for (Iterator itr = schemaLocations.iterator(); itr.hasNext();) {
                String schemaLocation = (String) itr.next();
                schemaSources[i] = new StreamSource(new Resolver(schemaLocation).getInputStream());
                i++;
            }
            
            schema = factory.newSchema(schemaSources);
        }
        /** make sure to close all ressources * */
        finally {
            for (int i = 0; i < schemaSources.length; i++) {
                if (schemaSources[i] != null) {
                    InputStream inputStream = schemaSources[i].getInputStream();
                    if (inputStream != null) {
                        inputStream.close();
                    }
                }
            }
        }
        
        return schema;
    }

    @SuppressWarnings("unchecked")
     private Schema getValidationSchema(MessageContext context, JAXBContext jc) {
         // check if we have a cached schema instance
         Schema schema = (Schema) context.getService()
                .getProperty(GENERATED_VALIDATION_SCHEMA);
         
         if (schema != null) {
        	 return schema;
        }
         
        // Do we have schema dedicated to validation
        Collection<String> schemas = (Collection<String>) context
                .getContextualProperty(VALIDATION_SCHEMA);
         
         if (schemas == null) {
            // No, we don't, so use schema specifed on service
            schemas = (Collection<String>) context.getService()
                    .getProperty(ObjectServiceFactory.SCHEMAS);
        }

         try {
        	 if (schemas != null) {
        		 // We have some schema loaded, so set them up on unmarshaler
        		 schema = setupValidationSchema(schemas);
        	 } else {
        		 final List<DOMResult> results = new ArrayList<DOMResult>();

        		 jc.generateSchema(new SchemaOutputResolver() {
                    public Result createOutput(String ns, String file)
        			 	throws IOException {
                        DOMResult result = new DOMResult();
                        result.setSystemId(file);
                        results.add(result);
                        return result;
                    }
                });

                DOMSource[] sources = new DOMSource[results.size()];
                for (int i = 0; i < sources.length; i++) {
                    sources[i] = new DOMSource();
                    sources[i].setNode(results.get(i).getNode().getFirstChild());
                }
                SchemaFactory factory = SchemaFactory
                        .newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);

                schema = factory.newSchema(sources);
            }
                 
            // Put generated schema on context
        	 context.getService().setProperty(GENERATED_VALIDATION_SCHEMA, schema);

         } catch (IOException e) {
            // we have configuration problem, so break to application
            throw new XFireRuntimeException("Error creating validating schema.", e);
         } catch (SAXException e) {
            throw new XFireRuntimeException("Error creating validating schema.", e);
        }

         return schema;
    }
     
    @SuppressWarnings("unchecked")
    public Object readObject(MessageReader reader, MessageContext context)
        throws XFireFault
    {
        try
        {
            JAXBContext jc = getJAXBContext(context);
            Unmarshaller u = jc.createUnmarshaller();
            
            u.setAttachmentUnmarshaller(new AttachmentUnmarshaller(context));
            
            // check if validation is enabled
            boolean validationEnabled = Boolean.valueOf((String) context.getContextualProperty(ENABLE_VALIDATION));
            boolean requestValidation = Boolean.valueOf((String) context.getContextualProperty(ENABLE_REQUEST_VALIDATION));
            if (validationEnabled || requestValidation) {
            	u.setSchema(getValidationSchema(context, jc));
            }
            
            Object o;
            if (isAbstract() && reader.getAttributeReader(XSI_TYPE).getValue() == null)
                o = u.unmarshal(reader.getXMLStreamReader(), actualTypeClass);
            else
                o = u.unmarshal(reader.getXMLStreamReader());
            
            if (o instanceof JAXBElement)
            {
                o = ((JAXBElement) o).getValue();
            }
            
            return o;
        }
        catch (JAXBException e)
        {
            Throwable ex = e;
            if( e.getLinkedException()!= null ){
                ex = e.getLinkedException();
            } 
            LOG.error(ex);
            throw new XFireFault("Could not unmarshall type : "+ ex.getMessage(), ex, XFireFault.RECEIVER);
        }

    }

    @SuppressWarnings("unchecked")
	public void writeObject(Object object, MessageWriter writer, MessageContext context)
        throws XFireFault
    {
        try
        {
            JAXBContext jc = getJAXBContext(context);

            Marshaller m = jc.createMarshaller();
            m.setProperty(Marshaller.JAXB_FRAGMENT, Boolean.TRUE);
            m.setAttachmentMarshaller(new AttachmentMarshaller(context));

            // check if validation is enabled
            boolean validationEnabled = Boolean.valueOf((String) context.getContextualProperty(ENABLE_VALIDATION));
            boolean responseValidation = Boolean.valueOf((String) context.getContextualProperty(ENABLE_RESPONSE_VALIDATION));
            if (validationEnabled || responseValidation) {
            	m.setSchema(getValidationSchema(context, jc));
            }
            
            if (isAbstract())
            {
                MessagePartInfo part = (MessagePartInfo) 
                    context.getProperty(AegisBindingProvider.CURRENT_MESSAGE_PART);
                object = new JAXBElement(part.getName(), getTypeClass(), object);
            }
            
            XMLStreamWriter xsw = ((ElementWriter) writer).getXMLStreamWriter();
            OutputStream os = (OutputStream) context.getOutMessage().getProperty(Channel.OUTPUTSTREAM);
            if (os != null && !(xsw instanceof DOMStreamWriter))
            {
                xsw.writeCharacters("");
                xsw.flush();
                m.setProperty(Marshaller.JAXB_ENCODING, context.getOutMessage().getEncoding());
                m.marshal(object, os);
            }
            else
            {
                m.marshal(object, ((ElementWriter) writer).getXMLStreamWriter());
            }
        }
        catch (JAXBException e)
        {
            throw new XFireFault("Could not marshall type.", e, XFireFault.RECEIVER);
        }
        catch (XMLStreamException e)
        {
            throw new XFireFault("Could not marshall type.", e, XFireFault.RECEIVER);
        }
    }

    @SuppressWarnings("unchecked")
    public synchronized JAXBContext getJAXBContext(MessageContext mc)
        throws JAXBException
    {
        if (context == null)
        {
            String pckg = getPackage(getTypeClass().getName());
            
            Collection extraPackages = 
                (Collection) mc.getContextualProperty(SEARCH_PACKAGES);
            
            if (extraPackages == null) 
            {
                extraPackages = new HashSet();
            }
        
            StringBuilder pckgs = new StringBuilder();
            Set<String> pkgSet = new HashSet<String>();
            pkgSet.addAll(extraPackages);
            pkgSet.add(pckg);
            
            boolean first = true;
            
            for (String p : pkgSet)
            {
                if (!first) pckgs.append(":");
                else first = false;
                
                pckgs.append(p);
            }
            pckg = pckgs.toString();
           
            context = JAXBContext.newInstance(pckg);
        }
        
        return context;
    }
    
    private String getPackage(String pckg)
    {
        int i = pckg.lastIndexOf(".");
        if (i != -1)
            pckg = pckg.substring(0, i);
        return pckg;
    }

    @Override
    public boolean isComplex()
    {
        return true;
    }

    @Override
    public boolean isWriteOuter()
    {
        return false;
    }

    @Override
    public QName getSchemaType()
    {
        return super.getSchemaType();
    }
    
    @SuppressWarnings("unchecked")
    public void initType()
    {
        Class clazz = getTypeClass();
        initType(clazz);
    }
    
    public void initType(Class<?> clazz)
    {
        actualTypeClass = clazz;
        XmlRootElement root = (XmlRootElement) clazz.getAnnotation(XmlRootElement.class);
        XmlType type = (XmlType) clazz.getAnnotation(XmlType.class);
        String local = null;
        String nsUri = null;
        
        if (root != null)
        {
            setAbstract(false);
            local = root.name();
            nsUri = root.namespace();
        }
        else if (type != null)
        {
            setAbstract(true);
            local = type.name();
            nsUri = type.namespace();
        }
        else if (clazz.isAnnotationPresent(XmlEnum.class))
        {
            setAbstract(true);
            local = clazz.getSimpleName();
            nsUri = "##default";
        }
        else if (clazz.isAnnotationPresent(XmlJavaTypeAdapter.class))
        {
            XmlJavaTypeAdapter xjta = clazz.getAnnotation(XmlJavaTypeAdapter.class);
            adapterClz = xjta.value();
            
            ParameterizedType genericSuperclass = (ParameterizedType) adapterClz.getGenericSuperclass();
            Class impl = (Class) genericSuperclass.getActualTypeArguments()[0];
            initType(impl);
            return;
        }
        else
        {
            throw new XFireRuntimeException("Couldn't determine element name.");
        }
        
        if (local.equals("##default"))
        {
            local = clazz.getSimpleName();
        }
        
        if (nsUri.equals("##default") || nsUri.equals(""))
        {
            nsUri = getPackageNs(clazz);
        }

        setSchemaType(new QName(nsUri, local));
    }

    public static String getPackageNs(Class clazz)
    {
        AnnotatedElement pack =  clazz.getPackage();
        //getPackage isn't guaranteed to return a package
        if (pack == null) 
        {
            try
            {
                pack = Class.forName(clazz.getName().substring(0, clazz.getName().lastIndexOf('.'))
                        + ".package-info", false, clazz.getClassLoader());
            }
            catch (Exception ex)
            {
            }
        }
        
        if (pack == null)
        {
            throw new XFireRuntimeException("No package info found for class " + clazz.getName()
                    + ". Cannot lookup default schema namespace");
        }
        
        XmlSchema schema = pack.getAnnotation(XmlSchema.class);
        String namespace = null;
        if (schema != null)
        {
            namespace = schema.namespace();
        }
        else
        {
            namespace = "";
        }
        return namespace;
    }

    /**
     * JAXB doesn't retain all the schema information at runtime, so schemas
     * must be added manually. So, this method does absolutely nothing.
     */
    @Override
    public void writeSchema(Element root)
    {
    }

    public Class getActualTypeClass()
    {
        return actualTypeClass;
    }
    
}