IOC 容器

1.什么是 IOC

（1）控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理
（2）使用 IOC 目的，为了耦合度降低
（3）做入门案例就是耦合度的实现
2.IOC 底层原理
（1）xml 解析、工厂模式、反射
3.IOC 底层原理图解
「IOC 过程」「IOC 接口」
1.IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂
2.Spring 提供 IOC 容器实现两种方式：（两个接口）
（1）BeanFactory:IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用
★ 加载配置文件时 BeanFactory 是延迟加载，举个例子：如果 Bean 没有完全注入，BeanFactory 加载后，会在你第一次调用 getBean 方法才会抛出异常
（2）ApplicationContext ：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用
★加载配置配置文件时候就会把在配置文件的对象进行创建
（3）ApplicationContext有实现类「IOC操作bean管理」
1.什么是Bean管理
Bean管理指的是两个操作
（1）Spring创建对象
（2）Spring注入属性
2.Bean管理操作有两种方式
（1）基于xml配置文件方式实现
（2）基于注解方式实现
「IOC操作Bean管理（基于xml方式）」
1.基于xml方式创建对象

<!--配置User对象创建-->
<bean id="user" class="com.atguigu.spring5.User"></bean>

（1）在Spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建
（2）在bean标签有很多常用属性，常用属性介绍

bean 标签：通过配置 bean 标签告诉 IOC 容器需要创建对象的组件是什么
id 属性：bean 的唯一标识
class 属性：组件类的全类名（包类路径）

（3）创建对象时候默认也是执行无参数构造方法完成对象创建
2.基于xml方式注入属性
（1）DI:依赖注入，就是注入属性
3.第一种注入方式：使用set方法进行注入
（1）创建类，定义属性和对应的set方法

public class Book {
    //创建属性
    private String bname;
    private String bauthor;
    //set方式注入
    public void setBname(String bname) {
        this.bname = bname;
    }

    public void setBauthor(String bauthor) {
            this.bauthor = bauthor;
    }
}

（2）在spring配置文件中，配置对象创建，配置属性注入

  <!--2.set方法注入属性-->
    <bean id="user" class="com.atguigu.spring5.Book">
        <!--
        使用property完成属性注入
        name:类里面属性名称
        value:向属性注入的值
        -->
        <property name="bname" value="易筋经"></property>
        <property name="bauthor" value="达摩老祖"></property>
    </bean>

4.第二种方式：使用有参数构造进行注入
（1）创建类，定义属性，创建属性对应有参数构造方法

public class Orders {
    //属性
    private String oname;
    private String address;
    //有参数构造
    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

（2）在Spring配置文件中进行配置

 <!--3.有参数构造注入属性-->
 <bean id="orders" class="com.atguigu.spring5.Orders">
   <constructor-arg name="oname" value="电脑"/>
   <constructor-arg name="address" value="China"/>
 </bean>

5.p 名称空间注入
（1）使用p名称空间注入，可以简化基于xml的配置方式

第一步：添加p名称空间在配置文件中
第二步：进行属性注入，在bean标签里进行操作

<!--4.p名称空间注入属性-->
  <bean id="book" class="com.atguigu.spring5.Book" p:bname="九阳神功" p:bauthor="无名氏">
  </bean>

「IOC操作Bean管理（xml注入其他类型属性）」
1.字面量
（1）null值

<property name="address">
   <null/>
</property>

（2）属性值包含特殊符号

<!--
    属性值包含特殊符号
    1. 把<>进行转义&lt ,&gt
    2. 把带特殊符号内容写到CDATA中
-->
    <property name="address">
        <value><![CDATA[<<南京>>]]>
        </value>
    </property>

2.注入属性-外部bean
（1）创建两个类service类和dao类
（2）service调用dao里面的方法
（3）在spring配置文件中进行配置

 <!--service和dao对象创建-->
<bean id="userService" class="com.atguigu.spring5.service.UserService">
    <!--
    注入userDao对象
    name属性值：类里面属性名称
    ref属性：创建userDao对象bean标签id值
    -->
  <property name="userDao" ref="userDaoImpl"></property>
 </bean>
 <bean id="userDaoImpl" class="com.atguigu.spring5.dao.UserDaoImpl"></bean>

3.注入属性-内部bean和级联赋值
（1）一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门,部门是一，员工是多
（2）在实体类之间表示一对多关系,员工所属部门，使用对象类型属性进行

//部门类
public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }
}

//员工类
public class Emp {
    private String ename;
    private String gender;
    //员工属性某一个部门，使用对象形式表示
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

（3）在spring配置文件中进行配置

  <!--内部bean-->
  <bean id="emp" class="com.atguigu.spring5.bean.Emp">
      <!--设置两个普通属性-->
      <property name="ename" value="lucy"></property>
      <property name="gender" value="、女"></property>
      <!--设置对象属性类型-->
      <property name="dept" >
          <bean id="dept" class="com.atguigu.spring5.bean.Dept">
              <property name="dname" value="安保部"></property>
          </bean>
      </property>
  </bean>

4.注入属性-级联赋值
（1）第一种写法

<!--级联赋值-->
    <bean id="emp" class="com.atguigu.spring5.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!--设置对象属性类型-->
        <property name="dept" ref="dept" ></property>

    </bean>
    <bean id="dept" class="com.atguigu.spring5.bean.Dept">
        <property name="dname" value="财务部"></property>
    </bean>

（2）第二种写法

 //员工属性某一个部门，使用对象形式表示
    private Dept dept;
    //生成dept的get方法
    public Dept getDept() {
        return dept;
    }

<!--级联赋值-->
  <bean id="emp" class="com.atguigu.spring5.bean.Emp">
      <!--设置两个普通属性-->
      <property name="ename" value="lucy"></property>
      <property name="gender" value="女"></property>
      <!--设置对象属性类型-->
      <property name="dept" ref="dept" ></property>
      <property name="dept.dname" value="技术部" ></property>
  </bean>
  <bean id="dept" class="com.atguigu.spring5.bean.Dept">
  </bean>

「IOC操作Bean管理（xml注入集合属性）」
1.注入数组类型属性
2.注入List集合类型属性
3.注入Map集合类型属性
（1）创建类，定义数组、list、Map、set类型属性，生成对应set方法

public class Stu {
    //1.数组类型属性、
    private String[] courses;

    //2.list集合类型属性
    private List<String> list;

    //3.map集合类型属性
    private Map<String,String> maps;

    //4.set集合类型属性
    private Set<String> sets;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
}

（2）在Spring配置文件中进行配置

 <!--1.集合类型属性注入-->
  <bean id="stu" class="com.atguigu.spring5.collectiontype.Stu">
      <!--数组类型属性注入-->
      <property name="courses" >
          <array>
              <value>java课程</value>
              <value>数据库课程</value>
          </array>
      </property>
      <!--list类型属性注入-->
      <property name="list">
          <list>
              <value>张三</value>
              <value>小三</value>
          </list>
      </property>
      <!--map类型属性注入-->
      <property name="maps">
          <map>
              <entry key="JAVA" value="java"></entry>
              <entry key="PHP" value="php"></entry>
          </map>
      </property>
      <!--set类型属性注入-->
      <property name="sets">
          <set>
              <value>MySQL</value>
              <value>Redis</value>
          </set>
      </property>
  </bean>

4.在集合里面设置对象类型值

  <!--创建多个course对象-->
    <bean id="course1" class="com.atguigu.spring5.collectiontype.Course">
        <property name="cname" value="Spring框架"></property>
    </bean>
    <bean id="course2" class="com.atguigu.spring5.collectiontype.Course">
        <property name="cname" value="mybatis框架"></property>
    </bean>

 <!--list类型属性注入-->
<property name="courseList">
  <list>
    <ref bean="course1"></ref>
    <ref bean="course1"></ref>
  </list>
</property>

5.把集合注入部分提取出来
（1）在Spring配置文件中引入名称空间util

<?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:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

（2）使用util标签完成list集合注入提取
「IOC操作Ban管理（FactoryBean)」
1.Spring有两种bean,一种是普通bean，另外一种是工厂bean（FactoryBean）
2.普通bean:在配置文件中定义bean类型就是返回类型
3.工厂bean:在配置文件中定义bean类型可以和返回类型不一样
第一步:创建类，让这个类作为工厂bean,实现接口FactoryBean
第二步：实现接口里面的方法，在实现的方法中定义返回的bean类型

public class MyBean implements FactoryBean<Course> {
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }

    public Class<?> getObjectType() {
        return null;
    }

    public boolean isSingleton() {
        return false;
    }
}

<bean id="myBean" class="com.atguigu.spring5.factorybean.MyBean"></bean>

    @Test
    public void testCollection3(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Course course = context.getBean("myBean", Course.class);
        System.out.println(course);
    }

「IOC操作Ban管理（bean作用域）」
1.在Spring里面，设置创建bean实例是单实例还是多实例
2.在Spring里面，默认情况下，bean是单实例对象

3.如何设置是单实例还是多实例
（1）在Spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例
（2）scope属性值
第一个值默认值，singleton,表示是单实例对象
第一个值 prototype,表示是多实例对象
第三个值 request 了解
第四个值 session 了解

 <!--2.提取list集合类型属性注入使用-->
    <bean id="book" class="com.atguigu.spring5.collectiontype.Book" scope="prototype">
        <property name="list" ref="bookList"></property>
    </bean>

3.singleton和prototype的区别
第一 singleton是单实例，prototype多实例
第二设置scope值是singleton时候，加载spring配置文件时候就会创建单实例对象，设置scope值是prototype时候，不是在加载spring配置文件时候创建对象，在调用getBean方法时候创建多实例对象 /
「IOC操作Ban管理（bean生命周期）」
1.生命周期
（1）从对象创建到对象销毁的过程
2.bean生命周期
（1）通过构造器创建bean实例（无参数构造）
（2）为bean的属性设置值和对其他bean的引用（调用set方法）
（3）调用bean的初始化方法（需要进行配置bean的初始化方法）
（4）bean可以使用了（对象获取到了）
（5）当容器关闭时候，调用bean的销毁方法（需要进行配置bean的销毁方法）
3.演示bean的生命周期

public class Orders {
    //无参数构造
    public Orders() {
        System.out.println("第一步，执行无参数构造创建bean实例");
    }

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("调用set方法设置属性值");
    }

    //创建执行的初始化的方法
    public void initMethod(){
        System.out.println("第三步 执行初始化方法");
    }

    //创建执行的销毁的方法
    public void destroyMethod(){
        System.out.println("第五步 执行销毁方法");
    }
}

  <bean id="orders" class="com.atguigu.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="手机"></property>
    </bean>

  @Test
    public void testCollection4(){
//        ApplicationContext context =
//                new ClassPathXmlApplicationContext("applicationContext.xml");
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("获取创建bean实例对象");
        System.out.println(orders);
        //手动让bean实例销毁
        context.close();

4.bean的后置处理器，bean的生命周期有七步
（1）通过构造器创建bean实例（无参数构造）
（2）为bean的属性设置值和对其他bean的引用（调用set方法）
（3）把bean实例传递bean后置处理器方法postProcessBeforeInitialization
（4）调用bean的初始化方法（需要进行配置bean的初始化方法）
（5）把bean实例传递bean后置处理器方法postProcessAfterInitialization
（6）bean可以使用了（对象获取到了）
（7）当容器关闭时候，调用bean的销毁方法（需要进行配置bean的销毁方法）
5.演示添加后置处理器效果
（1）创建类，实现接口BeanPostProcessor,创建后置处理器

public class Orders {
    //无参数构造
    public Orders() {
        System.out.println("第一步，执行无参数构造创建bean实例");
    }

    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用set方法设置属性值");
    }

    //创建执行的初始化的方法
    public void initMethod(){
        System.out.println("第三步 执行初始化方法");
    }

    //创建执行的销毁的方法
    public void destroyMethod(){
        System.out.println("第五步 执行销毁方法");
    }
}

 <!--配置后置处理器-->
    <bean id="myBeanPost" class="com.atguigu.spring5.bean.MyBeanPost" ></bean>

「IOC操作Ban管理（xml自动装配）」
1.什么是自动装配
（1）根据指定装配规则（属性名称或者属性类型）Spring自动将匹配的属性值进行注入
2.演示自动装配

 <!--
    实现自动装配
    bean标签autowire，配置自动装配
    autowire属性常用两个值：
    byName根据属性名称注入，注入值bean的id值和类属性名称一样
    byType根据属性类型注入
    -->
    <bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName"></bean>

    <bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

「IOC操作Ban管理（外部属性文件）」
1.配置数据库信息
（1）配置德鲁伊连接池
（2）引入德鲁伊依赖
（2）引入外部属性文件配置数据库连接池
2.创建外部属性文件配置数据库连接池
（1）创建外部属性文件，properties格式文件，写数据库信息

jdbc.user=root
jdbc.password=root
jdbc.url=jdbc:mysql://localhost:3306/mybatis-example
jdbc.driver=com.mysql.jdbc.Driver

（2）把外部properties属性文件引入到spring配置文件中

引入Context名称空间

在spring中使用标签引用外部属性文件

 <!-- 引入外部属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--给bean的属性赋值,配置连接池 -->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="username" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

「IOC操作Ban管理（基于注解方式）」
1.什么是注解
（1）注解是代码的标记，格式：@注解名称（属性名称=属性值，属性名称=属性值..）
（2）使用注解，注解作用在类上面，方法上面，属性上面
（3）使用注解目的：简化xml配置
2.Spring针对Bean管理中创建对象提供注解
（1）@Conponent
（2）@Service
（3）@Controller
（4）@Repository
上面四个注解功能是一样的，都可以用来创建bean实例
3.基于注解方式实现对象创建
（1）引入依赖

  <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.1</version>
        </dependency>
        <!-- junit测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

（2）开启组件扫描

  <!-- 配置自动扫描的包 -->
    <!-- 开启组件扫描
        1.如果扫面多个包，多个包使用逗号隔开
        2.扫面包上层目录
    -->
    <context:component-scan base-package="com.atguigu"/>

（3）创建类，在类上面添加创建对象注解

//在注解里面value属性值可以省略不写
//默认值是类名称，首字母小写
//UserService--userService
@Component(value = "userService")//<bean id="userService" class=".."/>
public class UserService {
        public void add(){
            System.out.println("service add......");
        }
}

4.开启组件扫描细节配置

  <!-- 指定不扫描的组件 -->
    <context:component-scan base-package="com.atguigu">

        <!-- context:exclude-filter标签：指定排除规则 -->
        <!-- type属性：指定根据什么来进行排除，annotation取值表示根据注解来排除 -->
        <!-- expression属性：指定排除规则的表达式，对于注解来说指定全类名即可 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 仅扫描指定的组件 -->
    <!-- 仅扫描 = 关闭默认规则 + 追加规则 -->
    <!-- use-default-filters属性：取值false表示关闭默认扫描规则 -->
    <context:component-scan base-package="com.atguigu" use-default-filters="false">
        <!-- context:include-filter标签：指定在原有扫描规则的基础上追加的规则 -->
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

5.基于注解方式实现属性注入
（1）@Autowired:根据属性类型进行装配
第一步：把service和dao对象创建，在service和dao类添加创建对象
第二步：在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解

@Service
public class UserService {
    //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    @Autowired//根据类型进行注入
    private UserDao userDao;

    public void add(){
        System.out.println("service add......");
        userDao.add();
    }
}

（2）@Qualifier:根据属性名称进行注入
这个@Qualifier注解的使用，和上面@Autowired一起使用

   //定义dao类型属性
    //不需要添加set方法
    //添加注入属性注解
    @Autowired//根据类型进行注入
    @Qualifier("userDaoImpl1")//根据名称注入
    private UserDao userDao;

（3）@Resource:可以根据类型注入，可以根据名称注入

//    @Resource//根据类型注入
    @Resource(name = "userDaoImpl1")
    private UserDao userDao;

（4）value：注入普通类型属性

  @Value("abc")
  private String name;

6.完全注解开发
（1）创建配置类，替代xml文件

@Configuration //作为配置类，替代xml文件
@ComponentScan(basePackages = {"com.atguigu"})
public class SpringConfig {
}

（2）编写测试类

    @Test
    public void testService2(){
        ApplicationContext context =
                new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.add();
    }