【Spring boot 普通类调用 Bean】

**Spring boot ****普通类调用 **Bean

我们知道如果我们要在一个类使用 spring 提供的 bean 对象，我们需要把这个类注入到 spring 容器中，

交给 spring

容器进行管理，但是在实际当中，我们往往会碰到在一个普通的 Java 类中，想直接使用 spring 提供的其他对象

或者说有一些不需要交给 spring 管理，但是需要用到 spring 里的一些对象。如果这是 spring 框架的独立应用程

序，我们通过:

ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml");

ac.getBean("beanId");

这样的方式就可以很轻易的获取我们所需要的对象。

但是往往我们所做的都是 Web Application，这时我们启动 spring 容器是通过在 web.xml 文件中配置，这样就不

适合使用上面的方式在普通类去获取对象了，因为这样做就相当于加载了两次 spring 容器，而我们想是否可以

通过在启动 web 服务器的时候，就把 Application 放在某一个类中，我们通过这个类在获取，这样就可以在普通

类获取 spring bean 对象了，让我们接着往下看。

**普通类调用 Spring bean 对象: **

可以参考：http://412887952-qq-com.iteye.com/blog/1479445

这里有更多这方面的介绍，比较详细，在这里只是抛装引玉说明在 Spring Boot 是如何进行调用的。

在 Spring Boot 可以扫描的包下

假设我们编写的工具类为 SpringUtil。

如果我们编写的 SpringUtil 在 Spring Boot 可以扫描的包下或者使用@ComponentScan 引入自定义的包了，那

么原理很简单，只需要使得 SpringUtil 实现接口：ApplicationContextAware，然后加上@Component 注解即可，

具体编码如下：

**package **com.hpit.springboot01.util;

**import **org.apache.log4j.Logger;

**import **org.springframework.beans.BeansException;

**import **org.springframework.context.ApplicationContext;

**import **org.springframework.context.ApplicationContextAware;

**import **org.springframework.stereotype.Component;

/**

• spring工具类，为了更方便的获取spring的applicationContext 直接实现接口ApplicationContextAware

*/

@Component

**public class **SpringUtil **implements **ApplicationContextAware {

**private **Logger logger = Logger.getLogger(getClass());

**private static **ApplicationContext applicationContext;

@Override

**public void **setApplicationContext(ApplicationContext applicationContext) **throws **BeansException {

**if **(SpringUtil.*applicationContext *== null) {

SpringUtil.*applicationContext *= applicationContext;

}

logger.info(

"========ApplicationContext配置成功,在普通类可以通过调用

SpringUtils.getApplicationContext()获取applicationContext对象,applicationContext="

• SpringUtil.*applicationContext *+ "========");

}

/**

• 获取spring上下wen

• **@return **

*/

**public static **ApplicationContext getApplicationContext() {

**return **applicationContext;

}

**public static **Object getBean(String beanName) {

**return **applicationContext.getBean(beanName);

}

**public static **<T> Object getBean(Class<T> class1) {

**return **applicationContext.getBean(class1);

}

**public static **<T> Object getBean(Class<T> class1, String beanName) {

**return **applicationContext.getBean(class1, beanName);

}

}

不在 Spring Boot 的扫描包下方式一

这种情况处理起来也很简单，先编写 SpringUtil 类，同样需要实现接口：ApplicationContextAware，具体编

码如下：

simple.plugin.spring.SpringUtil

**package **simple.plugin.spring;

**import **org.springframework.beans.BeansException;

**import **org.springframework.context.ApplicationContext;

**import **org.springframework.context.ApplicationContextAware;

**public class **SpringUtil **implements **ApplicationContextAware{

**private static **ApplicationContext *applicationContext *= null;

@Override

**public void **setApplicationContext(ApplicationContext applicationContext) **throws **BeansException

{

if(SpringUtil.*applicationContext *== null){

SpringUtil.*applicationContext *= applicationContext;

}

System.out.println("---------------------------------------------------------------------");

System.out.println("---------------------------------------------------------------------");

System.out.println("---------------simple.plugin.spring.SpringUtil--------------------------------------

----------------");

System.out.println("========ApplicationContext 配置成功 , 在普通类可以通过调用

SpringUtils.getAppContext()

获 取

applicationContext

对

象,applicationContext="+SpringUtil.applicationContext+"========");

System.out.println("---------------------------------------------------------------------");

}

//获取 applicationContext

**public static **ApplicationContext getApplicationContext() {

returnapplicationContext;

}

//通过 name 获取 Bean.

**public static **Object getBean(String name){

**return **getApplicationContext().getBean(name);

}

//通过 class 获取 Bean.

**public static **<T> T getBean(Class<T> clazz){

**return **getApplicationContext().getBean(clazz);

}

//通过 name,以及 Clazz 返回指定的 Bean

**public static **<T> T getBean(String name,Class<T> clazz){

**return **getApplicationContext().getBean(name, clazz);

}

}

之后这一步才是关键，使用@Bean 注解，在 App.java 类中将 SpringUtil 注解进来，代码如下：

**package com.hpit; **

**import org.springframework.boot.SpringApplication; **

**import org.springframework.boot.autoconfigure.SpringBootApplication; **

**import org.springframework.boot.web.servlet.ServletComponentScan; **

**import org.springframework.context.annotation.Bean; **

**import org.springframework.context.annotation.Import; **

**import simple.plugin.spring.SpringUtil; **

/ **

*** Hello world! **

***/ **

**//其中@SpringBootApplication ****申明让 ****spring boot ****自动给程序进行必要的配置，等价于以默认属性使用 **

@Configuration**，@EnableAutoConfiguration 和@ComponentScan **

**@SpringBootApplication **

**@ServletComponentScan **

**public class App { **

**/******注册 ****Spring Util **

*** 这里为了和上一个冲突，所以方面名为：springUtil2 **

*** ****实际中使用 ****springUtil **

***/ **

**@Bean **

**public SpringUtil springUtil2(){return new SpringUtil();} **

/ **

**参数里 ****VM ****参数设置为： **

**-javaagent:.\lib\springloaded-1.2.4.RELEASE.jar -noverify **

*** @param args **

***/ **

**public static void main(String[] args) { **

**SpringApplication.run(App.class, args); **

**} **

**} **

不在 Spring Boot 的扫描包下方式二

代码基本和上面都是相同的，主要是在 App.java 中使用@Import 进行导入。

而且在 SpringUtil 是不需要添加@Component 注解

@SpringBootApplication

@ServletComponentScan

@Import(value={SpringUtil.class})

**publicclass **App {

//省略其它代码.

}

说明以上 3 中方式都生效了，这 3 中方式根据实际情况选择一种方式就可以了。

那么这样子在普通类既可以使用:

SpringUtil.getBean() 获取到 Spring IOC 容器中的 bean。

当然也可以在 Spring 管理的类中使用：

@Resouce 或者@Autowired 进行注入使用，当然我们这个类的核心是普通类可以调用 spring 的 bean 进行使用

了，是不是很神奇呢。