org.glassfish.jersey.server.wadl.internal.generators.WadlGeneratorJAXBGrammarGenerator Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jaxrs-ri Show documentation
Show all versions of jaxrs-ri Show documentation
A bundle project producing JAX-RS RI bundles. The primary artifact is an "all-in-one" OSGi-fied JAX-RS RI bundle
(jaxrs-ri.jar).
Attached to that are two compressed JAX-RS RI archives. The first archive (jaxrs-ri.zip) consists of binary RI bits and
contains the API jar (under "api" directory), RI libraries (under "lib" directory) as well as all external
RI dependencies (under "ext" directory). The secondary archive (jaxrs-ri-src.zip) contains buildable JAX-RS RI source
bundle and contains the API jar (under "api" directory), RI sources (under "src" directory) as well as all external
RI dependencies (under "ext" directory). The second archive also contains "build.xml" ANT script that builds the RI
sources. To build the JAX-RS RI simply unzip the archive, cd to the created jaxrs-ri directory and invoke "ant" from
the command line.
/*
* Copyright (c) 2010, 2020 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package org.glassfish.jersey.server.wadl.internal.generators;
import java.io.CharArrayWriter;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import jakarta.ws.rs.core.GenericType;
import jakarta.ws.rs.core.MediaType;
import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.JAXBException;
import jakarta.xml.bind.JAXBIntrospector;
import jakarta.xml.bind.SchemaOutputResolver;
import jakarta.xml.bind.annotation.XmlRootElement;
import jakarta.xml.bind.annotation.XmlSeeAlso;
import javax.xml.namespace.QName;
import javax.xml.transform.Result;
import javax.xml.transform.stream.StreamResult;
import org.glassfish.jersey.server.model.Parameter;
import org.glassfish.jersey.server.wadl.WadlGenerator;
import org.glassfish.jersey.server.wadl.internal.ApplicationDescription;
import org.glassfish.jersey.server.wadl.internal.WadlGeneratorImpl;
import com.sun.research.ws.wadl.Application;
import com.sun.research.ws.wadl.Method;
import com.sun.research.ws.wadl.Param;
import com.sun.research.ws.wadl.Representation;
import com.sun.research.ws.wadl.Request;
import com.sun.research.ws.wadl.Resource;
import com.sun.research.ws.wadl.Resources;
import com.sun.research.ws.wadl.Response;
/**
* This {@link org.glassfish.jersey.server.wadl.WadlGenerator} generates a XML Schema content model based on
* referenced java beans.
*
* Created on: Jun 22, 2011
*
* @author Gerard Davison
* @author Miroslav Fuksa
*/
public class WadlGeneratorJAXBGrammarGenerator implements WadlGenerator {
private static interface NameCallbackSetter {
public void setName(QName name);
}
private class TypeCallbackPair {
public TypeCallbackPair(final GenericType genericType, final NameCallbackSetter nameCallbackSetter) {
this.genericType = genericType;
this.nameCallbackSetter = nameCallbackSetter;
}
GenericType genericType;
NameCallbackSetter nameCallbackSetter;
}
private static final Logger LOGGER = Logger.getLogger(WadlGeneratorJAXBGrammarGenerator.class.getName());
private static final java.util.Set SPECIAL_GENERIC_TYPES =
new HashSet() {{
// TODO - J2 - we do not have JResponse but we should support GenericEntity
// add(JResponse.class);
add(List.class);
}};
// The generator we are decorating
private WadlGenerator wadlGeneratorDelegate;
// Any SeeAlso references
private Set seeAlsoClasses;
// A matched list of Parm, Parameter to list the relavent
// entity objects that we might like to transform.
private List nameCallbacks;
public WadlGeneratorJAXBGrammarGenerator() {
wadlGeneratorDelegate = new WadlGeneratorImpl();
}
// =============== House keeping methods ================================
public void setWadlGeneratorDelegate(final WadlGenerator delegate) {
wadlGeneratorDelegate = delegate;
}
public String getRequiredJaxbContextPath() {
return wadlGeneratorDelegate.getRequiredJaxbContextPath();
}
public void init() throws Exception {
wadlGeneratorDelegate.init();
//
seeAlsoClasses = new HashSet<>();
// A matched list of Parm, Parameter to list the relavent
// entity objects that we might like to transform.
nameCallbacks = new ArrayList<>();
}
// =============== Application Creation ================================
/**
* @return application
* @see org.glassfish.jersey.server.wadl.WadlGenerator#createApplication()
*/
public Application createApplication() {
return wadlGeneratorDelegate.createApplication();
}
/**
* @param ar abstract resource
* @param arm abstract resource method
* @return method
* @see org.glassfish.jersey.server.wadl.WadlGenerator#createMethod(org.glassfish.jersey.server.model.Resource,
* org.glassfish.jersey.server.model.ResourceMethod)
*/
public Method createMethod(final org.glassfish.jersey.server.model.Resource ar,
final org.glassfish.jersey.server.model.ResourceMethod arm) {
return wadlGeneratorDelegate.createMethod(ar, arm);
}
/**
* @param ar abstract resource
* @param arm abstract resource method
* @return request
* @see org.glassfish.jersey.server.wadl.WadlGenerator#createRequest(org.glassfish.jersey.server.model.Resource,
* org.glassfish.jersey.server.model.ResourceMethod)
*/
public Request createRequest(final org.glassfish.jersey.server.model.Resource ar,
final org.glassfish.jersey.server.model.ResourceMethod arm) {
return wadlGeneratorDelegate.createRequest(ar, arm);
}
/**
* @param ar abstract resource
* @param am abstract method
* @param p parameter
* @return parameter
* @see org.glassfish.jersey.server.wadl.WadlGenerator#createParam(org.glassfish.jersey.server.model.Resource,
* org.glassfish.jersey.server.model.ResourceMethod, org.glassfish.jersey.server.model.Parameter)
*/
public Param createParam(final org.glassfish.jersey.server.model.Resource ar,
final org.glassfish.jersey.server.model.ResourceMethod am, final Parameter p) {
final Param param = wadlGeneratorDelegate.createParam(ar, am, p);
// If the parameter is an entity we probably want to convert this to XML
if (p.getSource() == Parameter.Source.ENTITY) {
nameCallbacks.add(new TypeCallbackPair(
new GenericType(p.getType()),
new NameCallbackSetter() {
public void setName(final QName name) {
param.setType(name);
}
}));
}
return param;
}
/**
* @param ar abstract resource
* @param arm abstract resource method
* @param mt media type
* @return respresentation type
* @see org.glassfish.jersey.server.wadl.WadlGenerator#createRequestRepresentation(org.glassfish.jersey.server.model.Resource,
* org.glassfish.jersey.server.model.ResourceMethod, jakarta.ws.rs.core.MediaType)
*/
public Representation createRequestRepresentation(
final org.glassfish.jersey.server.model.Resource ar,
final org.glassfish.jersey.server.model.ResourceMethod arm,
final MediaType mt) {
final Representation rt = wadlGeneratorDelegate.createRequestRepresentation(ar, arm, mt);
for (final Parameter p : arm.getInvocable().getParameters()) {
if (p.getSource() == Parameter.Source.ENTITY) {
nameCallbacks.add(new TypeCallbackPair(
new GenericType(p.getType()),
new NameCallbackSetter() {
@Override
public void setName(final QName name) {
rt.setElement(name);
}
}));
}
}
return rt;
}
/**
* @param ar abstract resource
* @param path resources path
* @return resource
* @see org.glassfish.jersey.server.wadl.WadlGenerator#createResource(org.glassfish.jersey.server.model.Resource, String)
*/
public Resource createResource(final org.glassfish.jersey.server.model.Resource ar, final String path) {
for (final Class resClass : ar.getHandlerClasses()) {
final XmlSeeAlso seeAlso = resClass.getAnnotation(XmlSeeAlso.class);
if (seeAlso != null) {
Collections.addAll(seeAlsoClasses, seeAlso.value());
}
}
return wadlGeneratorDelegate.createResource(ar, path);
}
/**
* @return resources
* @see org.glassfish.jersey.server.wadl.WadlGenerator#createResources()
*/
public Resources createResources() {
return wadlGeneratorDelegate.createResources();
}
/**
* @param resource abstract resource
* @param resourceMethod abstract resource method
* @return response
* @see org.glassfish.jersey.server.wadl.WadlGenerator#createResponses(org.glassfish.jersey.server.model.Resource,
* org.glassfish.jersey.server.model.ResourceMethod)
*/
public List createResponses(final org.glassfish.jersey.server.model.Resource resource,
final org.glassfish.jersey.server.model.ResourceMethod resourceMethod) {
final List responses = wadlGeneratorDelegate.createResponses(resource, resourceMethod);
if (responses != null) {
for (final Response response : responses) {
for (final Representation representation : response.getRepresentation()) {
// Process each representation
nameCallbacks.add(new TypeCallbackPair(
new GenericType(resourceMethod.getInvocable().getResponseType()),
new NameCallbackSetter() {
public void setName(final QName name) {
representation.setElement(name);
}
}));
}
}
}
return responses;
}
// ================ methods for post build actions =======================
public ExternalGrammarDefinition createExternalGrammar() {
// Right now lets generate some external metadata
final Map extraFiles = new HashMap<>();
// Build the model as required
final Resolver resolver = buildModelAndSchemas(extraFiles);
// Pass onto the next delegate
final ExternalGrammarDefinition previous = wadlGeneratorDelegate.createExternalGrammar();
previous.map.putAll(extraFiles);
if (resolver != null) {
previous.addResolver(resolver);
}
return previous;
}
/**
* Build the JAXB model and generate the schemas based on tha data
*
* @param extraFiles additional files.
* @return class to {@link QName} resolver.
*/
private Resolver buildModelAndSchemas(final Map extraFiles) {
// Lets get all candidate classes so we can create the JAX-B context
// include any @XmlSeeAlso references.
final Set classSet = new HashSet<>(seeAlsoClasses);
for (final TypeCallbackPair pair : nameCallbacks) {
final GenericType genericType = pair.genericType;
final Class clazz = genericType.getRawType();
// Is this class itself interesting?
if (clazz.getAnnotation(XmlRootElement.class) != null) {
classSet.add(clazz);
} else if (SPECIAL_GENERIC_TYPES.contains(clazz)) {
final Type type = genericType.getType();
if (type instanceof ParameterizedType) {
final Type parameterType = ((ParameterizedType) type).getActualTypeArguments()[0];
if (parameterType instanceof Class) {
classSet.add((Class) parameterType);
}
}
}
}
// Create a JAX-B context, and use this to generate us a bunch of
// schema objects
JAXBIntrospector introspector = null;
try {
final JAXBContext context = JAXBContext.newInstance(classSet.toArray(new Class[classSet.size()]));
final List results = new ArrayList<>();
context.generateSchema(new SchemaOutputResolver() {
int counter = 0;
@Override
public Result createOutput(final String namespaceUri, final String suggestedFileName) {
final StreamResult result = new StreamResult(new CharArrayWriter());
result.setSystemId("xsd" + (counter++) + ".xsd");
results.add(result);
return result;
}
});
// Store the new files for later use
//
for (final StreamResult result : results) {
final CharArrayWriter writer = (CharArrayWriter) result.getWriter();
final byte[] contents = writer.toString().getBytes("UTF8");
extraFiles.put(
result.getSystemId(),
new ApplicationDescription.ExternalGrammar(
MediaType.APPLICATION_XML_TYPE, // I don't think there is a specific media type for XML Schema
contents));
}
// Create an introspector
//
introspector = context.createJAXBIntrospector();
} catch (final JAXBException e) {
LOGGER.log(Level.SEVERE, "Failed to generate the schema for the JAX-B elements", e);
} catch (final IOException e) {
LOGGER.log(Level.SEVERE, "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() {
public QName resolve(final Class type) {
Object parameterClassInstance = null;
try {
final Constructor defaultConstructor =
AccessController.doPrivileged(new PrivilegedExceptionAction>() {
@SuppressWarnings("unchecked")
@Override
public Constructor run() throws NoSuchMethodException {
final Constructor constructor = type.getDeclaredConstructor();
constructor.setAccessible(true);
return constructor;
}
});
parameterClassInstance = defaultConstructor.newInstance();
} catch (final InstantiationException | SecurityException | IllegalAccessException
| IllegalArgumentException | InvocationTargetException ex) {
LOGGER.log(Level.FINE, null, ex);
} catch (final PrivilegedActionException ex) {
LOGGER.log(Level.FINE, null, ex.getCause());
}
if (parameterClassInstance == null) {
return null;
}
try {
return copy.getElementName(parameterClassInstance);
} catch (final 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
}
}
public void attachTypes(final ApplicationDescription introspector) {
// If we managed to get an introspector then lets go back an update the parameters
if (introspector != null) {
for (final TypeCallbackPair pair : nameCallbacks) {
// 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 = pair.genericType.getRawType();
// Fix those specific generic types
if (SPECIAL_GENERIC_TYPES.contains(parameterClass)) {
final Type type = pair.genericType.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
LOGGER.fine("Couldn't find JAX-B element due to nested parameterized type " + type);
return;
}
}
final QName name = introspector.resolve(parameterClass);
if (name != null) {
pair.nameCallbackSetter.setName(name);
} else {
LOGGER.fine("Couldn't find JAX-B element for class " + parameterClass.getName());
}
}
}
}
}