Spring中的资源文件框架—

摘要

Spring4 以后，官方推荐我们使用Java Config来代替applicationContext.xml，声明将Bean交给容器管理。
在Spring Boot中，Java Config的使用也已完全替代了applicationContext.xml。实现了xml的零配置。所以无论从Spring的演进，还是学习Spring Boot的需要，都应该深入学习Spring Java Config的使用方法。这篇文章主要从以下几个方面进行介绍:

Spring java Config 入门程序
bean标签的使用
bean的依赖
自动扫描
import 和 importResource
properties文件的加载及占位
profile

Spring Java Config入门介绍及简单程序

回顾以前的applicationContext.xml配置方式，我们会将需要使用bean通过xml的形式来配置，那么Java Config的方式，不需要多思考，就可以判断我们应该将bean配置在一个Java文件中，而且这个Java文件应当被Spring容器所识别。我们看如下这个例子：

创建一个bean类

public class SomeBean {

    public void doWork() {

        System.out.println("do work...");

    }

}

其中，doWork是逻辑方法。

创建一个Config类

@Configuration

public class Config {

    @Bean

    public SomeBean someBean() {

        return new SomeBean();

    }

}

需要注意的是，我们在config类上添加了一个@configuration的注解，见名知意，我们可以理解为Spring中的配置类。在返回值为SomeBean的someBean方法上我们添加了一个@Bean注解，也不难理解，返回的new SomeBean对象将交由Spring容器进行管理。

测试

public class Test {

    public static void main(String[] args) {

        ApplicationContext context = new AnnotationConfigApplicationContext(Config.class);

        SomeBean sb = context.getBean(SomeBean.class);

        sb.doWork();

    }

}

这里，我们创建了一个AnnotationConfigApplicationContext对象，传入了Config.class后，得到了SomeBean对象。

do work...

以上就是Spring Java Config 配置bean的最简单的程序，对不喜欢xml配置的开发人员还是比较有优势的。
我们知道，在xml中，一般是这样配置的：

<bean id="someBean" class="com.springboot.javaconfig.SomeBean" initMethod="init" destroyMethod="destroy" ref="otherBean" scope="singlon"

一个完整的bean配置包括了 id,class,initMethod,destroyMethod,·ref,scope。

那么，在Java Config如何配置这些属性呢？其实也是很简单的，我们修改第一个例子的代码：

public class SomeBean {

    private void init() {

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

    }

    public void doWork() {

        System.out.println("do work...");

    }

    private void destroy() {

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

    }

}

增加了init,destroy方法。

@Configuration

public class Config {

    @Bean(initMethod = "init",destroyMethod = "destroy")

    public SomeBean someBean() {

        return new SomeBean();

    }

}

在bean注解上，属性指向对应的方法名。

public class Test {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);

        SomeBean sb1 = context.getBean(SomeBean.class);

        System.out.println(sb1);

        SomeBean sb2 = context.getBean(SomeBean.class);

        System.out.println(sb2);

        context.close();

    }

}

输出结果为：

init...

com.spring.SomeBean@16022d9d

com.spring.SomeBean@16022d9d

destroy...

从这个程序我们可以看出如下信息：

init,destroy方法都在相应的阶段被调用
两次创建的SomeBean实例指向同一个地址，说明Spring容器给我们创建的SomeBean对象时单例的。

其它

如果希望创建了一个多例的bean,可以这样书写：

@Scope("prototype")

public class SomeBean {

}

如果希望使用id和class共同查找bean,可以这样书写：

SomeBean sb = context.getBean("someBean",SomeBean.class);

需要特别注意的是，Spring默认使用Config中的函数名作为该bean的id。

bean的依赖

在xml中，我们使用value来配置注入简单值，ref来配置注入其他对象，那么在Java Config中如何实现呢？我们来继续编写代码：

新建一个bean类

public class OtherBean {

}

修改SomeBean和Config类

public class SomeBean {

    @Autowired

    private OtherBean otherBean;

    public void sayHello() {

        System.out.println(otherBean);

    }

}

@Configuration

public class Config {

    @Bean

    public SomeBean someBean() {

        return new SomeBean;

    }

    @Bean

    public OtherBean otherBean () {

        return new OtherBean();

    }

}

此时，我们将OtherBean纳入spring容器进行管理，在SomeBean类中对OtherBean的实例进行注入。得到结果：

com.spring.OtherBean@51b279c9

由此，实现了Java Config中的依赖注入，只不过也就是将需要依赖的bean也加入Config类用bean以修饰。
当然，我们也可以不使用@AutoWired标签，而通过set方法注入。



@Configuration

public class Config {

    @Bean

    public SomeBean someBean(OtherBean otherBean) {

        SomeBean someBean = new SomeBean();

        // 1

        someBean.setOtherBean(new OtherBean());

        // 2

        someBean.setOtherBean(otherBean());

        // 3

        someBean.setOtherBean(otherBean);

        return someBean;

    }

    @Bean

    public OtherBean otherBean () {

        return new OtherBean();

    }

}

set注入方法比较多，可以自行创建一个OtherBean对象，因为都在Config类中，也可以调用otherBean()方法，也可以在参数列表中进行传入，参数名要使用OtherBean的方法名。因为OtherBean类型的可能有多个对象。

Java Config 和注解配置混用

我们知道，spring为我们提供了诸如@component,@controller,@service,@repositroy这类标签，它们增加了类的语义，然后将对应的类加入到了spring容器进行管理，也是避免了在xml中去配置。将Java Config和注解配置混用是我们在日常开发中经常使用的方式，我们来看如下代码，模拟MVC三层架构:

LoginDAO：

@Repository

public class LoginDAO {

    public void login() {

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

    }

}

LoginService

@Service

public class LoginService {

    @Autowired

    private LoginDao loginDao;

    public void login() {

        loginDao.login();

    }

}

LoginController

@RequestMapping("/user")

@RestController

public class LoginController {

    @Autowired

    private LoginService loginService;

    @RequestMapping(path = "/login",method = RequestMethod.POST)

    public void login() {

        loginService.login();

    }

}

Java Config

@ComponentScan(basePackages = "com.spring")

@Configuration

public class Config {

}

public class Test {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);

        LoginController controller = context.getBean("loginController",LoginController.class);

        controller.login();

    }

}

输出结果：

login...

解读：我们并没有将LoginDAO,LoginService,LoginController纳入Config,用@Bean修饰，而是使用了注解配置，在Config类中通过ComponentScan标签，将它们纳入sping容器。通过测试，我们发现，Java Config 和注解配置的混合使用时可行的。

Java Config 和 applicationContext.xml混用

有时候，我们会遇到必须使用xml配置的情况，这时候，我们可以这样来操作：

创建applicationContext.xml文件

<bean id="xmlBean" class="com.spring.XMLBean"/>

修改Config

@ImportResource("com/spring/applicationContext.xml")

@ComponentScan(basePackages = "com.spring")

@Configuration

public class Config {

}

运行结果：

com.spring.XMLBean@7bb58ca3

在Config类上使用@ImportResource标签，就可以将在xml配置的bean引入到spring容器。

占位符配置

自定义datasource

public class DataSource {

    private String url;

    private String driverClass;

    private String userName;

    private String password;

    // get()

    // set()

    // constructor()

}

在xml中，我们配置datasource时往往将连接信息封装在db.properties中:

driverClass=com.mysql.jdbc.driver

url=jdbc:mysql://localhost:3306/my-database

username=root

password=root

在xml中使用占位的方式来获取：

<context:property-placeholder location="com/spring/db.properties"/>

<bean id="dataSource" class="com.spring.DataSource">

        <property name="url" value="${url}"/>

        <property name="driverClass" value="${driverClass}"/>

        <property name="userName" value="${user}"/>

        <property name="password" value="${password}"/>

</bean>

测试

public class Test {

    public static void main(String[] args) {

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);

        DataSource dataSource = context.getBean("dataSource",DataSource.class);

        System.out.println(dataSource);

    }

}

输出结果：

DataSource{url='jdbc:mysql://localhost:3306/test', driverClass='com.mysql.jdbc.driver', userName='root', password='root'}

那么如何在Config中解读占位配置呢？继续编写代码：

以示区分，我们修改一下，db.properties:

driverClass=com.mysql.jdbc.driver

url=jdbc:mysql://localhost:3306/test

user=admin

password=admin

修改Config

//@ImportResource("com/spring/applicationContext.xml")

@PropertySource("com/spring/db.properties")

@ComponentScan(basePackages = "com.spring")

@Configuration

public class Config {

    @Autowired

    private Environment env;

    @Bean

    public DataSource dataSource() {

        return new DataSource(env.getProperty("url"),env.getProperty("driverClass"),

                env.getProperty("user"),env.getProperty("password"));

    }

}

此时，我们先是去掉了@ImportResource标签，因为已经不需要在xml中配置了，又使用了一个新的标签@PropertySource，来加载db,properties文件，然后又注入了一个env对象，Environment类继承了PropertyResolver接口，专门用来解析properties。

输出结果：

DataSource{url='jdbc:mysql://localhost:3306/test', driverClass='com.mysql.jdbc.driver', user='admin', password='admin'}

可以看到，加载properties文件，在Spring Java Config也提供了支持。