来自: com.zaxxer.HikariCP-java6#PropertyBeanSetter.java 

    1. import java.beans.BeanInfo;
    2. import java.beans.IntrospectionException;
    3. import java.beans.Introspector;
    4. import java.beans.PropertyDescriptor;
    5. import java.io.*;
    6. import java.lang.reflect.Method;
    7. import java.util.*;
    9. /**
    10.  * @author tonnyyi
    11.  * @since 15/4/22 10:52
    12.  */
    13. public class PropertyUtil {
    15.     public static void setProperties(Object bean, Properties properties) {
    16.         if (bean == null || properties == null) {
    17.             return;
    18.         }
    20.         Enumeration<?> propertyNames = properties.propertyNames();
    21.         while (propertyNames.hasMoreElements()) {
    22.             Object key = propertyNames.nextElement();
    23.             String propertyName = key.toString();
    24.             Object value = properties.getProperty(propertyName);
    25.             if (value == null) {
    26.                 value = properties.get(propertyName);
    27.             }
    29.             setProperty(bean, propertyName, value);
    30.         }
    31.     }
    33.     public static void setProperty(Object bean, String name, Object value) {
    34.         String setMethodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
    35.         PropertyDescriptor propertyDescriptor;
    36.         try {
    37.             propertyDescriptor = new PropertyDescriptor(name, bean.getClass(), null, setMethodName);
    38.         }
    39.         catch (IntrospectionException e) {
    40.             throw new RuntimeException(e);
    41.         }
    43.         try {
    44.             Method writeMethod = propertyDescriptor.getWriteMethod();
    45.             Class<?> paramClass = writeMethod.getParameterTypes()[0];
    46.             if (paramClass == int.class) {
    47.                 writeMethod.invoke(bean, Integer.parseInt(value.toString()));
    48.             }
    49.             else if (paramClass == long.class) {
    50.                 writeMethod.invoke(bean, Long.parseLong(value.toString()));
    51.             }
    52.             else if (paramClass == float.class) {
    53.                 writeMethod.invoke(bean, Float.parseFloat(value.toString()));
    54.             }
    55.             else if (paramClass == double.class) {
    56.                 writeMethod.invoke(bean, Double.parseDouble(value.toString()));
    57.             }
    58.             else if (paramClass == boolean.class) {
    59.                 writeMethod.invoke(bean, Boolean.parseBoolean(value.toString()));
    60.             }
    61.             else if (paramClass == String.class) {
    62.                 writeMethod.invoke(bean, value.toString());
    63.             }
    64.             else {
    65.                 writeMethod.invoke(bean, value);
    66.             }
    67.         }
    68.         catch (Exception e) {
    69.             throw new RuntimeException(e);
    70.         }
    71.     }
    73.     public static Set<String> getPropertyNames(Class<?> clazz) {
    74.         Set<String> propertyNames = new HashSet<>();
    75.         try {
    76.             BeanInfo beanInfo = Introspector.getBeanInfo(clazz);
    77.             for (PropertyDescriptor descriptor : beanInfo.getPropertyDescriptors()) {
    78.                 if (!descriptor.getName().equals("class")) {
    79.                     propertyNames.add(descriptor.getName());
    80.                 }
    81.             }
    82.         return propertyNames;
    83.         }
    84.         catch (IntrospectionException e) {
    85.             throw new RuntimeException(e);
    86.         }
    87.     }
    89.     public static Object getProperty(Object bean, String name) {
    90.         String getMethodName = "get" + name.substring(0, 1).toUpperCase() + name.substring(1);
    91.         try {
    92.             Method method = bean.getClass().getMethod(getMethodName);
    93.             return method.invoke(bean);
    94.         }
    95.         catch (Exception e) {
    96.             getMethodName = "is" + name.substring(0, 1).toUpperCase() + name.substring(1);
    97.             try {
    98.                 Method method = bean.getClass().getMethod(getMethodName);
    99.                 return method.invoke(bean);
    100.             }
    101.             catch (Exception e1) {
    102.                 throw new RuntimeException(e1);
    103.             }
    104.         }
    105.     }
    107.     public static Properties loadProperty(String filePath) {
    108.         if (filePath == null || filePath.trim().length() == 0) {
    109.             return null;
    110.         }
    112.         File file = new File(filePath);
    113.         try {
    114.             InputStream is = file.isFile() ? new FileInputStream(file) : PropertyUtil.class.getResourceAsStream(filePath);
    115.             if (is != null) {
    116.                 return loadProperty(is);
    117.             }
    118.             else {
    119.                 throw new IllegalArgumentException("Property file " + filePath + " was not found.");
    120.             }
    121.         }
    122.         catch (IOException e) {
    123.             throw new RuntimeException("Error loading properties file", e);
    124.         }
    126.         //return null;
    127.     }
    129.     public static Properties loadProperty(InputStream is) throws IOException {
    130.         Properties properties = null;
    131.         if (is != null) {
    132.             properties = new Properties();
    133.             try {
    134.                 properties.load(is);
    135.             }
    136.             finally {
    137.                 is.close();
    138.             }
    139.         }
    141.         return properties;
    142.     }
    143. }