Spring学习–IOC容器

最新推荐文章于 2023-03-25 20:47:39 发布
最新推荐文章于 2023-03-25 20:47:39 发布
阅读量235 收藏
点赞数
分类专栏： spring学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eos2009/article/details/76548974
版权

IOC容器分类（核心数据结构BeanDefinition）

  • BeanFactory基础实现
  • ApplicationContext高级实现

启动过程分析

IOC容器启动：包括BeanDefinition的Resource的定位、载入、注册三个过程。spring将其分开，通过不同模块来完成，以便用户可以对三个过程进行剪裁或扩展

  • 定位：ResourceLoader 如：FileSystemResource（读取文件系统中resource
    ）、ClassPathResource（读取classPath中resource）、servletContextResource
  • 载入：BeanDefinitionReader
  • 注册：BeanDefinitionRegistry

初始化完成的BeanDefinition保存在ConcurrentHashMap中

BeanFactory 和 FactoryBean &来区分

  • beanFactory是factory spring中的bean都由它管理
  • 一个是bean 特殊的bean 能产生或者修饰对象生成的工厂bean （工厂模式 修饰器模式）

基础IOC容器分析：BeanFactory

  • DefaultListablesBeanFactory spring将其当成一个默认的功能完整的IOC容器使用
  • XmlBeanDefinitionReader 解析xml方式配置的BeanDefinition
    使用方法loadBeanDefinitions(Resource resource)

编程方式分析IOC

  1. 创建IOC配置文件抽象资源，资源包含了BeanDefinitions定义
  2. 创建一个BeanFactory，一般使用DefaultListablesBeanFactory
  3. 创建一个BeanDefinition读取器，XmlBeanDefinitionReader
    载入XML形式的BeanDefinition
  4. 读取配置信息
  5. IOC容器建立，使用
    示例代码 
package com.chenfei;

import com.chenfei.entity.Teacker;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.core.io.ClassPathResource;

/**
 * Created by chenfei on 2017/7/31.
 */
public class SpringCode {
    public static void main(String[] args) {
        ClassPathResource resource = new ClassPathResource("beans.xml");
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory );
        reader.loadBeanDefinitions(resource);

         Teacker teacker = (Teacker)factory.getBean("teacher");
        teacker.teach();
    }
}

高级IOC容器分析：ApplicationContext

除了支持基本IOC容器功能，增加了
  1. 支持不同的信息源
  2. 访问资源（可以从不同的途径得到Bean定义的资源） 继承DefaultResourceLoader
  3. 支持应用事件 实现接口ApplicationEventPublisher
  4. 一般建议使用applicationContext作为IOC容器的基本形式

已FileSystemXmlApplicationContext来分析ApplicationContext ， 类图如下
这里写图片描述

FileSystemXmlApplicationContext 构造方法

  • 设置configLocation

  • 调用父类AbstractApplicationContext中refresh初始化容器

AbstractApplicationContext refresh()方法

  • 调用子类AbstractRefreshableApplicationContext中 refreshBeanFactory()
    创建IOC容器DefaultListableBeanFactory，启动载入BeanDefinition

AbstractRefreshableApplicationContext refreshBeanFactory()方法

  • 调用子类AbstractXmlApplicationContext中loadbeanDefinitions()方法 创建

XmlbeanDefinitionReader

  • 设置ResourceLoader

  • 启动载入BeanDefinition（AbstractBeanDefinitionReader实现方法loadBeanDefinitions()）

AbstractBeanDefinitionReader

  • 调用子类XmlBeanDefinitionReader loadBeanDefinitions() 方法

XmlBeanDefinitionReader

  • loadBeanDefinitions(resource) 方法
  • doLoadBeanDefinitions(InputSource ，resource)方法(1)
  • registerBeanDefinitions(Document，Resource)方法
    创建DefaultBeanDefinitionDocumentReader 调用其
  • registerBeanDefinitions(Document,XmlReaderContext)方法

DefaultBeanDefinitionDocumentReader

  • registerBeanDefinitions(Document,XmlReaderContext)方法
  • doRegisterbeanDefinitions(Element)
    创建BeanDefinitionParserDelegate
  • parseBeanDefinitions(Element,BeanDefinitionParserDelegate)(2)
  • parseDefaultElement(Element,BeanDefinitionParserDelegate)
  • processBeanDefinition(Element,BeanDefinitionParserDelegate)

BeanDefinitionParserDelegate的parserBeanDefinitionElement(Element)方法

  • 解析结果组装为BeanDefinitionHolder对象 ，该对象拥有BeanDefinition属性

BeanDefinitionReaderUtils

  • RegisterBeanDefinition(BeanDefinitionHolder,BeanDefinitionRegistry)方法
    将BeanDefinition注册到容器DefaultListableBeanFactory的map中

注意：
BeanDefinition载入分两部分
(1)调用Xml解析器得到document对象
(2)按照spring规则解析
BeanDefinition注册
isAllowBeanDefinitionOverriding有同名时判断，不允许抛出异常

源码分析

AbstractApplicationContext中实现refresh

public void refresh() throws BeansException, IllegalStateException {
    Object var1 = this.startupShutdownMonitor;
    synchronized(this.startupShutdownMonitor) {
        this.prepareRefresh();
        //创建beanFactory  在子类中启动refreshBeanFactory()
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        this.prepareBeanFactory(beanFactory);

        try {
            //设置beanFactory后置处理
            this.postProcessBeanFactory(beanFactory);
            //调用beanFactory后处理器，这些后处理器是在bean定义中向容器注册的
            this.invokeBeanFactoryPostProcessors(beanFactory);
            //注册bean的后处理器，在bean创建过程中调用
            this.registerBeanPostProcessors(beanFactory);
            //对上下文中的消息源进行初始化
            this.initMessageSource();
            //初始化上下文中的事件机制
            this.initApplicationEventMulticaster();
            //初始化其它特殊bean
            this.onRefresh();
            //检查监听bean，并将这些bean向容器注册
            this.registerListeners();
            //实例化所有的（non-lazy-init）
            this.finishBeanFactoryInitialization(beanFactory);
            //发布容器事件，结束refresh过程
            this.finishRefresh();
        } catch (BeansException var9) {
            if(this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
            }

            this.destroyBeans();
            this.cancelRefresh(var9);
            throw var9;
        } finally {
            this.resetCommonCaches();
        }
    }
}

应用于文件系统的Resource实现， 该方法在BeanDefinitionReader中loadBeanDefinition()中被调用  （loadBeanDefinition 才有模版模式，具体实现由子类实现）
protected Resource getResourceByPath(String path) {
    if(path != null && path.startsWith("/")) {
        path = path.substring(1);
    }

    return new FileSystemResource(path);
}

AbstractRefreshableApplicationContext

protected final void refreshBeanFactory() throws BeansException {
    if(this.hasBeanFactory()) {
        this.destroyBeans();
        this.closeBeanFactory();
    }

    try {
        //创建IOC容器  这里使用DefaultListableBeanFactory
        DefaultListableBeanFactory ex = this.createBeanFactory();
        ex.setSerializationId(this.getId());
        this.customizeBeanFactory(ex);
        //启动对BeanDefinition的载入
        this.loadBeanDefinitions(ex);
        Object var2 = this.beanFactoryMonitor;
        synchronized(this.beanFactoryMonitor) {
            this.beanFactory = ex;
        }
    } catch (IOException var5) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
    }
}

AbstractXmlApplicationContext

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    //创建BeanDefinitionReader，通过回调设置到beanFactory中
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    //配置ResourceLoader，因为父类是DefaultResourceLoader，所有this直接使用
    beanDefinitionReader.setResourceLoader(this);
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
    //启动bean信息定义载入过程
    this.initBeanDefinitionReader(beanDefinitionReader);
    this.loadBeanDefinitions(beanDefinitionReader);
}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    Resource[] configResources = this.getConfigResources();
    if(configResources != null) {
        reader.loadBeanDefinitions(configResources);
    }

    String[] configLocations = this.getConfigLocations();
    if(configLocations != null) {
        reader.loadBeanDefinitions(configLocations);
    }

}

AbstractBeanDefinitionReader

public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
    //这里获取的是DefaultResourceLoader
    ResourceLoader resourceLoader = getResourceLoader();
    if (resourceLoader == null) {
        throw new BeanDefinitionStoreException(
                "Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
    }

    if (resourceLoader instanceof ResourcePatternResolver) {
        // Resource pattern matching available.
        try {
            Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
            int loadCount = loadBeanDefinitions(resources);
            if (actualResources != null) {
                for (Resource resource : resources) {
                    actualResources.add(resource);
                }
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
            }
            return loadCount;
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(
                    "Could not resolve bean definition resource pattern [" + location + "]", ex);
        }
    }
    else {
        // Can only load single resources by absolute URL.
        Resource resource = resourceLoader.getResource(location);
        int loadCount = loadBeanDefinitions(resource);
        if (actualResources != null) {
            actualResources.add(resource);
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
        }
        return loadCount;
    }
}

DefaultResourceLoader

public Resource getResource(String location) {
    Assert.notNull(location, "Location must not be null");
    Iterator ex = this.protocolResolvers.iterator();

    Resource resource;
    do {
        if(!ex.hasNext()) {
            //处理'/'开头的Resource
            if(location.startsWith("/")) {
                return this.getResourceByPath(location);
            }

            //处理 classpath开头 的Resource
            if(location.startsWith("classpath:")) {
                return new ClassPathResource(location.substring("classpath:".length()), this.getClassLoader());
            }

            try {
                //处理URL标识的Resource
                URL ex1 = new URL(location);
                return new UrlResource(ex1);
            } catch (MalformedURLException var5) {
                //其它情况 默认得到ClassPathContextReaource   一般由子类实现见AbstractApplicationContext中实现
                return this.getResourceByPath(location);
            }
        }

        ProtocolResolver protocolResolver = (ProtocolResolver)ex.next();
        resource = protocolResolver.resolve(location, this);
    } while(resource == null);

    return resource;
}

XmlBeanDefinitionReader

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
    return loadBeanDefinitions(new EncodedResource(resource));
}
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
    Assert.notNull(encodedResource, "EncodedResource must not be null");
    if (logger.isInfoEnabled()) {
        logger.info("Loading XML bean definitions from " + encodedResource.getResource());
    }
    Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
    if (currentResources == null) {
        currentResources = new HashSet<EncodedResource>(4);
        this.resourcesCurrentlyBeingLoaded.set(currentResources);
    }
    if (!currentResources.add(encodedResource)) {
        throw new BeanDefinitionStoreException(
                "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
    }
    try {
        InputStream inputStream = encodedResource.getResource().getInputStream();
        try {
            InputSource inputSource = new InputSource(inputStream);
            if (encodedResource.getEncoding() != null) {
                inputSource.setEncoding(encodedResource.getEncoding());
            }
            return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
        }
        finally {
            inputStream.close();
        }
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException(
                "IOException parsing XML document from " + encodedResource.getResource(), ex);
    }
    finally {
        currentResources.remove(encodedResource);
        if (currentResources.isEmpty()) {
            this.resourcesCurrentlyBeingLoaded.remove();
        }
    }
}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
        throws BeanDefinitionStoreException {
    try {
        //调用xml解析器得到Document对象
        Document doc = doLoadDocument(inputSource, resource);
        //使用spring规则解析document  并调用BeanDefinitionReaderUtils注册BeanDefinition
        return registerBeanDefinitions(doc, resource);
    }
    catch (BeanDefinitionStoreException ex) {
        throw ex;
    }
    catch (SAXParseException ex) {
        throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
    }
    catch (SAXException ex) {
        throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                "XML document from " + resource + " is invalid", ex);
    }
    catch (ParserConfigurationException ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),
                "Parser configuration exception parsing XML from " + resource, ex);
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),
                "IOException parsing XML document from " + resource, ex);
    }
    catch (Throwable ex) {
        throw new BeanDefinitionStoreException(resource.getDescription(),
                "Unexpected exception parsing XML document from " + resource, ex);
    }
}
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    //创建BeanDefinitionDocumentReader 
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    int countBefore = getRegistry().getBeanDefinitionCount();
    //使用 documentReader 按spring规则解析document
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

DefaultBeanDefinitionDocumentReader

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
    this.readerContext = readerContext;
    logger.debug("Loading bean definitions");
    Element root = doc.getDocumentElement();
    doRegisterBeanDefinitions(root);
}
protected void doRegisterBeanDefinitions(Element root) {
    BeanDefinitionParserDelegate parent = this.delegate;
    this.delegate = createDelegate(getReaderContext(), root, parent);
    if (this.delegate.isDefaultNamespace(root)) {
        String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
        if (StringUtils.hasText(profileSpec)) {
            String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                    profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                if (logger.isInfoEnabled()) {
                    logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                            "] not matching: " + getReaderContext().getResource());
                }
                return;
            }
        }
    }
    preProcessXml(root);
    //使用BeanDefinitionParserDelegate 解析
    parseBeanDefinitions(root, this.delegate);
    postProcessXml(root);

    this.delegate = parent;
}
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    if (delegate.isDefaultNamespace(root)) {
        NodeList nl = root.getChildNodes();
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            if (node instanceof Element) {
                Element ele = (Element) node;
                if (delegate.isDefaultNamespace(ele)) {
                    parseDefaultElement(ele, delegate);
                }
                else {
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
        delegate.parseCustomElement(root);
    }
}
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    }
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    }
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        processBeanDefinition(ele, delegate);
    }
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        doRegisterBeanDefinitions(ele);
    }
}
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            //注册beanDefinition到容器  DefaultListableBeanFactory
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" +
                    bdHolder.getBeanName() + "'", ele, ex);
        }
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}
eos2009
关注
专栏目录
Spring——IOC容器
ouyangkq666的博客
12-13 937
​目录 一、IOC底层原理 1、什么是IOC 2、IOC底层原理 3、画图讲解IOC底层原理 二、IOC接口 三、IOC操作Bean管理（概念） 四、IOC操作Bean管理（基于xml） 五、IOC操作Bean管理（xml注入其他类型属性） 六、IOC操作Bean管理（xml注入集合属性） 七、IOC操作Bean管理（FactoryBean） 八、IOC操作Bean管理（bean作用域） 九、IOC操作Bean管理（bean生命周期） 十、IOC操作Bean管理（xml自动装配） 十一、IOC操作Bean
Spring IOC容器
weixin_41909330的博客
12-01 171
Spring IOC容器一、Spring IOC容器二、使用Spring IOC容器装载和配置Bean（使用AnnotationConfigApplicationContext容器） 一、Spring IOC容器 1、容器主要功能（BeanFactory容器） 发布Bean实例： 发布Bean到容器中。 获取Bean 根据名称获取实例 根据类型获取实例 获取Bean类型 获取Bean别名 容器是...
普元eos-springbean开发
10-24
普元eos-springbean开发
定时任务时间设置
weixin_40628102的博客
12-20 991
具体测试见：http://cron.qqe2.com/ 关于定时时间的设置方式如下： CronTrigger配置完整格式为： [秒] [分] [小时] [日] [月] [周] [年] 示例： 0 0 10,14,16 * * ? 每天上午10点，下午2点，4点 0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时 0 0 12 ? * WED 表示每个星期三中午12点 “0 0...
获取相关的spring bean定义
我轻轻驻足，为那颗滚落花下的露珠
10-24 682
/**  *  */ package cn.com.btmu.art.framework.util; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.BeansException; import org.springframework.context.
Spring之IOC容器
qq_36851469的博客
01-30 542
IOC容器 DefaultSingletonBeanRegistry中singletonObjects就是自定义Bean最终的IOC容器。 入口：AbstractApplicationContext–>finishBeanFactoryInitialization(beanFactory) DefaultListableBeanFactory /** Map of bean definit...
Spring的IoC容器
Lecheng_的博客
05-08 948
Spring的IoC容器 IoC在程序开发中，实例的创建不再由调用者管理，而是由Spring容器创建。Spring容器会负责控制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序代码转移到了Spring容器中，控制权发生了反转，这就是Spring的IoC思想基础理论回顾 Spring是一个轻量级的控制反转IoC/DI依赖注入和面向切面AOP的开源容器框架，是一个开源的 Java/Java EE全功能栈full-stack的应用程序框架，以Apache许可证形式发布 Spring是一个轻量级的DI/
Spring零基础入门到精通 --- IOC基础容器
shuai_h的博客
03-25 1534
Spring零基础入门到精通
Java - Spring-IoC（Inverse of Control）–> 控制反转
最新发布
03-11
综上所述，Spring框架通过其强大的IoC容器和依赖注入机制，极大地简化了Java应用的开发流程，并提升了应用的可维护性和扩展性。对于开发者而言，了解这些基础知识是非常重要的，它可以帮助我们更好地理解和使用...
Spring框架 -IOC、工厂类
sun_shine_szc的博客
03-04 305
一、Spring的概述 1、什么是Spring Spring框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring解决了开发者在J2EE开发中遇到的许多常见的问题，提供了功能强大IOC、AOP及Web MVC等功能。Spring可以单独应用于构筑应用程序，也可以和Stru...
Spring是如何通过IOC来创建对象的？一文足矣
程序媛小琬的博客
06-02 1524
Spring是如何获取对象的？①新建一个maven项目后导入webmvc的依赖：因为webmvc包含了很多其他依赖，为了省事，干脆导入一个总的，方便省事！版本嘛！个人比较喜欢用最新版。 ②新建实体测试类： ③在resources目录下新建ContextAplication.xml文件 ④以上前提之后，你会发现你的测试Person类种发生了变化：点击可以跳转到指定的xml位置哦~ ⑤测试：Context.getBean() 不指定类时，需要强制转换，所以建议使用第二种方式来获取对象 ⑥执行结果如下：...
sharding-jdbc使用
eos2009的博客
03-06 6213
示例代码    https://gitee.com/chenfei01/my-zb/tree/master/learn-sharding-jdbc简介    sharding-jdbc是当当提供的开源的分库分表，读写分离工具，已jar包形式提供服务，不需要中间层，不需要部署    功能简介：        分库分表        读写分离        分布式主键（64位   一位符号为 0  +...
springboot学习----事件监听
eos2009的博客
09-01 2094
起源Spring的Application拥有发布事件并且注册事件监听器的能力，拥有一套完整的事件发布和监听机制。在Java中，通过java.util. EventObject来描述事件，通过java.util. EventListener来描述事件监听器，在众多的框架和组件中，建立一套事件机制通常是基于这两个接口来进行扩展。概念 ApplicationEvent就是Spring的事件接口 Appli
spring学习----线程池
eos2009的博客
11-23 879
简介创建和销毁线程需要时间、资源 线程池可以达到这样的效果：一个线程执行完任务之后，继续去执行下一个任务，不被销毁，这样线程利用率提高了。 参数 corePoolSize：线程池的大小。线程池创建之后不会立即去创建线程，而是等待线程的到来。当当前执行的线程数大于改值是，线程会加入到缓冲队列； maximumPoolSize：线程池中创建的最大线程数； keepAliveTime：空闲的线程多久时
springboot学习----加载application.property
eos2009的博客
09-05 446
起因spring boot启动会自动加载资源目录下的application.property 默认加载路径 "classpath:/,classpath:/config/,file:./,file:./config/"; 默认文件名称 application 修改默认文件名称属性 "spring.config.name" 修改默认加载路径属性 "spring.config.location" pro
spring + mybatis + c3p0 整合（源码分析）
eos2009的博客
04-24 408
文章目录摘要通过一次数据库操作分析mybatismybatis核心对象示例代码mapper代理对象MapperProxyspring的mybatis相关bean加载MapperScannerConfigurer类ClassPathMapperScanner类MapperFactoryBean 实现Mapper的代理对象MapperProxy创建SqlSessionTemplate是mybatis核心类， 摘要 近期由于项目使用mybatis出现了数据源阻塞，导致应用程序假死，服务超时引发严重后果，故此下定决
spring学习----spring事物异常回滚
eos2009的博客
10-19 299
1、异常的一些基本知识异常的架构 　　异常的继承结构：Throwable为基类，Error和Exception继承Throwable。Error和RuntimeException及其子类成为未检查异常（unchecked），其它异常成为已检查异常（checked）。　　Error异常 　　Error表示程序在运行期间出现了十分严重、不可恢复的错误，在这种情况下应用程序只能中止运行，例如JAVA
spring学习----注解描述
eos2009的博客
12-04 295
有些注解总是忘记含义，特此记录一下java注解@Target({ ElementType.FIELD, ElementType.PARAMETER, ElementType.METHOD }) Java的元注解（指修饰注解的注解）之一。用来指定注解修饰类的哪个成员@Retention(RetentionPolicy.RUNTIME) 注解按生命周期来划分可分为3类：RetentionPolicy
spring学习----bean实例化
eos2009的博客
08-04 275
实例化相关核心类 AbstractBeanFactory 实现getBean AbstractAutowireCapableBeanFactory 实现createBean（即实例化bean） 其它类 ApplicationContextAwareProcessor （实现BeanPostProcessor接口） 使bean能获取容器相关特性 private void invokeAwa
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值