IOC

IOC原理

# 1.IOC简介
- 参考文档:https://baike.baidu.com/item/%E6%8E%A7%E5%88%B6%E5%8F%8D%E8%BD%AC/1158025?fr=aladdin

- 控制反转,把对象创建和对象之间的调用过程,交给 Spring 进行管理。

- IOC可降低耦合度。

# 2.IOC底层原理
- XML解析、工厂模式、反射

# 3.IOC(BeanFactory 接口)
- IOC 思想基于 IOC 容器完成，IOC 容器底层就是对象工厂。

- Spring 提供 IOC 容器实现两种方式
(1).BeanFactory: IOC 容器基本实现,是 Spring 内部的使用接口,不提供开发人员进行使用。加载配置文件时候不会创建对象，在获取对象(使用)才去创建对象。

(2).ApplicationContext: BeanFactory 接口的子接口,提供更多更强大的功能,一般由开发人员进行使用。加载配置文件时候就会把在配置文件对象进行创建。

IOC-Bean-XML方式

Bean-创建对象

# 1.Bean管理
- Bean 管理指的是两个操作
- Spring 创建对象
- Spirng 注入属性

# 2.Bean管理方式
- 基于 xml 配置文件方式
- 基于注解方式实现

• 基于 xml 配置文件方式

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

# 在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建

# 在 bean 标签有很多属性
- id:唯一标识
- class:类全路径(包类路径,当前目录默认为src路径下)

# 创建对象时候，默认也是执行无参数构造方法完成对象创建

Bean-DI依赖注入

set方法方式

• 创建类,定义属性和对应的set方法

// 1.创建类 set方法 和 有参构造 注入
public class Book {

    private String name;

    //set方式注入
    public void setName(String name) {
        this.name = name;
    }

    //有参构造注入
    public Book(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        Book book = new Book();
        book.setName("abc");
    }
}

• xml文件配置属性注入

    <!-- set方法注入属性 -->
    <bean id="book" class="com.hosystem.spring5.Book">
        <!-- 使用property完成属性注入 -->
        <!-- name:类里面的属性名称 -->
        <!-- value:向属性注入的值-->
        <property name="bname" value="jeck"></property>
        <property name="bauthor" value="hello"></property>
    </bean>

有参数构造函数方式

• 创建类,定义属性,创建属性对应有参数构造方法

/**
 *  使用有参构造注入
 */
public class Orders {

    private String oname;

    private String address;

    //有参构造
    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

• xml文件配置属性注入

    <!--    有参构造注入属性-->
    <bean id="orders" class="com.hosystem.spring5.Orders">
        <constructor-arg name="oname" value="value"></constructor-arg>
        <constructor-arg name="address" value="key"></constructor-arg>
        <!--        可以通过以上方式 也可以通过索引值 index:0 为有参构造函数第一个参数 index:1 有参构造函数第二个参数-->
        <!--        <constructor-arg index="0" value="value"></constructor-arg>-->
        <!--        <constructor-arg index="1" value="key"></constructor-arg>-->
    </bean>

p 名称空间注入

使用 p 名称空间注入，可以简化基于 xml 配置方式

• 添加 p 名称空间在配置文件中

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

• 属性注入,在 bean 标签里面进行操作

    <!-- set方法注入属性 -->
    <bean id="book" class="com.hosystem.spring5.Book" p:bname="jeck" p:bauthor="hello">
    </bean>

其他类型属性注入

• 字面量

(1).null值

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

(2).属性值中含特殊符号

    <bean>
        <!--        &lt;!&ndash; 注入null值 &ndash;&gt;-->
        <!--        <property name="address">-->
        <!--            <null/>-->
        <!--        </property>-->

        <!--        属性值包含特殊符号-->
        <!--        方法1：将<>进行转义 &lt;&gt;-->
        <!--        方法2：将特殊符号写到CDATA中-->
        <!--        <property name="address" value="&lt;&lt;hosystem&gt;&gt;"></property>-->
        <property name="address">
            <value><![CDATA[<<hosystem1>>]]></value>
        </property>
    </bean>

• 注入属性 – 外部bean

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

    <bean id="userDaoImpl" class="com.hosystem.spring5.dao.Impl.UserDaoImpl"></bean>

• 注入属性 – 内部bean

    <!--    内部bean-->
    <bean id="emp" class="com.hosystem.spring5.bean.Emp">
        <!--        设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="man"></property>

        <!--        对象类型属性-->
        <!--        方式1：外部bean-->
        <!--        方式2：内部bean-->
        <!--        推荐使用外部bean 看起来比较清晰-->
        <property name="dept">
            <bean id="dept" class="com.hosystem.spring5.bean.Dept">
                <property name="dname" value="技术服务部"></property>
            </bean>
        </property>
    </bean>

• 注入属性 – 级联赋值

(1).方式一

    <!--    级联赋值-->
    <bean id="emp" class="com.hosystem.spring5.bean.Emp">
        <!--        设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="man"></property>
        <!--        级联赋值-->
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.hosystem.spring5.bean.Dept">
        <property name="dname" value="HR部"></property>
    </bean>

(2).方式二

    <!--    级联赋值-->
    <bean id="emp" class="com.hosystem.spring5.bean.Emp">
        <!--        设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="man"></property>
        <!--        级联赋值-->
        <property name="dept" ref="dept"></property>
        <!--        若需要使用dept.xxx 则需要设置对应的get方法;若没有get方法 则Cannot resolve property 'dname' -->
        <property name="dept.dname" value="后勤部"></property>

    </bean>
    <!--    使用外部bean后使用<property赋值-->
    <!--    <bean id="dept" class="com.hosystem.spring5.bean.Dept">-->
    <!--        <property name="dname" value="HR部"></property>-->
    <!--    </bean>-->

    <!--将<property>不设置  放在第一个bean里面设置-->
    <bean id="dept" class="com.hosystem.spring5.bean.Dept">
    </bean>

注入集合属性

• 创建类
  定义数组、list、map、set 类型属性，生成对应 set 方法。

public class stu {

    //数组类型属性
    private String[] courses;

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

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

    private Set<String> sets;

    //courses、list、maps、sets的set方法
}

• xml文件配置属性注入

    <!--    1.数组类型属性注入-->
    <bean id="stu" class="com.hosystem.spring5.collectiontype.stu">
        <!--        数组类型属性注入-->
        <property name="courses">
            <array>
                <value>java</value>
                <value>php</value>
                <value>python</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>

• 集合设置对象类型值

    <!--    1.数组类型属性注入-->
    <bean id="stu" class="com.hosystem.spring5.collectiontype.stu">
        <!--        注入list集合类型 值为对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>

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

• 集合注入部分提取

(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">
    <!--        添加tuil空间: xmlns:p="http://www.springframework.org/schema/util"-->
    <!--  http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd  -->
</beans>

(2).使用 util 标签完成 list 集合注入提取

    <!--    1.提取list集合类型属性注入-->
    <util:list id="bookList">
        <value>lucy</value>
        <value>jeck</value>
        <value>tom</value>
    </util:list>

    <!--    2.注入使用-->
    <bean id="book" class="com.hosystem.spring5.collectiontype.Book">
        <property name="list" ref="bookList"></property>
    </bean>

Bean-FactoryBean

• Spring bean类型 ：普通 bean、工厂 bean(FactoryBean)。
• 普通 bean：在配置文件中定义 bean 类型就是返回类型。
• 工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样。

(1).创建类 | 实现接口方法
创建的类作为工厂 bean，实现接口 FactoryBean。
实现接口里面的方法，在实现的方法中定义返回的 bean 类型。

public class MyBean implements FactoryBean<Course> {


    //定义返回bean
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("aaa");
        return course;
    }

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

    @Override
    public boolean isSingleton() {
        return false;
    }
}

(2).xml配置文件

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

(3).测试

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

Bean-bean 作用域

# 1.在 Spring 里面，默认情况下,bean 是单实例对象

# 2.xml设置单实例、多实例

- 在 spring 配置文件 bean 标签里面有属性(scope)用于设置单实例还是多实例。

- scope属性值
(1).singleton:单实例对象,spring默认创建实例对象为单实例。
(2).prototype:多实例对象。

- scope设置多实例
    <bean id="book" class="com.hosystem.spring5.collectiontype.Book" scope="prototype">
        <property name="list" ref="bookList"></property>
    </bean>

# 3.singleton 和 prototype 区别

- singleton 单实例，prototype 多实例

- 设置 scope 值是 singleton 时候，加载 spring 配置文件时候就会创建单实例对象。

- 设置 scope 值是 prototype 时候，不是在加载 spring 配置文件时候创建 对象，在调用getBean 方法时候创建多实例对象。


# 4.request和session

Bean-生命周期

• spring生命周期

- 从对象创建到对象销毁的过程。

bean 生命周期

- 通过构造器创建 bean 实例(无参数构造)
- 为 bean 的属性设置值和对其他 bean 引用(调用 set 方法)
- 调用 bean 的初始化的方法(需要进行配置初始化的方法)
- bean 可以使用(对象获取到了)
- 当容器关闭时候，调用 bean 的销毁的方法(需要进行配置销毁的方法)

• bean 生命周期代码演示

public class Orders {

    private String oname;

    public Orders() {
        System.out.println("第一步 Orders无参构造方法");
    }

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 Orders setOname");
    }

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

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


    <!--    xml配置文件-->
    <!--    init-method:执行初始化方法 -->
    <!--   destroy-method:执行销毁方法 -->
    <bean id="orders" class="com.hosystem.spring5.bean.Orders" init-method="initMethod" destroy-method="detoryMethod">
        <property name="oname" value="hello"></property>
    </bean>
    
    
    //测试
    @Test
    public void testBean() {
        //ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean4.xml");
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders = applicationContext.getBean("orders", Orders.class);
        System.out.println("第四步 获取到bean实例对象");
        System.out.println(orders);

        //手动让bean实例销毁 需要使用ApplicationContext的实现子类`ClassPathXmlApplicationContext`等进行转换
        //ApplicationContext没有close方法
        applicationContext.close();
    }

bean 完整生命周期-七步

- 通过构造器创建 bean 实例(无参数构造)

- 为 bean 的属性设置值和对其他 bean 引用(调用 set 方法)

- bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization

- 调用 bean 的初始化的方法(需要进行配置初始化的方法)

- bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization

- bean 可以使用(对象获取到了)

- 当容器关闭时候，调用 bean 的销毁的方法(需要进行配置销毁的方法)

• bean 完整生命周期代码演示

public class MyBeanPost implements BeanPostProcessor {

    /**
     *      @Nullable
     *     default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
     *         return bean;
     *     }
     *
     *     @Nullable
     *     default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
     *         return bean;
     *     }
     *
     *     修改default -> public
     *     修改 @Nullable -> @Override
     */
    @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-自动装配

• 自动装配

根据指定装配规则(属性名称或者属性类型),Spring 自动将匹配的属性值进行注入。

• 自动装配过程

(1).根据属性名称自动注入

    <!--    实现自动装配-->
    <!--        private Dept dept;-->
    <!--    autowire:配置自动装配 -->
    <!--    autowire常用属性:byName、byType-->
    <!--    byName:根据属性名装配注入 注入值bean的id值(dept)和属性名称(dept)一样 byName能够定义多个外部bean-->
    <!--    byType:根据属性类型注入 注入值bean的type值(Dept)和属性类型(Dept)一样 byType不能够定义多个外部bean-->
    <bean id="emp" class="com.hosystem.spring5.autowire.Emp" autowire="byName">
        <!--        <property name="dept" ref="dept"></property>-->
    </bean>
    <bean id="dept" class="com.hosystem.spring5.autowire.Dept"></bean>
    <bean id="dept1" class="com.hosystem.spring5.autowire.Dept"></bean>

(2).根据属性类型自动注入

    <!--    实现自动装配-->
    <!--        private Dept dept;-->
    <!--    autowire:配置自动装配 -->
    <!--    autowire常用属性:byName、byType-->
    <!--    byName:根据属性名装配注入 注入值bean的id值(dept)和属性名称(dept)一样 byName能够定义多个外部bean-->
    <!--    byType:根据属性类型注入 注入值bean的type值(Dept)和属性类型(Dept)一样 byType不能够定义多个外部bean-->
    <bean id="emp" class="com.hosystem.spring5.autowire.Emp" autowire="byType">
        <!--        <property name="dept" ref="dept"></property>-->
    </bean>
    <bean id="dept" class="com.hosystem.spring5.autowire.Dept"></bean>

Bean-外部属性文件

• 直接配置数据库信息

配置数据库信息

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

• 外部属性文件配置数据库连接池

(1).创建properties文件

prop.driverClassName=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://192.168.188.128:3306/test
prop.username=root
prop.password=root

(2).引入名称空间

<?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"
       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">
    <!--        context:  xmlns:context="http://www.springframework.org/schema/context"-->
    <!-- http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd  -->
</beans>

(3).使用context标签引入外部属性文件

    <!--    引入外部属性-->
    <context:property-placeholder location="classpath:jdcb.properties"></context:property-placeholder>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="${prop.url}"/>
        <property name="username" value="${prop.username}"/>
        <property name="password" value="${prop.password}"/>
        <property name="driverClassName" value="${prop.driverClassName}"/>
    </bean>

IOC-Bean-注解方式

# 1.注解
- 注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值..)。

- 使用注解，注解作用在类上面，方法上面，属性上面。

- 使用注解目的：简化 xml 配置。

Bean-创建对象

• Bean 管理中创建对象提供注解

- @Component
- @Service
- @Controller
- @Repository

- 上面四个注解功能是一样的，都可以用来创建 bean 实例

• 基于注解方式实现对象创建

1. 引入依赖

spring-aop-5.2.6.RELEASE.jar

2. 开启组件扫描

    <!--     开启组件扫描 -->
    <!--    若要扫描多个包 多个包之间使用`,`隔开-->
    <!--    扫描包上层目录也可以-->
    <context:component-scan
            base-package="com.hosystem.spring5.dao,com.hosystem.spring5.service"></context:component-scan>

3. 创建类

/**
 *  在类上面添加创建对象注解
 *  @Component(value = "userService")  <==> <bean id="userService" class="com.hosystem.spring5.service.UserService"/>
 *  component 中的value可以省略,若省略则默认值为 类名称(首字母小写的类名称)  => UserService => userService
 */
@Component(value = "userService")
public class UserService {

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

Bean-组件扫描配置

    <!--    示例1-->
    <!--   use-default-filters:不使用默认filter 自定义配置filters -->
    <!--   context:include-filter:扫描那些内容 -->
    <!--    type="annotation":根据注解扫描-->
    <!--    expression:扫描包含那些注解 该扫描包含Controller的注解-->
    <context:component-scan base-package="com.hosystem" us e-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!--    实例2-->
    <!--    context:exclude-filter:设置不扫描那些内容-->
    <context:component-scan base-package="com.hosystem">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

Bean-属性注入

• 基于注解方式实现属性注入

- @Autowired:根据属性类型进行自动装配。

- @Qualifier:根据名称进行注入。

- @Resource:可以根据类型注入,可以根据名称注入。

- @Value:注入普通类型属性。

1. @Autowired

(1). 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

(2). 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

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

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

2. @Qualifier

@Qualifier 注解的使用，和上面@Autowired 一起使用。

@Service(value = "userService")
public class UserService {
    //定义dao类型属性
    //不需要设置set方法
    //添加注入属性注解
    @Autowired    //根据类型进行注入
    @Qualifier(value = "userDaoImpl2")	//根据名称进行注入
    /**
     *  @Qualifier要和@Autowired一起使用
     *  若UserDao有多个实现 我们可以使用@Qualifier 指定实现类
     *  如 UserDao有两个实现UserDaoImpl 和 UserDaoImpl2  这里我指定userDaoImpl2 作为该UserDao的实现
     */
    private UserDao userDao;

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

3. @Resource

@Resource：可以根据类型注入，可以根据名称注入

    @Resource(name = "userDaoImpl1") //根据类型进行注入  使用name则根据名称注入
    private UserDao userDao;

4. @Value

@Value：注入普通类型属性

    //<property>
    @Value(value = "hello")
    private String name;

Bean-注解开发

• 创建配置类(SpringConfig.java)

创建配置类(SpringConfig.java)，替代 xml 配置文件。

/**
 *  <context:component-scan base-package="com.hosystem"></context:component-scan>  <==> @ComponentScan(basePackages = {"com.hosystem"})
 */
@Configuration //作为配置类 替代xml配置文件
@ComponentScan(basePackages = {"com.hosystem"})
public class SpringConfig {
}

• 测试类

    @Test
    public void testService1() {
        //加载配置类
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService1 = applicationContext.getBean("userService", UserService.class);
        userService1.add();
    }