本章的学习目标看如下的思维导图:

思维导图

依赖注入

在实际环境中实现Ioc容器的方式主要分为:依赖查找和依赖注入
二者关系 : 我们知道Spring是先完成Bean的定义和生成,然后在寻找需要注入的资源,找到对应的类型然后将其注入,完成依赖注入.
依赖注入有三种方式:构造器注入,setter注入和接口注入.

构造器注入

构造器注入依赖于构造方法来实现,Spring也可以通过使用构造方法来完成注入,这是构造器注入原理

package pojo;

public class Role {
    private Long id;
    private String name;

    public Role() {
        super();
    }

    public Role(Long id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

配置构造器,其中constructor-arg 元素用于定义类构造方法的参数,index用于定义参数的位置,value是设置对应的值

    <bean id="role1" class="pojo.Role">
        <constructor-arg index="0" value="1" />
        <constructor-arg index="1" value="wt"/>
    </bean>

使用setter注入

setter是Spring中最主流的注入方式,它利用JAVA Bean规范定义的setter方法来完成注入,这里值得注意的是,这里的构造方法是无参构造方法,然后使用setter注入相对应的值,其实这也是通过JAVA发射技术得以实现的

    <!-- setter注入 -->
    <bean id="role2" class="pojo.Role">
         <property name="id" value="1"/>
         <property name="name" value="wt"/>
    </bean>

接口注入

来自外界的资源,我们一般使用接口来注入,虽然说,考虑使用注解的方式去装配Bean多一点,但是,对于外部的资源而言,很多情况之下是不能知晓其源码,更不可能一一为其加上注解,此时我们便可以使用接口注入.

装配Spring Bean

将以及开发好的Bean装配到Spring Ioc容器中,通常情况下,我们会使用ApplicationContext的具体实现类

通常情况下,在没有歧义的前提之下,优先使用注解来自动装配,这样可以减少大量的XML配置,如果所配置的类并非自己工程所开发的,那么建议使用XML的方式会更加方便一点

使用XML配置装配Bean

方法与依赖注入中使用setter注入的方式一样,常用属性有:
id :这个Bean的编号
class:类的全限定名
property:定义类的属性，其中name是属性的名称，value是其值
ref:可用于引用之前Bean的id . <ref bean="需要引入的Bean的ID"/>

下面介绍一下装配常用集合类的方法(直接上代码)：

    <!-- 集合类注入 -->
    <bean id="role3" class="">
        <!-- List -->
        <property name="list">
            <list>
                <value>one</value>
                <value>two</value>
            </list>
        </property>
        <!-- Map -->
        <property name="map">
            <map>
                <entry key="key1" value="value1" />
                <entry key="key2" value="value2" />
            </map>
        </property>
        <!-- Properties(该元素有一个必填属性key) -->
        <property name="pros">
            <props>
                <prop key="key1">value1</prop>
                <prop key="key2">value2</prop>
            </props>
        </property>
        <!-- set -->
        <property name="set">
            <set>
                <value>value1</value>
                <value>value2</value>
            </set>
        </property>
        <!-- array -->
        <property name="array">
            <array>
                <value>value1</value>
                <value>value2</value>
            </array>
        </property>
    </bean>

使用ApplicationContext来测试

    public static void main(String[] args) {
       ApplicationContext context = new ClassPathXmlApplicationContext("classpath:pojo/SpringBean-config.xml");
       ComplexRole role = (ComplexRole) context.getBean("role3");
       System.out.println(role.toString());
    }
输出：ComplexRole [list=[one, two], map={key1=value1, key2=value2}, props={key2=value2, key1=value1}, set=[value1, value2], array=[value1, value2]]

测试成功！

命名空间的装配

使用名字变量空间的时候需要引入对应的命名空间和XML模式(XSD)文件

通过注解来装配Bean

相比与XML,注解的功能更为强大,使用注解的方式可以减少XML的配置,它既能实现XML的功能,也提供了自动专装配的功能.在Spring中,它提供了两种方式让Spring IoC容器来发现Bean:
①组件扫描:通过定义资源的方式,让Spring IoC容器扫描对应的包,从而把Bean装配起来.
②自动装配:通过注解定义,使得一些依赖关系可以通过注解来完成.

使用@Component装配Bean

@Component(value="role1")
public class Role {
    @Value("1")
    private Long id;
    @Value("wt")
    private String name;
/***setter and getter ***/
}

解释一下,这里的注释Component 和 Value :
@Component : 代表Spring IoC会把这类扫描成Bean实例,而其中的Value代表这个类在Spring中的id,相当于XML中的id,对于没有表面的,容器就默认类名,以首字母为小写的形式作为id.
@Value : 代表的是值的注入

敲黑板的时候到了,虽然现在已经有了这个类,到时Spring Ioc并不知道去哪里扫描这个对象,这个时候我们则需要一个JAVA Config来告诉它(直接上代码)

package pojo;

import org.springframework.context.annotation.ComponentScan;

@ComponentScan
public class PojoConfig {
}

解释一下这里新增加的注释 @ComponentScan,扫描包,默认是当前包的路径.

       ApplicationContext context = new AnnotationConfigApplicationContext(PojoConfig.class);
       Role role = (Role) context.getBean(Role.class);
       System.out.println(role.toString());
输出:Role [id=1, name=wt]

测试成功!

下面,我们再来深入学习一下@ComponentScan这个注解,该注解存在两个配置项:basePackages(扫描指定包,可同时指定多个包) 和 basePackageClasses(扫描指定类,可以同时指定多个类)

import org.springframework.context.annotation.ComponentScan;

@ComponentScan(basePackageClasses= {Role.class, ComplexRole.class})
//扫描包的做法如下
//@ComponentScan(basePackages = {"pojo"})
public class PojoConfig {
}

自动装配@Autowired

在之前提到的@Value中,我们不难发现一个缺点,便是该注释只能注入简单的值而不能注入对象,此时,便有@Autowired注释的诞生,该注释可以注入对象,直接上代码

@Component("roleService")
public class RoleServiceImpl implements RoleService{

    @Autowired
    private Role role = null;
    
    public void printRoleInfo() {
        // TODO Auto-generated method stub
        System.out.println(role.toString());
    }

}

测试代码

       ApplicationContext context = new AnnotationConfigApplicationContext(PojoConfig.class);
       Role role = (Role) context.getBean(Role.class);
       System.out.println(role.toString());
输出:Role [id=1, name=wt]

测试成功!

解决自动装配的歧义性@Primary和@Qualifier

到了这里,相信大家都对自动装配注释@Autowired有了一定了解,此时,估计小伙伴们会有这样一个疑惑,在现实编程中,一个接口类往往会有多个实现类,若@Authowired的对象是一个接口类的话,如果这个接口类有多个实现类,那么此时,Spring IoC容器就会犯糊涂,它无法判断要把哪个对象注入进来,于是就会抛出异常,然后注入失败.
为了解决此类异常,
解释一下这两个注释：
＠Primary : 顾名思义，该注释代表首要的，可告诉Spring IoC 容器优先注入该类

@Component(value="role1")
@Primary
public class Role {
    @Value("1")
    private Long id;
    @Value("wt")
    private String name;
   .....
}

@Qualifier : 按名称去查找Bean而不是按类型查找

@Component("roleService")    
public class RoleServiceImpl implements RoleService{

    @Autowired
    @Qualifier("role1")　　　　＃这里传入的参数是Bean的id
    private Role role = null;
    
    public void printRoleInfo() {
        // TODO Auto-generated method stub
        System.out.println(role.toString());
    }

}

装载带有参数的构造方法类

我们可以通过@Autowired 和@Qualifier来注入参数，例如

    public RoleServiceImpl(@Autowired Role role) {
        super();
        this.role = role;
    }

使用@Bean装配Bean

在以上的学习中，我们不难发现，我们基本都是通过＠Component来装配Bean的，但是@Component只能注解在类上，而不能注解到方法上，这个时候Spring给予了一个注解@Bean，这个注解可以注解到方法智商，并且将方法返回来的对象作为Spring的Bean，存放在Spring IoC容器中．
＠Bean的优势在于，可以快速引入第三方的包所返回的对象，而不是一个个地为别人的代码加上@Component，而且这样也是不可取的．
举个栗子：
例如，我想使用第三方jar包中的TestBean对象，但是我总不能去那个jar包里面为这个类加上@Component注释吧，况且，很多情况下，第三方包的源码是不公开的，这种情况下，我们想加注释也加不了，此时，@Bean的优势便能体现出来,在以下例子中，我们可以在getTestBean()方法下加上@Bean注释，使之成为成功Bean，那么我们就可以调用这个Bean来得到TestBean这个对象，除此之外，这个Bean也可以和其它Bean一样，通过@Autowired和@Qualifier来注入别的Bean中

public class PojoConfiguration {

    //@Bean注解注册bean,同时可以指定初始化和销毁方法
    //@Bean(name="testNean",initMethod="initMethod",destroyMethod="destroyMethod")
    @Bean
    @Scope("prototype")
    public TestBean getTestBean() {
        return new TestBean();
    }
}

解释一下这几个属性：
name : 配置BeanName，可配置多个
autowired : 标志是否是一个引用的Bean对象
initMethod : 自定义初始化方法
destroyMethod：自定义销毁方法

测试代码

public class TestMain {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class);
        //获取bean
        TestBean tb = context.getTestBean("testBean");
    }
}

再次强调，在现实生活中，使用XML或者注解各有道理，笔者建议在自己的工程所开发的类尽量使用注解方式，而对于引入第三方包的或者服务的类，尽量使用ＸＭＬ方式，这样的好处是可以尽量对第三方包或者服务的细节减少理解，也更加清晰和明朗，开发者在引入第三方包之前要了解第三方包的使用规则，这样对XML进行改写就简单许多了．

扫描XML文件

@ComponentScan(basePackageClasses= {Role.class, ComplexRole.class, RoleServiceImpl.class})
//扫描包的做法如下
//@ComponentScan(basePackages = {"service.Impl"})
@ImportResource({"classPath:SpringBean-config.xml"})
public class PojoConfig {
}

@ImportResource配置的内容是一个数组，可以配置多个XML 文件，这样就可以引入多个XML定义的Bean了
此外,在介绍一下@Import注解,有些时候,JAVAConfig类会不止一个,这个时候,就可以使用@Import来映入其它的JavaConfig类

@Import({PojoConfig2.class, PojoConfig3.class})

最后在补充一个知识点:目前,XML是无法加载JAVA配置类的,即(JAVAConfig),但是,支持通过XML的配置来扫描注解的包,代码如下

@ComponentScan(basePackages={"pojo"})

等同于XML中的

<context:component-scan base-package="pojo"/>

一般都以注解为主

Profile

该注解可以满足在不同环境下切换的需求,方便开发人员和测试人员使用不同的环境,此处便不做过多介绍.

加载属性(properties)文件
首先,Spring提供了注解@PropertySource来加载属性文件,其中,该注解包含几个属性,先来了解一下
name:配置这次属性配置的名称
value:配置文件的名称,可以配置多个属性文件
ignoreResourceNotFound:boolean值,其含义是如果找不到对应的属性文件是否进行忽略处理,默认值为false,即抛出异常
encoding:编码

首先,创建属性文件config.properties,其内容如下:

name = wt
id = 1

然后,在Spring环境中使用属性文件

@ComponentScan(basePackageClasses= {Role.class, ComplexRole.class, RoleServiceImpl.class})
//扫描包的做法如下
//@ComponentScan(basePackages = {"service.Impl"})

//扫描配置文件
//@ImportResource({"classPath:SpringBean-config.xml"})

//扫描属性文件
@PropertySource(value= {"classpath:config.properties"})
public class PojoConfig {

}

测试加载属性文件

public class test {
    public static void main(String[] args) {
       ApplicationContext context = new AnnotationConfigApplicationContext(PojoConfig.class);
       String name = context.getEnvironment().getProperty("name");
       System.out.println(name);
    }
}
输出:wt

测试成功!
此时,我们可以直接将属性文件中的数据,通过@Value注解注入到类的属性中,此时,Spring推荐使用文件解析类来处理,即PropertySourcesPlaceholderConfigurer,使用它便以为着允许Spring解析对应的文件文件,并且通过占位符来应用对应的文件
这样说可能会比较抽象,下面我们通过一个例子来解答:
首先,先配置好JAVA配置类

@ComponentScan(basePackageClasses = { Role.class, ComplexRole.class, RoleServiceImpl.class })
//扫描包的做法如下
//@ComponentScan(basePackages = {"service.Impl"})

//扫描配置文件
//@ImportResource({"classPath:SpringBean-config.xml"})

//扫描属性文件
@PropertySource(value = { "classpath:myConfig.properties" })
public class PojoConfig {
    @Bean
    public PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
        return new PropertySourcesPlaceholderConfigurer();
    }
}

上述代码定义了一个PropertySourcesPlaceholderConfigurer类的Bean,它的作用是能够让Spring来解析属性占位符
引入属性文件的配置,通过占位符${name}来加载对应的属性

@Component(value="role1")
@Primary
public class Role {
    @Value("${id}")
    private Long id;
    @Value("${name}")
    private String name;

...
    @Override
    public String toString() {
        return "Role [id=" + id + ", name=" + name + "]";
    }

}

测试用例

public class test {
    public static void main(String[] args) {
       ApplicationContext context = new AnnotationConfigApplicationContext(PojoConfig.class);
       Role role = (Role) context.getBean(Role.class);
       System.out.println(role.toString());
    }
}
输出:Role [id=1, name=wt]

测试成功!

与此同时,我们也可以通过XML 方式来加载属性文件,代码如下

<context:property-placeholder ignore-resource-not-found="true" location="classpath:myConfig.properties"/>

条件化装配Bean

Spring提供了注解@Conditional来提供条件化装配Bean的功能,需要使用的读者可自行查阅,此处便不再累赘.

Bean的作用域

在默认的情况下,Spring IoC容器只会为配置的Bean生成一个实例,而不是多个
有时候,为了满足互联网并发的要求,有时候,我们需要创建多个实例,即每当我们请求的时候,就会产生一个新的独立对象,而不是默认的一个,这样多个实例就可以在不同的的线程运行,就不会存在并发问题了

Spring 提供了4种作用域,它会根据情况来决定是否生成新的对象:

单例singleton:默认选项,在整个应用中Spring 只为配置的Bean生成一个实例
原型prototype:当每次注入,或者通过Spring IoC容器获取Bean时,Spring都会为其创建一个新的实例
会话session:在Web应用中使用,就是在会话过程中Spring只创建一个新的实例
请求request:在Web应用中使用,根据不同的请求创建不同的实例

举个栗子:

@Component("roleService")
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class RoleServiceImpl implements RoleService{

    @Autowired
    @Qualifier("role1")
    private Role role = null;
    
    
    public RoleServiceImpl(@Autowired Role role) {
        super();
        this.role = role;
    }


    public void printRoleInfo() {
        // TODO Auto-generated method stub
        System.out.println(role.toString());
    }

}

这里使用的注解@Scope,并且修改声明为原型

Spring EL

下面通过例子来直接说明,首先介绍ExpressionParser接口

public class test {
    public static void main(String[] args) {
        //表达式解析器
        ExpressionParser parser = new SpelExpressionParser();
        //设置表达式
        Expression exp = parser.parseExpression("'hello world'");
        String str = (String) exp.getValue();
        System.out.println(str);      #输出hello world
        //通过EL访问普通方法
        exp = parser.parseExpression("'hello world'.charAt(0)");
        char ch = (Character) exp.getValue();
        System.out.println(ch);  #调用charAt(0),输出h
    }
}

Spring EL 具有对表达式的解析功能,但是Spring EL最重要的功能是对Bean属性进行注入

下面,笔者将会以注解的方式来介绍它们:

Bean的属性和方法

前面我们介绍到@Value,在属性文件读取中使用的是"$",而在Spring EL中使用的是"#"
举个栗子:

public class Role {
    
    //获取mess类的属性id
    @Value("#{mess.id}")
    private Long id;
    
    //调用bean的getnote方法,获取角色名称,注意下面的方法,有一个问号?,此处判断是否返回非null,如果是null,调用toString方法
    @Value("${mess.getNote()?.toString}")
    private String name;
...
}

使用类的静态变量和方法

举几个简单的栗子:

//注入圆周率π,此处不需要使用import导入
@Value("#{T(Math).PI}")
private double Pl;

这样就可以通过调用类的静态方法加载对应的数据

Spring EL运算

举几个简单的栗子:

加1操作

@Value("#{role,id+1}")
private int id;

字符串拼接

@Value("#{role,str1 + role .str2}")
private int str;

三目运算

@Value("#{role,id>1?5:1}")
private int id;

实际上,Spring EL的功能远不止这些,需要深入了解的读者可自行查询.