初学 spring —— bean 装配

此文介绍 spring 中装配bean的三种方式：xml配置文件装配、java代码装配和自动装配。本demo使用maven构建，具体如下：

准备

1、配置maven依赖，pom.xml文件如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>iamck.study</groupId>
  <artifactId>spring</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>spring</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.3.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>4.3.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>4.3.8.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

  </dependencies>
</project>

2、定义UserFacede接口

package iamck.study.spring.common.facade;

public interface UserFacade {
    public void work();
}

3、创建Programmer.java，实现UserFacade

package iamck.study.spring.common.beans;

import iamck.study.spring.common.facade.UserFacade;

@Component//此注解标志类为一个组件，用于组件扫描。自动装配时使用。
public class Programmer implements UserFacade{

    @Override
    public void work() {
        // TODO Auto-generated method stub
        System.out.println("好好敲代码。");
    }

}

4、创建 WiringService.java

package iamck.study.spring.ioc.wiring.service;

import iamck.study.spring.common.facade.UserFacade;

public class WiringService{

    UserFacade user;
    int flag;

    public WiringService(int flag){
        this.flag=flag;
    }

    public WiringService(UserFacade user){
        this.user=user;
    }

    public void setFlag(int flag){
        this.flag=flag;
    }

    public void print(){
        user.work();
    }

}

xml配置文件装配

1、配置applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"  
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util" xmlns:jdbc="http://www.springframework.org/schema/jdbc"  
    xmlns:cache="http://www.springframework.org/schema/cache"  
    xsi:schemaLocation="http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context.xsd  
    http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 
    <context:annotation-config />  开启注解处理器 

    <context:component-scan base-package="iamck.study.spring.ioc.wiring" />  开启组件扫描
    -->

    <!-- 定义bean 
    可选参数——
        name: 定义bean的别名
        class: bean的全路径
        id: bean的实例名，在同一个<beans>中唯一
        parent: 父类bean
        autowire: 注入类型。可选值——default、no、byName、byType、constructor
        scope: 
            singleton 从 bean 定义中只创建一个实例。此为默认的作用域。
            prototype 每次对 bean 定义的访问都会创建一个新的 bean 实例。类似 java 中的 new 操作符。
            request 在整个 Web 请求过程中使用相同的 bean 实例。每一个 Web 请求都会创建一个新的 bean 实例。仅用于 Web 的 ApplicationContexts。
            session 针对一个特定的 http 会话使用相同的 bean 实例。不同的 http 会话创建新的 bean 实例。仅用于 Web 的 ApplicationContexts。
            globalSession 类似于前面介绍的标准 HTTP Session作用域。仅用于基于 portlet 的 Web 应用程序的上下文。
        init-method: 指定初始化之后调用的操作方法
        destroy-method: 指定销毁之前调用的操作方法
    -->
    <bean id="programmer" class="iamck.study.spring.common.beans.Programmer" />
    <bean id="wiringService" class="iamck.study.spring.ioc.wiring.service.WiringService">
        <!-- 构造器注入 
        可选参数——
            ref: 引用其他bean
            index: 表示参数的位置，从 0 开始
            name: 构造器参数的名称
            type: 表示参数的类型
            value: 构造参数值
        -->
        <constructor-arg ref="pro"/>

        <!-- 为bean属性赋值，必须存在相应的setter方法
        可选参数——
            name: 属性名称
            value: 非引用类型赋值
            ref: 引用类型赋值
        -->
        <property name="flag" value="1" />

    </bean>

    <!-- 定义bean的别名 -->
    <alias name="programmer" alias="pro"/>

</beans>

2、编写测试类 XmlWiringTest.java

package iamck.study.spring.wiring;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import iamck.study.spring.ioc.wiring.xmlWiring.service.XmlWiringService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:iamck/study/spring/ioc/wiring/xmlWiring/config/applicationContext.xml")
public class XmlWiringTest {

    @Autowired
    @Qualifier("wiringService")
    WiringService service;

    @Test
    public void testXmlWiring(){
        service.print();
    }

}

测试结果：

好好敲代码。

java 代码装配

1、创建java配置类

package iamck.study.spring.ioc.wiring.javaConfigWiring;

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

import iamck.study.spring.common.beans.Programmer;
import iamck.study.spring.ioc.wiring.javaConfigWiring.service.JavaConfigWiringService;

@Configuration//此注解标记JavaConfig类为配置类
public class JavaConfig {

    @Bean
    public Programmer programmer(){
        return new Programmer();
    }

    @Bean
    public WiringService WiringService(){
        return new WiringService(programmer());//构造器注入
    }

}

2、编写测试类 JavaConfigWiringTest.java

package iamck.study.spring.wiring;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import iamck.study.spring.ioc.wiring.javaConfigWiring.JavaConfig;
import iamck.study.spring.ioc.wiring.service.WiringService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=JavaConfig.class)
public class JavaConfigWiringTest {

    @Autowired
    private WiringService service;

    @Test
    public void testJavaConfigWiring(){
        service.print();
    }

}

测试结果：

好好敲代码。

自动装配

1、创建配置类 AutowiringConfig.java

package iamck.study.spring.ioc.wiring.autowiring;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
//开启组件扫面，并设置扫描路径
@ComponentScan(basePackages={"iamck.study.spring"})
public class AutowiringConfig {

}

2、创建测试类 AutowiringTest.java

package iamck.study.spring.wiring;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import iamck.study.spring.common.facade.UserFacade;
import iamck.study.spring.ioc.wiring.autowiring.AutowiringConfig;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=AutowiringConfig.class)
public class AutowiringTest {

    @Autowired
    UserFacade user;

    @Test
    public void testAutowirng(){
        user.work();
    }

}

测试结果：

好好敲代码。