com.feilong.lib.beanutils.locale.LocaleConvertUtilsBean Maven / Gradle / Ivy
Show all versions of feilong Show documentation
/*
* 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 com.feilong.lib.beanutils.locale;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Collection;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.feilong.lib.beanutils.BeanUtils;
import com.feilong.lib.beanutils.FastHashMap;
import com.feilong.lib.beanutils.locale.converters.BigDecimalLocaleConverter;
import com.feilong.lib.beanutils.locale.converters.BigIntegerLocaleConverter;
import com.feilong.lib.beanutils.locale.converters.ByteLocaleConverter;
import com.feilong.lib.beanutils.locale.converters.DoubleLocaleConverter;
import com.feilong.lib.beanutils.locale.converters.FloatLocaleConverter;
import com.feilong.lib.beanutils.locale.converters.IntegerLocaleConverter;
import com.feilong.lib.beanutils.locale.converters.LongLocaleConverter;
import com.feilong.lib.beanutils.locale.converters.ShortLocaleConverter;
import com.feilong.lib.beanutils.locale.converters.SqlDateLocaleConverter;
import com.feilong.lib.beanutils.locale.converters.SqlTimeLocaleConverter;
import com.feilong.lib.beanutils.locale.converters.SqlTimestampLocaleConverter;
import com.feilong.lib.beanutils.locale.converters.StringLocaleConverter;
/**
*
* Utility methods for converting locale-sensitive String scalar values to objects of the
* specified Class, String arrays to arrays of the specified Class and
* object to locale-sensitive String scalar value.
*
*
*
* This class provides the implementations used by the static utility methods in
* {@link LocaleConvertUtils}.
*
*
*
* The actual {@link LocaleConverter} instance to be used
* can be registered for each possible destination Class. Unless you override them, standard
* {@link LocaleConverter} instances are provided for all of the following
* destination Classes:
*
*
* - java.lang.BigDecimal
* - java.lang.BigInteger
* - byte and java.lang.Byte
* - double and java.lang.Double
* - float and java.lang.Float
* - int and java.lang.Integer
* - long and java.lang.Long
* - short and java.lang.Short
* - java.lang.String
* - java.sql.Date
* - java.sql.Time
* - java.sql.Timestamp
*
*
*
* For backwards compatibility, the standard locale converters
* for primitive types (and the corresponding wrapper classes).
*
* If you prefer to have another {@link LocaleConverter}
* thrown instead, replace the standard {@link LocaleConverter} instances
* with ones created with the one of the appropriate constructors.
*
* It's important that {@link LocaleConverter} should be registered for
* the specified locale and Class (or primitive type).
*
* @since 1.7
* @version $Id$
*/
public class LocaleConvertUtilsBean{
/** The Constant log. */
private static final Logger LOGGER = LoggerFactory.getLogger(LocaleConvertUtilsBean.class);
//---------------------------------------------------------------
/**
* Gets singleton instance.
* This is the same as the instance used by the default {@link LocaleBeanUtilsBean} singleton.
*
* @return the singleton instance
*/
public static LocaleConvertUtilsBean getInstance(){
return LocaleBeanUtilsBean.getLocaleBeanUtilsInstance().getLocaleConvertUtils();
}
// ----------------------------------------------------- Instance Variables
/** The locale - default for convertion. */
private Locale defaultLocale = Locale.getDefault();
/** Indicate whether the pattern is localized or not */
private boolean applyLocalized = false;
/**
* Every entry of the mapConverters is:
* key = locale
* value = FastHashMap of converters for the certain locale.
*/
private final FastHashMap mapConverters = new DelegateFastHashMap(BeanUtils.createCache());
// --------------------------------------------------------- Constructors
/**
* Makes the state by default (deregisters all converters for all locales)
* and then registers default locale converters.
*/
public LocaleConvertUtilsBean(){
mapConverters.setFast(false);
deregister();
mapConverters.setFast(true);
}
// --------------------------------------------------------- Properties
/**
* getter for defaultLocale.
*
* @return the default locale
*/
public Locale getDefaultLocale(){
return defaultLocale;
}
/**
* setter for defaultLocale.
*
* @param locale
* the default locale
*/
public void setDefaultLocale(final Locale locale){
if (locale == null){
defaultLocale = Locale.getDefault();
}else{
defaultLocale = locale;
}
}
/**
* getter for applyLocalized
*
* @return true if pattern is localized,
* otherwise false
*/
public boolean getApplyLocalized(){
return applyLocalized;
}
/**
* setter for applyLocalized
*
* @param newApplyLocalized
* true if pattern is localized,
* otherwise false
*/
public void setApplyLocalized(final boolean newApplyLocalized){
applyLocalized = newApplyLocalized;
}
// --------------------------------------------------------- Methods
/**
* Convert the specified locale-sensitive value into a String.
*
* @param value
* The Value to be converted
* @return the converted value
*
* @throws com.feilong.lib.beanutils.ConversionException
* if thrown by an
* underlying Converter
*/
public String convert(final Object value){
return convert(value, defaultLocale, null);
}
/**
* Convert the specified locale-sensitive value into a String
* using the conversion pattern.
*
* @param value
* The Value to be converted
* @param pattern
* The convertion pattern
* @return the converted value
*
* @throws com.feilong.lib.beanutils.ConversionException
* if thrown by an
* underlying Converter
*/
public String convert(final Object value,final String pattern){
return convert(value, defaultLocale, pattern);
}
/**
* Convert the specified locale-sensitive value into a String
* using the paticular convertion pattern.
*
* @param value
* The Value to be converted
* @param locale
* The locale
* @param pattern
* The convertion pattern
* @return the converted value
*
* @throws com.feilong.lib.beanutils.ConversionException
* if thrown by an
* underlying Converter
*/
public String convert(final Object value,final Locale locale,final String pattern){
final LocaleConverter converter = lookup(String.class, locale);
return converter.convert(String.class, value, pattern);
}
/**
* Convert the specified value to an object of the specified class (if
* possible). Otherwise, return a String representation of the value.
*
* @param value
* The String scalar value to be converted
* @param clazz
* The Data type to which this value should be converted.
* @return the converted value
*
* @throws com.feilong.lib.beanutils.ConversionException
* if thrown by an
* underlying Converter
*/
public Object convert(final String value,final Class clazz){
return convert(value, clazz, defaultLocale, null);
}
/**
* Convert the specified value to an object of the specified class (if
* possible) using the convertion pattern. Otherwise, return a String
* representation of the value.
*
* @param value
* The String scalar value to be converted
* @param clazz
* The Data type to which this value should be converted.
* @param pattern
* The convertion pattern
* @return the converted value
*
* @throws com.feilong.lib.beanutils.ConversionException
* if thrown by an
* underlying Converter
*/
public Object convert(final String value,final Class clazz,final String pattern){
return convert(value, clazz, defaultLocale, pattern);
}
/**
* Convert the specified value to an object of the specified class (if
* possible) using the convertion pattern. Otherwise, return a String
* representation of the value.
*
* @param value
* The String scalar value to be converted
* @param clazz
* The Data type to which this value should be converted.
* @param locale
* The locale
* @param pattern
* The convertion pattern
* @return the converted value
*
* @throws com.feilong.lib.beanutils.ConversionException
* if thrown by an
* underlying Converter
*/
public Object convert(final String value,final Class clazz,final Locale locale,final String pattern){
if (LOGGER.isDebugEnabled()){
LOGGER.debug(
"Convert string " + value + " to class " + clazz.getName() + " using " + locale + " locale and " + pattern
+ " pattern");
}
Class targetClass = clazz;
LocaleConverter converter = lookup(clazz, locale);
if (converter == null){
converter = lookup(String.class, locale);
targetClass = String.class;
}
if (LOGGER.isTraceEnabled()){
LOGGER.trace(" Using converter " + converter);
}
return (converter.convert(targetClass, value, pattern));
}
/**
* Convert an array of specified values to an array of objects of the
* specified class (if possible) using the convertion pattern.
*
* @param values
* Value to be converted (may be null)
* @param clazz
* Java array or element class to be converted to
* @param pattern
* The convertion pattern
* @return the converted value
*
* @throws com.feilong.lib.beanutils.ConversionException
* if thrown by an
* underlying Converter
*/
public Object convert(final String[] values,final Class clazz,final String pattern){
return convert(values, clazz, getDefaultLocale(), pattern);
}
/**
* Convert an array of specified values to an array of objects of the
* specified class (if possible) .
*
* @param values
* Value to be converted (may be null)
* @param clazz
* Java array or element class to be converted to
* @return the converted value
*
* @throws com.feilong.lib.beanutils.ConversionException
* if thrown by an
* underlying Converter
*/
public Object convert(final String[] values,final Class clazz){
return convert(values, clazz, getDefaultLocale(), null);
}
/**
* Convert an array of specified values to an array of objects of the
* specified class (if possible) using the convertion pattern.
*
* @param values
* Value to be converted (may be null)
* @param clazz
* Java array or element class to be converted to
* @param locale
* The locale
* @param pattern
* The convertion pattern
* @return the converted value
*
* @throws com.feilong.lib.beanutils.ConversionException
* if thrown by an
* underlying Converter
*/
public Object convert(final String[] values,final Class clazz,final Locale locale,final String pattern){
Class type = clazz;
if (clazz.isArray()){
type = clazz.getComponentType();
}
if (LOGGER.isDebugEnabled()){
LOGGER.debug(
"Convert String[" + values.length + "] to class " + type.getName() + "[] using " + locale + " locale and "
+ pattern + " pattern");
}
final Object array = Array.newInstance(type, values.length);
for (int i = 0; i < values.length; i++){
Array.set(array, i, convert(values[i], type, locale, pattern));
}
return (array);
}
/**
* Register a custom {@link LocaleConverter} for the specified destination
* Class, replacing any previously registered converter.
*
* @param converter
* The LocaleConverter to be registered
* @param clazz
* The Destination class for conversions performed by this
* Converter
* @param locale
* The locale
*/
public void register(final LocaleConverter converter,final Class clazz,final Locale locale){
lookup(locale).put(clazz, converter);
}
/**
* Remove any registered {@link LocaleConverter}.
*/
public void deregister(){
final FastHashMap defaultConverter = lookup(defaultLocale);
mapConverters.setFast(false);
mapConverters.clear();
mapConverters.put(defaultLocale, defaultConverter);
mapConverters.setFast(true);
}
/**
* Remove any registered {@link LocaleConverter} for the specified locale
*
* @param locale
* The locale
*/
public void deregister(final Locale locale){
mapConverters.remove(locale);
}
/**
* Remove any registered {@link LocaleConverter} for the specified locale and Class.
*
* @param clazz
* Class for which to remove a registered Converter
* @param locale
* The locale
*/
public void deregister(final Class clazz,final Locale locale){
lookup(locale).remove(clazz);
}
/**
* Look up and return any registered {@link LocaleConverter} for the specified
* destination class and locale; if there is no registered Converter, return
* null.
*
* @param clazz
* Class for which to return a registered Converter
* @param locale
* The Locale
* @return The registered locale Converter, if any
*/
public LocaleConverter lookup(final Class clazz,final Locale locale){
final LocaleConverter converter = (LocaleConverter) lookup(locale).get(clazz);
if (LOGGER.isTraceEnabled()){
LOGGER.trace("LocaleConverter:" + converter);
}
return converter;
}
/**
* Look up and return any registered FastHashMap instance for the specified locale;
* if there is no registered one, return null.
*
* @param locale
* The Locale
* @return The FastHashMap instance contains the all {@link LocaleConverter} types for
* the specified locale.
* @deprecated This method will be modified to return a Map in the next release.
*/
@Deprecated
protected FastHashMap lookup(final Locale locale){
FastHashMap localeConverters;
if (locale == null){
localeConverters = (FastHashMap) mapConverters.get(defaultLocale);
}else{
localeConverters = (FastHashMap) mapConverters.get(locale);
if (localeConverters == null){
localeConverters = create(locale);
mapConverters.put(locale, localeConverters);
}
}
return localeConverters;
}
/**
* Create all {@link LocaleConverter} types for specified locale.
*
* @param locale
* The Locale
* @return The FastHashMap instance contains the all {@link LocaleConverter} types
* for the specified locale.
* @deprecated This method will be modified to return a Map in the next release.
*/
@Deprecated
protected FastHashMap create(final Locale locale){
final FastHashMap converter = new DelegateFastHashMap(BeanUtils.createCache());
converter.setFast(false);
converter.put(BigDecimal.class, new BigDecimalLocaleConverter(locale, applyLocalized));
converter.put(BigInteger.class, new BigIntegerLocaleConverter(locale, applyLocalized));
converter.put(Byte.class, new ByteLocaleConverter(locale, applyLocalized));
converter.put(Byte.TYPE, new ByteLocaleConverter(locale, applyLocalized));
converter.put(Double.class, new DoubleLocaleConverter(locale, applyLocalized));
converter.put(Double.TYPE, new DoubleLocaleConverter(locale, applyLocalized));
converter.put(Float.class, new FloatLocaleConverter(locale, applyLocalized));
converter.put(Float.TYPE, new FloatLocaleConverter(locale, applyLocalized));
converter.put(Integer.class, new IntegerLocaleConverter(locale, applyLocalized));
converter.put(Integer.TYPE, new IntegerLocaleConverter(locale, applyLocalized));
converter.put(Long.class, new LongLocaleConverter(locale, applyLocalized));
converter.put(Long.TYPE, new LongLocaleConverter(locale, applyLocalized));
converter.put(Short.class, new ShortLocaleConverter(locale, applyLocalized));
converter.put(Short.TYPE, new ShortLocaleConverter(locale, applyLocalized));
converter.put(String.class, new StringLocaleConverter(locale, applyLocalized));
// conversion format patterns of java.sql.* types should correspond to default
// behaviour of toString and valueOf methods of these classes
converter.put(java.sql.Date.class, new SqlDateLocaleConverter(locale, "yyyy-MM-dd"));
converter.put(java.sql.Time.class, new SqlTimeLocaleConverter(locale, "HH:mm:ss"));
converter.put(java.sql.Timestamp.class, new SqlTimestampLocaleConverter(locale, "yyyy-MM-dd HH:mm:ss.S"));
converter.setFast(true);
return converter;
}
/**
* FastHashMap implementation that uses WeakReferences to overcome
* memory leak problems.
*
* This is a hack to retain binary compatibility with previous
* releases (where FastHashMap is exposed in the API), but
* use WeakHashMap to resolve memory leaks.
*/
private static class DelegateFastHashMap extends FastHashMap{
/**
*
*/
private static final long serialVersionUID = 1375862117478376101L;
private final Map map;
private DelegateFastHashMap(final Map map){
this.map = map;
}
@Override
public void clear(){
map.clear();
}
@Override
public boolean containsKey(final Object key){
return map.containsKey(key);
}
@Override
public boolean containsValue(final Object value){
return map.containsValue(value);
}
@Override
public Set> entrySet(){
return map.entrySet();
}
@Override
public boolean equals(final Object o){
return map.equals(o);
}
@Override
public Object get(final Object key){
return map.get(key);
}
@Override
public int hashCode(){
return map.hashCode();
}
@Override
public boolean isEmpty(){
return map.isEmpty();
}
@Override
public Set