【Spring】IOC容器

Spring的IOC容器学习笔记

一、IOC容器概述

1.1 IOC介绍

• IOC：控制反转，减低计算机代码之间的耦合度
  • 把对象的创建和对象之间的调用过程，交给Spring进行管理

1.2 底层原理

• 底层使用xml解析，工厂设计模式，反射

1.3 IOC接口

• Spring提供IOC容器实现的两种方式（两个接口）：
  • （1）BeanFactory：
    • IOC容器最基本的实现方式，是Spring内部使用的接口，不提供开发人员进行使用
    • 加载配置文件时候不会创建（懒汉式），使用时再创建对象
  • （2）ApplicationContext：
    • BeanFactory接口的子接口，提供更多更强大的功能，一般有开发人员进行使用
    • 加载配置文件时，就会创建配置文件对象（饿汉式）
    • 把耗时耗资源的操作，交给启动服务器时使用更好

• ApplicationContext的实现类
  • ClassPathXmlApplicationContext
  • FileSystemXmlApplicationContext

---

二、xml配置文件实现bean管理

2.1 属性注入

• （1）通过set方法
  • 在类中创建set方法

<!--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">
	   
    <!--通过xml配置文件set方法进行属性注入-->
    <bean id="book" class="ClassPack.Book">
        <property name="name" value="易筋经"></property>
        <property name="author" value="达摩老祖"></property>
    </bean>
	
</beans>

• （2）通过带参构造器
  • 在类中创建一个带参构造器

<!--省略了beans配置内容-->
    <bean id="order" class="ClassPack.Order">
        <constructor-arg name="name" value="abc"></constructor-arg>
        <constructor-arg name="address" value="中国"></constructor-arg>
    </bean>

• （3）p名称空间—简化了set方法

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   
	   <!--添加名称为p的空间-->
       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">

    <!--简化set方法属性注入-->
    <!--p名称空间注入-->
    <bean id="book1" class="ClassPack.Book" p:name="呐喊" p:author="鲁迅"></bean>
	
</beans>

• （4）外部bean注入
• 举例：
  • 1.创建两个类service类和dao类
  • 2.在service类中调用dao里面的方法
  • 3.在Spring配置文件中进行配置
    • 利用property中ref属性，来进行对象赋值

<!--省略beans配置内容>

    <!--1.将Service和UserDao类的对象进行创建-->
    <bean id="userService" class="service.UserService">
        <!--2.在Service中注入userDao对象
            name属性：类里面属性名称
            red属性：创建userDao对象bean标签的id名称
        -->
        <property name="userDao" ref="userDao"></property>
    </bean>

    <bean id="userDao" class="dao.UserDaoImpl"></bean>

• （5）内部bean注入
  • 跟外部bean类似，只是另外一个对象bean不再外面创建，而在一个bean里面创建
  • 在<property>标签中，添加<bean>标签进行内部创建

<!--省略beans配置内容>

	<!--内部Bean操作-->
	<bean id="employee" class="ClassPack.Employee">
		<!--设置前两个基本属性-->
		<property name="name" value="咕料"></property>
		<property name="gender" value="男"></property>

		<!--内部bean形式注入对象-->
		<property name="department">
			<bean id="department" class="ClassPack.Department">
				<property name="name" value="人事部"></property>
			</bean>
		</property>
	</bean>

• （6）级联赋值
  • 方法一：跟外部bean操作一样，就是在创建外部bean的同时，用<property>标签进行赋值
  • 方法二：跟外部bean操作类似，但不在外部bean创建时进行赋值

<!--省略beans配置内容>

    <!--级联赋值-->
        <!--方法二：在方法一的基础上改进
            注意需要在类中添加get方法
        -->
    <bean id="employee" class="ClassPack.Employee">
        <property name="name" value="咕料"></property>
        <property name="gender" value="男"></property>
		
        <!--级联赋值-->
        <property name="department" ref="department"></property>
        <property name="department.name" value="技术部"></property>
		
    </bean>

    <bean id="department" class="ClassPack.Department"></bean>

• （7）集合属性注入
  • 在<property>标签内，添加对应的集合标签；数组用<array>，List集合用<List>，Set集合用<Set>，Map使用<Map>
  • Map集合在对应的<Map>下，还要添加<entry>标签才可以
  • 集合注入的内容是对象时，需要添加<ref>标签进行赋值

<!--省略beans配置内容>

    <!--集合类型属性注入-->
    <bean id="student" class="ClassPack.Student">

        <!--数组类型属性注入-->
        <property name="arr">
            <array>
                <value>java课程</value>
                <value>数据库</value>
            </array>
        </property>

        <!--List类型属性注入-->
        <property name="list">
            <list>
                <value>小学</value>
                <value>中学</value>
                <value>大学</value>
            </list>
        </property>

        <!--Map类型属性进行注入-->
        <property name="map">
            <map>
                <entry key="C酱" value="女"></entry>
                <entry key="咕料" value="男"></entry>
            </map>
        </property>

        <!--注入List集合，值为对象-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
	
	<!--外部bean创建对象-->
    <bean id="course1" class="ClassPack.Course">
        <property name="name" value="Java基础"></property>
    </bean>
    <bean id="course2" class="ClassPack.Course">
        <property name="name" value="Spring5"></property>
    </bean>

• （8）把集合注入部分提取出来
  • 1.在Spring配置文件中引入名称空间util
  • 2.使用util标签完成list集合注入提取

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   
	   <!--引入util名称空间-->
       xmlns:util="http://www.springframework.org/schema/util"
	   
	   <!--在下面空间添加内容-->
	   <!--可以将原本内容复制，再将里面的beans改成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">

    <!--1.提取list集合类型属性注入-->
    <util:list id="gameList">
        <value>塞尔达传说</value>
        <value>守望先锋</value>
        <value>赛博朋克2077</value>
        <!--如果是属性值是对象，就用ref-->
    </util:list>

    <!--2.使用提取出来的List集合-->
    <bean id="game" class="ClassPack.Game">
        <property name="name" ref="gameList"></property>
    </bean>
</beans>

2.2 工厂bean（FactoryBean）

• （1）Spring有两种类型的bean，一种是普通bean，另外一种是工厂bean(Factory Bean)

• （2）普通Bean特点：
  • 在配置文件中定义bean类型就是返回类型

• （3）工厂Bean特点：
  • 在配置文件中定义Bean类型可以和返回类型不一样

• （4）使用工厂Bean：
  • 创建一个类，让其实现接口FactoryBean，作为工厂Bean
  • 实现接口里面的方法，在实现方法中定义返回的Bean类型

//类实现FactoryBean接口，泛型填想要实现的另外一个类型

public class MyFactoryBean implements FactoryBean<Course> {

    //定义返回Bean的对象
    //MyFactoryBean类返回的对象是Course类
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setName("Java基础");
        return course;
    }

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

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

<!--跟普通创建bean方法一样-->
    <bean id="myFactoryBean" class="ClassPack.MyFactoryBean"></bean>

//实现代码
    @Test
    public void test1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("factoryBean.xml");
        Course myFactoryBean = context.getBean("myFactoryBean", Course.class);
        System.out.println(myFactoryBean);
    }

2.3 bean的作用域

• （1）在Spring里面，设置创建Bean实例是单实例还是多实例

• （2）在Spring情况下，默认情况下是单实例对象

• （3）如何设置单实例还是多实例

  • 在Spring配置文件bean标签里面，有属性(scope)设置用于单实例还是多实例
  • scope属性值：
    • singleton：表示单实例对象，是默认值
    • prototype，表示多实例对象
  • singleton和prototype区别：
    • singleton单实例，protptype是多实例
    • 设置scope值是singleton时候，加载spring配置文件时候就会创建单实例对象
    • 设置scope值是prototype时候，不是在加载spring配置文件时候创建对象，在调用getBean()时候才创建多实例对象

<!--省略beans配置内容-->

    <bean id="book" class="ClassPack.Book"></bean>

    <bean id="book1" class="ClassPack.Book" scope="prototype"></bean>

//单实例演示
@Test
public void singleTest(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("actionScope.xml");
    Book book1 = context.getBean("book", Book.class);
    Book book2 = context.getBean("book", Book.class);

    System.out.println(book1.equals(book2));//true
    //单例对象是指每次创建的对象，都是同一个对象
}

//多实例演示
@Test
public void prototypeTest(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("actionScope.xml");
    Book book1 = context.getBean("book1", Book.class);
    Book book2 = context.getBean("book1", Book.class);

    System.out.println(book1.equals(book2));//false
    //多实例对象是指每次创建的对象，都是不同的对象
}

• （4）还有其他不常用值：requesy、session

2.4 bean生命周期

• （1）生命周期：从对象的创建到对象的销毁的过程

• （2）bean的生命周期

  • 通过构造器创建Bean实例（无参数构造器）
  • 通过构造器创建Bean实例（无参数构造器）
  • 通过构造器创建Bean实例（无参数构造器）
  • bean可以使用（对象获取到了）、
  • 当容器关闭时，调用bean的销毁的方法（需要进行配置销毁的方法）

• （3）演示Bean的生命周期

  • 第一步，执行无参构造器创建Bean实例
  • 第二步，调用set方法设置属性值
  • 第三步，执行初始化方法
  • 第四步，获取创建Bean实例对象
  • ClassPack.LifeCycleBean@34123d65
  • 第五步，执行销毁的方法

//类
public class LifeCycleBean {
    private String name;

    public LifeCycleBean(){
        System.out.println("第一步，执行无参构造器创建Bean实例");
    }

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

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

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

<!--省略了beans配置内容-->
	<!--init-method配置执行初始化方法，destory-method配置销毁方法-->
    <bean id="lifeCycleBean" class="ClassPack.LifeCycleBean" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="生命周期"></property>
    </bean>

//执行代码
    @Test
    public void test(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("lifeCycle.xml");
        LifeCycleBean lifeCycleBean = context.getBean("lifeCycleBean", LifeCycleBean.class);
        System.out.println("第四步，获取创建Bean实例对象");
        System.out.println(lifeCycleBean);

        //手动让bean实例销毁
        context.close();
    }

• （4）Bean的后置处理器，bean的生命周期变成7步
  • • 第一步，执行无参构造器创建Bean实例
  • 第二步，调用set方法设置属性值
  • 把bean实例传递给bean后置处理器的方法：postProcessBeforeInitialization
  • 第三步，执行初始化方法
  • 把bean实例传递给bean后置处理器的方法：postProcessAfterInitialization
  • 第四步，获取创建Bean实例对象
  • ClassPack.LifeCycleBean@34123d65
  • 第五步，执行销毁的方法

• （5）实现方法：
  • 在上面的基础上，新建一个类，实现BeanPostProcessor接口，作为后置处理器
  • 在xml配置文件中配置

//后置处理器类
public class LifeCycleBean2  implements BeanPostProcessor{
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return null;
    }
}

<!--配置后置处理器-->
<bean id="lifeCycleBean2" class="ClassPack.LifeCycleBean2"></bean>

2.5 自动装配

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

<!--省略beans配置内容-->

    <!--手动装配-->
    <bean id="emp" class="beanManager.Emp">
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="beanManager.Dept"></bean>

    <!--自动装配
        autowire：自动装配
        参数：
            byName(根据属性名称注入)，注入值bean的id值和类属性名称一样
            byType(根据属性类型注入)，相同类型的bean必须只有一个
    -->
    <bean id="emp2" class="beanManager.Emp" autowire="byName"></bean>
    <bean id="emp3" class="beanManager.Emp" autowire="byType"></bean>

2.6 引入外部属性文件

• 一般将属性值比较固定的，通过文件进行保存，通过读取文件来获取属性内容（例如：连接数据库的内容）

• 举例：连接 数据库连接池
  • （1）直接配置数据库信息
    • 引入德鲁伊连接池依赖的jar包
    • 在xml文件中配置信息

<!--直接配置-->
<!--1.创建连接池对象-->
<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/jdbctest?serverTimezone=GMT%2B8"></property>
    <property name="username" value="root"></property>
    <property name="password" value="123"></property>
</bean>

• • （2）通过引入外部属性文件配置数据库连接池
    • 创建properties文件信息
    • 创建context名称空间（和之前的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: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/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--创建连接对象-->
    <bean id="dataSource1" 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.user}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>

</beans>

• 创建对象的方式没有改变的就不演示了

---

三、注解形式实现bean管理

3.1 注解介绍

• 注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…)
• 注解可以作用在类，属性，方法上
• 简化xml配置

3.2 利用注解创建对象

• 创建对象的四个注解：
  • （1）@Component
  • （2）@Service
  • （3）@Controller
  • （4）@Repository
  • 四个注解功能是一样的，但一般为了区分，会在不同的地方使用不同注解

• 创建方法：
  • （1）引入以来jar包：aop
  • （2）xml配置文件开启组件扫描，需要引入context名称空间
  • （3）类添加创建注解，创建方法和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"
       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/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--1.引入context名称空间-->

    <!--2.开始组建扫描-->
    <context:component-scan base-package="ClassPack"></context:component-scan>
        <!--如果需要扫描多个包，可以用','来添加其他路径-->
		
</beans>

//创建带注解的类

//value类似于<bean>的id；若不添加value，则value默认值为，类名首字母小写
@Component(value = "annotationClass") 
public class AnnotationClass {
    public void show(){
        System.out.println("注解创建类...");
    }
}

• 补充： 组件扫描可以开启更细致的扫描

<!--use-default-filters：是否扫描全部类-->
<!--iinclude-filter：只扫描特定内容-->

  <context:component-scan base-package="ClassPack" use-default-filters="false">
      <!--自己添加过滤器：只扫描包中有注解，且注解为Component的类-->
      <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
  </context:component-scan>

<!--exclude-filter：不扫描指定内容-->

    <context:component-scan base-package="ClassPack">
        <!--自己添加过滤器：不扫描包中有注解，且注解为Component的类-->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>

3.3 属性注入

• 属性注入的注解：
  • （1）@AutoWired：
    • 自动装填，根据属性类型进行注入
  • （2）@Qualifier：
    • 根据属性的名称进行注入，此注解要和@AutoWired一起使用
  • （3）@Resource：
    • 可以根据类型注入，可以根据名称注入
    • 此注解为javax.annotation.Resource当中，新版本JDK摒弃了此API，官方推荐用上面两注解来实现
    • 新版本JDK没有@Resource解决方法：https://blog.csdn.net/qq_44518192/article/details/107644905
  • （4）@Value：
    • 注入普通类型属性

//类：
//四种属性注入演示：

@Component()
public class Attribute1 {
    //不需要添加set方法
    @Autowired
    private Attribute2 a2;

    //Attriubute接口实现类有两个，通过指定id名称（默认转配：类名小写）来创建对象
    @Autowired
    @Qualifier(value = "attribute3")
    private Attribute a3; 	//类似于：Attrribute a3 = new Attriable3();

    //跟@AutoWired方法一样
    @Resource
    private Attribute2 a4;

    //跟@Qualifier(value = "")一样
    @Resource(name = "attribute3")
    private Attribute a5;

    @Value(value = "C酱")
    private String name;

    public void show(){
        a2.show();
        a3.show();
        a4.show();
        a5.show();
        System.out.println(name);
    }
}

interface Attribute{
    public void show();
}

@Repository()
class Attribute2 implements Attribute{

    @Override
    public void show(){
        System.out.println("这里是Attribute2！");
    }

}

@Component()
class Attribute3 implements Attribute{

    @Override
    public void show(){
        System.out.println("这里是Attribute3！");
    }
}

public class attributeInjection {
    @Test
    public void test(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(".\\annotationXml\\create.xml");
        Attribute1 bean = context.getBean("attribute1", Attribute1.class);
        bean.show();
    }
}

3.4 纯注解开发

• （1）创建配置类，替代xml配置文件

  • @Configuration：作为配置类，替代xml配置文件
  • @ComponentScan(basePackages = {"ClassPack"}) ：扫描注解路径，跟xml的开启组件扫描一样

• （2）public AnnotationConfigApplicationContext(Class<?>... componentClasses) ：加载配置类

//配置类

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

//创建对象

public class pureAnnotationDevelopment {
    @Test
    public void test(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);//加载配置类
        Attribute1 bean = context.getBean("attribute1", Attribute1.class);
        bean.show();
    }
}

• 此纯注解开发，一般是SpringBoot才使用到