org.apache.synapse.commons.util.MiscellaneousUtil.java Source code

Java tutorial

Introduction

Here is the source code for org.apache.synapse.commons.util.MiscellaneousUtil.java

Source

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.synapse.commons.util;

import org.apache.axiom.om.OMElement;
import org.apache.axiom.om.impl.builder.StAXOMBuilder;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.synapse.commons.SynapseCommonsException;

import javax.xml.stream.XMLStreamException;
import java.io.*;
import java.util.Properties;

/**
 *
 */
public class MiscellaneousUtil {

    private static Log log = LogFactory.getLog(MiscellaneousUtil.class);

    private static final String CONF_LOCATION = "conf.location";

    private MiscellaneousUtil() {
    }

    /**
     * Helper method to get the value of the property from a given property bag
     * 
     * @param properties
     *            The property collection
     * @param name
     *            The name of the property
     * @param defaultValue
     *            The default value for the property
     * @return The value of the property if it is found , otherwise , default
     *         value
     */
    public static String getProperty(Properties properties, String name, String defaultValue) {

        String result = properties.getProperty(name);
        if ((result == null || result.length() == 0) && defaultValue != null) {
            if (log.isDebugEnabled()) {
                log.debug(
                        "The name with '" + name + "' cannot be found. " + "Using default value : " + defaultValue);
            }
            result = defaultValue;
        }
        if (result != null) {
            return result.trim();
        } else {
            return defaultValue;
        }
    }

    /**
     * Helper method to get the value of the property from a given property bag
     * This method will return a value with the type equal to the type
     * given by the Class type parameter. Therefore, The user of this method
     * can ensure that he is get what he request
     * 
     * @param properties
     *            Properties bag
     * @param name
     *            Name of the property
     * @param defaultValue
     *            Default value
     * @param type
     *            Expected Type using Class
     * @return Value corresponding to the given property name
     */
    @SuppressWarnings({ "TypeParameterExplicitlyExtendsObject", "unchecked" })
    public static <T extends Object> T getProperty(Properties properties, String name, T defaultValue,
            Class<? extends T> type) {

        String result = properties.getProperty(name);
        if (result == null && defaultValue != null) {
            if (log.isDebugEnabled()) {
                log.debug(
                        "The name with '" + name + "' cannot be found. " + "Using default value : " + defaultValue);
            }
            return defaultValue;
        }

        if (result == null || type == null) {
            return null;
        }

        if (String.class.equals(type)) {
            return (T) result;
        } else if (Boolean.class.equals(type)) {
            return (T) Boolean.valueOf(Boolean.parseBoolean(result));
        } else if (Integer.class.equals(type)) {
            return (T) Integer.valueOf(Integer.parseInt(result));
        } else if (Long.class.equals(type)) {
            return (T) Long.valueOf(Long.parseLong(result));
        } else {
            handleException("Unsupported type : " + type);
        }

        return null;
    }

    /**
     * Loads the properties from a given property file path
     * 
     * @param filePath
     *            Path of the property file
     * @return Properties loaded from given file
     */
    public static Properties loadProperties(String filePath) {

        Properties properties = new Properties();
        ClassLoader cl = Thread.currentThread().getContextClassLoader();

        if (log.isDebugEnabled()) {
            log.debug("Loading a file '" + filePath + "' from classpath");
        }

        InputStream in = null;

        //if we reach to this assume that the we may have to looking to the customer provided external location for the 
        //given properties
        if (System.getProperty(CONF_LOCATION) != null) {
            try {
                in = new FileInputStream(System.getProperty(CONF_LOCATION) + File.separator + filePath);
            } catch (FileNotFoundException e) {
                String msg = "Error loading properties from a file at from the System defined location: "
                        + filePath;
                log.warn(msg);
            }
        }

        if (in == null) {
            //if can not find with system path definition looking to the class path for the given property file
            in = cl.getResourceAsStream(filePath);
        }

        if (in == null) {

            if (log.isDebugEnabled()) {
                log.debug("Unable to load file  '" + filePath + "'");
            }

            filePath = "conf" + File.separatorChar + filePath;
            if (log.isDebugEnabled()) {
                log.debug("Loading a file '" + filePath + "' from classpath");
            }

            in = cl.getResourceAsStream(filePath);
            if (in == null) {
                if (log.isDebugEnabled()) {
                    log.debug("Unable to load file  '" + filePath + "'");
                }
            }

        }
        if (in != null) {
            try {
                properties.load(in);
            } catch (IOException e) {
                handleException("Error loading properties from a file at : " + filePath, e);
            }
        }
        return properties;
    }

    /**
     * Load a xml configuration file
     *
     * @param filePath file path
     * @return OMElement of build from the config file
     */
    public static OMElement loadXMLConfig(String filePath) {

        ClassLoader cl = Thread.currentThread().getContextClassLoader();

        if (log.isDebugEnabled()) {
            log.debug("Loading a file '" + filePath + "' from classpath");
        }

        InputStream in = null;
        if (System.getProperty(CONF_LOCATION) != null) {
            try {
                in = new FileInputStream(System.getProperty(CONF_LOCATION) + File.separator + filePath);
            } catch (FileNotFoundException e) {
                String msg = "Error loading properties from a file at from the System defined location: "
                        + System.getProperty(CONF_LOCATION) + File.separator + filePath;
                log.warn(msg);
            }
        }

        if (in == null) {
            //if can not find with system path definition looking to the class path for the given config file
            in = cl.getResourceAsStream(filePath);
        }

        if (in == null) {

            if (log.isDebugEnabled()) {
                log.debug("Unable to load file  '" + filePath + "'");
            }

            filePath = "conf" + File.separatorChar + filePath;
            if (log.isDebugEnabled()) {
                log.debug("Loading a file '" + filePath + "' from classpath");
            }

            in = cl.getResourceAsStream(filePath);
            if (in == null) {
                if (log.isDebugEnabled()) {
                    log.debug("Unable to load file  '" + filePath + "'");
                }
            }
        }

        if (in != null) {
            try {
                OMElement document = new StAXOMBuilder(in).getDocumentElement();
                document.build();
                return document;
            } catch (Exception e) {
                handleException("Error while parsing the content of the file: " + filePath, e);
            } finally {
                try {
                    in.close();
                } catch (IOException e) {
                    log.warn("Error while closing the input stream from the file: " + filePath, e);
                }
            }
        }
        return null;
    }

    /**
     * Helper method to serialize object into a byte array
     * 
     * @param data
     *            The object to be serialized
     * @return The byte array representation of the provided object
     */
    public static byte[] serialize(Object data) {

        ObjectOutputStream outputStream = null;
        ByteArrayOutputStream binOut = null;
        byte[] result = null;
        try {
            binOut = new ByteArrayOutputStream();
            outputStream = new ObjectOutputStream(binOut);
            outputStream.writeObject(data);
            result = binOut.toByteArray();
        } catch (IOException e) {
            handleException("Error serializing object : " + data);
        } finally {
            if (binOut != null) {
                try {
                    binOut.close();
                } catch (IOException ignored) {
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException ignored) {
                }
            }
        }
        return result;
    }

    @SuppressWarnings({ "UnusedDeclaration" })
    public static byte[] asBytes(InputStream in) {

        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len;
        try {
            while ((len = in.read(buffer)) >= 0)
                out.write(buffer, 0, len);
        } catch (IOException e) {
            throw new SynapseCommonsException("Error during converting a input stream " + "into a byte array", e,
                    log);
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException ignored) {
                }
            }
            try {
                out.close();
            } catch (IOException ignored) {
            }
        }
        return out.toByteArray();
    }

    /**
     * Helper methods for handle errors.
     * 
     * @param msg
     *            The error message
     */
    private static void handleException(String msg) {
        log.error(msg);
        throw new SynapseCommonsException(msg);
    }

    /**
     * Helper method for handle errors.
     *
     * @param msg The error message
     * @param ex  Error exception
     */
    private static void handleException(String msg, Exception ex) {
        log.error(msg);
        throw new SynapseCommonsException(msg, ex);
    }
}