Spring获取bean的几种方式

　　工作中需要对一个原本加载属性文件的工具类修改成对数据库的操作当然，ado层已经写好，但是需要从Spring中获取bean,然而，工具类并没有交给Spring来管理，所以需要通过方法获取所需要的bean。于是整理了Spring获取bean的几种方法。

　　一. 在初始化时保存ApplicationContext对象

    ApplicationContext ac = new FileSystemXmlApplicationContext("classpath:beans.xml");
    ac.getBean("beanId");

　说明：这种方式适用于采用Spring框架的独立应用程序，需要程序通过配置文件手工初始化Spring的情况。不难理解对于通过web.xml配置启动的Spring来说也一定是里面实现了此方法。

二. 通过Spring提供的工具类获取ApplicationContext对象

    ApplicationContext ac1 = WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc);
    ApplicationContext ac2 = WebApplicationContextUtils.getWebApplicationContext(ServletContext sc);
    ac1.getBean("beanId");
    ac2.getBean("beanId");

说明:这种方法适合于B/S模式，需要提供ServletContext,局限性比较大，至于以上两个方法区别是前者出错会抛出异常，而后者会返回null。

三. 继承自抽象类ApplicationObjectSupport

说明：抽象类ApplicationObjectSupport提供getApplicationContext()方法，可以方便的获取ApplicationContext。

Spring初始化时，会通过该抽象类的setApplicationContext(ApplicationContext context)方法将ApplicationContext 对象注入。

四. 继承自抽象类WebApplicationObjectSupport

说明：类似上面方法，调用getWebApplicationContext()获取WebApplicationContext

五：实现接口ApplicationContextAware

说明：实现该接口的setApplicationContext(ApplicationContext context)方法，并保存ApplicationContext 对象。Spring初始化时，会通过该方法将ApplicationContext对象注入。

　　相比下来对于需要获取已经启动的bean。我们需要获取bean方法，这时我们可以通过实现接口ApplicationContextAware来获取。

　　实际应用：

　　一. SpringContextHolder类

package com.gren.supervise.commons;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
 * 以静态变量保存Spring ApplicationContext, 可在任何代码任何地方任何时候中取出ApplicaitonContext.
 *
 */
public class SpringContextHolder implements ApplicationContextAware {
private static ApplicationContext applicationContext;  

/**
* 实现ApplicationContextAware接口的context注入函数, 将其存入静态变量.
*/
public void setApplicationContext(ApplicationContext applicationContext) {
SpringContextHolder.applicationContext = applicationContext; // NOSONAR
}  

/**
* 取得存储在静态变量中的ApplicationContext.
*/
public static ApplicationContext getApplicationContext() {
checkApplicationContext();
return applicationContext;
}  

/**
* 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的类型.
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) {
checkApplicationContext();
return (T) applicationContext.getBean(name);
}  

/**
* 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的类型.
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(Class<T> clazz) {
checkApplicationContext();
return (T) applicationContext.getBeansOfType(clazz);
}  

/**
* 清除applicationContext静态变量.
*/
public static void cleanApplicationContext() {
applicationContext = null;
}  

private static void checkApplicationContext() {
if (applicationContext == null) {
throw new IllegalStateException("applicaitonContext未注入,请在applicationContext.xml中定义SpringContextHolder");
}
}
}

二. PropertyUtil

package com.gren.supervise.util;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import com.gren.supervise.commons.SpringContextHolder;
import com.gren.supervise.dao.MapCnfDao;
import com.gren.supervise.pojo.MapCnf;

/**
 * 媒资系统配置文件参数获取工具
 * */
public final class PropertyUtil {
    private static Properties props;
    private static MapCnfDao cnfDao;

    private PropertyUtil() {
    }

    static {
        cnfDao = (MapCnfDao) SpringContextHolder.getBean("cnfDao");
        props = new Properties();
        try {
            props.load(PropertyUtil.class
                    .getResourceAsStream("/config.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Properties getSysProperties() {
        Properties properties = new Properties();
        List<MapCnf> cnfs = cnfDao.list();
        for (int i = ; i < cnfs.size(); i++) {
            properties.put(cnfs.get(i).getKey(), cnfs.get(i).getValue());
        }
        return properties;
    }

    /**
     * 获取指定的系统属性
     *
     * @param key
     *            指定的属性名称
     * @return 指定的系统属性值
     */
    public static String getProperty(String key) {
        ConditionFilter conditionFilter = new ConditionFilter("key", key,
                ConditionFilter.EQ);
        List<ConditionFilter> conditionFilters = new ArrayList<ConditionFilter>();
        conditionFilters.add(conditionFilter);
        List<MapCnf> cnfs = cnfDao.queryByCondition(conditionFilters);
        if(null==cnfs){
            return null;
        }
        return cnfs.get().getValue();
    }

    /**
     * 获取指定的系统属性
     *
     * @param key
     *            指定的属性名称
     * @param defaultVal
     *            默认值
     * @return 指定的系统属性值
     */
    public static String getProperty(String key, String defaultVal) {
        return getProperty(key);
    }

    /*
     * 修改属性
     */
    public static void put(String key, String value) {
        MapCnf entity = new MapCnf();
        entity.setKey(key);
        entity.setValue(value);
        ConditionFilter conditionFilter = new ConditionFilter("key", key,
                ConditionFilter.EQ);
        List<ConditionFilter> conditionFilters = new ArrayList<ConditionFilter>();
        conditionFilters.add(conditionFilter);
        List<MapCnf> cnfs = cnfDao.queryByCondition(conditionFilters);
        if(null!=cnfs&&cnfs.get().getId()>){
            entity.setId(cnfs.get().getId());
        cnfDao.saveOrupdate(entity);
        }
    }

    public static void toCnfMap() {
        Enumeration enumeration = props.propertyNames();
        while (enumeration.hasMoreElements()) {
            String key = (String) enumeration.nextElement();
            PropertyUtil.put(key, (String) props.get(key));
        }
    }
}