IOC容器概述

框架概述

1、Spring是轻量级的开源的JavaEE框架

2、Spring可以解决企业应用开发的复杂性

3、Spring有两个核心部分：IOC和AOP

​ （1）IOC：控制反转，把创建对象的过程交给Spring管理

​ （2）Aop：面向切面，不修改源代码情况下进行功能增强

4、Spring特点：

​ （1）方便解耦，简化开发

​ （2）Aop编程支持

​ （3）方便程序测试

​ （4）方便和其他框架进行整合

​ （5）方便进行事务

​ （6）降低API开发难度

IOC容器

（1）IOC底层原理

1、什么是IOC？

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

b）使用IOC目的：为了耦合度降低

c）做入门案例就是IOC实现

2、xml解析、工厂模式、反射

工厂模式：原对象调用模式下，UserDao的路径一旦发生变化，那么创建UserDao对象的类中的路径也要一起跟着变化。使用UserFactory可以只改变UserFactory中UserDao的路径，从而实现解耦。

IOC过程

第一步：xml配置文件，配置创建的对象

<bean id="user" class="cn.wlxz.Spring5.User"></bean>

第二步：有service类和dao类，创建工厂类

class UserFactoty{
    public static UserDao getDao(){
        String classValue = class属性值;//xml解析
        Class class = Class.forName(classValue);//通过反射创建对象
        return (UserDao)class.newInstance();
    }
}

IOC过程可以进一步降低耦合度，让耦合度降低到最低限度。

Bean管理

​ （1）Bean管理指的是两个操作

​ （2）Spring创建对象

​ （3）Spring注入属性

Bean管理操作有两种方式

​ （1）基于xml配置文件方式实现

​ （2）基于注解方式实现

（2）IOC接口（BeanFactory）

1、IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

2、Spring提供IOC容器实现两种方式：（两个接口）

BeanFactory:IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用。*加载配置文件的时候不会创建对象，获取对象的时候才会创建对象

ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。*加载配置文件的时候直接创建配置文件中的对象

3、BeanFactory有实现类（两个主要实现类）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PZsrEkVf-1682231357282)(C:\Users\元亚捷\AppData\Roaming\Typora\typora-user-images\image-20230412174112082.png)]

ClassPath为src的相对路径

如果用FileSystem，则为对应资源盘符下的绝对路径

（3）IOC操作Bean管理（基于xml）

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

*id属性：唯一标识 //name属性与id属性差不多，但是id属性中不能添加特殊符号

*class属性：类全路径（包类路径）

创建对象时，默认使用无参数构造方法完成对象创建

2、注入属性

（1）DI：依赖注入，就是注入属性

3、第一种注入方式：使用set注入

​ 定义javabean类

​ 在Spring中配置对象的创建，再配置属性的注入

4、第二种注入方式：使用有参构造器注入

使用标签进行配置

5、p名称空间注入

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

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="Service.UserService">
        <!--
        注入userDao对象
        name属性：类里面的属性名称
        ref属性：创建userDao对象bean标签id值
        -->
        <property name="userdao" ref="userDaoImp1"></property>
    </bean>
    <bean id="userDaoImp1" class="dao.UserDaoImp1"></bean>

3、注入属性-注入内部bean和级联属性

<bean id="emp" class="cn.wlxz.Spring5.Emp">
    <property name="ename" value="lucy"></property>
    <property name="gender" value="女"></property>

    <property name="dept">
        <bean id="dept" class="cn.wlxz.Spring5.Dept">
            <property name="dname" value="保安部"></property>
        </bean>
    </property>
</bean>

4、注入属性-级联属性

第一种：

    <bean id="emp" class="cn.wlxz.Spring5.Emp">
        <property name="gender" value="女"></property>
        <property name="ename" value="lucy"></property>
        <property name="dept" ref="Dept"></property>
    </bean>
    <bean id="Dept" class="cn.wlxz.Spring5.Dept">
        <property name="dname" value="财务部"></property>
    </bean>

第二种：

    <bean id="emp" class="cn.wlxz.Spring5.Emp">
        <property name="gender" value="女"></property>
        <property name="ename" value="lucy"></property>
        <property name="dept.dname" value="技术部"></property>
    </bean>

第二种方法在设置dept对象的值时，要在emp类中写出对应对象的get方法

IOC操作Bean管理（xml注入集合属性）

1、注入数组类型属性

2、注入List集合类型属性

3、注入Map集合类型属性

（1）定义一个类，声明各个集合类型

（2）注入元素

<!--集合类型注入-->
    <bean id="Student" class="cn.wlxz.Spring5.Student">
<!--        数组类型注入-->
        <property name="courses">
            <array>
                <value>java课程</value>
                <value>数据库课程</value>
            </array>
        </property>
<!--        集合类型注入-->
        <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
            </list>
        </property>
        <property name="maps">
            <map>
                <entry key="JAVA" value="java"></entry>
                <entry key="PHP" value="php"></entry>
            </map>
        </property>
        <property name="sets">
            <set>
                <value>黑黑</value>
                <value>哈哈</value>
            </set>
        </property>

        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
    <bean id="course1" class="cn.wlxz.Spring5.Course">
        <property name="name" value="Spring框架"></property>
    </bean>
    <bean id="course2" class="cn.wlxz.Spring5.Course">
        <property name="name" value="mysql框架"></property>
    </bean>

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

<?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: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">
    <util:list id="booklist">
        <value>易筋经</value>
        <value>九阳神功</value>
        <value>大主宰</value>
    </util:list>

    <bean id="Student" class="cn.wlxz.Spring5.Student">
        <property name="list" ref="booklist"></property>
    </bean>
</beans>

IOC操作Bean管理（FactoryBean）

1、Spring有两种类型bean，一种普通bean，一种工厂bean（FactoryBean）

2、普通bean：在配置文件中定义bean类型就是返回类型

3、工厂bean：在配置文件中定义bean类型可以和返回类型不一样

第一步：创建类，让这个类作为工厂bean，实现接口FactoryBean

第二部：实现接口里的方法，在实现的方法中定义返回的bean类型

package cn.wlxz.Spring5;
import org.springframework.beans.factory.FactoryBean;
public class MyBean implements FactoryBean<Course> {

    //定义返回类
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setName("abc");
        return course;
    }

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

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

IOC操作Bean管理（Bean作用域）

1、在Spring里，设置创建的实例是单实例还是多实例

（1）在Spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例

（2）scope属性值

第一个值，默认值，singleton，表示是单实例对象

​ 加载Spring配置文件的时候就会创建单实例对象

第二个值，prototype，表示是多实例对象

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

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

第二第三个值：

request

session

2、在Spring里面，默认情况下是单实例

IOC操作bean管理（Bean生命周期）

1、生命周期

（1）从对象创建到对象销毁的过程

2、过程

（1）通过构造器创建bean实例（无参数构造）

（2）为bean的属性设置值和对其他bean引用（调用set方法）

（3）调用bean的初始化的方法（需要进行配置）

（4）使用bean

（5）当容器关闭的时候，调用bean的销毁的方法（需要进行配置销毁的方法）

<bean name="Order" class="cn.wlxz.Spring5.Order" init-method="initMethod" destroy-method="destoryMethod">
        <property name="name" value="wl"></property>
    </bean>

实体类文件:

package cn.wlxz.Spring5;

public class Order {
    private String name;

    public Order() {
        System.out.println("第一步：调用无参构造");
    }
    public void setName(String name) {
        System.out.println("第二步：调用set设置值");
        this.name = name;
    }
    public void initMethod(){
        System.out.println("第三步：执行初始化方法");
    }
    public void destoryMethod(){
        System.out.println("第五步：销毁bean");
    }
}

测试方法：

    @Test
    public void test2(){
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean7.xml");
        Order order = context.getBean("Order",Order.class);
        System.out.println("第四步：创建实例对象");
        System.out.println(order);
        context.close();

七步操作:

在bean初始化的前后加上后置处理器的操作

BeanPostProcessor

IOC操作Bean管理（自动装配）

1、什么是自动装配？

​ （1）根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入

2、演示自动装配过程

    <bean id="dept" class="cn.wlxz.Spring5.Dept">
        <property name="dname" value="保安"></property>
    </bean>
    <bean id="Emp" class="cn.wlxz.Spring5.Emp" autowire="byName"></bean>

根据名称实现自动装配，注入值和bean的id值和类属性名称一样

IOC操作Bean管理（外部属性文件）

1、直接配置数据库信息

（1）配置德鲁伊连接池

（2）引入德鲁伊连接池依赖jar包

<bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/imgtest"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456yyj"></property>
    </bean>

2、引入外部属性文件配置数据库连接池

<!--    外部引入-->
    <context:property-placeholder location="druid.properties"></context:property-placeholder>
    <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="prop.driverClassName"></property>
        <property name="url" value="prop.url"></property>
        <property name="username" value="prop.username"></property>
        <property name="password" value="prop.password"></property>
    </bean>

（4）IOC操作Bean管理（基于注解操作）

注解：注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值）

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

（1）@Component

（2）@Service

（3）@Controller

（4）@Repository

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

基于注解方式实现

1、引入依赖

spring-aop-5.2.6.RELEASE.jar

2、开启组件扫描

<context:component-scan base-package="net.wlgzs.Spring5.Dao"></context:component-scan>

逐渐扫描：选择扫描与选择不扫描：

选择扫描：

<context:component-scan base-package="com.atguigu" user-default-filters="false">
<context:include-filter type="annotation"
                        expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

选择不扫描：

<context:component-scan base-package="com.atguigu" user-default-filters="false">
<context:exclude-filter type="annotation"
                        expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

3、使用注解

@Component(value="userService")

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

（1）@Autowired：根据属性类型进行自动装配

第一步：把service和dao对象创建，在service和dao类添加创建对象注解

第二部：在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解

package net.wlgzs.Spring5.Service;

import net.wlgzs.Spring5.Dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component(value="userService")
public class UserService {
    @Autowired
    private UserDao userDao;

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

package net.wlgzs.Spring5.Dao;

import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

@Repository
public class UserDaoImp implements UserDao{
    @Override
    public void  add(){
        System.out.println("dao add....");
    }
}

（2）@Qualifier：根据属性名称进行注入

这个注解要和@Autowired一起使用

package net.wlgzs.Spring5.Service;

import net.wlgzs.Spring5.Dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component(value="userService")
public class UserService {
    @Autowired
    @Qualifier(value="userDaoImp")
    private UserDao userDao;

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

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

package net.wlgzs.Spring5.Service;

import net.wlgzs.Spring5.Dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import javax.annotation.Resources;

@Component(value="userService")
public class UserService {

    @Resource(name="userDaoImp")
    private UserDao userDao;

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

（4）@Value：普通类型注入

@Value("abc")
    private String name;

完全注解开发

创建配置类，替代xml配置文件

package net.wlgzs.Spring5.Config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan(basePackages={"net.wlgzs.Spring5.Dao"})
@ComponentScan(basePackages={"net.wlgzs.Spring5.Service"})
public class SpringConfig {

}

周总结

这次学习计划依旧很赶，Spring的各种操作不管是Bean管理还是AOP也只是刚入了个门，想要学深学透还是要多花时间去查看相关书籍，啃源码，了解底层逻辑和思想。好在项目时间给了一个月，算是充裕，虽说这一个月时间里项目占大头，但依旧不能忘了学习，在写项目的过程中思考Spring的IOC思想以及SpringMVC设计逻辑等等才是这次项目的重中之重，学海无涯，共勉。