自动将properties属性赋值到常量类中的静态变量

梦里梦外; 2022-05-19 00:28 181阅读 0赞

静态类因为编译成字节码，直接在虚拟机上运行，少了读取-从字符串读数据等一系列步骤。速度上肯定占有绝对优势。

但设立properties文件的目的，是为了不改动程序而实现配置数据的变化，特设的使 配置数据 和 程序 的一种简易分离机制。 除非这些配置参数永远不变，不然写成静态类对程序只会是一种退化。

如果需要频繁的读properties文件但是又不常修改文件中的属性，可以将properties文件加载到一个起中间作用的静态类中。

自定义CustomPropertyPlaceholderConfigurer 类，继承自PropertyPlaceholderConfigurer 类：

public class CustomPropertyPlaceholderConfigurer extends PropertyPlaceholderConfigurer {
    
    
        /**
         * 需要注入的常量类名数组
         */
        private String[] configureClasses;
        /**
         * 是否区分大小写
         */
        private boolean lowerCaseKey = false;
    
        @Override
        @SuppressWarnings("unchecked")
        protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
                throws BeansException {
            super.processProperties(beanFactoryToProcess, props);
    
            if (configureClasses == null) {
                return;
            }
    
    
            Map<String, String> propMap = new HashMap<>(props.size());
    
    
            String key = null;
            if (lowerCaseKey) {
                // key不区分大小写，所以将所有key转换成小写
                for (Enumeration<?> k = props.propertyNames(); k.hasMoreElements(); ) {
                    key = (String) k.nextElement();
                    propMap.put(key.toLowerCase(), props.getProperty(key));
                }
            } else {
                // key区分大小写
                for (Enumeration<?> k = props.propertyNames(); k.hasMoreElements(); ) {
                    key = (String) k.nextElement();
                    propMap.put(key, props.getProperty(key));
                }
            }
    
            Class c = null;
            Field[] fields = null;
            String keyStr = null, value = null;
            // 遍历多个常量类
            for (int i = 0; i < configureClasses.length; i++) {
                try {
                    c = Class.forName(configureClasses[i]);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                    continue;
                }
    
                fields = c.getFields();
    
                // 遍历属性列表，注入到常量字段中
                for (int j = 0; fields != null && j < fields.length; j++) {
                    keyStr = fields[j].getName();
                    // 判断常量字段是否有属性匹配，不区分大小写。
                    value = propMap.get(lowerCaseKey ? keyStr.toLowerCase() : key);
                    if (null != value && value.length() > 0) {
                        // 从属性中取出字段值，并存到字段中
                        if (value != null) {
                            value = value.trim();
                            fields[j].setAccessible(true);
                            try {
                                if (Integer.TYPE.equals(fields[j].getType())) {
                                    fields[j].setInt(null, Integer.parseInt(value));
                                } else if (Long.TYPE.equals(fields[j].getType())) {
                                    fields[j].setLong(null, Long.parseLong(value));
                                } else if (Short.TYPE.equals(fields[j].getType())) {
                                    fields[j].setShort(null, Short.parseShort(value));
                                } else if (Double.TYPE.equals(fields[j].getType())) {
                                    fields[j].setDouble(null, Double.parseDouble(value));
                                } else if (Float.TYPE.equals(fields[j].getType())) {
                                    fields[j].setFloat(null, Float.parseFloat(value));
                                } else if (Boolean.TYPE.equals(fields[j].getType())) {
                                    fields[j].setBoolean(null, Boolean.parseBoolean(value));
                                } else {
                                    fields[j].set(null, value);
                                }
                            } catch (IllegalArgumentException e) {
                                e.printStackTrace();
                            } catch (IllegalAccessException e) {
                                e.printStackTrace();
                            } finally {
                                fields[j].setAccessible(false);
                            }
                        }
                    }
                }
            }
    
        }
    
        public String[] getConfigureClasses() {
            return configureClasses;
        }
    
        public void setConfigureClasses(String[] configureClasses) {
            this.configureClasses = configureClasses;
        }
    
        public boolean isLowerCaseKey() {
            return lowerCaseKey;
        }
    
        public void setLowerCaseKey(boolean lowerCaseKey) {
            this.lowerCaseKey = lowerCaseKey;
        }
    }

Spring配置：

<bean class="com.xxx.xxx.CustomPropertyPlaceholderConfigurer">
            
            <property name="locations">
                <list>
                    <value>classpath*:test.properties</value>
                </list>
            </property>
            <property name="configureClasses">
                <list>
                    <value>com.xxx.xxx.cnst.AxxxCnst</value>
                    <value>com.xxx.xxx.cnst.BxxxCnst</value>
                </list>
            </property>
            
            <property name="lowerCaseKey" value="false"/>
            <property name="ignoreUnresolvablePlaceholders" value="true"/>
        </bean>

在项目启动时（初始化）会将properties文件中的属性读取到静态类（前提是，静态类中有以properties文件中属性key为名的静态常量）中。