Java tutorial
/* * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. * * Copyright (c) 1997-2017 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 * https://oss.oracle.com/licenses/CDDL+GPL-1.1 * or 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 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 javax.activation; import java.io.InputStream; import java.io.IOException; import java.io.OutputStream; import java.io.PipedInputStream; import java.io.PipedOutputStream; import java.io.OutputStreamWriter; import java.net.URL; //import java.awt.datatransfer.Transferable; //import java.awt.datatransfer.DataFlavor; //import java.awt.datatransfer.UnsupportedFlavorException; /** * The DataHandler class provides a consistent interface to data * available in many different sources and formats. * It manages simple stream to string conversions and related operations * using DataContentHandlers. * It provides access to commands that can operate on the data. * The commands are found using a CommandMap. <p> * * <b>DataHandler and the Transferable Interface</b><p> * DataHandler implements the Transferable interface so that data can * be used in AWT data transfer operations, such as cut and paste and * drag and drop. The implementation of the Transferable interface * relies on the availability of an installed DataContentHandler * object corresponding to the MIME type of the data represented in * the specific instance of the DataHandler.<p> * * <b>DataHandler and CommandMaps</b><p> * The DataHandler keeps track of the current CommandMap that it uses to * service requests for commands (<code>getCommand</code>, * <code>getAllCommands</code>, <code>getPreferredCommands</code>). * Each instance of a DataHandler may have a CommandMap associated with * it using the <code>setCommandMap</code> method. If a CommandMap was * not set, DataHandler calls the <code>getDefaultCommandMap</code> * method in CommandMap and uses the value it returns. See * <i>CommandMap</i> for more information. <p> * * <b>DataHandler and URLs</b><p> * The current DataHandler implementation creates a private * instance of URLDataSource when it is constructed with a URL. * * @see javax.activation.CommandMap * @see javax.activation.DataContentHandler * @see javax.activation.DataSource * @see javax.activation.URLDataSource */ public class DataHandler /*implements Transferable*/ { // Use the datasource to indicate whether we were started via the // DataSource constructor or the object constructor. private DataSource dataSource = null; private DataSource objDataSource = null; // The Object and mimetype from the constructor (if passed in). // object remains null if it was instantiated with a // DataSource. private Object object = null; private String objectMimeType = null; // Keep track of the CommandMap private CommandMap currentCommandMap = null; // our transfer flavors private static final ActivationDataFlavor emptyFlavors[] = new ActivationDataFlavor[0]; private ActivationDataFlavor transferFlavors[] = emptyFlavors; // our DataContentHandler private DataContentHandler dataContentHandler = null; private DataContentHandler factoryDCH = null; // our DataContentHandlerFactory private static DataContentHandlerFactory factory = null; private DataContentHandlerFactory oldFactory = null; // the short representation of the ContentType (sans params) private String shortType = null; /** * Create a <code>DataHandler</code> instance referencing the * specified DataSource. The data exists in a byte stream form. * The DataSource will provide an InputStream to access the data. * * @param ds the DataSource */ public DataHandler(DataSource ds) { // save a reference to the incoming DS dataSource = ds; oldFactory = factory; // keep track of the factory } /** * Create a <code>DataHandler</code> instance representing an object * of this MIME type. This constructor is * used when the application already has an in-memory representation * of the data in the form of a Java Object. * * @param obj the Java Object * @param mimeType the MIME type of the object */ public DataHandler(Object obj, String mimeType) { object = obj; objectMimeType = mimeType; oldFactory = factory; // keep track of the factory } /** * Create a <code>DataHandler</code> instance referencing a URL. * The DataHandler internally creates a <code>URLDataSource</code> * instance to represent the URL. * * @param url a URL object */ public DataHandler(URL url) { dataSource = new URLDataSource(url); oldFactory = factory; // keep track of the factory } /** * Return the CommandMap for this instance of DataHandler. */ private synchronized CommandMap getCommandMap() { if (currentCommandMap != null) return currentCommandMap; else return CommandMap.getDefaultCommandMap(); } /** * Return the DataSource associated with this instance * of DataHandler. * <p> * For DataHandlers that have been instantiated with a DataSource, * this method returns the DataSource that was used to create the * DataHandler object. In other cases the DataHandler * constructs a DataSource from the data used to construct * the DataHandler. DataSources created for DataHandlers <b>not</b> * instantiated with a DataSource are cached for performance * reasons. * * @return a valid DataSource object for this DataHandler */ public DataSource getDataSource() { if (dataSource == null) { // create one on the fly if (objDataSource == null) objDataSource = new DataHandlerDataSource(this); return objDataSource; } return dataSource; } /** * Return the name of the data object. If this DataHandler * was created with a DataSource, this method calls through * to the <code>DataSource.getName</code> method, otherwise it * returns <i>null</i>. * * @return the name of the object */ public String getName() { if (dataSource != null) return dataSource.getName(); else return null; } /** * Return the MIME type of this object as retrieved from * the source object. Note that this is the <i>full</i> * type with parameters. * * @return the MIME type */ public String getContentType() { if (dataSource != null) // data source case return dataSource.getContentType(); else return objectMimeType; // obj/type case } /** * Get the InputStream for this object. <p> * * For DataHandlers instantiated with a DataSource, the DataHandler * calls the <code>DataSource.getInputStream</code> method and * returns the result to the caller. * <p> * For DataHandlers instantiated with an Object, the DataHandler * first attempts to find a DataContentHandler for the Object. If * the DataHandler can not find a DataContentHandler for this MIME * type, it throws an UnsupportedDataTypeException. If it is * successful, it creates a pipe and a thread. The thread uses the * DataContentHandler's <code>writeTo</code> method to write the * stream data into one end of the pipe. The other end of the pipe * is returned to the caller. Because a thread is created to copy * the data, IOExceptions that may occur during the copy can not be * propagated back to the caller. The result is an empty stream.<p> * * @return the InputStream representing this data * @exception IOException if an I/O error occurs * * @see javax.activation.DataContentHandler#writeTo * @see javax.activation.UnsupportedDataTypeException */ public InputStream getInputStream() throws IOException { InputStream ins = null; if (dataSource != null) { ins = dataSource.getInputStream(); } else { DataContentHandler dch = getDataContentHandler(); // we won't even try if we can't get a dch if (dch == null) throw new UnsupportedDataTypeException("no DCH for MIME type " + getBaseType()); if (dch instanceof ObjectDataContentHandler) { if (((ObjectDataContentHandler) dch).getDCH() == null) throw new UnsupportedDataTypeException("no object DCH for MIME type " + getBaseType()); } // there is none but the default^^^^^^^^^^^^^^^^ final DataContentHandler fdch = dch; // from bill s. // ce n'est pas une pipe! // // NOTE: This block of code needs to throw exceptions, but // can't because it is in another thread!!! ARG! // final PipedOutputStream pos = new PipedOutputStream(); PipedInputStream pin = new PipedInputStream(pos); new Thread(new Runnable() { public void run() { try { fdch.writeTo(object, objectMimeType, pos); } catch (IOException e) { } finally { try { pos.close(); } catch (IOException ie) { } } } }, "DataHandler.getInputStream").start(); ins = pin; } return ins; } /** * Write the data to an <code>OutputStream</code>.<p> * * If the DataHandler was created with a DataSource, writeTo * retrieves the InputStream and copies the bytes from the * InputStream to the OutputStream passed in. * <p> * If the DataHandler was created with an object, writeTo * retrieves the DataContentHandler for the object's type. * If the DataContentHandler was found, it calls the * <code>writeTo</code> method on the <code>DataContentHandler</code>. * * @param os the OutputStream to write to * @exception IOException if an I/O error occurs */ public void writeTo(OutputStream os) throws IOException { // for the DataSource case if (dataSource != null) { InputStream is = null; byte data[] = new byte[8 * 1024]; int bytes_read; is = dataSource.getInputStream(); try { while ((bytes_read = is.read(data)) > 0) { os.write(data, 0, bytes_read); } } finally { is.close(); is = null; } } else { // for the Object case DataContentHandler dch = getDataContentHandler(); dch.writeTo(object, objectMimeType, os); } } /** * Get an OutputStream for this DataHandler to allow overwriting * the underlying data. * If the DataHandler was created with a DataSource, the * DataSource's <code>getOutputStream</code> method is called. * Otherwise, <code>null</code> is returned. * * @return the OutputStream * * @see javax.activation.DataSource#getOutputStream * @see javax.activation.URLDataSource */ public OutputStream getOutputStream() throws IOException { if (dataSource != null) return dataSource.getOutputStream(); else return null; } /** * Return the DataFlavors in which this data is available. <p> * * Returns an array of DataFlavor objects indicating the flavors * the data can be provided in. The array is usually ordered * according to preference for providing the data, from most * richly descriptive to least richly descriptive.<p> * * The DataHandler attempts to find a DataContentHandler that * corresponds to the MIME type of the data. If one is located, * the DataHandler calls the DataContentHandler's * <code>getTransferDataFlavors</code> method. <p> * * If a DataContentHandler can <i>not</i> be located, and if the * DataHandler was created with a DataSource (or URL), one * DataFlavor is returned that represents this object's MIME type * and the <code>java.io.InputStream</code> class. If the * DataHandler was created with an object and a MIME type, * getTransferDataFlavors returns one DataFlavor that represents * this object's MIME type and the object's class. * * @return an array of data flavors in which this data can be transferred * @see javax.activation.DataContentHandler#getTransferDataFlavors */ public synchronized ActivationDataFlavor[] getTransferDataFlavors() { if (factory != oldFactory) // if the factory has changed, clear cache transferFlavors = emptyFlavors; // if it's not set, set it... if (transferFlavors == emptyFlavors) transferFlavors = getDataContentHandler().getTransferDataFlavors(); if (transferFlavors == emptyFlavors) return transferFlavors; // no need to clone an empty array else return transferFlavors.clone(); } /** * Returns whether the specified data flavor is supported * for this object.<p> * * This method iterates through the DataFlavors returned from * <code>getTransferDataFlavors</code>, comparing each with * the specified flavor. * * @param flavor the requested flavor for the data * @return true if the data flavor is supported * @see javax.activation.DataHandler#getTransferDataFlavors */ public boolean isDataFlavorSupported(ActivationDataFlavor flavor) { ActivationDataFlavor[] lFlavors = getTransferDataFlavors(); for (int i = 0; i < lFlavors.length; i++) { if (lFlavors[i].equals(flavor)) return true; } return false; } /** * Returns an object that represents the data to be * transferred. The class of the object returned is defined by the * representation class of the data flavor.<p> * * <b>For DataHandler's created with DataSources or URLs:</b><p> * * The DataHandler attempts to locate a DataContentHandler * for this MIME type. If one is found, the passed in DataFlavor * and the type of the data are passed to its <code>getTransferData</code> * method. If the DataHandler fails to locate a DataContentHandler * and the flavor specifies this object's MIME type and the * <code>java.io.InputStream</code> class, this object's InputStream * is returned. * Otherwise it throws an UnsupportedFlavorException. <p> * * <b>For DataHandler's created with Objects:</b><p> * * The DataHandler attempts to locate a DataContentHandler * for this MIME type. If one is found, the passed in DataFlavor * and the type of the data are passed to its getTransferData * method. If the DataHandler fails to locate a DataContentHandler * and the flavor specifies this object's MIME type and its class, * this DataHandler's referenced object is returned. * Otherwise it throws an UnsupportedFlavorException. * * @param flavor the requested flavor for the data * @return the object * @exception IOException if an I/O error occurs * @see javax.activation.ActivationDataFlavor */ public Object getTransferData(ActivationDataFlavor flavor) throws /*UnsupportedFlavorException,*/ IOException { return getDataContentHandler().getTransferData(flavor, dataSource); } /** * Set the CommandMap for use by this DataHandler. * Setting it to <code>null</code> causes the CommandMap to revert * to the CommandMap returned by the * <code>CommandMap.getDefaultCommandMap</code> method. * Changing the CommandMap, or setting it to <code>null</code>, * clears out any data cached from the previous CommandMap. * * @param commandMap the CommandMap to use in this DataHandler * * @see javax.activation.CommandMap#setDefaultCommandMap */ public synchronized void setCommandMap(CommandMap commandMap) { if (commandMap != currentCommandMap || commandMap == null) { // clear cached values... transferFlavors = emptyFlavors; dataContentHandler = null; currentCommandMap = commandMap; } } /** * Return the <i>preferred</i> commands for this type of data. * This method calls the <code>getPreferredCommands</code> method * in the CommandMap associated with this instance of DataHandler. * This method returns an array that represents a subset of * available commands. In cases where multiple commands for the * MIME type represented by this DataHandler are present, the * installed CommandMap chooses the appropriate commands. * * @return the CommandInfo objects representing the preferred commands * * @see javax.activation.CommandMap#getPreferredCommands */ public CommandInfo[] getPreferredCommands() { if (dataSource != null) return getCommandMap().getPreferredCommands(getBaseType(), dataSource); else return getCommandMap().getPreferredCommands(getBaseType()); } /** * Return all the commands for this type of data. * This method returns an array containing all commands * for the type of data represented by this DataHandler. The * MIME type for the underlying data represented by this DataHandler * is used to call through to the <code>getAllCommands</code> method * of the CommandMap associated with this DataHandler. * * @return the CommandInfo objects representing all the commands * * @see javax.activation.CommandMap#getAllCommands */ public CommandInfo[] getAllCommands() { if (dataSource != null) return getCommandMap().getAllCommands(getBaseType(), dataSource); else return getCommandMap().getAllCommands(getBaseType()); } /** * Get the command <i>cmdName</i>. Use the search semantics as * defined by the CommandMap installed in this DataHandler. The * MIME type for the underlying data represented by this DataHandler * is used to call through to the <code>getCommand</code> method * of the CommandMap associated with this DataHandler. * * @param cmdName the command name * @return the CommandInfo corresponding to the command * * @see javax.activation.CommandMap#getCommand */ public CommandInfo getCommand(String cmdName) { if (dataSource != null) return getCommandMap().getCommand(getBaseType(), cmdName, dataSource); else return getCommandMap().getCommand(getBaseType(), cmdName); } /** * Return the data in its preferred Object form. <p> * * If the DataHandler was instantiated with an object, return * the object. <p> * * If the DataHandler was instantiated with a DataSource, * this method uses a DataContentHandler to return the content * object for the data represented by this DataHandler. If no * <code>DataContentHandler</code> can be found for the * the type of this data, the DataHandler returns an * InputStream for the data. * * @return the content. * @exception IOException if an IOException occurs during * this operation. */ public Object getContent() throws IOException { if (object != null) return object; else return getDataContentHandler().getContent(getDataSource()); } /** * A convenience method that takes a CommandInfo object * and instantiates the corresponding command, usually * a JavaBean component. * <p> * This method calls the CommandInfo's <code>getCommandObject</code> * method with the <code>ClassLoader</code> used to load * the <code>javax.activation.DataHandler</code> class itself. * * @param cmdinfo the CommandInfo corresponding to a command * @return the instantiated command object */ public Object getBean(CommandInfo cmdinfo) { Object bean = null; try { // make the bean ClassLoader cld = null; // First try the "application's" class loader. cld = SecuritySupport.getContextClassLoader(); if (cld == null) cld = this.getClass().getClassLoader(); bean = cmdinfo.getCommandObject(this, cld); } catch (IOException e) { } catch (ClassNotFoundException e) { } return bean; } /** * Get the DataContentHandler for this DataHandler: <p> * * If a DataContentHandlerFactory is set, use it. * Otherwise look for an object to serve DCH in the * following order: <p> * * 1) if a factory is set, use it <p> * 2) if a CommandMap is set, use it <p> * 3) use the default CommandMap <p> * * In any case, wrap the real DataContentHandler with one of our own * to handle any missing cases, fill in defaults, and to ensure that * we always have a non-null DataContentHandler. * * @return the requested DataContentHandler */ private synchronized DataContentHandler getDataContentHandler() { // make sure the factory didn't change if (factory != oldFactory) { oldFactory = factory; factoryDCH = null; dataContentHandler = null; transferFlavors = emptyFlavors; } if (dataContentHandler != null) return dataContentHandler; String simpleMT = getBaseType(); if (factoryDCH == null && factory != null) factoryDCH = factory.createDataContentHandler(simpleMT); if (factoryDCH != null) dataContentHandler = factoryDCH; if (dataContentHandler == null) { if (dataSource != null) dataContentHandler = getCommandMap().createDataContentHandler(simpleMT, dataSource); else dataContentHandler = getCommandMap().createDataContentHandler(simpleMT); } // getDataContentHandler always uses these 'wrapper' handlers // to make sure it returns SOMETHING meaningful... if (dataSource != null) dataContentHandler = new DataSourceDataContentHandler(dataContentHandler, dataSource); else dataContentHandler = new ObjectDataContentHandler(dataContentHandler, object, objectMimeType); return dataContentHandler; } /** * Use the MimeType class to extract the MIME type/subtype, * ignoring the parameters. The type is cached. */ private synchronized String getBaseType() { if (shortType == null) { String ct = getContentType(); try { MimeType mt = new MimeType(ct); shortType = mt.getBaseType(); } catch (MimeTypeParseException e) { shortType = ct; } } return shortType; } /** * Sets the DataContentHandlerFactory. The DataContentHandlerFactory * is called first to find DataContentHandlers. * The DataContentHandlerFactory can only be set once. * <p> * If the DataContentHandlerFactory has already been set, * this method throws an Error. * * @param newFactory the DataContentHandlerFactory * @exception Error if the factory has already been defined. * * @see javax.activation.DataContentHandlerFactory */ public static synchronized void setDataContentHandlerFactory(DataContentHandlerFactory newFactory) { if (factory != null) throw new Error("DataContentHandlerFactory already defined"); SecurityManager security = System.getSecurityManager(); if (security != null) { try { // if it's ok with the SecurityManager, it's ok with me... security.checkSetFactory(); } catch (SecurityException ex) { // otherwise, we also allow it if this code and the // factory come from the same class loader (e.g., // the JAF classes were loaded with the applet classes). if (DataHandler.class.getClassLoader() != newFactory.getClass().getClassLoader()) throw ex; } } factory = newFactory; } } /** * The DataHanderDataSource class implements the * DataSource interface when the DataHandler is constructed * with an Object and a mimeType string. */ class DataHandlerDataSource implements DataSource { DataHandler dataHandler = null; /** * The constructor. */ public DataHandlerDataSource(DataHandler dh) { this.dataHandler = dh; } /** * Returns an <code>InputStream</code> representing this object. * @return the <code>InputStream</code> */ public InputStream getInputStream() throws IOException { return dataHandler.getInputStream(); } /** * Returns the <code>OutputStream</code> for this object. * @return the <code>OutputStream</code> */ public OutputStream getOutputStream() throws IOException { return dataHandler.getOutputStream(); } /** * Returns the MIME type of the data represented by this object. * @return the MIME type */ public String getContentType() { return dataHandler.getContentType(); } /** * Returns the name of this object. * @return the name of this object */ public String getName() { return dataHandler.getName(); // what else would it be? } } /* * DataSourceDataContentHandler * * This is a <i>private</i> DataContentHandler that wraps the real * DataContentHandler in the case where the DataHandler was instantiated * with a DataSource. */ class DataSourceDataContentHandler implements DataContentHandler { private DataSource ds = null; private ActivationDataFlavor transferFlavors[] = null; private DataContentHandler dch = null; /** * The constructor. */ public DataSourceDataContentHandler(DataContentHandler dch, DataSource ds) { this.ds = ds; this.dch = dch; } /** * Return the DataFlavors for this <code>DataContentHandler</code>. * @return the DataFlavors */ public ActivationDataFlavor[] getTransferDataFlavors() { if (transferFlavors == null) { if (dch != null) { // is there a dch? transferFlavors = dch.getTransferDataFlavors(); } else { transferFlavors = new ActivationDataFlavor[1]; transferFlavors[0] = new ActivationDataFlavor(ds.getContentType(), ds.getContentType()); } } return transferFlavors; } /** * Return the Transfer Data of type DataFlavor from InputStream. * @param df the DataFlavor * @param ds the DataSource * @return the constructed Object */ public Object getTransferData(ActivationDataFlavor df, DataSource ds) throws /*UnsupportedFlavorException,*/ IOException { if (dch != null) return dch.getTransferData(df, ds); else if (df.equals(getTransferDataFlavors()[0])) // only have one now return ds.getInputStream(); else //throw new UnsupportedFlavorException(df); throw new IOException("Unsupported DataFlavor: " + df); } public Object getContent(DataSource ds) throws IOException { if (dch != null) return dch.getContent(ds); else return ds.getInputStream(); } /** * Write the object to the output stream. */ public void writeTo(Object obj, String mimeType, OutputStream os) throws IOException { if (dch != null) dch.writeTo(obj, mimeType, os); else throw new UnsupportedDataTypeException("no DCH for content type " + ds.getContentType()); } } /* * ObjectDataContentHandler * * This is a <i>private</i> DataContentHandler that wraps the real * DataContentHandler in the case where the DataHandler was instantiated * with an object. */ class ObjectDataContentHandler implements DataContentHandler { private ActivationDataFlavor transferFlavors[] = null; private Object obj; private String mimeType; private DataContentHandler dch = null; /** * The constructor. */ public ObjectDataContentHandler(DataContentHandler dch, Object obj, String mimeType) { this.obj = obj; this.mimeType = mimeType; this.dch = dch; } /** * Return the DataContentHandler for this object. * Used only by the DataHandler class. */ public DataContentHandler getDCH() { return dch; } /** * Return the DataFlavors for this <code>DataContentHandler</code>. * @return the DataFlavors */ public synchronized ActivationDataFlavor[] getTransferDataFlavors() { if (transferFlavors == null) { if (dch != null) { transferFlavors = dch.getTransferDataFlavors(); } else { transferFlavors = new ActivationDataFlavor[1]; transferFlavors[0] = new ActivationDataFlavor(obj.getClass(), mimeType, mimeType); } } return transferFlavors; } /** * Return the Transfer Data of type DataFlavor from InputStream. * @param df the DataFlavor * @param ds the DataSource * @return the constructed Object */ public Object getTransferData(ActivationDataFlavor df, DataSource ds) throws /*UnsupportedFlavorException,*/ IOException { if (dch != null) return dch.getTransferData(df, ds); else if (df.equals(getTransferDataFlavors()[0])) // only have one now return obj; else //throw new UnsupportedFlavorException(df); throw new IOException("Unsupported DataFlavor: " + df); } public Object getContent(DataSource ds) { return obj; } /** * Write the object to the output stream. */ public void writeTo(Object obj, String mimeType, OutputStream os) throws IOException { if (dch != null) dch.writeTo(obj, mimeType, os); else if (obj instanceof byte[]) os.write((byte[]) obj); else if (obj instanceof String) { OutputStreamWriter osw = new OutputStreamWriter(os); osw.write((String) obj); osw.flush(); } else throw new UnsupportedDataTypeException("no object DCH for MIME type " + this.mimeType); } }