Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright (c) 2010-2011 Oracle and/or its affiliates. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License.  You can
  * obtain a copy of the License at
  * http://glassfish.java.net/public/CDDL+GPL_1_1.html
  * or packager/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at packager/legal/LICENSE.txt.
  *
  * GPL Classpath Exception:
  * Oracle designates this particular file as subject to the "Classpath"
  * exception as provided by Oracle in the GPL Version 2 section of the License
  * file that accompanied this code.
  *
  * Modifications:
  * If applicable, add the following below the License Header, with the fields
  * enclosed by brackets [] replaced by your own identifying information:
  * "Portions Copyright [year] [name of copyright owner]"
  *
  * Contributor(s):
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  */
 package com.sun.jersey.server.wadl.generators;
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
This com.sun.jersey.server.wadl.WadlGenerator generates a XML Schema content model based on referenced java beans. Created on: Jun 22, 2011

Author(s):
Gerard Davison
Version:
$Id: WadlGeneratorJAXBGrammarGenerator.java $
 
 public class WadlGeneratorJAXBGrammarGenerator implements WadlGenerator {
 
     // Wrapper interfaces so I can treat dispirate types the same
     // when processing them later
     //
    private static interface HasType
    {
        public Class getPrimaryClass();
        public Type getType();
    }
    private static interface WantsName
    {
        public void setNameQName name );
    }

    

Parameters:
param parameter.
Returns:
An adapter for Parameter
    private static HasType parameter(final Parameter param)
    {
        return new HasType() {
            public Class getPrimaryClass() {
                return param.getParameterClass();
            }
            public Type getType() {
                return param.getParameterType();
            }
        };
    }
    private class Pair {
        public Pair(HasType hasTypeWantsName wantsName) {
            this. = hasType;
            this. = wantsName;
        }
        HasType hasType;
        WantsName wantsName;
    }
    // Static final fields
    private static final Logger LOGGER = Logger.getLoggerWadlGeneratorJAXBGrammarGenerator.class.getName() );
    private static final java.util.Set<ClassSPECIAL_GENERIC_TYPES =
            new HashSet<Class>()
            {{
                    add(JResponse.class);
                    add(List.class);
                }};
    // Instance fields
    // The generator we are decorating
    private WadlGenerator _delegate;
    // Any SeeAlso references
    private Set<Class_seeAlso;
    // A matched list of Parm, Parameter to list the relavent
    // entity objects that we might like to transform.
    private List<Pair_hasTypeWantsName;
         = new WadlGeneratorImpl();
    }
    // =============== House keeping methods ================================
    public void setWadlGeneratorDelegateWadlGenerator delegate ) {
         = delegate;
    }
        return .getRequiredJaxbContextPath();
    }
    public void init() throws Exception {
        .init();
        //
         = new HashSet<Class>();
        // A matched list of Parm, Parameter to list the relavent
        // entity objects that we might like to transform.
         = new ArrayList<Pair>();
    }
    // =============== Application Creation ================================


    
    public Application createApplication() {
        return .createApplication();
    }

    
    public Method createMethodAbstractResource ar,
                                AbstractResourceMethod arm ) {
        return .createMethodararm );
    }

    
    public Request createRequestAbstractResource ar,
                                  AbstractResourceMethod arm ) {
        return .createRequestararm );
    }

    
    public Param createParamAbstractResource ar,
                              AbstractMethod amParameter p ) {
        final Param param = .createParamaramp );
        // If the paramter is an entity we probably want to convert this to XML
        //
        if (p.getSource() == ..) {
            .addnew Pair(
                    parameter(p),
                    new WantsName() {
                        public void setName(QName name) {
                            param.setType(name);
                        }
                    }));
        }
        return param;
    }

    
            AbstractResource arAbstractResourceMethod armMediaType mt ) {
        final Representation rt = .createRequestRepresentationararmmt );
        for (Parameter p : arm.getParameters()) {
            if (p.getSource() == ..) {
                .addnew Pair(
                        parameter(p),
                        new WantsName() {
                            @Override
                            public void setName(QName name) {
                                rt.setElement(name);
                            }
                        }));
            }
        }
        return rt;
    }

    

Parameters:
ar abstract resource
path resources path
Returns:
resource
See also:
com.sun.jersey.server.wadl.WadlGenerator.createResource(com.sun.jersey.api.model.AbstractResource,java.lang.String)
    public Resource createResourceAbstractResource arString path ) {
        Class cls = ar.getResourceClass();
        XmlSeeAlso seeAlso = (XmlSeeAlso)cls.getAnnotationXmlSeeAlso.class );
        if ( seeAlso !=null ) {
            Collections.addAll(seeAlso.value());
        }
        return .createResourcearpath );
    }

    
    public Resources createResources() {
        return .createResources();
    }

    
                                          final AbstractResourceMethod arm) {
        final List<Responseresponses = .createResponses(ararm );
        if (responses!=null) {
            HasType hasType = new HasType()  {
                @Override
                public Class getPrimaryClass() {
                    return arm.getReturnType();
                }
                public Type getType() {
                    return arm.getGenericReturnType();
                }
            };
            for(Response response : responses) {
                for (final Representation representation : response.getRepresentation()) {
                    // Process each representation
                    .add(new Pair(
                            hasType,
                            new WantsName() {
                                @Override
                                public void setName(QName name) {
                                    representation.setElement(name);
                                }
                            }));
                }
            }
        }
        return responses;
    }
    // ================ methods for post build actions =======================
        // Right now lets generate some external metadata
        Map<StringApplicationDescription.ExternalGrammarextraFiles =
                new HashMap<StringApplicationDescription.ExternalGrammar>();
        // Build the model as required
        Resolver resolver = buildModelAndSchemas(extraFiles);
        // Pass onto the next delegate
        previous.map.putAll(extraFiles);
        if (resolver!=null) {
            previous.addResolver(resolver);
        }
        return previous;
    }

    
Build the JAXB model and generate the schemas based on tha data

Parameters:
extraFiles
    private Resolver buildModelAndSchemas(Map<StringExternalGrammarextraFiles) {
        // Lets get all candidate classes so we can create the JAX-B context
        // include any @XmlSeeAlso references.
        Set<ClassclassSet = new HashSet<Class>();
        for ( Pair pair :  ) {
            HasType hasType = pair.hasType;
            Class clazz = hasType.getPrimaryClass();
            // Is this class itself interesting?
            if ( clazz.getAnnotationXmlRootElement.class ) !=null ) {
                classSet.addclazz );
            }
            else if ( .contains (clazz) ) {
                Type type = hasType.getType();
                if ( type instanceof ParameterizedType )
                {
                    Type parameterType = ((ParameterizedType)type).getActualTypeArguments()[0];
                    if (parameterType instanceof Class)
                    {
                        classSet.add( (ClassparameterType );
                    }
                }
            }
        }
        // Create a JAX-B context, and use this to generate us a bunch of
        // schema objects
        JAXBIntrospector introspector = null;
        try {
            JAXBContext context = JAXBContext.newInstanceclassSet.toArraynew Class[classSet.size()] ) );
            final List<StreamResultresults = new ArrayList<StreamResult>();
            context.generateSchemanew SchemaOutputResolver() {
                int counter = 0;
                @Override
                public Result createOutputString namespaceUriString suggestedFileName ) {
                    StreamResult result = new StreamResultnew CharArrayWriter() );
                    result.setSystemId"xsd" + (++)  + ".xsd");
                    results.add(result);
                    return result;
                }
            });
            // Store the new files for later use
            //
            for (StreamResult result : results) {
                CharArrayWriter writer = ( CharArrayWriter )result.getWriter();
                byte[] contents = writer.toString().getBytes"UTF8" );
                extraFiles.put(
                        result.getSystemId() ,
                        new ApplicationDescription.ExternalGrammar(
                                .// I don't think there is a specific media type for XML Schema
                                contents));
            }
            // Create an introspector
            //
            introspector = context.createJAXBIntrospector();
        } catch ( JAXBException e ) {
            .log."Failed to generate the schema for the JAX-B elements"e );
        }
        catch ( IOException e ) {
            .log."Failed to generate the schema for the JAX-B elements due to an IO error"e );
        }
        // Create introspector
        if (introspector!=null) {
            final JAXBIntrospector copy = introspector;
            return new Resolver() {
                @Override
                public QName resolve(Class type) {
                    Object parameterClassInstance = null;
                    try {
                        Constructor<?> defaultConstructor = type.getDeclaredConstructor();
                        defaultConstructor.setAccessible(true);
                        parameterClassInstance = defaultConstructor.newInstance();
                    } catch (InstantiationException ex) {
                        .log(.nullex);
                    } catch (IllegalAccessException ex) {
                        .log(.nullex);
                    } catch (IllegalArgumentException ex) {
                        .log(.nullex);
                    } catch (InvocationTargetException ex) {
                        .log(.nullex);
                    } catch (SecurityException ex) {
                        .log(.nullex);
                    } catch (NoSuchMethodException ex) {
                        .log(.nullex);
                    }
                    if (parameterClassInstance==null) {
                        return null;
                    }
                    try {
                        return copy.getElementName(parameterClassInstance);
                    } catch (NullPointerException e) {
                        // EclipseLink throws an NPE if an object annotated with @XmlType and without the @XmlRootElement
                        // annotation is passed as a parameter of #getElementName method.
                        return null;
                    }
                }
            };
        }
        else {
            return null// No resolver created
        }
    }
    @Override
    public void attachTypes(ApplicationDescription introspector) {
        // If we managed to get an introspector then lets go back an update the parameters
        if (introspector!=null) {
            int i = .size();
            nextItem : for ( int j = 0; j < ij++ ) {
                Pair pair = .getj );
                WantsName nextToProcess = pair.wantsName;
                HasType nextType = pair.hasType;
                // There is a method on the RI version that works with just
                // the class name; but using the introspector for the moment
                // as it leads to cleaner code
                Class<?> parameterClass = nextType.getPrimaryClass();
                // Fix those specific generic types
                if (.contains(parameterClass)) {
                    Type type = nextType.getType();
                    if (ParameterizedType.class.isAssignableFrom(type.getClass()) &&
                            Class.class.isAssignableFrom(((ParameterizedType)type).getActualTypeArguments()[0].getClass())) {
                        parameterClass = (Class) ((ParameterizedType)type).getActualTypeArguments()[0];
                    } else {
                        // Works around JERSEY-830
                        .info("Couldn't find JAX-B element due to nested parameterized type " + type);
                        return;
                    }
                }
                QName name = introspector.resolve(parameterClass);
                if ( name !=null ) {
                    nextToProcess.setName(name);
                } else  {
                    .info("Couldn't find JAX-B element for class " + parameterClass.getName());
                }
            }
        }
    }
New to GrepCode? Check out our FAQ X