本章介绍的内容可查阅如下思维导图:
依赖注入
在实际环境中实现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的功能远不止这些,需要深入了解的读者可自行查询.