Spring_day01
今日目标
- 掌握Spring相关概念
- 完成IOC/DI的入门案例编写
- 掌握IOC的相关配置与使用
- 掌握DI的相关配置与使用
1，课程介绍
1.2 学什么?
Spring框架主要的优势是在简化开发和框架整合上
(1)IOC,(2)整合Mybatis(IOC的具体应用)，(3)AOP,(4)声明式事务(AOP的具体应用)
2，Spring相关概念
2.1.1 Spring家族
Spring Framework：Spring框架，是Spring中最早最核心的技术，也是所有其他技术的基础。
SpringBoot：Spring是来简化开发，而SpringBoot是来帮助Spring在简化的基础上能更快速进行开发。
SpringCloud：分布式之微服务架构的相关开发。
2.1.2 Spring发展史
- Spring1.0是纯配置文件开发
- Spring2.0为了简化开发引入了注解开发，此时是配置文件加注解的开发方式
- Spring3.0已经可以进行纯注解开发，使开发效率大幅提升
- Spring4.0根据JDK的版本升级对个别API进行了调整
- Spring5.0已经全面支持JDK8，现在Spring最新的是5系列所以建议大家把JDK安装成1.8版
2.2 Spring系统架构
2.2.1 系统架构图
Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基。
Spring Framework的发展也经历了很多版本的变更，每个版本都有相应的调整
Spring Framework的5版本目前没有最新的架构图，最新的是4版本的架构图
(1)核心层
- Core Container:核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块
(2)AOP层
- AOP:面向切面编程，它依赖核心层容器，目的是在不改变原有代码的前提下对其进行功能增强
- Aspects:AOP是思想,Aspects是对AOP思想的具体实现
(3)数据层
- Data Access:数据访问，Spring全家桶中有对数据访问的具体实现技术
- Data Integration:数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis
- Transactions:事务，Spring中事务管理是Spring AOP的一个具体实现，也是后期学习的重点内容
(4)Web层
- 这一层的内容将在SpringMVC框架具体学习
(5)Test层
- Spring主要整合了Junit来完成单元测试和集成测试
2.3 Spring核心概念
2.3.1 IOC、IOC容器、Bean
IOC（Inversion of Control）控制反转：对象的创建权交给spring来创建，他会将创建的对象放入到Ioc容器中（核心容器）
(1)控制反转：
- 使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部
(2)Spring和IOC之间的关系：
- Spring技术对IOC思想进行了实现
- Spring提供了一个容器，称为IOC容器，用来充当IOC思想中的"外部"
(3)IOC容器的作用以及内部存放的是什么?
- IOC容器负责对象的创建、初始化等一系列工作，其中包含了数据层和业务层的类对象
- 被创建或被管理的对象在IOC容器中统称为Bean
2.3.2 DI
DI（Dependency Injection）依赖注入
(1)什么是依赖注入呢?
- 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入
核心容器中的多个对象，使用DI绑定关系后，从容器中获得的对象，他就能找到具体的那个接口的实现类了
(2)IOC容器中哪些bean之间要建立依赖关系呢?
- 这个需要程序员根据业务需求提前建立好关系，如业务层需要依赖数据层，service就要和dao建立依赖关系
Spring的IOC和DI这两个概念的最终目标就是:充分解耦，具体实现靠:
- 使用IOC容器管理bean（IOC)
- 在IOC容器内将有依赖关系的bean进行关系绑定（DI）
- 最终结果为:使用对象时不仅可以直接从IOC容器中获取，并且获取到的bean已经绑定了所有的依赖关系.
2.3.3 核心概念小结
(1)什么IOC/DI思想?
- IOC:控制反转，控制反转的是对象的创建权
- DI:依赖注入，绑定对象与对象之间的依赖关系
(2)什么是IOC容器?
Spring创建了一个容器用来存放所创建的对象，这个容器就叫IOC容器
(3)什么是Bean?
容器中所存放的一个个对象就叫Bean或Bean对象
3，入门案例
3.1.1 入门案例思路分析
(1)Spring是使用容器来管理bean对象的，那么管什么?
- 主要管理项目中所使用到的类对象，比如(Service和Dao)
(2)如何将被管理的对象告知IOC容器?
- 使用配置文件
(3)被管理的对象交给IOC容器，要想从容器中获取对象，就先得思考如何获取到IOC容器?
- Spring框架提供相应的接口
(4)IOC容器得到后，如何从容器中获取bean?
- 调用Spring框架提供对应接口中的方法
(5)使用Spring导入哪些坐标?
- 用别人的东西，就需要在pom.xml添加对应的依赖
在配置文件（applicationContext.xml）中完成bean的配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--bean标签标示配置bean
id属性标示给bean起名字
class属性表示给bean定义类型
-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl"/>
</beans>
注意事项：bean定义时id属性在同一个上下文中(配置文件)不能重复
3.2 DI入门案例
3.2.1 入门案例思路分析
(1)要想实现依赖注入，必须要基于IOC管理Bean
- DI的入门案例要依赖于前面IOC的入门案例
(2)Service中使用new形式创建的Dao对象是否保留?
- 需要删除掉，最终要使用IOC容器中的bean对象
(3)Service中需要的Dao对象如何进入到Service中?
- 在Service中提供方法，让Spring的IOC容器可以通过该方法传入bean对象
(4)Service与Dao间的关系如何描述?
- 使用配置文件
3.2.2 入门案例代码实现
在配置文件中添加依赖注入的配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--bean标签标示配置bean
id属性标示给bean起名字
class属性表示给bean定义类型
-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
<!--配置server与dao的关系-->
<!--property标签表示配置当前bean的属性
name属性表示配置哪一个具体的属性
ref属性表示参照哪一个bean
-->
<property name="bookDao" ref="bookDao"/>
</bean>
</beans>
注意:配置中的两个bookDao的含义是不一样的
- name="bookDao"中
bookDao的作用是让Spring的IOC容器在获取到名称后，将首字母大写，前面加set找对应的setBookDao()方法进行对象注入 - ref="bookDao"中
bookDao的作用是让Spring能在IOC容器中找到id为bookDao的Bean对象给bookService进行注入 - 综上所述，对应关系如下:
4，IOC相关内容
4.1 bean基础配置
4.1.2 bean的name（别名）属性
- bean依赖注入的ref属性指定bean，必须在容器中存在
- 获取bean无论是通过id还是name获取，如果无法获取到，将抛出异常NoSuchBeanDefinitionException
4.1.3 bean作用范围scope配置
4.1.3.2 配置bean为非单例
使用bean的
scope属性可以控制bean的创建是否为单例：singleton默认为单例prototype为非单例
4.1.3.3 scope使用后续思考
为什么bean默认为单例?
- bean为单例的意思是在Spring的IOC容器中只会有该类的一个对象
- bean对象只有一个就避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高
bean在容器中是单例的，会不会产生线程安全问题?
- 如果对象是有状态对象，即该对象有成员变量可以用来存储数据的，
- 因为所有请求线程共用一个bean对象，所以会存在线程安全问题。
- 如果对象是无状态对象，即该对象没有成员变量没有进行数据存储的，
- 因方法中的局部变量在方法调用完成后会被销毁，所以不会存在线程安全问题。
Spring中的Bean是否是线程安全的（面试题）
如果是单例，你把这个数据定义在成员变量位置上，此时他就是不安全的
如果是单例，你把他定义在局部变量位置上，他就是线程安全的(servlet就是这么做的)
如果是多例,就不存在安全问题
哪些bean对象适合交给容器进行管理?
- 表现层对象
- 业务层对象
- 数据层对象
- 工具对象
哪些bean对象不适合交给容器进行管理?
- 封装实例的域对象，因为会引发线程安全问题，所以不适合。
4.14 bean基础配置小结
4.2 bean实例化
4.2.2 构造方法实例化Bean对象（常用）
bean本质上就是对象，对象在new的时候会使用构造方法完成，那创建bean也是使用构造方法完成的。
Spring底层使用反射技术，使用类的无参构造方法实例化Bean对象
4.2.4 静态工厂实例化Bean对象
4.2.4.1 工厂方式创建bean
(1)准备一个OrderDao和OrderDaoImpl类
public interface OrderDao {
public void save();
}
public class OrderDaoImpl implements OrderDao {
public void save() {
System.out.println("order dao save ...");
}
}
(2)创建一个工厂类OrderDaoFactory并提供一个静态方法
//静态工厂创建对象
public class OrderDaoFactory {
public static OrderDao getOrderDao(){
return new OrderDaoImpl();
}
}
(3)编写AppForInstanceOrder运行类，在类中通过工厂获取对象
public class AppForInstanceOrder {
public static void main(String[] args) {
//通过静态工厂创建对象
OrderDao orderDao = OrderDaoFactory.getOrderDao();
orderDao.save();
}
}
注意：需要写上factory-method属性，指定使用哪一个方法创建bean对象
<!--方式二：使用静态工厂实例化bean-->
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>
class:工厂类的类全名
factory-mehod:具体工厂类中创建对象的方法名
这种方式的意义：
- 在工厂的静态方法中，我们除了new对象还可以做其他的一些业务操作，这些操作必不可少
4.2.5 实例工厂与FactoryBean
(1)准备一个UserDao和UserDaoImpl类
public interface UserDao {
public void save();
}
public class UserDaoImpl implements UserDao {
public void save() {
System.out.println("user dao save ...");
}
}
(2)创建一个工厂类OrderDaoFactory并提供一个普通方法
public class UserDaoFactory {
public UserDao getUserDao(){
return new UserDaoImpl();
}
}
(3)编写AppForInstanceUser运行类，在类中通过工厂获取对象
public class AppForInstanceUser {
public static void main(String[] args) {
//创建实例工厂对象
UserDaoFactory userDaoFactory = new UserDaoFactory();
//通过实例工厂对象创建对象
UserDao userDao = userDaoFactory.getUserDao();
userDao.save();
}
注意：factory-bean属性代表：先创建实例工厂对象 factory-method属性：代表使用哪一个方法来创建对象
<!--方式三：使用实例工厂实例化bean-->
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
<!--factory-bean属性代表：先创建实例工厂对象 factory-method属性：代表使用哪一个方法来创建对象-->
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
实例化工厂运行的顺序是:
创建实例化工厂对象,对应的是第一行配置
调用对象中的方法来创建bean，对应的是第二行配置
factory-bean:工厂的实例对象
factory-method:工厂对象中的具体创建对象的方法名
4.2.3.3 FactoryBean的使用
注意：该方式创建出的bean，默认是单例，可以通过实现第三个方法，创建出非单例的bean
(1)步骤：创建一个类实现FactoryBean接口，指定需要创建的bean的类型，实现方法，
- 第一个方法是代替原始实例工厂中创建对象
- 第二个方法是创建出来的bean的类型
//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
//代替原始实例工厂中创建对象的方法
public UserDao getObject() throws Exception {
return new UserDaoImpl();
}
//指定出来的bean的类型
public Class<?> getObjectType() {
return UserDao.class;
}
//改变创建出的bean为非单例（可选）
public boolean isSingleton() {
return true;
}
}
(2)在Spring的配置文件中进行配置
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>
这种方式在Spring去整合其他框架的时候会被用到，所以这种方式需要大家理解掌握。
查看源码会发现，FactoryBean接口其实会有三个方法，分别是:
T getObject() throws Exception;
Class<?> getObjectType();
default boolean isSingleton() {
return true;
}
方法一:getObject()，被重写后，在方法中进行对象的创建并返回
方法二:getObjectType(),被重写后，主要返回的是被创建类的Class对象
方法三:没有被重写，因为它已经给了默认值，从方法名中可以看出其作用是设置对象是否为单例，默认true，默认应该是单例
想改成非单例具体如何实现?
只需要将isSingleton()方法进行重写，修改返回为false，即可
//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
//代替原始实例工厂中创建对象的方法
public UserDao getObject() throws Exception {
return new UserDaoImpl();
}
public Class<?> getObjectType() {
return UserDao.class;
}
public boolean isSingleton() {
return false;
}
}
一般情况下我们都会采用单例，也就是采用默认即可。所以isSingleton()方法一般不需要进行重写。
4.2.6 bean实例化小结
通过这一节的学习，需要掌握:
(1)bean是如何创建：构造方法
(2)Spring的IOC实例化对象的三种方式分别是:
- 构造方法(常用)
- 静态工厂(了解)
- 实例工厂(了解)
- FactoryBean(实用)
四种实例化Bean配置文件的对比
4.3 bean的生命周期
- 什么是生命周期?
- 从创建到消亡的完整过程,例如人从出生到死亡的整个过程就是一个生命周期。
- bean生命周期是什么?
- bean对象从创建到销毁的整体过程。
- bean生命周期控制是什么?
- 在bean创建后到销毁前做一些事情。
4.3.1 环境准备
步骤1:添加初始化和销毁方法
public class BookDaoImpl implements BookDao {
public void save() {
System.out.println("book dao save ...");
}
//表示bean初始化对应的操作
public void init(){
System.out.println("init...");
}
//表示bean销毁前对应的操作
public void destory(){
System.out.println("destory...");
}
}
步骤2:配置生命周期
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>
4.3.2 close关闭容器
ApplicationContext中没有close方法
需要将ApplicationContext更换成ClassPathXmlApplicationContext
调用ctx的close()方法
运行程序，就能执行destroy方法的内容
注意：在多例情况下，容器关闭时，并不会执行destroy销毁方法
4.3.3 注册钩子关闭容器
在容器未关闭之前，提前设置好回调函数，让JVM在退出之前回调此函数来关闭容器
调用ctx的registerShutdownHook()方法
ctx.registerShutdownHook();
**注意:**registerShutdownHook在ApplicationContext中也没有
关闭容器的close和registerShutdownHook的对比：
相同点:这两种都能用来关闭容器
不同点:close()是在调用的时候关闭，registerShutdownHook()是在JVM退出前调用关闭。
使用Spring提供的接口来完成生命周期的控制
修改BookServiceImpl类，添加两个接口InitializingBean， DisposableBean并实现接口中的两个方法afterPropertiesSet和destroy
public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
private BookDao bookDao;
public void setBookDao(BookDao bookDao) {
this.bookDao = bookDao;
}
public void save() {
System.out.println("book service save ...");
bookDao.save();
}
public void destroy() throws Exception {
System.out.println("service destroy");
}
public void afterPropertiesSet() throws Exception {
System.out.println("service init");
}
}
小细节
对于InitializingBean接口中的afterPropertiesSet方法，翻译过来为
属性设置之后。对于BookServiceImpl来说，bookDao是它的一个属性
setBookDao方法是Spring的IOC容器为其注入属性的方法
思考:afterPropertiesSet和setBookDao谁先执行?
- 初始化方法会在类中属性设置之后执行。
4.3.5 bean生命周期小结
(1)关于Spring中对bean生命周期控制提供了两种方式:
- 在配置文件中的bean标签中添加
init-method和destroy-method属性 - 类实现
InitializingBean与DisposableBean接口，了解下即可。
(2)对于bean的生命周期控制在bean的整个生命周期中所处的位置如下:
- 初始化容器
- 1.创建对象(内存分配)
- 2.执行构造方法
- 3.执行属性注入(set操作)
- 4.执行bean初始化方法
- 使用bean
- 1.执行业务操作
- 关闭/销毁容器
- 1.执行bean销毁方法
(3)关闭容器的两种方式:
- ConfigurableApplicationContext是ApplicationContext的子类
- close()方法
- registerShutdownHook()方法
5，DI相关内容
Spring为我们提供了两种注入方式，分别是:
- setter注入
- 简单类型
- 引用类型
- 构造器注入
- 简单类型
- 引用类型
5.1 setter注入
- 在bean中定义引用类型属性，并提供可访问的set方法
public class BookServiceImpl implements BookService {
private BookDao bookDao;
public void setBookDao(BookDao bookDao) {
this.bookDao = bookDao;
}
}
- 配置中使用property标签ref属性注入引用类型对象
<!--setter注入-->
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"/>//注入dao引用类型
<property name="num" value="666"/>//注入成员变量简单类型
</bean>
说明:
value:后面跟的是简单数据类型，对于参数类型，Spring在注入的时候会自动转换，但是不能写成
<property name="connectionNum" value="abc"/>
这样的话，spring在将abc转换成int类型的时候就会报错
**注意:**两个property注入标签的顺序可以任意。
- 对于引用数据类型使用的是
<property name="" ref=""/> - 对于简单数据类型使用的是
<property name="" value=""/>
5.2 构造器注入
步骤1:提供构造方法
步骤2:配置文件中进行配置构造方式注入
<!--构造器注入-->
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
<constructor-arg name="bookDao" ref="bookDao"/>//注入dao引用类型
<constructor-arg name="num" value="李四"/>//注入成员变量简单类型
</bean>
说明:
标签中
- name属性对应的值为构造函数中方法形参的参数名，必须要保持一致。
- ref属性指向的是spring的IOC容器中其他bean对象。
5.2.3 构造器注入多个引用数据类型
步骤1:提供多个属性的构造函数
public class BookServiceImpl implements BookService{
private BookDao bookDao;
private UserDao userDao;
public BookServiceImpl(BookDao bookDao,UserDao userDao) {
this.bookDao = bookDao;
this.userDao = userDao;
}
public void save() {
System.out.println("book service save ...");
bookDao.save();
userDao.save();
}
}
步骤2:配置文件中配置多参数注入
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
<constructor-arg name="bookDao" ref="bookDao"/>
<constructor-arg name="userDao" ref="userDao"/>
</bean>
</beans>
5.2.4 构造器注入多个简单数据类型
步骤1:添加多个简单属性并提供构造方法
public class BookDaoImpl implements BookDao {
private String databaseName;
private int connectionNum;
public BookDaoImpl(String databaseName, int connectionNum) {
this.databaseName = databaseName;
this.connectionNum = connectionNum;
}
public void save() {
System.out.println("book dao save ..."+databaseName+","+connectionNum);
}
}
步骤2:配置完成多个属性构造器注入
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
<constructor-arg name="databaseName" value="mysql"/>
<constructor-arg name="connectionNum" value="666"/>
</bean>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
<constructor-arg name="bookDao" ref="bookDao"/>
<constructor-arg name="userDao" ref="userDao"/>
</bean>
</beans>
构造器注入方式变种写法
方式一:删除name属性，添加type属性，按照类型注入
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
<constructor-arg type="int" value="10"/>
<constructor-arg type="java.lang.String" value="mysql"/>
</bean>
- 这种方式可以解决构造函数形参名发生变化带来的耦合问题
- 但是如果构造方法参数中有类型相同的参数，这种方式就不太好实现了
方式二:删除type属性，添加index属性，按照索引下标注入，下标从0开始
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
<constructor-arg index="1" value="100"/>
<constructor-arg index="0" value="mysql"/>
</bean>
- 这种方式可以解决参数类型重复问题
- 但是如果构造方法参数顺序发生变化后，这种方式又带来了耦合问题
依赖注入方式选择
- 强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
- 强制依赖指对象在创建的过程中必须要注入指定的参数
- 可选依赖使用setter注入进行，灵活性强
- 可选依赖指对象在创建过程中注入的参数可有可无
- Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
- 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
- 实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
- 自己开发的模块推荐使用setter注入
Spring的依赖注入的实现方式:
setter注入（）
简单数据类型
<bean ...> <property name="" value=""/> </bean>
引用数据类型
<bean ...> <property name="" ref=""/> </bean>构造器注入（）
简单数据类型
<bean ...> <constructor-arg name="" index="" type="" value=""/> </bean>
引用数据类型
<bean ...> <constructor-arg name="" index="" type="" ref=""/> </bean>依赖注入的方式选择上
- 建议使用setter注入
- 第三方技术根据情况选择
5.3 自动配置
5.3.1 什么是依赖自动装配?
IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程
5.3.2 自动装配方式有哪些?
- 按类型（常用）
- 按名称
- 按构造方法
- 不启用自动装配
5.3.3 完成自动装配的配置
自动装配只需要修改applicationContext.xml配置文件即可:
(1)将<property>标签删除
(2)在<bean>标签中添加autowire属性
首先来实现按照类型注入的配置
<bean class="com.itheima.dao.impl.BookDaoImpl"/>
<!--autowire属性：开启自动装配，通常使用按类型装配-->
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
注意事项:
- 需要注入属性的类中对应属性的setter方法不能省略
- 被注入的对象必须要被Spring的IOC容器管理
- 按照类型在Spring的IOC容器中如果找到多个对象，会报
NoUniqueBeanDefinitionException
一个类型在IOC中有多个对象，还想要注入成功，这个时候就需要按照名称注入，配置方式为:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="com.itheima.dao.impl.BookDaoImpl"/>
<!--autowire属性：开启自动装配，通常使用按类型装配-->
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byName"/>
</beans>
注意事项:
按照名称注入中的名称指的是什么?
- 按照名称注入，其实是和对应的set方法有关，但是如果按照标准起名称，属性名和set对应的名是一致的
如果按照名称去找对应的bean对象，找不到则注入Null
当某一个类型在IOC容器中有多个对象，按照名称注入只找其指定名称对应的bean对象，不会报错
5.3.4 依赖注入的注意事项:
- 自动装配用于引用类型依赖注入，不能对简单类型进行操作
- 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
- 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
- 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效
5.4 集合注入
5.4.1 环境准备
(1)项目中添加添加BookDao、BookDaoImpl类
public interface BookDao {
public void save();
}
public class BookDaoImpl implements BookDao {
public class BookDaoImpl implements BookDao {
private int[] array;
private List<String> list;
private Set<String> set;
private Map<String,String> map;
private Properties properties;
public void save() {
System.out.println("book dao save ...");
System.out.println("遍历数组:" + Arrays.toString(array));
System.out.println("遍历List" + list);
System.out.println("遍历Set" + set);
System.out.println("遍历Map" + map);
System.out.println("遍历Properties" + properties);
}
//setter....方法省略，自己使用工具生成
}
(2)resources下提供spring的配置文件，applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
</beans>
(3)编写AppForDICollection运行类，加载Spring的IOC容器，并从中获取对应的bean对象
public class AppForDICollection {
public static void main( String[] args ) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
BookDao bookDao = (BookDao) ctx.getBean("bookDao");
bookDao.save();
}
}
都是在bookDao的bean标签中使用进行注入
5.4.2 注入数组类型数据
<property name="array">
<array>
<value>100</value>
<value>200</value>
<value>300</value>
</array>
</property>
5.4.3 注入List类型数据
<property name="list">
<list>
<value>itcast</value>
<value>itheima</value>
<value>boxuegu</value>
<value>chuanzhihui</value>
</list>
</property>
5.4.4 注入Set类型数据
<property name="set">
<set>
<value>itcast</value>
<value>itheima</value>
<value>boxuegu</value>
<value>boxuegu</value>
</set>
</property>
5.4.5 注入Map类型数据
<property name="map">
<map>
<entry key="country" value="china"/>
<entry key="province" value="henan"/>
<entry key="city" value="kaifeng"/>
</map>
</property>
5.4.6 注入Properties类型数据
<property name="properties">
<props>
<prop key="country">china</prop>
<prop key="province">henan</prop>
<prop key="city">kaifeng</prop>
</props>
</property>
说明：
- property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写
<array>、<list>、<set>、<map>、<props>标签 - List的底层也是通过数组实现的，所以
<list>和<array>标签是可以混用
200
300
#### 5.4.3 注入List类型数据
```xml
<property name="list">
<list>
<value>itcast</value>
<value>itheima</value>
<value>boxuegu</value>
<value>chuanzhihui</value>
</list>
</property>
5.4.4 注入Set类型数据
<property name="set">
<set>
<value>itcast</value>
<value>itheima</value>
<value>boxuegu</value>
<value>boxuegu</value>
</set>
</property>
5.4.5 注入Map类型数据
<property name="map">
<map>
<entry key="country" value="china"/>
<entry key="province" value="henan"/>
<entry key="city" value="kaifeng"/>
</map>
</property>
5.4.6 注入Properties类型数据
<property name="properties">
<props>
<prop key="country">china</prop>
<prop key="province">henan</prop>
<prop key="city">kaifeng</prop>
</props>
</property>
说明：
- property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写
<array>、<list>、<set>、<map>、<props>标签 - List的底层也是通过数组实现的，所以
<list>和<array>标签是可以混用 - 集合中要添加引用类型，只需要把
<value>标签改成<ref>标签，这种方式用的比较少