文章目录

一、Spring概述

1.1、Spring概述
1.2、Spring体系结构

二、IoC控制反转

2.1、什么是IoC？
2.2、spring基于XML的IOC环境搭建和入门
2.3、spring对Bean对象的管理细节

2.3.1、创建Bean对象的三种方式
2.3.2、Bean对象的使用范围
2.3.3、Bean对象的生命周期

三、spring的依赖注入

3.1、依赖注入概念
3.2、依赖注入三种基本类型

3.2.1、构造函数注入
3.2.2、set方法注入
3.2.3、复杂类型/集合类型注入

四、spring在IOC的常用注解

4.1、用于创建对象的注解

4.1.1、@Component注解
4.1.2、@Controller、@Service、@Repository注解

4.2、用于注入数据的

4.2.1、@Autowired注解
4.2.2、@Qualifier注解
4.2.3、@Resource注解
4.2.4、@Value注解

4.3、作用范围注解
4.4、生命周期相关注解

一、Spring概述

1.1、Spring概述

Spring是分层的java SE/EE应用full—stack（全栈式）轻量级开源框架，以IOC（反转控制）和AOP（面向切面编程）两个核心，使用Spring开发可以将Bean对象，Dao组件对象，Service组件对象等交给Spring容器来管理，这样使得很多复杂的代码在Spring中开发却变得非常的优雅和简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。提供了展现层MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术

控制反转思想（用容器来进行类之间的联系）、面向切面编程思想（采用了设计模式中的动态代理模式）。它能使得我们可以很好的书写遵守开闭原则的软件代码，轻松面对需求的变更。

Spring是一个IOC(DI)和AOP容器框架
在这里插入图片描述

那么啥是IoC？啥是AOP呢？

我们知道在设计模式中，有个很重要的指导性思想叫开闭原则，亦称OCP原则：对扩展开放，对修改闭合。
啥意思呢？假设我们开发了一套管理系统，每收到一笔订单后，系统调用message.notify(Sender)给客户发送订单成功邮件（Sender是发送器类）。有天老板（也有可能是产品）突然要改个需求：将原来的向客户发送邮件改为发手机短信。你无需改动任何代码，只是在配置中将“发送器Sender”改成手机，就完成了工作。这里将发送器Sender作为参数传给message.notify方法，就是IoC(控制反转:Inverse of Control)。因为Sender不是在message.notify方法内生产的，而是在外部创建好，然后注入给message.notify方法使用的，这个过程中对Sender类的控制权移到了外部，因此叫控制反转。
过了几天，老板觉得收到订单后，除了要给客户发送通知外，还要扩展一个功能：给自己再发个通知（假设通知格式、内容不同于发给客户的）。这时本着OCP原则，我们不改动原有的任何代码，只需写新的通知功能的实现代码，然后装配到原来的程序上去就完成了。如果老板过几天说这功能不要了，那么你也可以很轻松的卸载下来。在发通知这个事情上，我们可以根据需要增加、删除任何事件，而不需要改动原有的程序，这就是AOP（Aspect Oriented Programming的缩写,意为:面向切面编程）。随着后面文章的深入，会专门对AOP做讲解，现在先了解一下就好。

上面说的Ioc，AOP这些方法，在没有spring的时侯，其实我们也能自己通过代码做到。现在有了spring，我们可以更轻松快捷做到以上的事情。

spring的优良特性

[1]非侵入式：基于Spring开发的应用中的对象可以不依赖于Spring的API

[2]控制反转：IOC——Inversion of Control，指的是将对象的创建权交给Spring去创建。使用Spring之前，对象的创建都是由我们自己在代码中new创建。而使用Spring之后。对象的创建都是由给了Spring框架。

[3]依赖注入：DI——Dependency Injection，是指依赖的对象不需要手动调用setXX方法去设置，而是通过配置赋值。

[4]面向切面编程：Aspect Oriented Programming——AOP

[5]容器：Spring是一个容器，因为它包含并且管理应用对象的生命周期

[6]组件化：Spring实现了使用简单的组件配置组合成一个复杂的应用。在 Spring 中可以使用XML和Java注解组合这些对象。

[7]一站式：在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上Spring 自身也提供了表述层的SpringMVC和持久层的Spring JDBC）

1.2、Spring体系结构

在这里插入图片描述
Spring框架分为四大模块：
Core核心模块。负责管理组件的Bean对象

spring-beans-4.0.0.RELEASE.jar

spring-context-4.0.0.RELEASE.jar

spring-core-4.0.0.RELEASE.jar

spring-expression-4.0.0.RELEASE.jar

面向切面编程

spring-aop-4.0.0.RELEASE.jar

spring-aspects-4.0.0.RELEASE.jar

数据库操作

spring-jdbc-4.0.0.RELEASE.jar

spring-orm-4.0.0.RELEASE.jar

spring-oxm-4.0.0.RELEASE.jar

spring-tx-4.0.0.RELEASE.jar

spring-jms-4.0.0.RELEASE.jar

Web模块

spring-web-4.0.0.RELEASE.jar

spring-webmvc-4.0.0.RELEASE.jar

spring-websocket-4.0.0.RELEASE.jar

spring-webmvc-portlet-4.0.0.RELEASE.jar

在Web应用程序应用场景中，典型的三层架构：数据模型层实现域对象；数据访问层实现数据访问；逻辑层实现业务逻辑；web层提供页面展示；所有这些层组件都由Spring进行管理，享受到Spring事务管理、AOP等好处，而且请求唯一入口就是DispachterServlet，它通过把请求映射为相应web层组件来实现相应请求功能。

二、IoC控制反转

2.1、什么是IoC？

控制反转思想（用容器来进行类之间的联系）。把对象创建的权利交>给框架或工厂，由框架或工程来控制创建对象的控制权。并非面向对象编程，是框架的重要特征。

程序耦合：就是程序与程序之间的依赖关系，例如：（类与类之依赖，方法与方法依赖等）。程序依赖关系越强，程序灵活机制越差，代码越臃肿。编码提倡高内聚，低耦合和的原则。

程序解耦：降低程序与程序之间的依赖关系。

通过代码解释IoC思想：
未使用spring之前的程序代码，我们的controller层调用service层或service层调用dao层的接口，必须得new一个对象。不创建对象则代码无法通过编译期。而且每次调用都得创建一个对象，也就是该对象是非单列对象。如下：

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {
    //面向对象创建思想，创建什么对象及何时创建的控制权由自身决定。
        IAccountService as = new AccountServiceImpl();
            as.saveAccount();
        }
    }
}

/**
 * service层：账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
   //面向对象创建思想，创建什么对象及何时创建的控制权由自身决定。
    private IAccountDao accountDao = new AccountDaoImpl();    
    public void  saveAccount(){
        accountDao.saveAccount();
    }
}

这种做法增加了类与类之间、层与层之间的耦合性。

问：要解决怎么代码耦合问题我们该怎么做呢？
答：（1）需要一个配置文件（xml 或 properties）来配置service和Dao
配置Bean类要求唯一：唯一表示 = 全类名的方式（也就搜key =value的方式）
（2）通过读取配置文件内容，采用反射机制来创建对象

步骤：
1、新建一个bean.properties配置文件，里面分别存储Service和Dao层的实现类对象：

##采用key、value的形式。 对象=类名
accountService=com.service.Impl.AccountServiceImp
accountDao=com.Dao.Impl.AccountDaoImp

2、创建一个Bean工厂类来读取配置文件，不断的生产Bean对象：

package com.factory;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
/**
 * 一个创建Bean对象的工厂
 *
 * Bean：在计算机英语中，有可重用组件的含义。
 * JavaBean：用java语言编写的可重用组件。
 *      javabean >  实体类
 *
 *   它就是创建我们的service和dao对象的。
 *
 *   第一个：需要一个配置文件来配置我们的service和dao
 *           配置的内容：唯一标识=全限定类名（key=value)
 *   第二个：通过读取配置文件中配置的内容，反射创建对象
 *
 *   我的配置文件可以是xml也可以是properties
 */
public class BeanFactory {
    //定义一个Properties对象
    private static Properties props;

    //定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
    //使用这个容器解决对象非单列问题
    private static Map<String,Object> beans;

    //使用静态代码块为Properties对象赋值
    static {
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch(Exception e){
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }

    /**
     * 根据bean的名称获取对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }
}

3、修改controller层调用Service层的代码：

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {
        //IAccountService as = new AccountServiceImpl();
        
        for(int i=0;i<5;i++) {//可以生产多个Bean对象
           //创建什么对象及何时创建的控制权由工厂决定。
            IAccountService as = (IAccountService) BeanFactory.getBean("accountService");
            System.out.println(as);
            as.saveAccount();
        }
    }
}

4、修改service层调用Dao层的代码：

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
//  private IAccountDao accountDao = new AccountDaoImpl();

    private IAccountDao accountDao = (IAccountDao)BeanFactory.getBean("accountDao");

    public void  saveAccount(){
        int i = 1;
        accountDao.saveAccount();
        System.out.println(i);
        i++;
    }
}

未使用Ioc思想的程序：
在这里插入图片描述
使用IoC思想的程序：

总结：
以上方法解决了两个问题：
（1）IoC主要就是解决程序之间的耦合关系。通过读取配置文件，利用工厂模式和反射的方式来创建对象，以此来降低代码的耦合，减少程序之间依赖。

（2）将每次调用Service层和Dao层接口都需要创建不同的对象修改成了单列模式。避免了多线程访问的时候出现线程安全问题

2.2、spring基于XML的IOC环境搭建和入门

如何使用Spring解决程序耦合问题？下面通过spring入门案例来演示。

步骤：
1、创建“账户”数据表：

create table account(
	id int primary key auto_increment,
	name varchar(16),
	money float
)character set utf8 collate utf8_general_ci;

insert into account(name,money) values('张三',1007);
insert into account(name,money) values('李四',1000);
insert into account(name,money) values('王五',1020);

在这里插入图片描述

2、不使用骨架，创建一个Maven项目，并创建好文件夹：
在这里插入图片描述
分别写入java文件：

package com.it.ui;

import com.it.service.IAccountService;
import com.it.service.impl.AccountServiceImpl;
/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
    public static void main(String[] args) {

        IAccountService accountService = new AccountServiceImpl();
        accountService.saveAccount();

    }
}

service：
在这里插入图片描述

package com.it.service;
/**
 * 账户业务层的接口
 */
public interface IAccountService {

    /**
     * 模拟保存账户
     */
    void saveAccount();
}

在这里插入图片描述

package com.it.service.impl;
import com.it.dao.IAccountDao;
import com.it.service.IAccountService;
/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao ;

    public AccountServiceImpl(){
        System.out.println("对象创建了");
    }

    public void  saveAccount(){
        accountDao.saveAccount();
    }
}

Dao：
在这里插入图片描述

package com.it.dao;
/**
 * 账户的持久层接口
 */
public interface IAccountDao {

    /**
     * 模拟保存账户
     */
    void saveAccount();
}

在这里插入图片描述

package com.it.dao.impl;
import com.it.dao.IAccountDao;
/**
 * 账户的持久层实现类
 */
public class AccountDaoImpl implements IAccountDao {

    public  void saveAccount(){
        System.out.println("保存了账户");
    }
}

3、导入spring-context jar包：
在这里插入图片描述
发现：

导入spring-context之后查看spring-context项目依赖关系：

发现此时的项目依赖就是Spring核心容易必备组件的jar包。

4、创建一个非中文名的配置文件，此处我们用xml作为配置文件：
在这里插入图片描述
在该文件中导入spring约束和把创建对象的工作交给Spring来管理（也是通过key=value的方式）：

<?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">

    <!--把对象的创建交给spring来管理-->
    <bean id="accountService" class="com.it.service.impl.AccountServiceImpl"></bean>

    <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl"></bean>
</beans>

5、获取Spring核心容器，并根据唯一id获取对象：

首先我们先了解一下Spring中类工厂结构图：
在这里插入图片描述
从上我们发现，想要获取核心容器对象，我们需要使用实现类，获取核心容易的方式有三种：
* ApplicationContext的三个常用实现类：
* ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)
*
* FileSystemXmlApplicationContext：它可以加载磁盘任意路径下的配置文件(前提该磁盘必须有访问权限）
*
* AnnotationConfigApplicationContext：它是用于读取注解创建容器的，是明天的内容。

 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

接下来我们先使用第一种来演示：
在这里插入图片描述

总结：
（1）将创建对象和将对象存入容器中的工作交给Spring来做
（2）我们主要的做就是将配置信息存入配置文件，获取Spring容器对象，并根据Id从核心容器中取出对象。
（3）获取容器的方式有三种，常用的是：
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
如果使用第二种：
ApplicationContext ac = new FileSystemXmlApplicationContext("D:\\zhy\\bean.xml");
第三种明天讲。

此外在核心容器接口（ApplicationContent）中发现了还有一个子容器接口BeanFactory，那么区别是什么呢？：
在这里插入图片描述
答案：

1、 ApplicationContext: 单例对象适用。它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。
2、BeanFactory: 多例对象使用。它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。

如果使用BeanFactory容器，可以使用下面代码段：

 //--------BeanFactory----------
 Resource resource = new ClassPathResource("bean.xml");
 BeanFactory factory = new XmlBeanFactory(resource);
 IAccountService as  = (IAccountService)factory.getBean("accountService");
 System.out.println(as);

当然，Spring是一个智能的容器，可以根据实际情况来分别使用不同的容器策略，接下来我们就会将一下。

2.3、spring对Bean对象的管理细节

2.3.1、创建Bean对象的三种方式

方式一：使用默认构造函数创建

解释：在spring配置文件中使用<bean>标签，配以id和class属性之后，且没有其他属性和标签时，采用的就是默认构造器创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。

修改AccountServiceImpl的无参构造修改成有参构造：
在这里插入图片描述

修改Client代码并执行程序：
在这里插入图片描述
结果： 由于不存在空构造函数，所以实例化对象失败

结论：当在配置文件中写如下配置
<bean id="accountService" class="com.it.service.impl.AccountServiceImpl"></bean>
在没有其他属性出场，没有其他标签出场的时候，创建Bean对象找的是类中的无参构造函数。如果没有则不能创建对象。

场景：在实际开发中使用到别人的jar包，可能会调用到一些别人写好的类，且是字节码文件无法修改，在别人写好的类里面如果没有创建空构造函数，但是有创建对象的方法，该怎么办呢？下面说一下方式二

方式二：使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）
1、新建一个工厂包和工程类，此包和类用来模拟调用jar包中获取对象的方法：
在这里插入图片描述

2、修改配置文件，配置文件第二种配置方式：
在这里插入图片描述
3、执行测试：

结果：

结论：如果想要调用到一个jar包中的某个方法来获取对象，且这个类中没有无参构造函数，那么可以使用方法二来配置

场景：如果调用到外部jar包中的类中没有无参数构造，只提供一个>静态方法来获取对象，那么此时又改怎么做的？

方式三：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器

1、新建一个静态工程类类进行模拟：
在这里插入图片描述

2、第三种配置方式来配置xml：

 <!-- 第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器) -->
<bean id="accountService" class="com.it.factory.StaticFactory" factory-method="getAccountService"></bean>

结果能成功。

总结：如果想要调用到一个jar包中的某个类的方法来获取对象，且这个类中没有无参构造函数，只有静态方法，那么可以使用方法三的配置
来调用静态方法创建Bean对象。

2.3.2、Bean对象的使用范围

问题：spring容器多次创建一个的Bean对象，该对象会是单例的吗？
答案：YES

验证：（这里我们使用第一中Bean创建方式来验证）
在这里插入图片描述
结果：true

结论：spring的创建的Bean对象默认是单列的。

知识
bean的作用范围调整
bean标签的scope属性：
作用：用于指定bean的作用范围
取值：常用的就是单例的和多例的
singleton：单例的（默认值）
prototype：多例的
request：作用于web应用的请求范围
session：作用于web应用的会话范围
global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session
这里我们用一个服务器集群的图来说明global-session的范围

2.3.3、Bean对象的生命周期

知识
bean对象的生命周期
单例对象
出生：当容器创建时对象出生
活着：只要容器还在，对象一直活着
死亡：容器销毁，对象消亡
总结：单例对象的生命周期和容器相同
多例对象
出生：当我们使用对象时spring框架为我们创建
活着：对象只要是在使用过程中就一直活着。
死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收

单例对象生命周期测试：
1、在service实现类中新增两个方法：
在这里插入图片描述

2、修改Bean配置文件：
在这里插入图片描述

3、执行测试：
在这里插入图片描述
结果：

疑问：结果未执行Bean的销毁方法，为什么这样呢？
答案：main方法作为所有程序的入口，当程序执行完毕之后就释放了内存，此时还未等执行销毁方法程序就结束了。
将代码修改成这样即可：

多例对象生命周期测试：
在以上代码不修改的基础上，将配置文件中Bean对象的范围修改成多例：
在这里插入图片描述
此时再运行代码发现，虽然手动执行了关闭容器，但是还是不执行销毁的方法。

总结：spring框架是个很智能的框架，它可以通过感知到对象的作用范围是单例还是多例，从而来选择Bean对象的创建时机是立即还是延迟。

三、spring的依赖注入

3.1、依赖注入概念

依赖注入Dependency Injection。IOC的作用是降低程序间的耦合（依赖关系），而依赖关系的管理以后都交给spring来维护。在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明。依赖关系的维护就称之为依赖注入。

知识：
依赖注入能注入的数据有三类：
（1）基本类型和String
（2）其他bean类型（在配置文件中或者注解配置过的bean）
（3）复杂类型/集合类型

依赖注入注入的方式：有三种
第一种：使用构造函数提供
第二种：使用set方法提供
第三种：使用注解提供（明天的内容）

3.2、依赖注入三种基本类型

依赖注入的数据都是不经常变化的。如果经常变化的Bean不适合使用依赖注入。下面我们定义三种基本类型的数据来模拟依赖注入。

3.2.1、构造函数注入

方式一：构造函数注入

知识
构造函数注入：
使用的标签:constructor-arg
标签出现的位置：bean标签的内部
constructor-arg标签中的属性：
type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型。该属性一般不单独使用，如果一个构造函数里面出现两个String类型数据，那么无法判断给哪个参数赋值，所以一般需要配合index使用。

index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始。该无法判断参数类型。一般需要配合“Type”属性使用。
name：用于指定给构造函数中指定名称的参数赋值。（更推荐使用name属性来注入）
=以上三个用于指定给构造函数中哪个参数赋值===================
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过（已经配置过的）的bean对象
优势：
获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。（使用constructor-arg标签，不执行无参构造函数，只执行有参构造函数）
弊端：
改变了bean对象的实例化方式，如果用不到这些数据，也必须提供。（使用constructor-arg标签，不执行无参构造函数，只执行有参构造函数）

构造函数注入方式

1、选择一个类，定义三种不同类型的数据（数据类型才是重点），这里以修改service实现类为例子：

package com.it.service.impl;
import com.it.dao.IAccountDao;
import com.it.service.IAccountService;
import java.util.Date;
/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService {
    //如果是经常变化的数据，并不适用于注入的方式
    private String name;  //String类型
    private Integer age;  //引用类型
    private Date birthday; //其他类型

    public AccountServiceImpl(String name,Integer age,Date birthday){
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
    }
}

2、给Bean.xml赋值，将值注入到有参数构造函数：在这里插入图片描述
3、运行测试：

结果：Date类型不能进行转化。因为在Bean中'1994-03-13'是，在配置文件中只是一个字符串，并不知道是一个Dete类型的。

4、由于Date类型无法正常注入，所以需要使用constructor-arg标签中的ref属性来进行引用，如下：
在这里插入图片描述
再测试运行即可解决问题。

总结：
使用constructor-arg标签，不执行无参构造函数，只执行有参构造函数。所以此时必须注入值。

3.2.2、set方法注入

方式二：set方法注入

知识
构造函数注入：
使用的标签:property
标签出现的位置：bean标签的内部
property标签中的属性：
name：用于指定给构造函数中指定名称的参数赋值。（更推荐使用name属性来注入）
=以上三个用于指定给构造函数中哪个参数赋值===================
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过（已经配置过的）的bean对象
优势：
创建对象时没有明确的限制，会直接使用默认（无参）构造函数。
弊端：
如果有某个成员必须有值，则获取对象是有可能set方法没有执行。

set注入方式步骤：
1、为了不覆盖构造注入方式，新创建一个类：
在这里插入图片描述
类中定义三个成员变量，一个无参构造函数，增加set方法：

2、修改Bean.xml文件为Set注入：
在这里插入图片描述

3、测试：
在这里插入图片描述

总结：
（1）Set注入方式与成员变量名无关，只与Set方法名称有关（自己去验证）
（2）Set注入默认会先执行无参构造函数，再执行Set方法

3.2.3、复杂类型/集合类型注入

集合类型注册实际上是选取构造函数注入或Set注入其中一种注入方式，将集合类型或其他类型进行注入。

选择Set方式注入复杂类型：
1、为了不覆盖以上两种方式，新建一个类，里面定义各种类型，并重写Set方法：
在这里插入图片描述

2、修改Bean.xml文件：

<bean id="accountService3" class="com.itheima.service.impl.AccountServiceImpl3">
       <property name="myStrs">
           <set>
               <value>AAA</value>
               <value>BBB</value>
               <value>CCC</value>
           </set>
       </property>

        <property name="myList">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>

        <property name="mySet">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>

        <property name="myMap">
            <props>
                <prop key="testC">ccc</prop>
                <prop key="testD">ddd</prop>
            </props>
        </property>

        <property name="myProps">
            <map>
                <entry key="testA" value="aaa"></entry>
                <entry key="testB">
                    <value>BBB</value>
                </entry>
            </map>
        </property>
    </bean>

总结：

复杂类型的注入/集合类型的注入：
用于给List结构集合注入的标签：list array set
用于个Map结构集合注入的标签：map props
结构相同，标签可以互换使用
也就是实际开发中需要区分是List结构还是Map结构即可

四、spring在IOC的常用注解

明确：SprinigIoC无论是xml配置和注解配置，要实现的功能都是一样的，都是要降低程序间的耦合，只是配置形式不一样。这章主要是将上一章的xml配置换成注解来讲。

准备工作：
1、新建一个Maven工程
在这里插入图片描述
2、导入Sprinig-context的jar包（Spring核心包），并在各个文件中准备代码：

bean.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">

    <!--把对象的创建交给spring来管理-->
    <bean id="accountService" class="com.it.service.impl.AccountServiceImpl"></bean>

    <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl"></bean>
</beans>

AccountDao：
在这里插入图片描述

AccountDaoImpl：
在这里插入图片描述

IAccountService：
在这里插入图片描述

IAccountServiceImpl：
在这里插入图片描述

Client：
在这里插入图片描述
准备完毕。

曾经XML的配置：

<bean id="accountService"
class="com.itheima.service.impl.AccountServiceImpl"
scope=""
init-method=""
destroy-method=""
<property name="" value="" ref="">
</property>
</bean>

现在我们需要使用注解来替代XML配置，其中注解的分类和xml的差不多，如图：
在这里插入图片描述

4.1、用于创建对象的注解

用于创建容器对象的注解：
他们的作用就和在XML配置文件中编写一个<bean>标签实现的功能是一样的
@Component：
作用：用于把当前类作为对象存入spring容器中
属性：
value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。
Controller：：一般用在表现层
Service：一般用在业务层
Repository：一般用在持久层
以上三个注解他们的作用和属性与Component是一模一样。
他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰

4.1.1、@Component注解

@Component注解用于创建Bean对象。被@Component注解的类将创建一个Bean对象，并存入的Spring容器中。

@Component：
作用：用于把当前类作为对象存入spring容器中
属性：
value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。

例子：
1、修改serviceImpl代码（暂时将ServiceImp作为Bean对象）：
在这里插入图片描述

2、告知Spring需要扫描的包，所以需要配置xml：
在这里插入图片描述
3、测试：

当然，也可以在注解上给Bean加上id，如：

此时获取Bean对象的时候就需要使用account

总结：
使用注解比XML的<Bean>方便的多，因为每个类创建一个bean对象都需要在XML中配置，但使用注解可以直接扫描整个包。具体使用xml还是注解看公司发展需要。

4.1.2、@Controller、@Service、@Repository注解

这三个注解的作用和@Component一模一样，都是用于创建Bean对象，区别在于：

Controller：：一般用在表现层
Service：一般用在业务层
Repository：一般用在持久层
以上三个注解他们的作用和属性与Component是一模一样。
他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰
也就是四个标签可以随便替换用，没有限制。为了代码方便维护，建议使用分层的标签。

4.2、用于注入数据的

4.2.1、@Autowired注解

用于注入数据的注解：
他们的作用就和在xml配置文件中的bean标签中写一个<property>标签的作用是一样的
Autowired:：
作用：自动按照类型注入。只要容器中有唯一的一个bean对象类型（子类和实现类都可以）和要注入的变量类型匹配，就可以注入成功；
如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错；
如果Ioc容器中有多个类型匹配时：Autowired出现位置可以是变量上，也可以是方法上；

上述的例子中，如果我们直接执行代码中的saveAccount()方法，那么会报空指针异常。如图所示：
在这里插入图片描述
异常的原因是因为没有给AccountServiceImpl类中的成员变量accountDao对象赋值，accountDao为null。所以我们接下来要解决的就是给成员变量IAccountDao赋值：

此时再运行测试，发现：
在这里插入图片描述

问：什么原因导致的呢？
答：现在我们要注入的类型变量类型是IAccountDao，那么请问，此时Spring容器中有这类类型和他的子类型么？如果Spring容器中没有这个类型，我们又从哪里拿值注入？所以我们需要先将IAccountDao的子类注入到容器中，才能解决才问题。

注入IAccountDaoImpl：
在这里插入图片描述

此时再来运行则没问题：
在这里插入图片描述

以上分别说了容器里面不存在Bean对象时使用注入数据、和容器里面存在一个Bean对象时注入数据的情况。那要是Spring容器中存在多个Bean类型的数据，会怎么样呢？下面我们通过原理图说明：
在这里插入图片描述

总结：
如果在容器中存在多个Bean对象，此时多个变量Bean对象的id和已注入数据的变量名不一致，此时也会报错。这为开发人员增加了限制。那么怎么解决这个问题呢？下面我们来说一下

4.2.2、@Qualifier注解

知识：
Qualifier
作用：在按照类中注入的基础之上再按照类名称注入。它在给类成员注入时不能单独使用，但是在给方法参数注入时可以。
value：用于指定注入Bean的ID。

Qualifier不能单独使用，需要配合@Autowired一起使用
例如：当Spring容器中存在两个Bean对象的时候：

1、新建一个Dao实现类：
在这里插入图片描述
代码中注解分别为dao1和dao2：

在这里插入图片描述

2、serviceImple中使用@Autowired注入Bean：
在这里插入图片描述

问题：此时运行代码会调用的值是Spring容器中的dao1还是dao2：
答案：都不会调用。在srping容器中有两个Bean，首先会根据类型去找，能找到dao1和dao2，其次会再根据定义的变量名称去找：

由于变量名称是accountDao，而不是dao1或dao2。所以此时注入失败。想要注入成功，有以下两种解决方案：
（1）将变量名修改成dao1或者dao2

（2）配合@Qualifier注解指定注入dao1还是dao2

总结：
1、注解@Qualifier不能单独使用，需要配合@Autowired一起使用。
可理解为注解@Autowired不能定义定义指定注入哪个Bean对象，没有value属性，如果需要指明调用注入哪个Bean对象，需要使用@Qualifier来指明。
2、@Qualifier的作用就是为指明注入Bean对象，所以它一般存在于容器中存在多个同类型或子类型的Bean对象的情况。

4.2.3、@Resource注解

@Resource
作用：直接按照bean的id注入。它可以独立使用。
属性：
name：用于指定bean的id，也就是一个@Resource可以顶@Autowired和@Qualifier同时使用。

例如：
在这里插入图片描述

4.2.4、@Value注解

总结：：
以上三个注入数据都只能注入其他类型的数据，而对于基本类型和String类型无法使用上述注解实现。另外，集合类型的注入只能通过XML的方式来实现。

知识：
@Value
作用：用于注入基本类型和String类型的数据。该注解的作用是将我们配置文件的属性读出来，有@Value(“${}”)和@Value(“#{}”)两种方式，区别之后介绍，先不多说上图感受

属性：
value：用于指定数据的值。它可以使用spring中SqEL（也就是spring的el表达式）
写SqEL写法：${表达式}

具体怎么使用，参考帖子：
https://blog.csdn.net/woheniccc/article/details/79804600