要想解答这个问题，就需要先分析下目前咱们代码在编写过程中遇到的问题:

(1)业务层需要调用数据层的方法，就需要在业务层new数据层的对象

(2)如果数据层的实现类发生变化，那么业务层的代码也需要跟着改变，发生变更后，都需要进行编译打包和重部署

(3)所以，现在代码在编写的过程中存在的问题是：耦合度偏高

针对这个问题，该如何解决呢?

我们就想，如果能把框中的内容给去掉，不就可以降低依赖了么，但是又会引入新的问题，去掉以后程序能运行么?

答案肯定是不行，因为bookDao没有赋值为Null，强行运行就会出空指针异常。

所以现在的问题就是，业务层不想new对象，运行的时候又需要这个对象，该咋办呢?

针对这个问题，Spring就提出了一个解决方案:

• 使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象

这种实现思就是Spring的一个核心概念

• Ico：控制反转

• DI：依赖注入

• Bean：对象

• 在Spring框架里为了实现充分解耦，它使用IoC容器来创建了大量Bean对象，当你需要的时候从IcO容器里边取对象而不用你去手动创建，因为手动创建对象和实现接口会造成耦合，那么当项目代码发生变化就需要重新编译。这种有IcO容器管理对象，从你手中夺取了对象控制权的方式就称为控制反转

• 可是一个项目里边的接口、对象等往往存在各种依赖关系，单纯的获取一个对象是不行的，所以IcO容器除了创建管理对象外它还会将所有存在依赖关系的对象进行绑定形成一个新的对象，到时我们只需要导入这个对象即可。这种管理方式就是DI：依赖注入

• Bean就是对象但又和以前的对象有些区别，因为DI依赖注入，它是多个依赖关系对象的集合对象

那怎样才能实现避免耦合，那就是交由IcO管理对象，那对象和Service之间的映射关系又是怎么知道的呢？就是通过设置和加载配置文件，因为配置文件里边的内容不需要进行编译。好了接下来就是给调用对象添加一个set方法从加载的配置文件数据里获取到具体调用的对象了

对应的代码实现就是三步走

1. Bean怎么定义配置

2. DI怎么制作配置

3. IcO容器怎么获取配置

当然了使用Spring之前得先通过pom.xml配置文件添加Spring相应的依赖，有了框架后才能在resources目录下右键生成配置文件Application.xml

1. 注入引用类型

   

2. 注入简单类型

   

说白了其实和setter注入没啥不同只是，由setter方法改成了构造器来实现注入，配置文件中constructor-arg属性替代了setter注入方法的property属性。但是构造器注入存在不少问题，如果按正常写法是会导致耦合度极大提高，所以Spring又兼容给出了两种方案：

• type：解决形参名称的问题，与形参名不耦合

• index：解决参数类型重复问题，使用位置解决参数匹配

BookServiceImpl.java

package com.itheima.service.impl;

import com.itheima.dao.BookDao;
import com.itheima.dao.UserDao;
import com.itheima.service.BookService;

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();
    }
}
复制

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">
        根据构造方法参数名称注入
        <constructor-arg name="connectionNum" value="10"/>
        <constructor-arg name="databaseName" value="mysql"/>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="userDao" ref="userDao"/>
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>
-->
<!--
    解决形参名称的问题，与形参名不耦合
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        根据构造方法参数类型注入
        <constructor-arg type="int" value="10"/>
        <constructor-arg type="java.lang.String" value="mysql"/>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="userDao" ref="userDao"/>
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>-->

    <!--解决参数类型重复问题，使用位置解决参数匹配-->
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <!--根据构造方法参数位置注入-->
        <constructor-arg index="0" value="mysql"/>
        <constructor-arg index="1" value="100"/>
    </bean>
    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="userDao" ref="userDao"/>
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>
</beans>
复制

首先构造器注入，有构造器就必须实现不然报错，所以更为严谨

1. 强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
2. 可选依赖使用setter注入进行，灵活性强
3. Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
4. 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
5. 实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
6. 自己开发的模块推荐使用setter注入

概念：Ioc容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配

自动装配方式：

• 按类型（常用)
• 按名称
• 按构造方法
• 不启用自动装配、

注意事项

• 自动装配用于引用类型依赖注入，不能对简单类型进行操作

• 使用按类型装配时( byType )必须保障容器中相同类型的bean唯一，推荐使用

• 使用按名称装配时( byName )必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用

• 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

事实上Spring又怎么会让我们自己做这些事呢，只需要通过autowire属性指定自动装配的方式即可自动完成依赖的注入配置。当然了别忘了这只是配置文件的自动配置，根据具体的配置方式，我们仍旧需要在相应类中书写setter方法或者构造器方法

<?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 class="com.itheima.dao.impl.BookDaoImpl"/>
    <!--autowire属性：开启自动装配，通常使用按类型装配-->
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>

</beans>
复制

前面的依赖注入都是单一一个数据或对象的注入，那怎样去注入集合呢？

首先呢，肯定是要在com.itheima.dao.impl.BookDaoImpl这个实现类上添加属性和setter方法才行，下面是配置文件的注入方式

<?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">
        <!--数组注入-->
        <property name="array">
            <array>
                <value>100</value>
                <value>200</value>
                <value>300</value>
            </array>
        </property>
        <!--list集合注入-->
        <property name="list">
            <list>
                <value>itcast</value>
                <value>itheima</value>
                <value>boxuegu</value>
                <value>chuanzhihui</value>
            </list>
        </property>
        <!--set集合注入-->
        <property name="set">
            <set>
                <value>itcast</value>
                <value>itheima</value>
                <value>boxuegu</value>
                <value>boxuegu</value>
            </set>
        </property>
        <!--map集合注入-->
        <property name="map">
            <map>
                <entry key="country" value="china"/>
                <entry key="province" value="henan"/>
                <entry key="city" value="kaifeng"/>
            </map>
        </property>
        <!--Properties注入-->
        <property name="properties">
            <props>
                <prop key="country">china</prop>
                <prop key="province">henan</prop>
                <prop key="city">kaifeng</prop>
            </props>
        </property>
    </bean>
</beans>
复制

事实上如果集合里边的值还有引用类型，那就用ref代替value，和之前是同理的。但是其实集合注入很少用到，一般是框架需要用到用来初始化数据的，只需了解一下其格式

案例：数据源依赖管理

前面学习所管理的对象都是管理自己创建的Bean，但其实我们更多的是用来管理第三方资源

下面以啊里巴巴的Druid数据库连接池技术为例：

1. 首先肯定要先通过Maven引入依赖jar包这不用说

2. 然后就是配置bean（配置方式要根据第三方类提供的是setter还是构造器适合）

   • 先找到Druid的class全路径，然后自定义Bean的id

   • 接下来就是通过property标签定义属性配置

     • name：对应待配置属性的名字
     • value：对应待配置属性的值

以数据库连接技术Druid来说，最基本要配置的就是：

• 数据库连接驱动
• 数据库访问地址
• 数据库用户名
• 数据库用户密码
• ......

参考如下：对于不熟悉的第三方资源可以自行百度，也可以进入class里面再按Ctrl+F12查看所有方法，根据其给出的方法来判断是使用setter注入还是构造器注入

• setter注入的注意事项：
  • 在bean中定义引用类型属性并提供可访问的set方法
• 构造器注入的注意事项：
  • 在类中中定义构造方法
  • 必须完成构造方法中的所有实现【严谨】
• Spring提供了自动装配的机制（但只能用于引用类型依赖注入）
• 其它通用事项：
  • 引用类型用ref引入其它的bean
  • 基本数据类型注入直接value赋值
  • 集合注入简单了解
  • 事实上后面用到注解的方式会更加简单

事实上像上面案例的数据库连接池技术的配置信息不应该直接写死在Spring配置文件中，而应该是写在properties文件里边。那么Spring框架又是如何加载properties文件的呢？

案例中创建ApplicationContext的方式为:

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
复制

这种方式翻译为:类路径下的XML配置文件

除了上面这种方式，Spring还提供了另外一种创建方式为:

ApplicationContext ctx = new FileSystemXmlApplicationContext("applicationContext.xml");
复制

这种方式翻译为:文件系统下的XML配置文件

这种方式虽能实现，但是当项目的位置发生变化后,代码也需要跟着改,耦合度较高,不推荐使用。

方式一，就是目前案例中获取的方式:

BookDao bookDao = (BookDao) ctx.getBean("bookDao");
复制

这种方式存在的问题是每次获取的时候都需要进行类型转换，有没有更简单的方式呢?

方式二：

BookDao bookDao = ctx.getBean("bookDao"，BookDao.class);
复制

这种方式可以解决类型强转问题，但是参数又多加了一个，相对来说没有简化多少。

方式三:

BookDao bookDao = ctx.getBean(BookDao.class);
复制

这种方式就类似我们之前所学习依赖注入中的按类型注入。必须要确保IOC容器中该类型对应的bean对象只能有一个。

(1)在IDEA中双击shift,输入BeanFactory

(2)点击进入BeanFactory类，ctrl+h,就能查看到如下结构的层次关系

从图中可以看出，容器类也是从无到有根据需要一层层叠加上来的，大家重点理解下这种设计思想。

使用BeanFactory来创建IOC容器的具体实现方式为:

public class AppForBeanFactory {
    public static void main(String[] args) {
        Resource resources = new ClassPathResource("applicationContext.xml");
        BeanFactory bf = new XmlBeanFactory(resources);
        BookDao bookDao = bf.getBean(BookDao.class);
        bookDao.save();
    }
}
复制

为了更好的看出BeanFactory和ApplicationContext之间的区别，在BookDaoImpl添加如下构造函数:

public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("constructor");
    }
    public void save() {
        System.out.println("book dao save ..." );
    }
}
复制

如果不去获取bean对象，打印会发现：

• BeanFactory是延迟加载，只有在获取bean对象的时候才会去创建

• ApplicationContext是立即加载，容器加载的时候就会创建bean对象

• ApplicationContext要想成为延迟加载，只需要按照如下方式进行配置

  <?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"  lazy-init="true"/>
  </beans>
  复制

小结

这一节中所讲的知识点包括:

• 容器创建的两种方式

  • ClassPathXmlApplicationContext[掌握]
  • FileSystemXmlApplicationContext[知道即可]
• 获取Bean的三种方式

  • getBean("名称"):需要类型转换
  • getBean("名称",类型.class):多了一个参数
  • getBean(类型.class):容器中不能有多个该类的bean对象

  上述三种方式，各有各的优缺点，用哪个都可以。

• 容器类层次结构

  • 只需要知晓容器的最上级的父接口为 BeanFactory即可
• BeanFactory

  • 使用BeanFactory创建的容器是延迟加载
  • 使用ApplicationContext创建的容器是立即加载
  • 具体BeanFactory如何创建只需要了解即可。

在上述环境的基础上，我们来学一学Spring是如何通过注解实现bean的定义开发?

上面已经可以使用注解来配置bean,但是依然有用到配置文件，在配置文件中对包进行了扫描，Spring在3.0版已经支持纯注解开发

• Spring3.0开启了纯注解开发模式，使用Java类替代配置文件，开启了Spring快速开发赛道

具体如何实现?

相关注解

• @Scope：作用范围（默认单例）

• @PostConstruct：构造方法后执行

• @PreDestroy：销毁前执行

图示：

注意:@PostConstruct和@PreDestroy注解如果找不到，需要导入下面的jar包

<dependency>
  <groupId>javax.annotation</groupId>
  <artifactId>javax.annotation-api</artifactId>
  <version>1.3.2</version>
</dependency>
复制

找不到的原因是，从JDK9以后jdk中的javax.annotation包被移除了，这两个注解刚好就在这个包中。

Spring为了使用注解简化开发，并没有提供构造函数注入、setter注入对应的注解，只提供了自动装配的注解实现。

相关注解

• @Autowired：自动装配写在属性上，按类型分配，并且不需要setter方法，也就是说不需要构造器注入和setter注入了
  • 自动装配基于反射设计创建对象并通过暴力反射为私有属性进行设值
  • 普通反射只能获取public修饰的内容
  • 暴力反射除了获取public修饰的内容还可以获取private修改的内容
  • 所以此处无需提供setter方法

• @Qualifier：按名称注入，来指定注入哪个名称的bean对象。
  • 因为@Autowired是按类型注入的，如果有多个实现类就会不知道注入哪个实现类，这是就需要加上@Qualifier指定注入实现类
  • 注意:@Qualifier不能独立使用，必须和@Autowired一起使用

• @Value：简单类型注入，将值写入注解的参数中就行了
  • 注意数据格式要匹配，如将"abc"注入给int值，这样程序就会报错。
  • 注解存在的意义是直接读取配置文件的内容，而不是简单赋值。@Value一般会被用在从properties配置文件中读取内容进行使用
• @PropertySource：在配置类上添加@PropertySource注解，加载properties配置文件

例子：注解读取properties配置文件

步骤1：resource下准备properties文件jdbc.properties

name=itheima888
复制

步骤2: 使用注解加载properties配置文件，在配置类上添加@PropertySource注解

@Configuration
@ComponentScan("com.itheima")
@PropertySource("jdbc.properties")
public class SpringConfig {
}
复制

步骤3：使用@Value读取配置文件中的内容

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    @Value("${name}")
    private String name;
    public void save() {
        System.out.println("book dao save ..." + name);
    }
}
复制

步骤4:运行程序

运行App类，查看运行结果，说明配置文件中的内容已经被加载到

注意:

• 如果读取的properties配置文件有多个，可以使用@PropertySource的属性来指定多个

  @PropertySource({"jdbc.properties","xxx.properties"})
  复制

• @PropertySource注解属性中不支持使用通配符*,运行会报错

  @PropertySource({"*.properties"})
  复制

• @PropertySource注解属性中可以把classpath:加上,代表从当前项目的根路径找文件

  @PropertySource({"classpath:jdbc.properties"})
  复制

整合Junit与整合Druid和MyBatis差异比较大，为什么呢？Junit是一个搞单元测试用的工具，它不是我们程序的主体，也不会参加最终程序的运行，从作用上来说就和之前的东西不一样，它不是做功能的，看做是一个辅助工具就可以了。

在test\java下创建一个AccountServiceTest,这个名字任意

//设置类运行器
@RunWith(SpringJUnit4ClassRunner.class)
//设置Spring环境对应的配置类
@ContextConfiguration(classes = {SpringConfiguration.class}) //加载配置类
//@ContextConfiguration(locations={"classpath:applicationContext.xml"})//加载配置文件
public class AccountServiceTest {
    //支持自动装配注入bean
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        System.out.println(accountService.findById(1));

    }
    @Test
    public void testFindAll(){
        System.out.println(accountService.findAll());
    }
}
复制

注意:

• 单元测试，如果测试的是注解配置类，则使用@ContextConfiguration(classes = 配置类.class)
• 单元测试，如果测试的是配置文件，则使用@ContextConfiguration(locations={配置文件名,...})
• Junit运行后是基于Spring环境运行的，所以Spring提供了一个专用的类运行器，这个务必要设置，这个类运行器就在Spring的测试专用包中提供的，导入的坐标就是这个东西SpringJUnit4ClassRunner
• 上面两个配置都是固定格式，当需要测试哪个bean时，使用自动装配加载对应的对象，下面的工作就和以前做Junit单元测试完全一样了