【2】IOC 容器和依赖注入

1、IOC（概念和原理）

1.1、什么是 IOC

（1）操控回转，把目标创立和目标之间的调用进程，交给 Spring 进行办理

（2）运用 IOC 意图：为了耦合度下降

（3）做入门事例便是 IOC 完结

1.2、IOC 底层原理

xml 解析、工厂模式、反射

1.3、画图讲解

IOC 底层原理 IOC（BeanFactory 接口）

2、IOC（BeanFactory 接口）

2.1、IOC 思维依据 IOC 容器完结，IOC 容器底层便是目标工厂

2.2、Spring 供给 IOC 容器完结两种办法：（两个接口）

（1）BeanFactory：IOC 容器基本完结，是 Spring 内部的运用接口，不供给开发人员进行运用

 加载装备文件时分不会创立目标，在获取目标（运用）才去创立目标

（2）ApplicationContext：BeanFactory 接口的子接口，供给更多更强壮的功用，一般由开发人 员进行运用

加载装备文件时分就会把在装备文件目标进行创立

2.3、ApplicationContext 接口有完结类

3、IOC 操作 Bean 办理（概念）

3.1、什么是 Bean 办理

Bean 办理指的是两个操作 （1）Spring 创立目标

（2）Spirng 注入特点

3.2、Bean 办理操作有两种办法

（1）依据 xml 装备文件办法完结

1、依据 xml 办法创立目标

（1）在 spring 装备文件中，运用 bean 标签，标签里边增加对应特点，就能够完结目标创立

（2）在 bean 标签有许多特点，介绍常用的特点 * id 特点：唯一标识 * class 特点：类全路径（包类路径）

（3）创立目标时分，默许也是履行无参数结构办法完结目标创立

2、依据 xml 办法注入特点

3、依靠注入第一种注入办法：运用 set 办法进行注入

（1）创立类，界说特点和对应的 set 办法

/**
 * 演示运用 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 装备文件装备目标创立，装备特点注入

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>
    <constructor-arg name="address" value="China"></constructor-arg>
</bean>

5、p 称号空间注入（了解）

（1）运用 p 称号空间注入，能够简化依据 xml 装备办法 第一步 增加 p 称号空间在装备文件中

第二步 进行特点注入，在 bean 标签里边进行操作

<!--2 set 办法注入特点-->
<bean id="book" class="com.atguigu.spring5.Book" p:bname="九阳神功"
        p:bauthor="无名氏"></bean

（2）依据注解办法完结

1、什么是注解

（1）注解是代码特别符号，格式：@注解称号(特点称号=特点值, 特点称号=特点值..)
（2）运用注解，注解作用在类上面，办法上面，特点上面 
（3）运用注解意图：简化 xml 装备 

2、Spring 针对 Bean 办理中创立目标供给注解

（1）@Component

（2）@Service

（3）@Controller

（4）@Repository

上面四个注解功用是相同的，都能够用来创立 bean 实例

3、依据注解办法完结目标创立

第一步 引进依靠

第二步 敞开组件扫描

<!--敞开组件扫描
       1 假如扫描多个包，多个包运用逗号隔开
       2 扫描包上层目录
       -->
<context:component-scan base-package="com.atguigu"></context:component-scan>

第三步 创立类，在类上面增加创立目标注解

//在注解里边 value 特点值能够省掉不写，
//默许值是类称号，首字母小写
//UserService -- userService
@Component(value = "userService") //<bean id="userService" class=".."/>
public class UserService {
   public void add() {
       System.out.println("service add.......");
   }
}

4、敞开组件扫描细节装备

<!--示例 1
        use-default-filters="false" 表明现在不运用默许 filter，自己装备 filter
        context:include-filter ，设置扫描哪些内容
        -->
<context:component-scan base-package="com.atguigu" use-defaultfilters="false">
<context:include-filter type="annotation"
        expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例 2
        下面装备扫描包所有内容
        context:exclude-filter： 设置哪些内容不进行扫描
        -->
<context:component-scan base-package="com.atguigu">
<context:exclude-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(value = "userDaoImpl1") //依据称号进行注入
private UserDao userDao;

（3）@Resource：能够依据类型注入，能够依据称号注入

//@Resource //依据类型进行注入
@Resource(name = "userDaoImpl1") //依据称号进行注入
private UserDao userDao;

（4）@Value：注入一般类型特点

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

3.3、IOC 操作 Bean 办理（FactoryBean）

1、Spring 有两种类型 bean，一种一般 bean，另外一种工厂 bean（FactoryBean）

2、一般 bean：在装备文件中界说 bean 类型便是回来类型

3、工厂 bean：在装备件界说 bean 类型能够和回来类型不相同

第一步 创立类，让这个类作为工厂 bean，完结接口 FactoryBean

第二步 完结接口里边的办法，在完结的办法中界说回来的 bean 类型

public class MyBean implements FactoryBean<Course> {
    //界说回来 bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }
    @Override
    public Class<?> getObjectType() {
        return null;
    }
    @Override
    public boolean isSingleton() {
        return false;
    }
}

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

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

3.4、bean 作用域

1、在 Spring 里边，设置创立 bean 实例是单实例仍是多实例

2、在 Spring 里边，默许情况下，bean 是单实例目标

3、怎么设置单实例仍是多实例

（1）在 spring 装备文件 bean 标签里边有特点（scope）用于设置单实例仍是多实例
（2）scope 特点值 
第一个值 默许值，singleton，表明是单实例目标 
第二个值 prototype，表明是多实例目标

（3）singleton 和 prototype 差异
第一 singleton 单实例，prototype 多实例 
第二 设置 scope 值是 singleton 时分，加载 spring 装备文件时分就会创立单实例目标 设置 scope 值是 prototype 时分，不是在加载 spring 装备文件时分创立 目标，在调用 getBean 办法时分创立多实例目标

3.5、bean 生命周期

1、生命周期阐明

（1）从目标创立到目标毁掉的进程

2、bean 创立进程

（1）经过结构器创立 bean 实例（无参数结构）
（2）为 bean 的特点设置值和对其他 bean 引用（调用 set 办法） 
（3）调用 bean 的初始化的办法（需求进行装备初始化的办法） 
（4）bean 能够运用了（目标获取到了） 
（5）当容器关闭时分，调用 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" initmethod="initMethod" destroy-method="destroyMethod">
<property name="oname" value="手机"></property>
</bean>

@Test
public void testBean3() {
// ApplicationContext context =
// new ClassPathXmlApplicationContext("bean4.xml");
        ClassPathXmlApplicationContext context =
        new ClassPathXmlApplicationContext("bean4.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 的初始化的办法（需求进行装备初始化的办法） 
（5）把 bean 实例传递 bean 后置处理器的办法 postProcessAfterInitialization 
（6）bean 能够运用了（目标获取到了） 
（7）当容器关闭时分，调用 bean 的毁掉的办法（需求进行装备毁掉的办法）

5、演示增加后置处理器作用

（1）创立类，完结接口 BeanPostProcessor，创立后置处理器

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("在初始化之前履行的办法");
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("在初始化之后履行的办法");
        return bean;
    }
}

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

3.6、xml 主动安装

1、什么是主动安装

依据指定安装规则（特点称号或许特点类型），Spring 主动将匹配的特点值进行注入

2、演示主动安装进程

（1）依据特点称号主动注入

<!--完结主动安装
        bean 标签特点 autowire，装备主动安装
        autowire 特点常用两个值：
        byName 依据特点称号注入 ，注入值 bean 的 id 值和类特点称号相同
        byType 依据特点类型注入
        -->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byName">
<!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean

（2）依据特点类型主动注入

<!--完结主动安装
        bean 标签特点 autowire，装备主动安装
        autowire 特点常用两个值：
        byName 依据特点称号注入 ，注入值 bean 的 id 值和类特点称号相同
        byType 依据特点类型注入
        -->
<bean id="emp" class="com.atguigu.spring5.autowire.Emp" autowire="byType">
<!--<property name="dept" ref="dept"></property>-->
</bean>
<bean id="dept" class="com.atguigu.spring5.autowire.Dept"></bean>

3.7、外部特点文件

1、直接装备数据库信息

（1）装备德鲁伊连接池

（2）引进德鲁伊连接池依靠 jar 包

<!--直接装备连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url"
        value="jdbc:mysql://localhost:3306/userDb"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>

2、引进外部特点文件装备数据库连接池

（1）创立外部特点文件，properties 格式文件，写数据库信息

（2）把外部 properties 特点文件引进到 spring 装备文件中

引进 context 称号空间

<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"
        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/util 
        http://www.springframework.org/schema/util/spring-util.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd">

⚫ 在 spring 装备文件运用标签引进外部特点文件

<!--引进外部特点文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--装备连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${prop.driverClass}"></property>
<property name="url" value="${prop.url}"></property>
<property name="username" value="${prop.userName}"></property>
<property name="password" value="${prop.password}"></property>
</bean>