(一) 配置形式
1.基于XML文件的方式
2.基于注解的方式
组件扫描(component scanning): Spring 能够从 classpath 下自动扫描, 侦测和实例化具有特定注解的组件.
特定组件包括:
@Component: 基本注解, 标识了一个受 Spring 管理的组件
@Respository: 标识持久层组件
@Service: 标识服务层(业务层)组件
@Controller: 标识表现层组件
对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称
当在组件类上使用了特定的注解之后, 还需要在 Spring 的配置文件中声明 context:component-scan :
base-package 属性指定一个需要扫描的基类包,Spring 容器将会扫描这个基类包里及其子包中的所有类.
当需要扫描多个包时, 可以使用逗号分隔.
如果仅希望扫描特定的类而非基包下的所有类,可使用 resource-pattern 属性过滤特定的类,示例:
context:include-filter 子节点表示要包含的目标类
<!-- context:include-filter子节点指定包含哪些表达式的组件,该子节点需要 use-default-filters配合使用-->
<context:component-scan
base-package="com.atguigu.spring.beans.annotation"
use-default-filters="false">
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
context:exclude-filter 子节点表示要排除在外的目标类
context:component-scan 下可以拥有若干个 context:include-filter 和 context:exclude-filter 子节点
context:include-filter 和 context:exclude-filter 子节点支持多种类型的过滤表达式:
组件装配:
context:component-scan 元素还会自动注册 AutowiredAnnotationBeanPostProcessor 实例, 该实例可以自动装配具有 @Autowired 和 @Resource 、@Inject注解的属性.
使用@Autowired自动装配Bean:
@Autowired 注解自动装配具有兼容类型的单个 Bean属性
构造器, 普通字段(即使是非 public), 一切具有参数的方法都可以应用
@Service("userService")
public class UserService {
@Autowired
private UserRepository userRepository;
public void add() {
System.out.println("UserService");
userRepository.save();
}
}
@Authwired 注解
默认情况下, 所有使用 @Authwired 注解的属性都需要被设置. 当 Spring 找不到匹配的 Bean 装配属性时, 会抛出异常, 若某一属性允许不被设置, 可以设置 @Authwired 注解的 required 属性为 false
@Repository("userRepository")
public class UserRepositoryImpl implements UserRepository {
@Override
public void save() {
System.out.println("UserRepository Save...");
}
}
默认情况下, 当 IOC 容器里存在多个类型兼容的 Bean 时, 通过类型的自动装配将无法工作. 此时可以在 @Qualifier 注解里提供 Bean 的名称. Spring 允许对方法的入参标注 @Qualifiter 已指定注入 Bean 的名称
@Qualifier("UserRepositoryImpl")
private UserRepository userRepository;
@Authwired 注解也可以应用在数组类型的属性上, 此时 Spring 将会把所有匹配的 Bean 进行自动装配.
@Authwired 注解也可以应用在集合属性上, 此时 Spring 读取该集合的类型信息, 然后自动装配所有与之兼容的 Bean.
@Authwired 注解用在 java.util.Map 上时, 若该 Map 的键值为 String, 那么 Spring 将自动装配与之 Map 值类型兼容的 Bean, 此时 Bean 的名称作为键值
使用@Resource 或@Inject自动装配Bean:
Spring 还支持 @Resource 和 @Inject 注解,这两个注解和 @Autowired 注解的功用类似
@Resource 注解要求提供一个 Bean 名称的属性,若该属性为空,则自动采用标注处的变量或方法名作为 Bean 的名称
@Inject 和 @Autowired 注解一样也是按类型匹配注入的 Bean, 但没有 reqired 属性
建议使用 @Autowired 注解
(二)Bean的配置方式
1.通过全类名(反射)
<!--
配置bean
class: bean 的全类名,通过反射在IOC容器中创建Bean,所以要求Bean中必须有无参数的构造器
id:标识,唯一
-->
<bean id="c" class="com.how2java.pojo.Category">
<property name="name" value="category 1" />
</bean>
如果没有无参构造函数会怎样呢
public HelloWorld(String str) {
}
异常:No default constructor found;
为什么反射需要无参构造器呢?
Class class = Class.forName(className);
Object object = class.newInstance(); // 只能调用无参构造函数
2.通过工厂方法(静态工厂方法 & 实例工厂方法)
调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节.
要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称. 最后, 使用 元素为该方法传递方法参数.
<!-- 通过静态配置方法来配置bean,注意不是配置静态工厂方法实例,而是配置bean实例 -->
<!--
class:指向静态工厂的全类名
factory-method:指向静态工厂方法的名字
constructor-arg:如果工厂方法需要传入参数,则使用constructor-arg来配置参数
-->
<bean id="car1"
class="com.atguigu.spring.beans.factory.staticCarFactory"
factory-method="getCar">
<constructor-arg value="da"></constructor-arg>
</bean>
实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节.
要声明通过实例工厂方法创建的 Bean
在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean
在 factory-method 属性里指定该工厂方法的名称
使用 construtor-arg 元素为工厂方法传递方法参数
<!-- 配置工厂的实例 -->
<bean id="carFactory" class="com.atguigu.spring.beans.factory.InstanceCarFactory"></bean>
<!-- 通过实例工厂方法来配置bean -->
<bean id="car2"
factory-bean="carFactory" factory-method="getCar">
<constructor-arg value="da"></constructor-arg>
</bean>
3.FactoryBean
Spring 中有两种类型的 Bean, 一种是普通Bean, 另一种是工厂Bean, 即FactoryBean.
工厂 Bean 跟普通Bean不同, 其返回的对象不是指定类的一个实例, 其返回的是该工厂 Bean 的 getObject 方法所返回的对象
<!--
通过FactoryBean来配置Bean的实例
class:指向FactoryBean的全类名
property:配置FactoryBean的属性
但实际返回的实例确是FactoryBean的getObject()方法的实例!
-->
<bean id="car" class="com.atguigu.spring.beans.factorybean.CarFactoryBean">
<property name="brand" value="BMW"></property>
</bean>
(三)IOC容器
1.BeanFactory
BeanFactory是Application的父接口,有如下方法
getBean(String):Object
getBean(Class):T (类型获取方法)
<bean id="helloWorld" class="com.atguigu.spring.beans.HelloWorld">
<property name="name" value="Spring" />
</bean>
//利用类型返回IOC容器中的Bean,但要求IOC容器中必须只能有一个该类型的Bean
HelloWorld helloWord = ctx.getBean(HelloWorld.class);
2.ApplicationContext
ApplicationContext 面向使用 Spring 框架的开发者,几乎所有的应用场合都直接使用 ApplicationContext 而非底层的 BeanFactory
提供了更多的高级特性. 是 BeanFactory 的子接口.
ApplicationContext 在初始化上下文时就实例化所有单例的 Bean。
ApplicationContext 的主要实现类:
ClassPathXmlApplicationContext:从 类路径下加载配置文件
ApplicationContext context = new ClassPathXmlApplicationContext(new String[] { "applicationContext.xml" });
FileSystemXmlApplicationContext: 从文件系统中加载配置文件
ConfigurableApplicationContext 扩展于 ApplicationContext,新增加两个主要方法:refresh() 和 close(), 让 ApplicationContext 具有启动、刷新和关闭上下文的能力
WebApplicationContext 是专门为 WEB 应用而准备的,它允许从相对于 WEB 根目录的路径中完成初始化工作
(四)依赖注入的方式
1.属性注入
属性注入即通过 setter 方法注入Bean 的属性值或依赖的对象
属性注入使用 元素, 使用 name 属性指定 Bean 的属性名称,value 属性或 子节点指定属性值
<bean id="c" class="com.how2java.pojo.Category">
<property name="name" value="category 1" />
</bean>
属性注入是实际应用中最常用的注入方式
2.构造器注入
通过构造方法注入Bean 的属性值或依赖的对象,它保证了 Bean 实例在实例化后就可以使用。
为什么要指定顺序或类型?
有参数的构造,没有指定顺序,那么spring会按照属性依次注入属性值
如果指定index,那么就会按照index指定的值顺序对属性值进行注入。
如果提供两个或者多个形同参数不同属性的构造方法,那么就需要指定每个属性的类型,不然spring无法判别到底使用哪个构造方法进行注入
<!-- 通过构造方法来配置bean的属性 -->
<bean id="car" class="com.atguigu.spring.beans.Car">
<constructor-arg value="Audi" index="0"></constructor-arg>
<constructor-arg value="shangHai" index="1"></constructor-arg>
<constructor-arg value="300000" type="double"></constructor-arg>
</bean>
<bean id="car2" class="com.atguigu.spring.beans.Car">
<constructor-arg value="Baoma" type="java.lang.String"></constructor-arg>
<constructor-arg value="shangHai" type="java.lang.String"></constructor-arg>
<constructor-arg value="240" type="int"></constructor-arg>
</bean>
3.工厂方法注入(不推荐使用)
(五)注入属性值细节
1.字面值
字面值:可用字符串表示的值,可以通过 元素标签或 value 属性进行注入。
基本数据类型及其封装类、String 等类型都可以采取字面值注入的方式
若字面值中包含特殊字符,可以使用 <![CDATA[]]> 把字面值包裹起来。
<bean id="car2" class="com.atguigu.spring.beans.Car">
<constructor-arg value="Baoma" type="java.lang.String"></constructor-arg>
<constructor-arg type="java.lang.String">
<value><![CDATA[<ShangHai>]]></value>
</constructor-arg>
<constructor-arg type="int">
<value>240</value>
</constructor-arg>
</bean>
2.引用其他的Bean
组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能. 要使 Bean 能够相互访问, 就必须在 Bean 配置文件中指定对 Bean 的引用
在 Bean 的配置文件中, 可以通过 元素
<property name="car">
<ref bean="car2"/>
</property>
或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用.
<property name="car" ref="car2"></property>
<constructor-arg ref="car"></constructor-arg>
也可以在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean
当 Bean 实例仅仅给一个特定的属性使用时, 可以将其声明为内部 Bean. 内部 Bean 声明直接包含在 或 元素里, 不需要设置任何 id 或 name 属性
内部 Bean 不能使用在任何其他地方
<!-- 内部bean -->
<property name="car">
<bean class="com.atguigu.spring.beans.Car">
<constructor-arg value="Audi" index="0"></constructor-arg>
<constructor-arg value="shangHai" index="1"></constructor-arg>
<constructor-arg value="300000" type="double"></constructor-arg>
</bean>
</property>
可以使用专用的 元素标签为 Bean 的字符串或其它对象类型的属性注入 null 值
<!-- 测试赋值null -->
<constructor-arg><null/></constructor-arg>
和 Struts、Hiberante 等框架一样,Spring 支持级联属性的配置
级联:所谓级联就是下级调用 这样吧给你举个例子 有这样两个类 一个省份 一个是市你想通过市得到省或者省得到市
就可以通过级联不需要第二次编码
<!-- 为级联属性赋值,注意:属性(car)需要先初始化才可以为级联属性赋值,否则会有异常 -->
<property name="car.maxSpeed" value="200"></property>
配置 java.util.List 类型的属性, 需要指定 标签, 在标签里包含一些元素. 这些标签可以通过 指定简单的常量值, 通过 指定对其他 Bean 的引用. 通过 指定内置 Bean 定义. 通过 指定空元素. 甚至可以内嵌其他集合.
public class Person {
private String name;
private int age;
private List<Car> cars;
}
<property name="cars">
<list>
<ref bean="car"/>
<ref bean="car2"/>
</list>
</property>
Java.util.Map 通过
public class NewPerson {
private String name;
private int age;
private Map<String,Car> cars;
}
<property name="cars">
<map>
<entry key="AA" value-ref="car"></entry>
<entry key="BB" value-ref="car2"></entry>
</map>
</property>
使用 定义 java.util.Properties, 该标签使用多个 作为子标签. 每个 标签必须定义 key 属性
<!-- 使用props和prop来配置Properties属性赋值 -->
<props>
<prop key="user">root</prop>
<prop key="password">1234</prop>
<prop key="jdbcUrl">jdbc:mysql:///test</prop>
<prop key="driverClass">com.mysql.jdbc.Driver</prop>
</props>
使用基本的集合标签定义集合时, 不能将集合作为独立的 Bean 定义, 导致其他 Bean 无法引用该集合, 所以无法在不同 Bean 之间共享集合.
可以使用 util schema 里的集合标签定义独立的集合 Bean. 需要注意的是, 必须在 根元素里添加 util schema 定义
<!-- 配置单例的集合bean,以供多个bean进行引用,需要导入util命名空间 -->
<util:list id="cars">
<ref bean="car"/>
<ref bean="car2"/>
</util:list>
<bean id="person4" class="com.atguigu.spring.beans.collection.Person">
<property name="name" value="Jack"></property>
<property name="age" value="26"></property>
<property name="cars" ref="cars"></property>
</bean>
为了简化 XML 文件的配置,越来越多的 XML 文件采用属性而非子元素配置信息。
Spring 从 2.5 版本开始引入了一个新的 p 命名空间,可以通过 元素属性的方式配置 Bean 的属性。
使用 p 命名空间后,基于 XML 的配置方式将进一步简化
<!-- 通过P命名空间为bean的属性赋值,需要先导入p命名空间 -->
<bean id="person5" class="com.atguigu.spring.beans.collection.Person" p:age="30"
p:name="Queen" p:cars-ref="cars"></bean>
(六)自动装配
Spring IOC 容器可以自动装配 Bean. 需要做的仅仅是在 的 autowire 属性里指定自动装配的模式
byType(根据类型自动装配): 若 IOC 容器中有多个与目标 Bean 类型一致的 Bean. 在这种情况下, Spring 将无法判定哪个 Bean 最合适该属性, 所以不能执行自动装配.
byName(根据名称自动装配): 必须将目标 Bean 的名称和属性名设置的完全相同.
<bean id="address" class="com.atguigu.spring.beans.autowire.Address"
p:city="BeiJing" p:street="HuiLongGuan"></bean>
<bean id="car" class="com.atguigu.spring.beans.autowire.Car"
p:brand="Audi" p:price="300000"></bean>
<!-- 自动装配: 只声明 bean, 而把 bean 之间的关系交给 IOC 容器来完成 -->
<!--
byType: 根据类型进行自动装配. 但要求 IOC 容器中只有一个类型对应的 bean, 若有多个则无法完成自动装配.
byName: 若属性名和某一个 bean 的 id 名一致, 即可完成自动装配. 若没有 id 一致的, 则无法完成自动装配
-->
<!-- 在使用 XML 配置时, 自动转配用的不多. 但在基于 注解 的配置时, 自动装配使用的较多. -->
<bean id="person" class="com.atguigu.spring.beans.autowire.Person"
p:name="Tom" autowire="byName"></bean>
constructor(通过构造器自动装配): 当 Bean 中存在多个构造器时, 此种自动装配方式将会很复杂. 不推荐使用
在 Bean 配置文件里设置 autowire 属性进行自动装配将会装配 Bean 的所有属性. 然而, 若只希望装配个别属性时, autowire 属性就不够灵活了.
autowire 属性要么根据类型自动装配, 要么根据名称自动装配, 不能两者兼而有之.
一般情况下,在实际的项目中很少使用自动装配功能,因为和自动装配功能所带来的好处比起来,明确清晰的配置文档更有说服力一些
(七)bean之间的关系:继承、依赖
Spring 允许继承 bean 的配置, 被继承的 bean 称为父 bean. 继承这个父 Bean 的 Bean 称为子 Bean
子 Bean 从父 Bean 中继承配置, 包括 Bean 的属性配置
子 Bean 也可以覆盖从父 Bean 继承过来的配置
<bean id="address" class="com.atguigu.spring.beans.autowire.Address"
p:city="BeiJing" p:street="WuDaoKou"></bean>
<!-- bean配置的继承:使用bean的parent -->
<bean id="address2" p:street="DaZhongSi" parent="address"></bean>
父 Bean 可以作为配置模板, 也可以作为 Bean 实例. 若只想把父 Bean 作为模板, 可以设置 的abstract 属性为 true, 这样 Spring 将不会实例化这个 Bean
<!-- 抽象bean:bean的abstract属性为true的bean,这样的bean不能被IOC容器实例化,只能被继承 -->
<bean id="address" class="com.atguigu.spring.beans.autowire.Address"
p:city="BeiJing" p:street="WuDaoKou" abstract="true"></bean>
并不是 元素里的所有属性都会被继承. 比如: autowire, abstract 等.
也可以忽略父 Bean 的 class 属性, 让子 Bean 指定自己的类, 而共享相同的属性配置. 但此时 abstract 必须设为 true
<!-- 若某一个bean的class属性没有指定,则该bean必须是一个抽象bean -->
<bean id="address"
p:city="BeiJing" p:street="WuDaoKou" abstract="true"></bean>
Spring 允许用户通过 depends-on 属性设定 Bean 前置依赖的Bean,前置依赖的 Bean 会在本 Bean 实例化之前创建好
<!-- 要求配置Person时,必须有一个关联的car!换句话说person这个bean依赖于Car这个bean -->
<bean id="Person" class="com.atguigu.spring.beans.autowire.Person"
p:name="Tom" p:address-ref="address2" depends-on="car"></bean>
如果前置依赖于多个 Bean,则可以通过逗号,空格或的方式配置 Bean 的名称
(八)bean 的作用域
在 Spring 中, 可以在 元素的 scope 属性里设置 Bean 的作用域.
默认情况下, Spring 只为每个在 IOC 容器里声明的 Bean 创建唯一一个实例, 整个 IOC 容器范围内都能共享该实例:所有后续的 getBean() 调用和 Bean 引用都将返回这个唯一的 Bean 实例.该作用域被称为 singleton, 它是所有 Bean 的默认作用域.
这里以singleton为例:
public Car() {
System.out.println("Car's Constructor...");
}
<!-- singleton:默认值,容器初始时创建bean实例,在整个容器的生命周期内只创建这一个bean,单例的 -->
<bean id="car" class="com.atguigu.spring.beans.autowire.Car"
p:brand="Audi" p:price="300000" scope="singleton"></bean>
Car car1 = (Car) ctx.getBean("car");
Car car2 = (Car) ctx.getBean("car");
System.out.println(car1 == car2);
Car's Constructor...
true
prototype:
容器初始时不创建bean实例,在每次请求时都创建一个bean实例,并返回
(九)使用外部属性文件
在配置文件里配置 Bean 时, 有时需要在 Bean 的配置里混入系统部署的细节信息(例如: 文件路径, 数据源配置信息等). 而这些部署细节实际上需要和 Bean 配置相分离
Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器, 这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中. 可以在 Bean 配置文件里使用形式为 ${var} 的变量, PropertyPlaceholderConfigurer 从属性文件里加载属性, 并使用这些属性来替换变量.
Spring 还允许在属性文件中使用 ${propName},以实现属性之间的相互引用。
jdbc.user=root
jdbc.password=admin
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///test
<!-- 导入属性文件 -->
<context:property-placeholder location="classpath:db.properties"/>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- 使用外部属性文件的属性 -->
<property name="user" value="${jdbc.user}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="driverClass" value="${jdbc.driverClass}"></property>
<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
</bean>
(十)SpEL
Spring 表达式语言(简称SpEL):是一个支持运行时查询和操作对象图的强大的表达式语言。
语法类似于 EL:SpEL 使用 #{…} 作为定界符,所有在大框号中的字符都将被认为是 SpEL
SpEL 为 bean 的属性进行动态赋值提供了便利
通过 SpEL 可以实现:
通过 bean 的 id 对 bean 进行引用
调用方法以及引用对象中的属性
计算表达式的值
<!-- 使用SpEL来引用其他的Bean -->
<property name="car" value="#{car}"></property>
<!-- 来引用其他的Bean的属性 -->
<property name="city" value="#{address.city}"></property>
<!-- 在SpEL中使用运算符 -->
<property name="info" value="#{car.price > 300000 ? '金领':'白领'}"></property>
正则表达式的匹配
字面量的表示:
整数:<property name="count" value="#{5}"/>
小数:<property name="frequency" value="#{89.7}"/>
科学计数法:<property name="capacity" value="#{1e4}"/>
String可以使用单引号或者双引号作为字符串的定界符号:
<property name=“name” value="#{'Chuck'}"/>
或 <property name='name' value='#{"Chuck"}'/>
Boolean:<property name="enabled" value="#{false}"/>
(十一)IOC容器中Bean的生命周期
1.Spring IOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务.
Spring IOC 容器对 Bean 的生命周期进行管理的过程:
通过构造器或工厂方法创建 Bean 实例
为 Bean 的属性设置值和对其他 Bean 的引用
调用 Bean 的初始化方法
Bean 可以使用了
当容器关闭时, 调用 Bean 的销毁方法
在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法.
<bean id="car" class="com.atguigu.spring.beans.cycle.Car"
init-method="init" destroy-method="destroy">
<property name="brand" value="audo"></property>
</bean>
Spring IOC 容器对 Bean 的生命周期进行管理的过程:
通过构造器或工厂方法创建 Bean 实例
为 Bean 的属性设置值和对其他 Bean 的引用
将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法
调用 Bean 的初始化方法
将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization方法
Bean 可以使用了
当容器关闭时, 调用 Bean 的销毁方法
<!-- 实现BeanPostProcessor接口,并具体提供
Object postProcessAfterInitialization(Object bean, String beanName):init-method 之前被调用
Object postProcessBeforeInitialization(Object bean, String beanName):init-method 之后被调用的实现
bean:bean 实例本身
beanName:IOC容器配置的bean的名字
返回值:是实际上赶回给用户的那个Bean,注意:可以在以上两个方法中返回修改后的bean,甚至返回一个新的bean
-->
<!-- 配置bean的后置处理器:不需要配置id,IOC容器自动识别是一个BeanPostProcessor -->
<bean class="com.atguigu.spring.beans.cycle.MyBeanPostProcessor"></bean>
(十二)Spring 4.x 新特性:泛型依赖注入
Spring 4.x 中可以为子类注入子类对应的泛型类型的成员变量的引用
public class BaseRepository<T>{}
public class BaseService<T> {
@Autowired
protected BaseRepository<T> repository;
public void add() {
System.out.println("add...");
System.out.println(repository);
}
}
public class User {}
@Repository
public class UserRepository extends BaseRepository<User>{}
@Service
public class UserService extends BaseService<User>{}
public class Main {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-generic.xml");
UserService userService = (UserService) ctx.getBean("userService");
userService.add();
}
}
整合多个配置文件:
Spring 允许通过 将多个配置文件引入到一个文件中,进行配置文件的集成。这样在启动 Spring 容器时,仅需要指定这个合并好的配置文件就可以。
import 元素的 resource 属性支持 Spring 的标准的路径资源