Spring详细介绍 zh-IOC/DI（2）

梦里梦外; 2023-09-24 20:42 72阅读 0赞

> `目标`

*  掌握IOC/DI配置管理第三方bean
 *  掌握IOC/DI的注解开发
 *  掌握IOC/DI注解管理第三方bean
 *  完成Spring与Mybatis及Junit的整合开发

# 1.IOC/DI配置管理第三方bean #

## 1)数据源对象管理 ##

### pom.xml添加依赖 ###

<dependencies>
            <dependency>
                <groupId>org.springframework</groupId>//spring-context
                <artifactId>spring-context</artifactId>
                <version>5.2.10.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>//druid
                <artifactId>druid</artifactId>
                <version>1.1.16</version>
            </dependency>
            <dependency>
                <groupId>c3p0</groupId>//c3p0
                <artifactId>c3p0</artifactId>
                <version>0.9.1.2</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>//mysql
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
        </dependencies>

### resources下添加spring的配置文件applicationContext.xml ###

### 编写一个运行类App ###

public class App {
        
        public static void main(String[] args) {
        
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        }
    }

### (1)实现Druid管理 ###

对数据源进行配置管理，先来分析下思路:

> 需求:使用Spring的IOC容器来管理Druid连接池对象
> 
> 1.使用第三方的技术，需要在pom.xml添加依赖
> 
> 2.在配置文件中将【第三方的类】制作成一个bean，让IOC容器进行管理
> 
> 3.数据库连接需要基础的四要素`驱动`、`连接`、`用户名`和`密码`，【如何注入】到对应的bean中
> 
> 4.从IOC容器中获取对应的bean对象，将其打印到控制台查看结果

**思考:**

*  第三方的类指的是什么?pom.xml添加依赖
 *  如何注入数据库连接四要素?applicationContext.xml中注入jdbc文件

#### 步骤1:导入`druid`的依赖 ####

pom.xml中添加依赖

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.16</version>
    </dependency>

#### 步骤2:配置第三方bean ####

在applicationContext.xml配置文件中添加`DruidDataSource`的配置

<?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="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
            <property name="username" value="root"/>
            <property name="password" value="root"/>
        </bean>
    </beans>

**说明:**

*  `driverClassName`:`数据库驱动`
 *  `url`:`数据库连接地址`
 *  `username`:`数据库连接用户名`
 *  `password`:`数据库连接密码`
 *  数据库连接的四要素要和自己使用的数据库信息一致。

#### 步骤3:从IOC容器中获取对应的bean对象 ####

public class App {
        
        public static void main(String[] args) {
        
           ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
           DataSource dataSource = (DataSource) ctx.getBean("dataSource");
           System.out.println(dataSource);
        }
    }

#### 步骤4:运行程序 ####

打印如下结果: 说明第三方bean对象已经被spring的IOC容器进行管理

{
        
    	CreateTime:"2023-02-27 16:33:44",
    	ActiveCount:0,
    	PoolingCount:0,
    	CreateCount:0,
    	DestroyCount:0,
    	CloseCount:0,
    	ConnectCount:0,
    	Connections:[
    	]
    }

做完案例后，我们可以将刚才思考的两个问题答案说下:

*  第三方的类指的是什么?
    
        DruidDataSource
 *  如何注入数据库连接四要素?
    
        setter注入

### (2)实现C3P0管理 ###

完成了DruidDataSource的管理，接下来我们再来加深下练习，这次我们来管理`C3P0`数据源，具体的实现步骤是什么呢?

> 需求:使用Spring的IOC容器来管理C3P0连接池对象
> 
> 实现方案和上面基本一致，重点要关注管理的是哪个bean对象?

#### 步骤1:导入`C3P0`的依赖 ####

pom.xml中添加依赖

C3P0的依赖还需要导入`com.mysql.jdbc.Driver`，否则报错为ClassNotFoundException

*  Druid和C3P0在没有导入mysql驱动包的前提下，一个没报错一个报错，说明`Druid在初始化的时候没有去加载驱动`，`而C3P0刚好相反`
 *  Druid程序运行虽然没有报错，但是`当调用DruidDataSource的getConnection()方法获取连接的时候`，也`会报找不到驱动类的错误`

<dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>

#### 步骤2:配置第三方bean ####

在applicationContext.xml配置文件中添加配置

**注意:**

*  `ComboPooledDataSource`的属性是通过`setter方式`进行注入
 *  想注入属性就需要在`ComboPooledDataSource`类或其上层类中有提供属性对应的setter方法
 *  `C3P0的四个属性`和`Druid的四个属性`是`不一样`的

#### 步骤3:运行程序 ####

com.mchange.v2.c3p0.ComboPooledDataSource [ acquireIncrement -> 3, acquireRetryAttempts -> 30, acquireRetryDelay -> 1000, autoCommitOnClose -> false, automaticTestTable -> null, breakAfterAcquireFailure -> false, checkoutTimeout -> 0, connectionCustomizerClassName -> null, connectionTesterClassName -> com.mchange.v2.c3p0.impl.DefaultConnectionTester, dataSourceName -> 1hgf08xau15aia7gad4jm4|42d80b78, debugUnreturnedConnectionStackTraces -> false, description -> null, driverClass -> com.mysql.jdbc.Driver, factoryClassLocation -> null, forceIgnoreUnresolvedTransactions -> false, identityToken -> 1hgf08xau15aia7gad4jm4|42d80b78, idleConnectionTestPeriod -> 0, initialPoolSize -> 3, jdbcUrl -> jdbc:mysql://localhost:3306/test, maxAdministrativeTaskTime -> 0, maxConnectionAge -> 0, maxIdleTime -> 0, maxIdleTimeExcessConnections -> 0, maxPoolSize -> 10, maxStatements -> 0, maxStatementsPerConnection -> 0, minPoolSize -> 3, numHelperThreads -> 3, numThreadsAwaitingCheckoutDefaultUser -> 0, preferredTestQuery -> null, properties -> {
        user=******, password=******}, propertyCycle -> 0, testConnectionOnCheckin -> false, testConnectionOnCheckout -> false, unreturnedConnectionTimeout -> 0, usesTraditionalReflectiveProxies -> false ]

## 2）加载properties文件 ##

*  这两个数据源中都使用到了一些固定的常量如数据库连接四要素，把这些值写在Spring的配置文件中不利于后期维护
 *  需要将这些`值提取到一个外部的properties配置文件中`
 *  Spring框架如何从配置文件中读取属性值来配置就是接下来要解决的问题。

### (1)第三方bean属性优化 ###

**读取外部properties配置文件中的内容**

> 需求:将数据库连接四要素提取到properties配置文件，spring来加载配置信息并使用这些信息来完成属性注入。
> 
> 1.在resources下创建一个jdbc.properties(文件的名称可以任意)
> 
> 2.将数据库连接四要素配置到配置文件中
> 
> 3.在Spring的配置文件中加载properties文件
> 
> 4.使用加载到的值实现属性注入
> 
> 其中第3，4步骤是需要大家重点关注，具体是如何实现。

#### 步骤1:准备properties配置文件 ####

resources下创建一个jdbc.properties文件,并添加对应的属性键值对

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/test
    jdbc.username=root
    jdbc.password=123456

#### 步骤2:开启`context`命名空间 ####

在applicationContext.xml中开`context`命名空间

![在这里插入图片描述][06e1d041a68544d6a94c8196faedabbb.png]  
**之前**  
![在这里插入图片描述][a82abafc6fc243939822ee1fe53b2542.png]

#### 步骤3:加载properties配置文件 ####

在配置文件中使用`context`命名空间下的标签来加载properties配置文件

<context:property-placeholder location="jdbc.properties"/>

#### 步骤4:完成属性注入 ####

使用`${key}`来读取properties配置文件中的内容并完成属性注入

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="
                http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd">
        
        <context:property-placeholder location="jdbc.properties"/>
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="${jdbc.driver}"/>
            <property name="url" value="${jdbc.url}"/>
            <property name="username" value="${jdbc.username}"/>
            <property name="password" value="${jdbc.password}"/>
        </bean>
    </beans>

### (2) 读取单个属性 ###

> 需求:从properties配置文件中读取key为name的值，并将其注入到BookDao中并在save方法中进行打印。
> 
> 1.在项目中添加BookDao和BookDaoImpl类
> 
> 2.为BookDaoImpl添加一个name属性并提供setter方法
> 
> 3.在jdbc.properties中添加数据注入到bookDao中打印方便查询结果
> 
> 4.在applicationContext.xml添加配置完成配置文件加载、属性注入($\{key\})

#### 步骤1:在项目中添对应的类 ####

BookDao和BookDaoImpl类，并在BookDaoImpl类中添加`name`属性与setter方法

public interface BookDao {
        
        public void save();
    }
    
    public class BookDaoImpl implements BookDao {
        
        private String name;
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public void save() {
        
            System.out.println("book dao save ..." + name);
        }
    }

#### 步骤2:完成配置文件的读取与注入 ####

在applicationContext.xml添加配置，`bean的配置管理`、`读取外部properties`、`依赖注入`:

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="
                http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd">
        
        <context:property-placeholder location="jdbc.properties"/>
        
        <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
            <property name="name" value="${jdbc.driver}"/>
        </bean>
    </beans>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/test
    jdbc.username=root
    jdbc.password=123456

#### 步骤3:运行程序 ####

在App类中，从IOC容器中获取bookDao对象，调用方法，查看值是否已经被获取到并打印控制台

public class App {
        
        public static void main(String[] args) throws Exception{
        
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            BookDao bookDao = (BookDao) ctx.getBean("bookDao");
            bookDao.save();
    
        }
    }

book dao save ...com.mysql.jdbc.Driver

### (3) 注意事项 ###

读取properties配置文件中的内容有些注意事项:

> **问题一:键值对的key为`username`引发的问题**

1.在properties中配置键值对的时候，如果key设置为`username`

**jdbc2.properties**

username=root666

**jdbc.properties**

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/test
    jdbc.username=root
    jdbc.password=123456

2.在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"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="
                http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd">
        
        <context:property-placeholder location="jdbc.properties"/>
        
        <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
            <property name="name" value="${username}"/>
        </bean>
    </beans>

3.运行后，在控制台打印的却不是`root666`，而是自己电脑的用户名

book dao save ...amy

4.出现问题的原因是`<context:property-placeholder/>`标签会加载系统的环境变量，而且`环境变量的值会被优先加载`，如何查看系统的环境变量?

public static void main(String[] args) throws Exception{
        
        Map<String, String> env = System.getenv();
        System.out.println(env);
    }

大家可以自行运行，在打印出来的结果中会有一个`USERNAME=XXX[自己电脑的用户名称]`

5.解决方案

`system-properties-mode:`设置为`NEVER`,`表示不加载系统属性`，就可以解决上述问题。

当然还有一个解决方案就是避免使用`username`作为属性的`key`。

> **问题二:当有多个properties配置文件需要被加载，该如何配置?**

1.调整下配置文件的内容，在resources下添加`jdbc.properties`,`jdbc2.properties`,内容如下:

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
    jdbc.username=root
    jdbc.password=root

jdbc2.properties

username=root666

2.修改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"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="
                http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd">
        
        <context:property-placeholder location="jdbc.properties,jdbc2.properties" system-properties-mode="NEVER"/>
        
        <context:property-placeholder location="*.properties" system-properties-mode="NEVER"/>
        
        <context:property-placeholder location="classpath:*.properties" system-properties-mode="NEVER"/>
        
        <context:property-placeholder location="classpath*:*.properties" system-properties-mode="NEVER"/>
    </beans>

**说明:**

*  方式一:可以实现，`如果配置文件多的话，每个都需要配置`
 *  方式二:`*.properties`代表所有以properties结尾的文件都会被加载，可以解决方式一的问题，但是不标准
 *  方式三:标准的写法，`classpath:`代表的是从根路径下开始查找，但是只能查询当前项目的根路径
 *  方式四:`不仅可以加载当前项目还可以加载当前项目所依赖的所有项目的根路径下的properties配置文件`

### (4)加载properties文件小结 ###

*  如何开启`context`命名空间  
    ![在这里插入图片描述][06e1d041a68544d6a94c8196faedabbb.png]
 *  如何加载properties配置文件
    
        <context:property-placeholder location="" system-properties-mode="NEVER"/>
 *  如何在applicationContext.xml引入properties配置文件中的值
    
        ${key}

##  ##

## 2.核心容器 ##

IOC容器中的核心容器。

*  `如何创建容器?`
 *  `创建好容器后，如何从容器中获取bean对象?`
 *  `容器类的层次结构是什么?`
 *  `BeanFactory是什么?`

创建一个Maven项目

*  pom.xml添加Spring的依赖
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.10.RELEASE</version>
            </dependency>
        </dependencies>
 *  resources下添加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>
 *  添加BookDao和BookDaoImpl类
    
        public interface BookDao {
              
            public void save();
        }
        public class BookDaoImpl implements BookDao {
              
            public void save() {
              
                System.out.println("book dao save ..." );
            }
        }
 *  创建运行类App
    
        public class App {
              
            public static void main(String[] args) {
              
                ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
                BookDao bookDao = (BookDao) ctx.getBean("bookDao");
                bookDao.save();
            }
        }

### (1) 容器的创建方式 ###

案例中创建`ApplicationContext`的方式为:

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

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

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

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

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

使用这种方式，运行，会出现如下错误:  
![在这里插入图片描述][df9e65331bd44973bc0095be4655cb3e.png]

从错误信息中能发现，这种方式是从项目路径下开始查找`applicationContext.xml`配置文件的，所以需要将其修改为:

ApplicationContext ctx = new FileSystemXmlApplicationContext("C:\testcode\2022SSM\day02\spring_10_container\applicationContext.xml");

### (2) Bean的三种获取方式 ###

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

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

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

`方式二：`

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

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

`方式三:`

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

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

### (3)容器类层次结构 ###

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

![在这里插入图片描述][7295299c45a54b00a891be3446720023.png]

(2)点击进入BeanFactory类，ctrl+h,就能查看到如下结构的层次关系  
![在这里插入图片描述][9386de79bcf641c2a77d4568ee40bb30.png]

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

`使用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要想成为延迟加载`，只需要按照如下方式进行配置 `lazy-init="true"`
    
        <?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>

### (4)**小结** ###

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

*  `容器创建的两种方式`
    
     *  `ClassPathXmlApplicationContext`
     *  `FileSystemXmlApplicationContext`
 *  `获取Bean的三种方式`
    
     *  getBean(“名称”):`需要类型转换`
     *  getBean(“名称”,类型.class):`多了一个参数`
     *  getBean(类型.class):`容器中不能有多个该类的bean对象`
    
    上述三种方式，各有各的优缺点，用哪个都可以。
 *  `容器类层次结构`
    
     *  只需要知晓容器的最上级的`父接口为 BeanFactory`即可
 *  `BeanFactory`
    
     *  使用`BeanFactory创建的容器是延迟加载`
     *  使用`ApplicationContext创建的容器是立即加载`
     *  具体`BeanFactory`如何创建只需要了解即可。

# 3.IOC/DI注解开发 #

pring的注解开发，Spring对注解支持的版本历程:

*  2.0版开始支持注解
 *  2.5版注解功能趋于完善
 *  3.0版支持纯注解开发

关于注解开发，重点内容`注解开发定义bean`和`纯注解开发`。

*  创建一个Maven项目
 *  pom.xml添加Spring的依赖
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.10.RELEASE</version>
            </dependency>
        </dependencies>
 *  resources下添加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>
 *  添加BookDao、BookDaoImpl、BookService、BookServiceImpl类
    
        public interface BookDao {
              
            public void save();
        }
        public class BookDaoImpl implements BookDao {
              
            public void save() {
              
                System.out.println("book dao save ..." );
            }
        }
        public interface BookService {
              
            public void save();
        }
        
        public class BookServiceImpl implements BookService {
              
            public void save() {
              
                System.out.println("book service save ...");
            }
        }
 *  创建运行类App
    
        public class App {
              
            public static void main(String[] args) {
              
                ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
                BookDao bookDao = (BookDao) ctx.getBean("bookDao");
                bookDao.save();
            }
        }

## 1)注解开发定义bean ##

### 步骤1:删除原XML配置 ###

将配置文件中的`<bean>`标签删除掉

### 步骤2:Dao上添加注解 ###

在BookDaoImpl类上添加`@Component`注解

@Component("bookDao")
    public class BookDaoImpl implements BookDao {
        
        public void save() {
        
            System.out.println("book dao save ..." );
        }
    }

注意:@Component注解不可以添加在接口上，因为接口是无法创建对象的。  
**XML与注解配置的对应关系:**  
![在这里插入图片描述][31d3126d0b7b42c2a85f4e8743bcd23b.png]

### 步骤3:配置Spring的注解包扫描 ###

为了让Spring框架能够扫描到写在类上的注解，需要在配置文件上进行包扫描

**说明:**

component-scan

*  `component:组件,Spring将管理的bean视作自己的一个组件`
 *  `scan:扫描`

`base-package`指定`Spring框架扫描的包路径`，它会`扫描指定包及其子包中的所有类上的注解`。

*  包路径越多\[如:com.itheima.dao.impl\]，`扫描的范围越小速度越快`
 *  包路径越少\[如:com.itheima\],`描的范围越大速度越慢`
 *  一般扫描到项目的组织名称即Maven的groupId下\[如:com.itheima\]即可。

### 步骤4：运行程序 ###

com.itheima.dao.impl.BookDaoImpl@15761df8

### 步骤5:Service上添加注解 ###

在BookServiceImpl类上也添加`@Component`交给Spring框架管理

@Component
    public class BookServiceImpl implements BookService {
        
        private BookDao bookDao;
    
        public void setBookDao(BookDao bookDao) {
        
            this.bookDao = bookDao;
        }
    
        public void save() {
        
            System.out.println("book service save ...");
            bookDao.save();
        }
    }

### 步骤6:运行程序 ###

在App类中，从IOC容器中获取BookServiceImpl对应的bean对象，打印

public class App {
        
        public static void main(String[] args) {
        
            ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
            BookDao bookDao = (BookDao) ctx.getBean("bookDao");
            System.out.println(bookDao);
            //按类型获取bean
            BookService bookService = ctx.getBean(BookService.class);
            System.out.println(bookService);
        }
    }

com.itheima.dao.impl.BookDaoImpl@15761df8
    com.itheima.service.impl.BookServiceImpl@3745e5c6

**说明:**

*  `BookServiceImpl类没有起名称，所以在App中是按照类型来获取bean对象`

\*`@Component注解如果不起名称，会有一个默认值就是当前类名首字母小写`，所以也`可以按照名称获取`，如

BookService bookService = (BookService)ctx.getBean("bookServiceImpl");
    System.out.println(bookService);

对于@Component注解，还衍生出了其他三个注解`@Controller`、`@Service`、`@Repository`

通过查看源码会发现:

![在这里插入图片描述][25c041a81a1046bb9a9de1eb910c2c64.png]

这三个注解和@Component注解的作用是一样的，为什么要衍生出这三个呢?

方便我们后期在编写类的时候能很好的区分出这个类是属于`表现层`、`业务层`还是`数据层`的类。

### 知识点1:@Component等 ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Component/@Controller/@Service/@Repository</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置该类为spring管理的bean</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：定义bean的id</td> 
  </tr> 
 </tbody> 
</table>

## 2)纯注解开发模式 ##

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

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

### 步骤1:创建配置类 ###

创建一个配置类`SpringConfig`

public class SpringConfig {
        
    }

### 步骤2:标识该类为配置类 ###

在配置类上添加`@Configuration`注解，将其标识为一个配置类,替换`applicationContext.xml`

@Configuration
    public class SpringConfig {
        
    }

### 步骤3:用注解替换包扫描配置 ###

在配置类上添加包扫描注解`@ComponentScan`替换`<context:component-scan base-package=""/>`

@Configuration
    @ComponentScan("com.itheima")
    public class SpringConfig {
        
    }

### 步骤4:创建运行类并执行 ###

创建一个新的运行类`AppForAnnotation`

public class AppForAnnotation {
        
    
        public static void main(String[] args) {
        
            ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            BookDao bookDao = (BookDao) ctx.getBean("bookDao");
            System.out.println(bookDao);
            BookService bookService = ctx.getBean(BookService.class);
            System.out.println(bookService);
        }
    }

//声明当前类为Spring配置类
    @Configuration
    //设置bean扫描路径，多个路径书写为字符串数组格式
    @ComponentScan({
        "com.itheima.service","com.itheima.dao"})
    public class SpringConfig {
        
    }
    public interface BookDao {
        
        public void save();
    }
    
    //@Component定义bean
    //@Component("bookDao")
    //@Repository：@Component衍生注解
    @Repository("bookDao")
    public class BookDaoImpl implements BookDao {
        
        public void save() {
        
            System.out.println("book dao save ...");
        }
    }
    public interface BookService {
        
        public void save();
    }
    //@Component定义bean
    //@Component
    //@Service：@Component衍生注解
    @Service
    public class BookServiceImpl implements BookService {
        
        private BookDao bookDao;
    
        public void setBookDao(BookDao bookDao) {
        
            this.bookDao = bookDao;
        }
    
        public void save() {
        
            System.out.println("book service save ...");
            bookDao.save();
        }
    }
    public class AppForAnnotation {
        
        public static void main(String[] args) {
        
            //AnnotationConfigApplicationContext加载Spring配置类初始化Spring容器
            ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            BookDao bookDao = (BookDao) ctx.getBean("bookDao");
            System.out.println(bookDao);
            //按类型获取bean
            BookService bookService = ctx.getBean(BookService.class);
            System.out.println(bookService);
        }
    }

运行AppForAnnotation,可以看到两个对象依然被获取成功

com.itheima.dao.impl.BookDaoImpl@77e4c80f
    com.itheima.service.impl.BookServiceImpl@255b53dc

至此，纯注解开发的方式就已经完成了，主要内容包括:

*  Java类替换Spring核心配置文件

![在这里插入图片描述][3e34cd3a8c1145c1818ad506cf466007.png]

*  `@Configuration注解`用于设定`当前类为配置类`
 *  `@ComponentScan`注解用于`设定扫描路径`，此注解只能添加一次，多个数据请用数组格式
    
        @ComponentScan({com.itheima.service","com.itheima.dao"})
 *  `读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象`
    
        //加载配置文件初始化容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //加载配置类初始化容器
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

### 知识点1：@Configuration ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Configuration</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置该类为spring配置类</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：定义bean的id</td> 
  </tr> 
 </tbody> 
</table>

### 知识点2：@ComponentScan ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@ComponentScan</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置spring配置类扫描路径，用于加载使用注解格式定义的bean</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：扫描路径，此路径可以逐层向下扫描</td> 
  </tr> 
 </tbody> 
</table>

### **小结:** ###

这一节重点掌握的是使用注解完成Spring的bean管理，需要掌握的内容为:

*  记住`@Component、@Controller、@Service、@Repository`这四个注解
 *  applicationContext.xml中`<context:component-san/>`的作用是指定扫描包路径，注解为`@ComponentScan`
 *  `@Configuration`标识该类为`配置类`，使用类替换`applicationContext.xml`文件
 *  `ClassPathXmlApplicationContext`是加载`XML配置文件`
 *  `AnnotationConfigApplicationContext`是`加载配置类`

## 3)注解开发bean作用范围与生命周期管理 ##

*  创建一个Maven项目
 *  pom.xml添加Spring的依赖
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.10.RELEASE</version>
            </dependency>
        </dependencies>
 *  添加一个配置类`SpringConfig`
    
        @Configuration
        @ComponentScan("com.itheima")
        public class SpringConfig {
              
        }
 *  添加BookDao、BookDaoImpl类
    
        public interface BookDao {
              
            public void save();
        }
        @Repository
        public class BookDaoImpl implements BookDao {
              
            public void save() {
              
                System.out.println("book dao save ..." );
            }
        }
 *  创建运行类App
    
        public class App {
              
            public static void main(String[] args) {
              
                AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
                BookDao bookDao1 = ctx.getBean(BookDao.class);
                BookDao bookDao2 = ctx.getBean(BookDao.class);
                System.out.println(bookDao1);
                System.out.println(bookDao2);
            }
        }

### bean作用范围 ###

#### 单例 ####

@Configuration
    @ComponentScan("com.itheima")
    public class SpringConfig {
        
    }
    public interface BookDao {
        
        public void save();
    }
    @Repository
    //@Scope设置bean的作用范围
    @Scope("singleton")
    public class BookDaoImpl implements BookDao {
        
        public void save() {
        
            System.out.println("book dao save ...");
        }
    }
    public class App {
        
        public static void main(String[] args) {
        
            AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            BookDao bookDao1 = ctx.getBean(BookDao.class);
            BookDao bookDao2 = ctx.getBean(BookDao.class);
            System.out.println(bookDao1);
            System.out.println(bookDao2);
        }
    }

**地址相同**

com.itheima.dao.impl.BookDaoImpl@491666ad
    com.itheima.dao.impl.BookDaoImpl@491666ad

#### 非单例 ####

@Configuration
    @ComponentScan("com.itheima")
    public class SpringConfig {
        
    }
    public interface BookDao {
        
        public void save();
    }
    @Repository
    //@Scope设置bean的作用范围
    @Scope("prototype")
    public class BookDaoImpl implements BookDao {
        
        public void save() {
        
            System.out.println("book dao save ...");
        }
    }
    public class App {
        
        public static void main(String[] args) {
        
            AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            BookDao bookDao1 = ctx.getBean(BookDao.class);
            BookDao bookDao2 = ctx.getBean(BookDao.class);
            System.out.println(bookDao1);
            System.out.println(bookDao2);
        }
    }

**地址不同**

com.itheima.dao.impl.BookDaoImpl@491666ad
    com.itheima.dao.impl.BookDaoImpl@176d53b2

### 知识点1：@Scope ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Scope</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置该类创建对象的作用范围<br>可用于设置创建出的bean是否为单例对象</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：定义bean作用范围，<br>默认值singleton（单例），可选值prototype（非单例）</td> 
  </tr> 
 </tbody> 
</table>

### 生命周期管理 ###

(1)在BookDaoImpl中添加两个方法，`init`和`destroy`,方法名可以任意

@Repository
    public class BookDaoImpl implements BookDao {
        
        public void save() {
        
            System.out.println("book dao save ...");
        }
        public void init() {
        
            System.out.println("init ...");
        }
        public void destroy() {
        
            System.out.println("destroy ...");
        }
    }

(2)如何对方法进行标识，哪个是初始化方法，哪个是销毁方法?

只需要在对应的方法上添加`@PostConstruct`和`@PreDestroy`注解即可。

@Repository
    public class BookDaoImpl implements BookDao {
        
        public void save() {
        
            System.out.println("book dao save ...");
        }
        @PostConstruct //在构造方法之后执行，替换 init-method
        public void init() {
        
            System.out.println("init ...");
        }
        @PreDestroy //在销毁方法之前执行,替换 destroy-method
        public void destroy() {
        
            System.out.println("destroy ...");
        }
    }

(3)要想看到两个方法执行，需要注意的是`destroy`只有在容器关闭的时候，才会执行，所以需要修改App的类

public class App {
        
        public static void main(String[] args) {
        
            AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            BookDao bookDao1 = ctx.getBean(BookDao.class);
            BookDao bookDao2 = ctx.getBean(BookDao.class);
            System.out.println(bookDao1);
            System.out.println(bookDao2);
            ctx.close(); //关闭容器
        }
    }

(4)运行App,类查看打印结果，证明init和destroy方法都被执行了。

init ...
    com.itheima.dao.impl.BookDaoImpl@176d53b2
    com.itheima.dao.impl.BookDaoImpl@176d53b2
    destroy .

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

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

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

### 知识点1：@PostConstruct ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@PostConstruct</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>方法注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>方法上</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置该方法为初始化方法</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>无</td> 
  </tr> 
 </tbody> 
</table>

### 知识点2：@PreDestroy ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@PreDestroy</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>方法注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>方法上</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置该方法为销毁方法</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>无</td> 
  </tr> 
 </tbody> 
</table>

### **小结** ###

![在这里插入图片描述][f4e3d2dd0e8544b9921e4f00cc136bb4.png]

## 4)注解开发依赖注入 ##

*  pom.xml添加Spring的依赖
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.10.RELEASE</version>
            </dependency>
        </dependencies>
 *  添加一个配置类`SpringConfig`
    
        @Configuration
        @ComponentScan("com.itheima")
        public class SpringConfig {
              
        }
 *  添加BookDao、BookDaoImpl、BookService、BookServiceImpl类
    
        public interface BookDao {
              
            public void save();
        }
        @Repository
        public class BookDaoImpl implements BookDao {
              
            public void save() {
              
                System.out.println("book dao save ..." );
            }
        }
        public interface BookService {
              
            public void save();
        }
        @Service
        public class BookServiceImpl implements BookService {
              
            private BookDao bookDao;
        	public void setBookDao(BookDao bookDao) {
              
                this.bookDao = bookDao;
            }
            public void save() {
              
                System.out.println("book service save ...");
                bookDao.save();
            }
        }
 *  创建运行类App
    
        public class App {
              
            public static void main(String[] args) {
              
                AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
                BookService bookService = ctx.getBean(BookService.class);
                bookService.save();
            }
        }

book service save ...
    Exception in thread "main" java.lang.NullPointerException
    	at com.itheima.service.impl.BookServiceImpl.save(BookServiceImpl.java:20)
    	at com.itheima.App.main(App.java:14)

出现问题的原因是，**在BookServiceImpl类中添加了BookDao的属性，并提供了setter方法，但是目前是没有提供配置注入BookDao的**，所以`bookDao对象为Null`,调用其save方法就会报`控指针异常`。

### (1)注解实现按照类型注入 ###

(1) 在BookServiceImpl类的bookDao属性上添加`@Autowired`注解

@Service
    public class BookServiceImpl implements BookService {
        
        @Autowired
        private BookDao bookDao;
        
    //	  public void setBookDao(BookDao bookDao) {
        
    //        this.bookDao = bookDao;
    //    }
        public void save() {
        
            System.out.println("book service save ...");
            bookDao.save();
        }
    }

**注意:**

*  @Autowired可以写在属性上，也可也写在setter方法上，最简单的处理方式是`写在属性上并将setter方法删除掉`
 *  为什么setter方法可以删除呢?
    
     *  `自动装配`基于`反射`设计创建对象并通过`暴力反射`为`私有属性进行设值`
     *  普通反射只能获取public修饰的内容
     *  `暴力反射除了获取public修饰的内容还可以获取private修改的内容`
     *  `所以此处无需提供setter方法`

(2)`@Autowired`是按照`类型注入`，那么对应BookDao接口如果有多个实现类，比如添加BookDaoImpl2

@Repository
    public class BookDaoImpl2 implements BookDao {
        
        public void save() {
        
            System.out.println("book dao save ...2");
        }
    }

这个时候再次运行App，就会报错

![在这里插入图片描述][a2f05021bb2e4a6d8ad0e7fdba474619.png]

此时，**按照类型注入就无法区分到底注入哪个对象**，解决方案:`按照名称注入`

*  先给两个Dao类分别起个名称
    
        @Repository("bookDao")
        public class BookDaoImpl implements BookDao {
              
            public void save() {
              
                System.out.println("book dao save ..." );
            }
        }
        @Repository("bookDao2")
        public class BookDaoImpl2 implements BookDao {
              
            public void save() {
              
                System.out.println("book dao save ...2" );
            }
        }
    
    此时就可以注入成功，但是得思考个问题:
    
     *  `@Autowired`是`按照类型注入`的，给BookDao的两个实现起了名称，它还是有两个bean对象，为什么不报错?
     *  `@Autowired`默认`按照类型自动装配`，如果IOC容器中同类的Bean找到多个，就按照变量名和Bean的名称匹配因为变量名叫`bookDao`而容器中也有一个`booDao`，所以可以成功注入。
     *  分析下面这种情况是否能完成注入呢?

![在这里插入图片描述][398d7d46a19b41d79b640dcf28333348.png]  
不行，因为按照类型会找到多个bean对象，此时会按照`bookDao`名称去找，因为IOC容器只有名称叫`bookDao1`和`bookDao2`,所以找不到，会报`NoUniqueBeanDefinitionException`

### (2) 注解实现按照名称注入 ###

`当根据类型在容器中找到多个bean,注入参数的属性名又和容器中bean的名称不一致`，这个时候该如何解决，就需要使用到`@Qualifier`来指定注入哪个名称的bean对象。

@Service
    public class BookServiceImpl implements BookService {
        
        @Autowired
        @Qualifier("bookDao1")
        private BookDao bookDao;
        
        public void save() {
        
            System.out.println("book service save ...");
            bookDao.save();
        }
    }

`@Qualifier`注解后的值就是`需要注入的bean的名称`。

注意:@Qualifier不能独立使用，必须和@Autowired一起使用

### (3)简单数据类型注入 ###

`简单类型注入的是基本数据类型或者字符串类型`，下面在`BookDaoImpl`类中添加一个`name`属性，用其进行`简单类型注入`

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

`数据类型换了，对应的注解也要跟着换`，这次使用`@Value`注解，将值写入注解的参数中就行了

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

book service save ...
    book dao save ...amy

注意`数据格式要匹配`，如将"abc"注入给int值，这样程序就会报错。

### (4)注解读取properties配置文件 ###

`@Value`一般会被用在`从properties配置文件中读取内容进行使用`，具体如何实现?

#### 步骤1：resource下准备properties文件 ####

jdbc.properties

name=amy1234

#### 步骤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类，查看运行结果，说明配置文件中的内容已经被加载到

book service save ...
    book dao save ...amy1234

**注意:**

*  如果读取的properties配置文件有多个，可以使用`@PropertySource`的属性来指定多个
    
        @PropertySource({
              "jdbc.properties","xxx.properties"})
 *  `@PropertySource`注解属性中不支持使用通配符`*`,运行会报错
    
        @PropertySource({
              "*.properties"})
 *  `@PropertySource`注解属性中可以把`classpath:`加上,代表从当前项目的根路径找文件
    
        @PropertySource({
              "classpath:jdbc.properties"})

#### 知识点1：@Autowired ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Autowired</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>属性注解 或 方法注解（了解） 或 方法形参注解（了解）</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>属性定义上方 或 标准set方法上方 或 类set方法上方 或 方法形参前面</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>为引用类型属性设置值</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>required：true/false，定义该属性是否允许为null</td> 
  </tr> 
 </tbody> 
</table>

#### 知识点2：@Qualifier ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Qualifier</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>属性注解 或 方法注解（了解）</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>属性定义上方 或 标准set方法上方 或 类set方法上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>为引用类型属性指定注入的beanId</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：设置注入的beanId</td> 
  </tr> 
 </tbody> 
</table>

#### 知识点3：@Value ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Value</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>属性注解 或 方法注解（了解）</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>属性定义上方 或 标准set方法上方 或 类set方法上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>为 基本数据类型 或 字符串类型 属性设置值</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：要注入的属性值</td> 
  </tr> 
 </tbody> 
</table>

#### 知识点4：@PropertySource ####

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@PropertySource</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>加载properties文件中的属性值</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：设置加载的properties文件对应的文件名或文件名组成的数组</td> 
  </tr> 
 </tbody> 
</table>

# 4.IOC/DI注解开发管理第三方bean #

`前面定义bean的时候都是在自己开发的类上面写个注解就完成了，但如果是第三方的类，这些类都是在jar包中，我们没有办法在类上面添加注解，这个时候该怎么办?`

遇到上述问题，我们就需要`有一种更加灵活的方式来定义bean,这种方式不能在原始代码上面书写注解，一样能定义bean`,这就用到了一个全新的注解`@Bean`

这个注解该如何使用呢?

咱们把之前使用配置方式管理的数据源使用注解再来一遍，通过这个案例来学习下`@Bean的使用`。

## 环境准备 ##

学习@Bean注解之前先来准备环境:

*  创建一个Maven项目
 *  pom.xml添加Spring的依赖
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.2.10.RELEASE</version>
            </dependency>
        </dependencies>
 *  添加一个配置类`SpringConfig`
    
        @Configuration
        public class SpringConfig {
              
        }
 *  添加BookDao、BookDaoImpl类
    
        public interface BookDao {
              
            public void save();
        }
        @Repository
        public class BookDaoImpl implements BookDao {
              
            public void save() {
              
                System.out.println("book dao save ..." );
            }
        }
 *  创建运行类App
    
        public class App {
              
            public static void main(String[] args) {
              
                AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            }
        }

## 1)注解开发管理第三方bean ##

在上述环境中完成对`Druid`数据源的管理，具体的实现步骤为:

#### 步骤1:导入对应的jar包 ####

<dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.16</version>
    </dependency>

#### 步骤2:在配置类中添加一个方法 ####

注意该方法的返回值就是要创建的Bean对象类型

@Configuration
    public class SpringConfig {
        
        public DataSource dataSource(){
        
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName("com.mysql.jdbc.Driver");
            ds.setUrl("jdbc:mysql://localhost:3306/test");
            ds.setUsername("root");
            ds.setPassword("123456");
            return ds;
        }
    }

#### 步骤3:在方法上添加`@Bean`注解 ####

`@Bean注解的作用是将方法的返回值制作为Spring管理的一个bean对象`

@Configuration
    public class SpringConfig {
        
    	@Bean
        public DataSource dataSource(){
        
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName("com.mysql.jdbc.Driver");
            ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
            ds.setUsername("root");
            ds.setPassword("root");
            return ds;
        }
    }

**注意:不能使用`DataSource ds = new DruidDataSource()`**

`因为DataSource接口中没有对应的setter方法来设置属性。`

#### 步骤4:从IOC容器中获取对象并打印 ####

public class App {
        
        public static void main(String[] args) {
        
            AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
            DataSource dataSource = ctx.getBean(DataSource.class);
            System.out.println(dataSource);
        }
    }

至此使用@Bean来管理第三方bean的案例就已经完成。

如果有多个bean要被Spring管理，直接在配置类中多些几个方法，方法上添加@Bean注解即可。

com.itheima.dao.impl.BookDaoImpl@29ba4338
    {
        
    	CreateTime:"2023-02-28 07:57:04",
    	ActiveCount:0,
    	PoolingCount:0,
    	CreateCount:0,
    	DestroyCount:0,
    	CloseCount:0,
    	ConnectCount:0,
    	Connections:[
    	]
    }

## 2)引入外部配置类 ##

**如果把所有的第三方bean都配置到Spring的配置类`SpringConfig`中，虽然可以，但是不利于代码阅读和分类管理，所有我们就想能不能按照类别将这些bean配置到不同的配置类中?**

对于数据源的bean,我们新建一个`JdbcConfig`配置类，并把数据源配置到该类下。

public class JdbcConfig {
        
    	@Bean
        public DataSource dataSource(){
        
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName("com.mysql.jdbc.Driver");
            ds.setUrl("jdbc:mysql://localhost:3306/test");
            ds.setUsername("root");
            ds.setPassword("123456");
            return ds;
        }
    }

现在的问题是，`这个配置类如何能被Spring配置类加载到，并创建DataSource对象在IOC容器中`?

针对这个问题，有两个解决方案:`(1)使用包扫描引入` `(2) 使用@Import引入`

### (1)使用`包扫描`引入 ###

##### 步骤1:在Spring的配置类上添加包扫描 #####

`@ComponentScan("com.itheima.config")`

@Configuration
    @ComponentScan("com.itheima.config")
    public class SpringConfig {
        
    	
    }

##### 步骤2:在JdbcConfig上添加配置注解 #####

JdbcConfig类要放入到`com.itheima.config`包下，需要被Spring的配置类扫描到即可

@Configuration
    public class JdbcConfig {
        
    	@Bean
        public DataSource dataSource(){
        
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName("com.mysql.jdbc.Driver");
            ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
            ds.setUsername("root");
            ds.setPassword("root");
            return ds;
        }
    }

##### 步骤3:运行程序 #####

依然能获取到bean对象并打印控制台。

这种方式虽然能够扫描到，但是`不能很快的知晓都引入了哪些配置类`，所有这种方式不推荐使用。

### (2) 使用`@Import`引入 ###

这种方案可以不用加`@Configuration`注解，但是必须在Spring配置类上使用`@Import`注解手动引入需要加载的配置类

##### 步骤1:去除JdbcConfig类上的注解 #####

public class JdbcConfig {
        
    	@Bean
        public DataSource dataSource(){
        
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName("com.mysql.jdbc.Driver");
            ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
            ds.setUsername("root");
            ds.setPassword("root");
            return ds;
        }
    }

##### 步骤2:在Spring配置类中引入 #####

@Configuration
    //@ComponentScan("com.itheima.config")
    @Import({
        JdbcConfig.class})
    public class SpringConfig {
        
    	
    }

**注意:**

*  扫描注解可以移除
 *  `@Import参数需要的是一个数组，可以引入多个配置类`。
 *  `@Import注解在配置类中只能写一次`，下面的方式是不允许的
    
        @Configuration
        //@ComponentScan("com.itheima.config")
        @Import(JdbcConfig.class)
        @Import(Xxx.class)
        public class SpringConfig {
              
        	
        }

##### 步骤3:运行程序 #####

### 知识点1：@Bean ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Bean</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>方法注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>方法定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置该方法的返回值作为spring管理的bean</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：定义bean的id</td> 
  </tr> 
 </tbody> 
</table>

### 知识点2：@Import ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@Import</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>导入配置类</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：定义导入的配置类类名，<br>当配置类有多个时使用数组格式一次性导入多个配置类</td> 
  </tr> 
 </tbody> 
</table>

## 3)注解开发实现为第三方bean注入资源 ##

在使用@Bean创建bean对象的时候，如果方法在创建的过程中需要其他资源该怎么办?

这些资源会有两大类，分别是`简单数据类型` 和`引用数据类型`。

### (1)简单数据类型 ###

#### 需求分析 ####

对于下面代码关于`数据库的四要素不应该写死在代码中，应该是从properties配置文件中读取`。如何来优化下面的代码?

public class JdbcConfig {
        
    	@Bean
        public DataSource dataSource(){
        
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName("com.mysql.jdbc.Driver");
            ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
            ds.setUsername("root");
            ds.setPassword("root");
            return ds;
        }
    }

#### 注入简单数据类型步骤 ####

##### 步骤1:类中提供四个属性 #####

public class JdbcConfig {
        
        private String driver;
        private String url;
        private String userName;
        private String password;
    	@Bean
        public DataSource dataSource(){
        
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName("com.mysql.jdbc.Driver");
            ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
            ds.setUsername("root");
            ds.setPassword("root");
            return ds;
        }
    }

##### 步骤2:使用`@Value`注解引入值 #####

public class JdbcConfig {
        
      //1.定义一个方法获得要管理的对象
        @Value("com.mysql.jdbc.Driver")
        private String driver;
        @Value("jdbc:mysql://localhost:3306/spring_db")
        private String url;
        @Value("root")
        private String userName;
        @Value("password")
        private String password;
         //2.添加@Bean，表示当前方法的返回值是一个bean
        //@Bean修饰的方法，形参根据类型自动装配
    	@Bean
        public DataSource dataSource(){
        
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName(driver);
            ds.setUrl(url);
            ds.setUsername(userName);
            ds.setPassword(password);
            return ds;
        }
    }

##### 扩展 #####

现在的数据库连接四要素还是写在代码中，需要做的是将这些内容`提取到jdbc.properties配置文件，大家思考下该如何实现?`

> 1.resources目录下添加jdbc.properties
> 
> 2.配置文件中提供四个键值对分别是数据库的四要素
> 
> 3.使用`@PropertySource加载jdbc.properties配置文件`
> 
> 4.修改@Value注解属性的值，将其修改为`${key}`，key就是键值对中的键的值

具体的实现就交由大家自行实现下。

### (2) 引用数据类型 ###

#### 需求分析 ####

假设在`构建DataSource对象的时候，需要用到BookDao对象，该如何把BookDao对象注入进方法内让其使用呢?`

public class JdbcConfig {
        
    	@Bean
        public DataSource dataSource(){
        
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName("com.mysql.jdbc.Driver");
            ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
            ds.setUsername("root");
            ds.setPassword("root");
            return ds;
        }
    }

#### 注入引用数据类型步骤 ####

#### 步骤1:在SpringConfig中扫描BookDao ####

`扫描的目的是让Spring能管理到BookDao,也就是说要让IOC容器中有一个bookDao对象`

@Configuration
    @ComponentScan("com.itheima.dao")
    @Import({
        JdbcConfig.class})
    public class SpringConfig {
        
    }

#### 步骤2:在JdbcConfig类的方法上添加参数 ####

@Bean
    public DataSource dataSource(BookDao bookDao){
        
        System.out.println(bookDao);
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }

引用类型注入只需要为bean定义方法设置形参即可，容器会根据类型自动装配对象。

#### 步骤3:运行程序 ####

`System.out.println(bookDao);`的结果在构建DataSource对象时输出

com.itheima.dao.impl.BookDaoImpl@564718df
    {
        
    	CreateTime:"2023-02-28 09:32:29",
    	ActiveCount:0,
    	PoolingCount:0,
    	CreateCount:0,
    	DestroyCount:0,
    	CloseCount:0,
    	ConnectCount:0,
    	Connections:[
    	]
    }

# 5.注解开发总结 #

前面我们已经完成了XML配置和注解的开发实现，至于两者之间的差异，咱们放在一块去对比回顾下:  
![在这里插入图片描述][080904a076cc4170a17e5f0f6286d1b7.png]

# 6.Spring整合 #

`Spring有一个容器，叫做IoC容器，里面保存bean。`在进行企业级开发的时候，其实除了将自己写的类让Spring管理之外，还有一部分重要的工作就是`使用第三方的技术`。前面已经讲了如何管理第三方bean了，下面结合IoC和DI，整合2个常用技术，进一步加深对Spring的使用理解。

## 1)Spring整合Mybatis思路分析 ##

### (1)非注解开发 ###

![在这里插入图片描述][121475764ab04a68b562ba43986fe7fb.png]

#### 环境准备 ####

在准备环境的过程中，我们也来回顾下Mybatis开发的相关内容:

##### 步骤1:准备数据库表 #####

Mybatis是来操作数据库表，所以先创建一个数据库及表

create database spring_db character set utf8;
    use spring_db;
    create table tbl_account(
        id int primary key auto_increment,
        name varchar(35),
        money double
    );

##### 步骤2:创建项目导入jar包 #####

项目的pom.xml添加相关依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
    </dependencies>

##### 步骤3:根据表创建模型类 #####

public class Account implements Serializable {
        
    
        private Integer id;
        private String name;
        private Double money;
    
        public Integer getId() {
        
            return id;
        }
    
        public void setId(Integer id) {
        
            this.id = id;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public Double getMoney() {
        
            return money;
        }
    
        public void setMoney(Double money) {
        
            this.money = money;
        }
    
        @Override
        public String toString() {
        
            return "Account{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", money=" + money +
                    '}';
        }
    }

##### 步骤4:创建Dao接口 #####

public interface AccountDao {
        
    
        @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
        void save(Account account);
    
        @Delete("delete from tbl_account where id = #{id} ")
        void delete(Integer id);
    
        @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
        void update(Account account);
    
        @Select("select * from tbl_account")
        List<Account> findAll();
    
        @Select("select * from tbl_account where id = #{id} ")
        Account findById(Integer id);
    }

##### 步骤5:创建Service接口和实现类 #####

public interface AccountService {
        
    
        void save(Account account);
    
        void delete(Integer id);
    
        void update(Account account);
    
        List<Account> findAll();
    
        Account findById(Integer id);
    
    }
    
    @Service
    public class AccountServiceImpl implements AccountService {
        
    
        @Autowired
        private AccountDao accountDao;
    
        public void save(Account account) {
        
            accountDao.save(account);
        }
    
        public void update(Account account){
        
            accountDao.update(account);
        }
    
        public void delete(Integer id) {
        
            accountDao.delete(id);
        }
    
        public Account findById(Integer id) {
        
            return accountDao.findById(id);
        }
    
        public List<Account> findAll() {
        
            return accountDao.findAll();
        }
    }

##### 步骤6:添加jdbc.properties文件 #####

resources目录下添加，用于配置数据库连接四要素

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
    jdbc.username=root
    jdbc.password=root

useSSL:关闭MySQL的SSL连接

##### 步骤7:添加Mybatis核心配置文件 #####

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        
        <properties resource="jdbc.properties"></properties>
        
        <typeAliases>
            <package name="com.amy.domain"/>
        </typeAliases>
        
        <environments default="mysql">
            <environment id="mysql">
                <transactionManager type="JDBC"></transactionManager>
                <dataSource type="POOLED">
                    <property name="driver" value="${jdbc.driver}"></property>
                    <property name="url" value="${jdbc.url}"></property>
                    <property name="username" value="${jdbc.username}"></property>
                    <property name="password" value="${jdbc.password}"></property>
                </dataSource>
            </environment>
        </environments>
        
        <mappers>
            <package name="com.amy.dao"></package>
        </mappers>
    </configuration>

##### 步骤8:编写应用程序 #####

public class App {
        
        public static void main(String[] args) throws IOException {
        
            // 1. 创建SqlSessionFactoryBuilder对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            // 2. 加载SqlMapConfig.xml配置文件
            InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
            // 3. 创建SqlSessionFactory对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
            // 4. 获取SqlSession
            SqlSession sqlSession = sqlSessionFactory.openSession();
            // 5. 执行SqlSession对象执行查询，获取结果User
            AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
    
            Account ac = accountDao.findById(1);
            System.out.println(ac);
    
            // 6. 释放资源
            sqlSession.close();
        }
    }

##### 步骤9:运行程序 #####

Account{
        id=2, name='Jerry', money=500.0}

#### 整合思路分析 ####

![在这里插入图片描述][a6eec5aa67063d3fadafef0da18990e9.png_pic_center]

Mybatis的基础环境我们已经准备好了，接下来就得分析下在上述的内容中，哪些对象可以交给Spring来管理?

*  Mybatis程序核心对象分析

![在这里插入图片描述][9fc2514370864bd69f5a7e3c24e83f7b.png]

从图中可以获取到，真正需要交给Spring管理的是SqlSessionFactory

*  整合Mybatis，就是将Mybatis用到的内容交给Spring管理，分析下配置文件

![在这里插入图片描述][3e48454db22d441a88cecc6de1492630.png]

**说明:**

*  第一行`读取外部properties配置文件`，Spring有提供具体的解决方案`@PropertySource`,需要交给Spring
 *  第二行`起别名包扫描`，`为SqlSessionFactory服务的`，需要交给Spring
 *  第三行主要用于做`连接池`，Spring之前我们已经`整合了Druid连接池`，这块也需要交给Spring
 *  前面三行一起都是为了`创建SqlSession对象`用的，那么用Spring管理SqlSession对象吗?回忆下`SqlSession是由SqlSessionFactory创`建出来的，所以只需要将`SqlSessionFactory交给Spring管理`即可。
 *  第四行是`Mapper接口和映射文件[如果使用注解就没有该映射文件]`，这个是在获取到SqlSession以后执行具体操作的时候用，所以它和SqlSessionFactory创建的时机都不在同一个时间，可能需要单独管理。

### (2)注解开发 ###

前面我们已经分析了Spring与Mybatis的整合，大体需要做两件事，

`第一件事是:Spring要管理MyBatis中的SqlSessionFactory`

`第二件事是:Spring要管理Mapper接口的扫描`

具体该如何实现，具体的步骤为:

#### 步骤1:项目中导入整合需要的jar包 ####

<dependency>
        
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>
    <dependency>
        
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.0</version>
    </dependency>

#### 步骤2:创建Spring的主配置类 ####

//配置类注解
    @Configuration
    //包扫描，主要扫描的是项目中的AccountServiceImpl类
    @ComponentScan("com.amy")
    public class SpringConfig {
        
    }

#### 步骤3:创建数据源的配置类 ####

在配置类中完成数据源的创建

public class JdbcConfig {
        
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String userName;
        @Value("${jdbc.password}")
        private String password;
    
        @Bean
        public DataSource dataSource(){
        
            DruidDataSource ds = new DruidDataSource();
            ds.setDriverClassName(driver);
            ds.setUrl(url);
            ds.setUsername(userName);
            ds.setPassword(password);
            return ds;
        }
    }

#### 步骤4:主配置类中读properties并引入数据源配置类 ####

@Configuration
    @ComponentScan("com.amy")
    @PropertySource("classpath:jdbc.properties")
    @Import(JdbcConfig.class)
    public class SpringConfig {
        
    }

#### 步骤5:创建Mybatis配置类并配置SqlSessionFactory ####

public class MybatisConfig {
        
        //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
        @Bean
        public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        
            SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
            //设置模型类的别名扫描
            ssfb.setTypeAliasesPackage("com.amy.domain");
            //设置数据源
            ssfb.setDataSource(dataSource);
            return ssfb;
        }
        //定义bean，返回MapperScannerConfigurer对象
        @Bean
        public MapperScannerConfigurer mapperScannerConfigurer(){
        
            MapperScannerConfigurer msc = new MapperScannerConfigurer();
            msc.setBasePackage("com.amy.dao");
            return msc;
        }
    }

**说明:**

1.使用`SqlSessionFactoryBean`封装`SqlSessionFactory`需要的环境信息

![在这里插入图片描述][0b50d112337e47d29d94bbd178272f40.png]

*  `SqlSessionFactoryBean`是前面我们讲解`FactoryBean`的一个`子类`，在该类中将`SqlSessionFactory的创建进行了封装，简化对象的创建`，我们只需要将其需要的内容设置即可。
 *  方法中有一个参数为`dataSource`,当前Spring容器中`已经创建了Druid数据源，类型刚好是DataSource类型`，此时在初始化SqlSessionFactoryBean这个对象的时候，发现需要使用DataSource对象，而容器中刚好有这么一个对象，就`自动加载了DruidDataSource对象`。

2.使用`MapperScannerConfigurer`加载`Dao接口`，`创建代理对象保存到IOC容器中`

![在这里插入图片描述][75e6000324f14d2eaf6cc008284f9d64.png]

*  这个`MapperScannerConfigurer`对象也是MyBatis提供的专用于整合的jar包中的类，用来`处理原始配置文件中的mappers相关配置`，`加载数据层的Mapper接口类`
 *  `MapperScannerConfigurer`有一个核心属性`basePackage`，就是用来`设置所扫描的包路径`

#### 步骤6:主配置类中引入Mybatis配置类 ####

@Configuration
    @ComponentScan("com.itheima")
    @PropertySource("classpath:jdbc.properties")
    @Import({
        JdbcConfig.class,MybatisConfig.class})
    public class SpringConfig {
        
    }

#### 步骤7:编写运行类 ####

在运行类中，·从IOC容器中获取Service对象·，调用方法获取结果

public class App2 {
        
        public static void main(String[] args) {
        
            ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
    
            AccountService accountService = ctx.getBean(AccountService.class);
    
            Account ac = accountService.findById(1);
            System.out.println(ac);
        }
    }

#### 步骤8:运行程序 ####

Account{
        id=1, name='Tom', money=1000.0}

支持Spring与Mybatis的整合就已经完成了，其中`主要用到的两个类`分别是:

*  SqlSessionFactoryBean
 *  MapperScannerConfigurer

## 2)Spring整合Junit ##

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

### (1)环境准备 ###

这块环境，大家可以直接使用Spring与Mybatis整合的环境即可。当然也可以重新创建一个，因为内容是一模一样，所以我们直接来看下项目结构即可:

![在这里插入图片描述][57687c9948b242e7adce68ee428fd594.png]

### (2) 整合Junit步骤 ###

在上述环境的基础上，我们来对Junit进行整合。

##### 步骤1:引入依赖 #####

pom.xml

<dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.2.10.RELEASE</version>
    </dependency>

##### 步骤2:编写测试类 #####

在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单元测试完全一样了

### 知识点1：@RunWith ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@RunWith</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>测试类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>测试类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置JUnit运行器</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>value（默认）：运行所使用的运行期</td> 
  </tr> 
 </tbody> 
</table>

### 知识点2：@ContextConfiguration ###

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>@ContextConfiguration</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>类型</td> 
   <td>测试类注解</td> 
  </tr> 
  <tr> 
   <td>位置</td> 
   <td>测试类定义上方</td> 
  </tr> 
  <tr> 
   <td>作用</td> 
   <td>设置JUnit加载的Spring核心配置</td> 
  </tr> 
  <tr> 
   <td>属性</td> 
   <td>classes：核心配置类，可以使用数组的格式设定加载多个配置类<br>locations:配置文件，可以使用数组的格式设定加载多个配置文件名称</td> 
  </tr> 
 </tbody> 
</table>

[06e1d041a68544d6a94c8196faedabbb.png]: https://img-blog.csdnimg.cn/06e1d041a68544d6a94c8196faedabbb.png
[a82abafc6fc243939822ee1fe53b2542.png]: https://img-blog.csdnimg.cn/a82abafc6fc243939822ee1fe53b2542.png
[df9e65331bd44973bc0095be4655cb3e.png]: https://img-blog.csdnimg.cn/df9e65331bd44973bc0095be4655cb3e.png
[7295299c45a54b00a891be3446720023.png]: https://img-blog.csdnimg.cn/7295299c45a54b00a891be3446720023.png
[9386de79bcf641c2a77d4568ee40bb30.png]: https://img-blog.csdnimg.cn/9386de79bcf641c2a77d4568ee40bb30.png
[31d3126d0b7b42c2a85f4e8743bcd23b.png]: https://img-blog.csdnimg.cn/31d3126d0b7b42c2a85f4e8743bcd23b.png
[25c041a81a1046bb9a9de1eb910c2c64.png]: https://img-blog.csdnimg.cn/25c041a81a1046bb9a9de1eb910c2c64.png
[3e34cd3a8c1145c1818ad506cf466007.png]: https://img-blog.csdnimg.cn/3e34cd3a8c1145c1818ad506cf466007.png
[f4e3d2dd0e8544b9921e4f00cc136bb4.png]: https://img-blog.csdnimg.cn/f4e3d2dd0e8544b9921e4f00cc136bb4.png
[a2f05021bb2e4a6d8ad0e7fdba474619.png]: https://img-blog.csdnimg.cn/a2f05021bb2e4a6d8ad0e7fdba474619.png
[398d7d46a19b41d79b640dcf28333348.png]: https://img-blog.csdnimg.cn/398d7d46a19b41d79b640dcf28333348.png
[080904a076cc4170a17e5f0f6286d1b7.png]: https://img-blog.csdnimg.cn/080904a076cc4170a17e5f0f6286d1b7.png
[121475764ab04a68b562ba43986fe7fb.png]: https://img-blog.csdnimg.cn/121475764ab04a68b562ba43986fe7fb.png
[a6eec5aa67063d3fadafef0da18990e9.png_pic_center]: https://img-blog.csdnimg.cn/img_convert/a6eec5aa67063d3fadafef0da18990e9.png#pic_center
[9fc2514370864bd69f5a7e3c24e83f7b.png]: https://img-blog.csdnimg.cn/9fc2514370864bd69f5a7e3c24e83f7b.png
[3e48454db22d441a88cecc6de1492630.png]: https://img-blog.csdnimg.cn/3e48454db22d441a88cecc6de1492630.png
[0b50d112337e47d29d94bbd178272f40.png]: https://img-blog.csdnimg.cn/0b50d112337e47d29d94bbd178272f40.png
[75e6000324f14d2eaf6cc008284f9d64.png]: https://img-blog.csdnimg.cn/75e6000324f14d2eaf6cc008284f9d64.png
[57687c9948b242e7adce68ee428fd594.png]: https://img-blog.csdnimg.cn/57687c9948b242e7adce68ee428fd594.png