BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
User user = (User) beanFactory.getBean("user");

public interface BeanFactoryAware extends Aware {
 /**
  * 初始化回調(diào)方法，Spring會(huì)自動(dòng)將BeanFactory注入進(jìn)去，接收之后即可使用BeanFactory
  */
 void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}

@Component
public class BeanFactoryHelper implements BeanFactoryAware {
 private static BeanFactory beanFactory;
 /**
  * 重寫 BeanFactoryAware 接口的方法
  * @param beanFactory ：參數(shù)賦值給本地屬性之后即可使用 BeanFactory
  * @throws BeansException BeansException
  */
 @Override
 public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
  BeanFactoryHelper.beanFactory = beanFactory;
 }
 /**
  * 根據(jù)名稱獲取容器中的對(duì)象實(shí)例
  * @param beanName ：注入的實(shí)例必須已經(jīng)存在容器中，否則拋異常：NoSuchBeanDefinitionException
  * @return Object
  */
 public static Object getBean(String beanName) {
  return beanFactory.getBean(beanName);
 }
 /**
  * 根據(jù) class 獲取容器中的對(duì)象實(shí)例
  * @param requiredType ：被注入的必須已經(jīng)存在容器中，否則拋異常：NoSuchBeanDefinitionException
  * @param <T> Class
  * @return 對(duì)象
  */
 public static <T> T getBean(Class<T> requiredType) {
  return beanFactory.getBean(requiredType);
 }
 /**
  * 判斷 spring 容器中是否包含指定名稱的對(duì)象
  * @param beanName bean名稱
  * @return 是否存在
  */
 public static boolean containsBean(String beanName) {
  return beanFactory.containsBean(beanName);
 }
 //其它需求皆可參考 BeanFactory 接口和它的實(shí)現(xiàn)類
}

// 其中applicationContext.xml 為配置容器的xml，不過現(xiàn)在一般很少使用了
ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml");

@SpringBootApplication
public class ExampleApplication {
    public static void main(String[] args) {
        // 啟動(dòng)時(shí)，保存上下文，并保存為靜態(tài)
        ConfigurableApplicationContext ac = SpringApplication.run(ExampleApplication.class, args);
        SpringContextUtil.setApplicationContext(ac);
    }
}

public class SpringContextUtil1 {
    private static ApplicationContext ac;
    public static <T>  T getBean(String beanName, Class<T> clazz) {
        T bean = ac.getBean(beanName, clazz);
        return bean;
    }
    public static void setApplicationContext(ApplicationContext applicationContext){
        ac = applicationContext;
    }
}

@Component
public class SpringContextUtil extends ApplicationObjectSupport {
 public <T> T getBean(Class<T> clazz) {
  ApplicationContext ac = getApplicationContext();
  if(ac == null){
   return null;
  }
  return ac.getBean(clazz);
 }
}

@Component
public class SpringContextUtil extends WebApplicationObjectSupport {
 public <T> T getBean(Class<T> clazz) {
  ApplicationContext ac = getApplicationContext();
  if(ac == null){
   return null;
  }
  return ac.getBean(clazz);
 }
}

public class SpringContextUtil2 {
 public static <T> T getBean(ServletContext request, String name, Class<T> clazz){
  WebApplicationContext webApplicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(request);
  // 或者
  WebApplicationContext webApplicationContext1 = WebApplicationContextUtils.getWebApplicationContext(request);
//        webApplicationContext1.getBean(name, clazz)
  T bean = webApplicationContext.getBean(name, clazz);
  return bean;
 }
}

@Component
public class SpringContextUtil3 implements ApplicationContextAware {
 private static ApplicationContext ac;
 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  ac = applicationContext;
 }
 public static <T> T getBean(Class<T> clazz) {
  T bean = ac.getBean(clazz);
  return bean;
 }
}

WebApplicationContext wac = ContextLoader.getCurrentWebApplicationContext();
wac.getBean(beanID);

@Component
public final class SpringUtils implements BeanFactoryPostProcessor{
    /** Spring應(yīng)用上下文環(huán)境 */
    private static ConfigurableListableBeanFactory beanFactory;
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException{
        SpringUtilsS.beanFactory = beanFactory;
    }
    /**
     * 獲取對(duì)象
     *
     * @param name
     * @return Object 一個(gè)以所給名字注冊(cè)的bean的實(shí)例
     * @throws BeansException
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException{
        return (T) beanFactory.getBean(name);
    }
    /**
     * 獲取類型為requiredType的對(duì)象
     *
     * @param clz
     * @return
     * @throws BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException{
        T result = (T) beanFactory.getBean(clz);
        return result;
    }
    /**
     * 如果BeanFactory包含一個(gè)與所給名稱匹配的bean定義，則返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name){
        return beanFactory.containsBean(name);
    }
    /**
     * 判斷以給定名字注冊(cè)的bean定義是一個(gè)singleton還是一個(gè)prototype。 如果與給定名字相應(yīng)的bean定義沒有被找到，將會(huì)拋出一個(gè)異常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException{
        return beanFactory.isSingleton(name);
    }
    /**
     * @param name
     * @return Class 注冊(cè)對(duì)象的類型
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException{
        return beanFactory.getType(name);
    }
    /**
     * 如果給定的bean名字在bean定義中有別名，則返回這些別名
     *
     * @param name
     * @return
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException{
        return beanFactory.getAliases(name);
    }
    /**
     * 獲取aop代理對(duì)象
     * 
     * @param invoker
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T getAopProxy(T invoker){
        return (T) AopContext.currentProxy();
    }
}