Spring5学习之基础知识总结

1.概述

1、spring 是轻量级的开源的 javaee 框架

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

3、spring 有两个核心部分：ioc 和 aop

ioc：控制反转，把创建对象过程交给 spring 进行管理aop：面向切面，不修改源代码进行功能增强

4、spring 特点

方便解耦，简化开发aop 编程支持方便程序测试方便和其他框架进行整合方便进行事务操作降低 api 开发难度

2.入门demo

1.jar包引入

<project xmlns="http://maven.apache.org/pom/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
    xsi:schemalocation="http://maven.apache.org/pom/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelversion>4.0.0</modelversion>
    <groupid>cn.zj.springdemo</groupid>
    <artifactid>springdemo</artifactid>
    <version>0.0.1-snapshot</version>
    <description>spring的入门demo</description>


    <dependencies>

        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-core</artifactid>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-beans</artifactid>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupid>org.springframework</groupid>
            <artifactid>spring-context</artifactid>
            <version>5.3.6</version>
        </dependency>
    </dependencies>
</project>

2.bean

package cn.zj.demo.bean;

public class user {

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

3.spring的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">

    <!--1 配置user对象创建-->
    <bean id="user" class="cn.zj.demo.bean.user"></bean>

  
</beans>

4.测试代码

package cn.zj.demo.test;

import org.junit.jupiter.api.test;
import org.springframework.context.applicationcontext;
import org.springframework.context.support.classpathxmlapplicationcontext;

import cn.zj.demo.bean.user;

public class springtest {

    @test
    public void testadd() {
        // 1 加载 spring 配置文件
        applicationcontext context = new classpathxmlapplicationcontext("bean1.xml");
        // 2 获取配置创建的对象
        user user = context.getbean("user", user.class);
        system.out.println(user);
        user.add();
    }
}

5.输出

cn.zj.demo.bean.user@24111ef1
add....

3.源码

applicationcontext context = new classpathxmlapplicationcontext("bean1.xml");
public classpathxmlapplicationcontext(
            string[] configlocations, boolean refresh, @nullable applicationcontext parent)
            throws beansexception {

        super(parent);
        setconfiglocations(configlocations);
        if (refresh) {
            refresh();
        }
    }

public void refresh() throws beansexception, illegalstateexception {
        synchronized (this.startupshutdownmonitor) {
            startupstep contextrefresh = this.applicationstartup.start("spring.context.refresh");

             //容器刷新前的准备，设置上下文状态，获取属性，验证必要的属性等
            preparerefresh();

            //获取新的beanfactory，销毁原有beanfactory、为每个bean生成beandefinition等
            configurablelistablebeanfactory beanfactory = obtainfreshbeanfactory();

            // prepare the bean factory for use in this context.
            preparebeanfactory(beanfactory);

            try {
                  //配置标准的beanfactory，设置classloader，设置spel表达式解析器，添加忽略注入的接口，添加bean，添加bean后置处理器等
                postprocessbeanfactory(beanfactory);

                // 实例化并调用所有注册的beanfactory后置处理器（实现接口beanfactorypostprocessor的bean，在beanfactory标准初始化之后执行）。
                startupstep beanpostprocess = this.applicationstartup.start("spring.context.beans.post-process");
                // invoke factory processors registered as beans in the context.
                invokebeanfactorypostprocessors(beanfactory);

                //实例化和注册beanfactory中扩展了beanpostprocessor的bean。
                registerbeanpostprocessors(beanfactory);
                beanpostprocess.end();

                 //初始化国际化工具类messagesource
                initmessagesource();

                 //初始化事件广播器
                initapplicationeventmulticaster();

                 //模板方法，在容器刷新的时候可以自定义逻辑，不同的spring容器做不同的事情。
                onrefresh();

                  //注册监听器，广播early application events
                registerlisteners();

                 //实例化所有剩余的（非懒加载）单例
                //实例化的过程各种beanpostprocessor开始起作用。
                finishbeanfactoryinitialization(beanfactory);

              //refresh做完之后需要做的其他事情。
                //清除上下文资源缓存（如扫描中的asm元数据）
                //初始化上下文的生命周期处理器，并刷新（找出spring容器中实现了lifecycle接口的bean并执行start()方法）。
                //发布contextrefreshedevent事件告知对应的applicationlistener进行响应的操作

                finishrefresh();
            }

            catch (beansexception ex) {
                if (logger.iswarnenabled()) {
                    logger.warn("exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // destroy already created singletons to avoid dangling resources.
                destroybeans();

                // reset 'active' flag.
                cancelrefresh(ex);

                // propagate exception to caller.
                throw ex;
            }

            finally {
                // reset common introspection caches in spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetcommoncaches();
                contextrefresh.end();
            }
        }
    }

三级缓存

到此这篇关于spring5学习之基础知识总结的文章就介绍到这了,更多相关spring5知识总结内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！