Spring中的资源文件框架——Resource

标签：itme   prot   func   ber   file   返回   system   mys   dmi   

摘要

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也提供了支持。

Spring中的资源文件框架——Resource

标签：itme   prot   func   ber   file   返回   system   mys   dmi   

原文地址：https://www.cnblogs.com/exmyth/p/11306487.html