Java tutorial
/******************************************************************************* * Copyright (c) 2010-2014 SAP AG and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * SAP AG - initial API and implementation *******************************************************************************/ package org.eclipse.skalli.services.extension.rest; import java.io.IOException; import java.io.InputStream; import java.io.Reader; import java.io.Writer; import java.text.MessageFormat; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import org.apache.commons.lang.StringUtils; import org.eclipse.skalli.services.Services; import org.eclipse.skalli.services.rest.RequestContext; import org.eclipse.skalli.services.rest.RestReader; import org.eclipse.skalli.services.rest.RestService; import org.eclipse.skalli.services.rest.RestWriter; import org.restlet.data.MediaType; import org.restlet.representation.Representation; import org.restlet.representation.WriterRepresentation; import com.thoughtworks.xstream.XStream; import com.thoughtworks.xstream.io.xml.CompactWriter; import com.thoughtworks.xstream.mapper.MapperWrapper; /** * Base class for REST resources based on XStream as converter technology between beans * and their XML representation. * * @param <T> the type of the bean with which this REST representation is associated. */ public class ResourceRepresentation<T> extends WriterRepresentation { private static final String RELATIVE_LINKS = "relative"; //$NON-NLS-1$ private static final String LINKS_QUERY_ATTRIBUTE = "links"; //$NON-NLS-1$ private static final String MEMBERS_QUERY_ATTRIBUTE = "members"; //$NON-NLS-1$ private static final String ALL_MEMBERS = "all"; //$NON-NLS-1$ private T object; private RequestContext context; private RestConverter<T> converter; private XStream xstream; private Set<Class<?>> annotatedClasses = new HashSet<Class<?>>(); private Set<RestConverter<?>> converters = new HashSet<RestConverter<?>>(); private Map<String, Class<?>> aliases = new HashMap<String, Class<?>>(); private ClassLoader classLoader; private boolean compact; /** * Creates an uninitialized representation for converting an XML representation * into an instance of the bean. */ public ResourceRepresentation() { super(MediaType.APPLICATION_XML); } /** * Creates a representation initialized with the given bean instance for * converting it to its XML representation. * * @param object a bean instance. */ @Deprecated public ResourceRepresentation(T object) { this(); this.object = object; if (object != null) { addAnnotatedClass(object.getClass()); } } /** * Creates a representation initialized with the given bean instance for * converting it to its XML representation, and adds additional converters * for non-standard property types. * * @param object a bean instance. * @param converters additional converters that may be necessary for * conversion of certain properties or inner beans of the bean. */ @Deprecated public ResourceRepresentation(T object, RestConverter<?>... converters) { this(object); if (converters != null) { for (RestConverter<?> converter : converters) { addConverter(converter); } } } /** * Creates a resource representation for unmarshalling an input stream to * an object using the given REST converter. The REST converter must implement * {@link RestConverter#unmarshal(RestReader)}. * * @param context * @param converter */ public ResourceRepresentation(RequestContext context, RestConverter<T> converter) { super(context.getMediaType()); this.context = context; this.converter = converter; } /** * Creates a resource representation for marshalling a given object to * an output stream using the given REST converter. The REST converter must implement * {@link RestConverter#marshal(Object, RestWriter)}. * * @param context the request context. * @param object the object to convert. * @param converter the converter to use. */ public ResourceRepresentation(RequestContext context, T object, RestConverter<T> converter) { this(context, converter); this.object = object; } @Override public void write(Writer writer) throws IOException { if (object != null) { if (context == null) { writer.append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"); //$NON-NLS-1$ XStream xstream = getXStream(); if (compact) { xstream.marshal(object, new CompactWriter(writer)); } else { xstream.toXML(object, writer); } } else if (converter.getConversionClass().isAssignableFrom(object.getClass())) { RestService restService = Services.getRequiredService(RestService.class); MediaType mediaType = context.getMediaType(); if (!restService.isSupported(context)) { throw new IOException(MessageFormat.format("Unsupported media type ''{0}''", mediaType)); } RestWriter restWriter = restService.getRestWriter(writer, context); String hrefQueryAttr = context.getQueryAttribute(LINKS_QUERY_ATTRIBUTE); if (RELATIVE_LINKS.equalsIgnoreCase(hrefQueryAttr)) { restWriter.set(RestWriter.RELATIVE_LINKS); } String membersQueryAttr = context.getQueryAttribute(MEMBERS_QUERY_ATTRIBUTE); if (ALL_MEMBERS.equalsIgnoreCase(membersQueryAttr)) { restWriter.set(RestWriter.ALL_MEMBERS); } try { converter.marshal(object, restWriter); } catch (RuntimeException e) { // don't trust the integrity of plugins! throw new IOException( MessageFormat.format("Failed to write response for {0}", context.getPath()), e); } finally { restWriter.flush(); } } else { throw new IOException("Failed to create resource representation"); } } } public T read(Reader reader) throws IOException, RestException { RestService restService = Services.getRequiredService(RestService.class); if (!restService.isSupported(context)) { throw new IOException(MessageFormat.format("Unsupported media type ''{0}''", context.getMediaType())); } RestReader restReader = restService.getRestReader(reader, context); try { return converter.unmarshal(restReader); } catch (RuntimeException e) { // don't trust the integrity of plugins! throw new RestException( MessageFormat.format("Failed to read request {0} {1}", context.getAction(), context.getPath()), e); } } /** * Reads the XML representation of a bean from a given representation (e.g. a string * or a socket) and initializes a bean instance from it. * * @param representation the representation from which to read the XML representation of the bean. * @param c the class of the bean to instantiate. * * @return an instance of the requested bean class initialized from it XML representation. * * @throws IOException if reading the bean caused an i/o error. * @throws ClassCastExeption if the XML representation of the bean cannot be casted to the * requested class. */ @Deprecated public T read(Representation representation, Class<T> c) throws IOException { return read(representation.getStream(), c); } /** * Reads the XML representation of a bean from a given input stream and initializes * a bean instance from it. * * @param in the stream to read. * @param c the class of the bean to instantiate. * * @return an instance of the requested bean class initialized from it XML representation. * * @throws IOException if reading the bean caused an i/o error. * @throws ClassCastExeption if the XML representation of the bean cannot be casted to the * requested class. */ @Deprecated public T read(InputStream in, Class<T> c) throws IOException { return c.cast(getXStream().fromXML(in)); } /** * Adds an additional class with XStream annotations that represents an inner structure * of the class to convert, e.g. the entries of a collection-like property. If the class * to convert and the classes representing its inner structure live in different bundles, * calling this method is mandatory. * <p> * The class to convert is automatically added. * * @param annotatedClass the class to add to the conversion. */ @Deprecated public void addAnnotatedClass(Class<?> annotatedClass) { if (annotatedClass != null) { annotatedClasses.add(annotatedClass); } } /** * Adds an alias name for a given type. * * @param name the alias. * @param type the class for which to use the alias. */ @Deprecated public void addAlias(String name, Class<?> type) { if (StringUtils.isNotBlank(name) && type != null) { aliases.put(name, type); } } /** * Adds an additional converter for the conversion of certain properties * or inner classes, which are not supported by XStream out-of-the-box. * * @param converter the REST converter to add. */ @Deprecated public void addConverter(RestConverter<?> converter) { if (converter != null) { converters.add(converter); } } /** * Sets an alternative classloader for the conversion. * @param classLoader the classloader to use, or <code>null</code> * if the default classloader should be used. */ @Deprecated public void setClassLoader(ClassLoader classLoader) { this.classLoader = classLoader; } /** * Sets an alternative {@link XStream} instance. By default, a suitable * <code>XStream</code> instance is constructed automatically. * * @param xstream a <code>XStream</code> instance, or <code>null</code> * if the default <code>XStream</code> instance should be used. */ @Deprecated public void setXStream(XStream xstream) { this.xstream = xstream; } /** * Switches compact output on or off (default is off). Switching on * compact output will remove line breaks and indentations from the output * performing slightly faster and reducing the amount of data written * to the underlying socket. * * @param compact if <code>true</code> the output is compacted. */ @Deprecated public void setCompact(boolean compact) { this.compact = compact; } /** * Creates an <code>XStream</code> instance for rendering/parsing the XML * representation of the bean. * * @return an <code>XStream</code> instance pre-initialized with the * specified {@link #setClassLoader(ClassLoader) class loader}, * {@link #setConverters(RestConverter...) converters} and * {@link #setAnnotatedClasses(Class...) (inner) bean classes}. A special * wrapper is used to skip unknown tags in the XML representation. * {@link XStream#NO_REFERENCES} is set so that references betweem tags * are always resolved. */ @Deprecated protected XStream getXStream() { if (xstream != null) { return xstream; } XStream result = new XStream() { @Override protected MapperWrapper wrapMapper(MapperWrapper next) { return new MapperWrapperIgnoreUnknownElements(next); } }; for (RestConverter<?> converter : converters) { result.registerConverter(converter); result.alias(converter.getAlias(), converter.getConversionClass()); } for (Class<?> annotatedClass : annotatedClasses) { result.processAnnotations(annotatedClass); } for (Entry<String, Class<?>> alias : aliases.entrySet()) { result.alias(alias.getKey(), alias.getValue()); } if (classLoader != null) { result.setClassLoader(classLoader); } result.setMode(XStream.NO_REFERENCES); return result; } @Deprecated private static class MapperWrapperIgnoreUnknownElements extends MapperWrapper { public MapperWrapperIgnoreUnknownElements(MapperWrapper next) { super(next); } @SuppressWarnings("rawtypes") @Override public boolean shouldSerializeMember(Class definedIn, String fieldName) { if (definedIn == Object.class) { return false; } return super.shouldSerializeMember(definedIn, fieldName); } } }