精华内容
下载资源
问答
  • 生命周期: 当session创建的时候,session的缓存就存在了, 当执行

    生命周期:

    当session创建的时候,session的缓存就存在了,

    当执行session.close方法时,session关闭,

    缓存清空

    展开全文
  • Session缓存和持久化生命周期

    千次阅读 2017-02-26 16:51:55
    持久化对象的生命周期Session缓存原理: Session缓存:在Hibernate中被称为一级缓存。 原理: 当应用程序调用Session的CRUD方法、以及调用查询接口的list()、iterate()或filter()方法时,如果在Session缓存中还不...

    主要内容:
    Session缓存原理
    Session缓存的应用
    持久化对象的生命周期

    Session缓存原理:
    Session缓存:在Hibernate中被称为一级缓存。
    原理:

    1. 当应用程序调用Session的CRUD方法、以及调用查询接口的list()、iterate()或filter()方法时,如果在Session缓存中还不存在相应的对象,Hibernate就会把该对象加入到第一级缓存中
    2. 当清理缓存时,Hibernate会根据缓存中对象的状态变化来同步更新数据库

    Session缓存的作用。
    1.减少访问数据库的频率
    2.保证缓存中的对象与数据库中的数据同步
    3.当缓存中的持久化对象之间存在循环关联关系时,Session会保证不4.出现访问对象图的死循环,以及由死循环引起的JVM堆栈溢出异常

    1.当应用程序调用Transaction的commit()方法时,commit()方法会清理缓存,然后再向数据库提交事务
    2.当应用程序中显示调用session的flush()方法时,通过Session的setFushMode(FlushMode fm)方法来设定清理缓存的时间点。
    3.FlushMode.ALWAYS
    4.FlushMode.AUTO
    5.FlushMode.COMMIT
    6.FlushMode.MANUAL

    持久化对象的生命周期
    瞬时(Transient)状态
    持久化(Persistent)状态
    脱管(detached)状态
    移除(removed)状态

    这里写图片描述

    展开全文
  • Spring中Bean的生命周期以及三级缓存介绍

    千次阅读 多人点赞 2019-10-09 09:18:05
    Bean的生命周期以及三级缓存介绍简述测试代码编写创建IOC容器功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中...

    简述

    spring中的bean的生命周期我们都知道有创建、使用、销毁这三个步骤,那么在源码中是怎么做的呢,以及spring中三级缓存是如何使用的呢(三级缓存也是解决循环依赖问题的关键)

    测试代码编写

    由于我搭建了源码的阅读环境,所以我就直接让项目之间关联就行了,
    在这里插入图片描述
    此处不做详解
    InstantC.java

    import org.springframework.stereotype.Component;
    
    @Component
    public class InstantC {
    	public InstantC(){
    		System.out.println("ic的构造器被调用了");
    	}
    	public void print() {
    		System.out.println("ic的bean使用");
    	}
    }
    

    MainConfigure.java

    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.ImportResource;
    
    @Configuration
    @ImportResource(locations="classpath:spring.xml")
    @ComponentScan(basePackages= {"com.zk.test"})
    public class MainConfigure {
    
    }
    

    Main .java

    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    public class Main {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		//上下文 创建IOC容器
    		AnnotationConfigApplicationContext ctx=new AnnotationConfigApplicationContext(MainConfigure.class);
    		//获取bean  去容器的缓存中直接拿
    		InstantC instantC=(InstantC) ctx.getBean("ic");
    		ctx.close();
    	}
    
    }
    

    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" 
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:tx="http://www.springframework.org/schema/tx"
        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 
            http://www.springframework.org/schema/tx 
            http://www.springframework.org/schema/tx/spring-tx.xsd">
    	<bean id="ic" class="com.zk.test.InstantC"></bean>
    </beans>
    

    以上就是测试的代码,下面来分析一下Main.java代码,需要结合源码来看

    创建IOC容器(Bean创建)

    //上下文 创建IOC容器
    AnnotationConfigApplicationContext ctx=new AnnotationConfigApplicationContext(MainConfigure.class);
    

    要想使用bean,首先要创建bean,并将bean保存到相应的容器之中,然后获取的时候直接从容器之中获取就行,我们可以断点调试一下,然后就会发现走了一下几个关键性的方法
    在这里插入图片描述
    流程图画的不美观,从上面可以看出bean创建的整个流程,
    简单叙述一下流程

    1. 创建上下文实例(AnnotationConfigApplicationContext ctx=new AnnotationConfigApplicationContext(MainConfigure.class);)的时候,会调用refresh方法刷新上下文
    2. 调用finishBeanFactoryInitialization(beanFactory);方法实例化剩余的bean;(为什么是剩余的一会可以看下代码)
    3. 执行beanFactory.preInstantiateSingletons();bean的创建就在这个方法里面
    4. 执行getBean(beanName)去获取bean
    5. 然后执行doGetBean(name, null, null, false);方法,这一块在源码有个注释是beanfactory接口的实现
    6. 执行getSingleton(beanName)方法,尝试从缓存中获取bean,由于是创建所以是不存在bean的
    7. 中间处理省略,标记玩bean正在被创建,然后执行 getSingleton(beanName,...)方法,这个在源码中是
    sharedInstance = getSingleton(beanName, () -> {
    						try {
    							//正式开始创建bean实例
    							return createBean(beanName, mbd, args);
    						}
    						catch (BeansException ex) {
    							// Explicitly remove instance from singleton cache: It might have been put there
    							// eagerly by the creation process, to allow for circular reference resolution.
    							// Also remove any beans that received a temporary reference to the bean.
    							destroySingleton(beanName);
    							throw ex;
    						}
    					});
    

    在此方法中,是先执行lambel函数的方法,然后继续往下执行,下面详细说

    1. 执行createBean(beanName, mbd, args);去创建bean
    2. 判断处理完毕之后 ,执行doCreateBean(beanName, mbdToUse, args);继续创建bean
    3. 执行createBeanInstance(beanName, mbd, args); 方法,去调用bean的构造器方法,创建一个早期对象,这个对象的属性还未被赋值
    4. 执行 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));将早期对象加入三级缓存,这是为了解决循环依赖
    5. 执行populateBean(beanName, mbd, instanceWrapper);方法,用属性值填充bean定义的实例,如果是在这一步存在依赖,就会去创建依赖的bean
    6. 执行initializeBean(beanName, exposedObject, mbd);方法初始化bean
    7. lambel函数执行结束,继续执行第七步的方法,将二三级缓存的数据清除
    8. 结束

    1.refresh()方法

    了解的话可以查看中文注释

    @Override
    	public void refresh() throws BeansException, IllegalStateException {
    		synchronized (this.startupShutdownMonitor) {
    			// Prepare this context for refreshing.
    			//准备刷新此上下文。
    			prepareRefresh();
    
    			// Tell the subclass to refresh the internal bean factory.
    			//告诉子类刷新内部bean工厂。
    			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    			// Prepare the bean factory for use in this context.
    			//准备bean工厂以供在此上下文中使用。
    			prepareBeanFactory(beanFactory);
    
    			try {
    				// Allows post-processing of the bean factory in context subclasses.
    				//允许在上下文子类中对bean工厂进行后处理。
    				postProcessBeanFactory(beanFactory);
    
    				// Invoke factory processors registered as beans in the context.
    				//调用上下文中注册为bean的工厂处理器。
    				invokeBeanFactoryPostProcessors(beanFactory);
    
    				// Register bean processors that intercept bean creation.
    				//注册拦截bean创建的bean处理器。
    				registerBeanPostProcessors(beanFactory);
    
    				// Initialize message source for this context.
    				//初始化此上下文的消息源。
    				initMessageSource();
    
    				// Initialize event multicaster for this context.
    				//为此上下文初始化事件
    				initApplicationEventMulticaster();
    
    				// Initialize other special beans in specific context subclasses.
    				//初始化特定上下文子类中的其他特殊bean。
    				onRefresh();
    
    				// Check for listener beans and register them.
    				//检查侦听器bean并注册它们。
    				registerListeners();
    
    				// Instantiate all remaining (non-lazy-init) singletons.
    				//实例化所有剩余的(非延迟初始化)单例 明显创建我们自定义的bean是在这一步
    				finishBeanFactoryInitialization(beanFactory);
    
    				// Last step: publish corresponding event.
    				//最后一步:发布对应的事件
    				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...
    				//在spring的核心中重置常见的内省缓存,因为我们可能不再需要singleton bean的元数据了……
    				resetCommonCaches();
    			}
    		}
    	}
    

    这个方法在注释里面各个部分都说的很清楚,我们只需要看finishBeanFactoryInitialization(beanFactory);这个方法就行了

    2.finishBeanFactoryInitialization(beanFactory)方法

    源码如下

    /**
    	 * Finish the initialization of this context's bean factory,
    	 * initializing all remaining singleton beans.
    	 */
    	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    		// Initialize conversion service for this context.
    		//初始化此上下文的转换服务。
    		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
    				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
    			beanFactory.setConversionService(
    					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    		}
    
    		// Register a default embedded value resolver if no bean post-processor
    		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
    		// at this point, primarily for resolution in annotation attribute values.
    		//如果在此之前没有任何bean后处理器(如propertyplaceholderconfigurerbean)注册,
    		//则注册默认的嵌入式值解析器:
    		//此时,主要是为了在注释属性值中进行解析
    		if (!beanFactory.hasEmbeddedValueResolver()) {
    			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    		}
    
    		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    		//尽早初始化loadTimeWeaveraware bean,以便尽早注册其转换器。
    		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    		for (String weaverAwareName : weaverAwareNames) {
    			getBean(weaverAwareName);
    		}
    
    		// Stop using the temporary ClassLoader for type matching.
    		//停止使用临时类加载器进行类型匹配。
    		beanFactory.setTempClassLoader(null);
    
    		// Allow for caching all bean definition metadata, not expecting further changes.
    		//允许缓存所有bean定义元数据,不需要进一步更改。
    		beanFactory.freezeConfiguration();
    
    		// Instantiate all remaining (non-lazy-init) singletons.
    		//实例化所有剩余的(非延迟初始化)单例 很明显这一步是创建的入口
    		beanFactory.preInstantiateSingletons();
    	}
    

    3. beanFactory.preInstantiateSingletons()

    源码如下

    	@Override
    	public void preInstantiateSingletons() throws BeansException {
    		if (logger.isDebugEnabled()) {
    			logger.debug("Pre-instantiating singletons in " + this);
    		}
    
    		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
    		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
    		// Trigger initialization of all non-lazy singleton beans...
    		//所有非惰性单例bean的触发器初始化…
    		for (String beanName : beanNames) {
    			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    				if (isFactoryBean(beanName)) {
    					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    					if (bean instanceof FactoryBean) {
    						final FactoryBean<?> factory = (FactoryBean<?>) bean;
    						boolean isEagerInit;
    						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
    							isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
    											((SmartFactoryBean<?>) factory)::isEagerInit,
    									getAccessControlContext());
    						}
    						else {
    							isEagerInit = (factory instanceof SmartFactoryBean &&
    									((SmartFactoryBean<?>) factory).isEagerInit());
    						}
    						if (isEagerInit) {
    							getBean(beanName);
    						}
    					}
    				}
    				else {
    					//获取bean
    					getBean(beanName);
    				}
    			}
    		}
    
    		// Trigger post-initialization callback for all applicable beans...
    		//为所有适用的bean触发初始化后回调…
    		for (String beanName : beanNames) {
    			Object singletonInstance = getSingleton(beanName);
    			if (singletonInstance instanceof SmartInitializingSingleton) {
    				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
    				if (System.getSecurityManager() != null) {
    					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
    						smartSingleton.afterSingletonsInstantiated();
    						return null;
    					}, getAccessControlContext());
    				}
    				else {
    					smartSingleton.afterSingletonsInstantiated();
    				}
    			}
    		}
    	}
    

    这一部分,我们只需要跟着断点,然后就会走到getBean(beanName);这个方法,这个地方就是获取beanNames然后遍历去执行getBean(beanName);,这个地方我们需要用到条件断点,条件断点设置方式如下
    1.先设置一个断点
    在这里插入图片描述
    2.在这个断点上右键,选择最后一个breakpoint properties,然后开始设置条件
    在这里插入图片描述
    这样条件断点就设置好了,满足条件才会进入这个断点。

    4.getBean(beanName)

    方法源码如下:

    	//---------------------------------------------------------------------
    	// Implementation of BeanFactory interface
    	//---------------------------------------------------------------------
    	//beanfactory接口的实现
    	@Override
    	public Object getBean(String name) throws BeansException {
    		return doGetBean(name, null, null, false);
    	}
    

    这一步就是为了进入doGetBean(name, null, null, false)方法

    5.doGetBean(name, null, null, false)

    源码:

    	/**
    	 * Return an instance, which may be shared or independent, of the specified bean.
    	 * @param name the name of the bean to retrieve
    	 * @param requiredType the required type of the bean to retrieve
    	 * @param args arguments to use when creating a bean instance using explicit arguments
    	 * (only applied when creating a new instance as opposed to retrieving an existing one)
    	 * @param typeCheckOnly whether the instance is obtained for a type check,
    	 * not for actual use
    	 * @return an instance of the bean
    	 * @throws BeansException if the bean could not be created
    	 */
    	@SuppressWarnings("unchecked")
    	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
    			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    		//解析bean的别名i
    		final String beanName = transformedBeanName(name);
    		Object bean;
    
    		// Eagerly check singleton cache for manually registered singletons.
    		//首先尝试去缓存池中去获取对象,是第一次创建bean缓存池中没有对象
    		Object sharedInstance = getSingleton(beanName);
    		if (sharedInstance != null && args == null) {
    			if (logger.isDebugEnabled()) {
    				if (isSingletonCurrentlyInCreation(beanName)) {
    					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
    							"' that is not fully initialized yet - a consequence of a circular reference");
    				}
    				else {
    					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
    				}
    			}
    			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    		}
    
    		else {
    			// Fail if we're already creating this bean instance:
    			// We're assumably within a circular reference.
    			//若出现循环依赖,判断bean是不是单利的不是就抛出异常
    			if (isPrototypeCurrentlyInCreation(beanName)) {
    				throw new BeanCurrentlyInCreationException(beanName);
    			}
    
    			// Check if bean definition exists in this factory.
    			//当前容器是否有父工厂,有的话,就由父工厂加载
    			BeanFactory parentBeanFactory = getParentBeanFactory();
    			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    				// Not found -> check parent.
    				String nameToLookup = originalBeanName(name);
    				if (parentBeanFactory instanceof AbstractBeanFactory) {
    					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
    							nameToLookup, requiredType, args, typeCheckOnly);
    				}
    				else if (args != null) {
    					// Delegation to parent with explicit args.
    					return (T) parentBeanFactory.getBean(nameToLookup, args);
    				}
    				else {
    					// No args -> delegate to standard getBean method.
    					return parentBeanFactory.getBean(nameToLookup, requiredType);
    				}
    			}
    			//标记为该bean正在创建
    			if (!typeCheckOnly) {
    				markBeanAsCreated(beanName);
    			}
    
    			try {
    				//合并bean并定义 合并父bean里面的属性
    				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    				//检查bean定义是不是抽象的
    				checkMergedBeanDefinition(mbd, beanName, args);
    
    				// Guarantee initialization of beans that the current bean depends on.
    				//bean加载顺序,必须dependsOn中的bean全部实例化之后 做依赖检查
    				String[] dependsOn = mbd.getDependsOn();
    				if (dependsOn != null) {
    					for (String dep : dependsOn) {
    						if (isDependent(beanName, dep)) {
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
    						}
    						registerDependentBean(dep, beanName);
    						try {
    							getBean(dep);
    						}
    						catch (NoSuchBeanDefinitionException ex) {
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
    						}
    					}
    				}
    
    				// Create bean instance.
    				//创建bean实例
    				if (mbd.isSingleton()) {
    					//再次判断缓存池中是否有bean ,没有就在回调函数里面创建bean
    					sharedInstance = getSingleton(beanName, () -> {
    						try {
    							//正式开始创建bean实例
    							return createBean(beanName, mbd, args);
    						}
    						catch (BeansException ex) {
    							// Explicitly remove instance from singleton cache: It might have been put there
    							// eagerly by the creation process, to allow for circular reference resolution.
    							// Also remove any beans that received a temporary reference to the bean.
    							destroySingleton(beanName);
    							throw ex;
    						}
    					});
    					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    				}
    
    				else if (mbd.isPrototype()) {
    					// It's a prototype -> create a new instance.
    					Object prototypeInstance = null;
    					try {
    						beforePrototypeCreation(beanName);
    						prototypeInstance = createBean(beanName, mbd, args);
    					}
    					finally {
    						afterPrototypeCreation(beanName);
    					}
    					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    				}
    
    				else {
    					String scopeName = mbd.getScope();
    					final Scope scope = this.scopes.get(scopeName);
    					if (scope == null) {
    						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
    					}
    					try {
    						Object scopedInstance = scope.get(beanName, () -> {
    							beforePrototypeCreation(beanName);
    							try {
    								return createBean(beanName, mbd, args);
    							}
    							finally {
    								afterPrototypeCreation(beanName);
    							}
    						});
    						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    					}
    					catch (IllegalStateException ex) {
    						throw new BeanCreationException(beanName,
    								"Scope '" + scopeName + "' is not active for the current thread; consider " +
    								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
    								ex);
    					}
    				}
    			}
    			catch (BeansException ex) {
    				cleanupAfterBeanCreationFailure(beanName);
    				throw ex;
    			}
    		}
    
    		// Check if required type matches the type of the actual bean instance.
    		//检查所需类型是否与实际bean实例的类型匹配。
    		if (requiredType != null && !requiredType.isInstance(bean)) {
    			try {
    				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
    				if (convertedBean == null) {
    					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    				}
    				return convertedBean;
    			}
    			catch (TypeMismatchException ex) {
    				if (logger.isDebugEnabled()) {
    					logger.debug("Failed to convert bean '" + name + "' to required type '" +
    							ClassUtils.getQualifiedName(requiredType) + "'", ex);
    				}
    				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    			}
    		}
    		return (T) bean;
    	}
    

    这个里面主要的方法有
    1.首先尝试去缓存池中去获取对象Object sharedInstance = getSingleton(beanName);
    2.markBeanAsCreated(beanName);将该bean标记为正在创建
    3.getSingleton(beanName,...);这个是再次判断缓存中是否存在bean,如果不存在该bean就会去执行创建bean的方法,以及将创建结束的bean从二级缓存移入一级缓存中
    4.createBean(beanName, mbd, args);创建bean的方法
    这里面要介绍一下dependsOn,dependsOn指的是要先进行实例化的bean,也就是有beanA和beanB,如果用注解在beanB上加上@DependsOn(beanA),那么在创建beanB之前一点更要先创建beanA,和依赖不同,依赖是指在创建beanB的过程中去创建beanA。

    6.getSingleton(String beanName)

    源码;

    @Override
    	@Nullable
    	public Object getSingleton(String beanName) {
    		return getSingleton(beanName, true);
    	}
    
    	/**
    	 * Return the (raw) singleton object registered under the given name.
    	 * <p>Checks already instantiated singletons and also allows for an early
    	 * reference to a currently created singleton (resolving a circular reference).
    	 * @param beanName the name of the bean to look for
    	 * @param allowEarlyReference whether early references should be created or not
    	 * @return the registered singleton object, or {@code null} if none found
    	 */
    	@Nullable
    	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    		//从一级缓存获取
    		Object singletonObject = this.singletonObjects.get(beanName);
    		//如果一级缓存中没有,并且已标记这个bean正在被定义
    		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    			synchronized (this.singletonObjects) {
    				//从二级缓存获取bean
    				singletonObject = this.earlySingletonObjects.get(beanName);
    				//如果二级缓存也拿不到 去三级缓存拿
    				if (singletonObject == null && allowEarlyReference) {
    					//从三级缓存取值
    					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
    					if (singletonFactory != null) {
    						singletonObject = singletonFactory.getObject();
    						//如果三级缓存存在值,将三级缓存中的缓存移除,加入二级缓存
    						this.earlySingletonObjects.put(beanName, singletonObject);
    						this.singletonFactories.remove(beanName);
    					}
    				}
    			}
    		}
    		return singletonObject;
    	}
    

    这一部分的解释都已经加在了注释上面,没有其他需要过多解释的地方

    7.getSingleton(beanName,…)

    使用的地方如下

    //创建bean实例
    if (mbd.isSingleton()) {
    	//再次判断缓存池中是否有bean ,没有就在回调函数里面创建bean
    	sharedInstance = getSingleton(beanName, () -> {
    		try {
    			//正式开始创建bean实例
    			return createBean(beanName, mbd, args);
    		}
    		catch (BeansException ex) {
    			// Explicitly remove instance from singleton cache: It might have been put there
    			// eagerly by the creation process, to allow for circular reference resolution.
    			// Also remove any beans that received a temporary reference to the bean.
    			destroySingleton(beanName);
    			throw ex;
    		}
    	});
    	bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }
    

    方法源码如下:

    	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    		Assert.notNull(beanName, "Bean name must not be null");
    		synchronized (this.singletonObjects) {
    			Object singletonObject = this.singletonObjects.get(beanName);
    			if (singletonObject == null) {
    				if (this.singletonsCurrentlyInDestruction) {
    					throw new BeanCreationNotAllowedException(beanName,
    							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
    							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
    				}
    				if (logger.isDebugEnabled()) {
    					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
    				}
    				//标识bean要被创建
    				beforeSingletonCreation(beanName);
    				boolean newSingleton = false;
    				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
    				if (recordSuppressedExceptions) {
    					this.suppressedExceptions = new LinkedHashSet<>();
    				}
    				try {
    					//执行创建bean
    					singletonObject = singletonFactory.getObject();
    					newSingleton = true;
    				}
    				catch (IllegalStateException ex) {
    					// Has the singleton object implicitly appeared in the meantime ->
    					// if yes, proceed with it since the exception indicates that state.
    					singletonObject = this.singletonObjects.get(beanName);
    					if (singletonObject == null) {
    						throw ex;
    					}
    				}
    				catch (BeanCreationException ex) {
    					if (recordSuppressedExceptions) {
    						for (Exception suppressedException : this.suppressedExceptions) {
    							ex.addRelatedCause(suppressedException);
    						}
    					}
    					throw ex;
    				}
    				finally {
    					if (recordSuppressedExceptions) {
    						this.suppressedExceptions = null;
    					}
    					afterSingletonCreation(beanName);
    				}
    				if (newSingleton) {
    					addSingleton(beanName, singletonObject);
    				}
    			}
    			return singletonObject;
    		}
    	}
    

    要关注的地方
    1.有singletonFactory调用的地方,因为这是lambel函数被调用的地方;
    2.addSingleton(beanName, singletonObject);这个地方是把二级缓存的内容加入一级缓存之中。

    	/**
    	 * Add the given singleton object to the singleton cache of this factory.
    	 * <p>To be called for eager registration of singletons.
    	 * @param beanName the name of the bean
    	 * @param singletonObject the singleton object
    	 */
    	protected void addSingleton(String beanName, Object singletonObject) {
    		synchronized (this.singletonObjects) {
    			this.singletonObjects.put(beanName, singletonObject);
    			this.singletonFactories.remove(beanName);
    			this.earlySingletonObjects.remove(beanName);
    			this.registeredSingletons.add(beanName);
    		}
    	}
    

    先把流程写完,在下面再写各级缓存如果传值的。

    8.createBean(beanName, mbd, args)

    对于这个方法,我们不需要过多看,只需要关注下面的doCreateBean(beanName, mbdToUse, args);方法

    try {
    	//真正开始创建的地方
    		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    		if (logger.isDebugEnabled()) {
    			logger.debug("Finished creating instance of bean '" + beanName + "'");
    		}
    		return beanInstance;
    	}
    

    9.doCreateBean(beanName, mbdToUse, args)

    源码如下

    	/**
    	 * Actually create the specified bean. Pre-creation processing has already happened
    	 * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
    	 * <p>Differentiates between default bean instantiation, use of a
    	 * factory method, and autowiring a constructor.
    	 * @param beanName the name of the bean
    	 * @param mbd the merged bean definition for the bean
    	 * @param args explicit arguments to use for constructor or factory method invocation
    	 * @return a new instance of the bean
    	 * @throws BeanCreationException if the bean could not be created
    	 * @see #instantiateBean
    	 * @see #instantiateUsingFactoryMethod
    	 * @see #autowireConstructor
    	 */
    	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    			throws BeanCreationException {
    
    		// Instantiate the bean.
    		//实例化bean
    		BeanWrapper instanceWrapper = null;
    		if (mbd.isSingleton()) {
    			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    		}
    		if (instanceWrapper == null) {
    			//调用bean的构造器方法进行实例化 属性还没有被赋值 早期对象
    			instanceWrapper = createBeanInstance(beanName, mbd, args);
    		}
    		final Object bean = instanceWrapper.getWrappedInstance();
    		Class<?> beanType = instanceWrapper.getWrappedClass();
    		if (beanType != NullBean.class) {
    			mbd.resolvedTargetType = beanType;
    		}
    
    		// Allow post-processors to modify the merged bean definition.
    		synchronized (mbd.postProcessingLock) {
    			if (!mbd.postProcessed) {
    				try {
    					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    				}
    				catch (Throwable ex) {
    					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    							"Post-processing of merged bean definition failed", ex);
    				}
    				mbd.postProcessed = true;
    			}
    		}
    
    		// Eagerly cache singletons to be able to resolve circular references
    		// even when triggered by lifecycle interfaces like BeanFactoryAware.
    		//这一块的意思是 将早期对象加入缓存中,以便解决循环依赖问题
    		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    				isSingletonCurrentlyInCreation(beanName));
    		if (earlySingletonExposure) {
    			if (logger.isDebugEnabled()) {
    				logger.debug("Eagerly caching bean '" + beanName +
    						"' to allow for resolving potential circular references");
    			}
    			//提前暴露早期对象 加入缓存 加入三级缓存
    			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    		}
    
    		// Initialize the bean instance.
    		//初始化bean实例
    		Object exposedObject = bean;
    		try {
    			//用属性值填充bean定义的实例,如果是在这一步存在依赖,就会去创建依赖的bean
    			populateBean(beanName, mbd, instanceWrapper);
    			//初始化方法
    			exposedObject = initializeBean(beanName, exposedObject, mbd);
    		}
    		catch (Throwable ex) {
    			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
    				throw (BeanCreationException) ex;
    			}
    			else {
    				throw new BeanCreationException(
    						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
    			}
    		}
    
    		if (earlySingletonExposure) {
    			Object earlySingletonReference = getSingleton(beanName, false);
    			if (earlySingletonReference != null) {
    				if (exposedObject == bean) {
    					exposedObject = earlySingletonReference;
    				}
    				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
    					String[] dependentBeans = getDependentBeans(beanName);
    					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
    					for (String dependentBean : dependentBeans) {
    						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
    							actualDependentBeans.add(dependentBean);
    						}
    					}
    					if (!actualDependentBeans.isEmpty()) {
    						throw new BeanCurrentlyInCreationException(beanName,
    								"Bean with name '" + beanName + "' has been injected into other beans [" +
    								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
    								"] in its raw version as part of a circular reference, but has eventually been " +
    								"wrapped. This means that said other beans do not use the final version of the " +
    								"bean. This is often the result of over-eager type matching - consider using " +
    								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
    					}
    				}
    			}
    		}
    
    		// Register bean as disposable.
    		//将bean注册为一次性的。
    		try {
    			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    		}
    		catch (BeanDefinitionValidationException ex) {
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    		}
    
    		return exposedObject;
    	}
    

    这个方法里面需要重点关注
    1.instanceWrapper = createBeanInstance(beanName, mbd, args);这是调用bean的构造器方法,创建早期对象,此时属性值还没有赋值,可以尝试在bean的构造器里面加上打印语句,执行到这一步之后就会输出
    2.addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));提前暴露早期对象 加入缓存 加入三级缓存,这一步是解决非构造注入循环依赖的关键,因为如果a和b相互依赖,那么在创建a的时候,要给a的早期对象的属性赋值,他就会去创建bean b,然后创建b的时候,b又需要a,如果不把早期对象加入缓存,那么b就会在缓存中获取不到a,然后就会去创建a,然后就形成了死循环,所以这一步是把bean暴露出来,让循环依赖的bean可以使用
    3.populateBean(beanName, mbd, instanceWrapper);这一步就是给早期对象赋属性值,如果这个bean依赖的有其他bean,那么也会在这个方法上赋值给它,如果依赖的bean获取不到,就会直接去创建这个依赖的bean,这个循环依赖的关系,下篇文章介绍
    4.exposedObject = initializeBean(beanName, exposedObject, mbd);初始化bean
    这一部分是创建bean的关键部分,也就是在这一步中把bean加入了三级缓存之中。

    10.createBeanInstance(beanName, mbd, args)

    源码:

    	/**
    	 * Create a new instance for the specified bean, using an appropriate instantiation strategy:
    	 * factory method, constructor autowiring, or simple instantiation.
    	 * @param beanName the name of the bean
    	 * @param mbd the bean definition for the bean
    	 * @param args explicit arguments to use for constructor or factory method invocation
    	 * @return a BeanWrapper for the new instance
    	 * @see #obtainFromSupplier
    	 * @see #instantiateUsingFactoryMethod
    	 * @see #autowireConstructor
    	 * @see #instantiateBean
    	 */
    	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    		// Make sure bean class is actually resolved at this point.
    		Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
    		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    		}
    
    		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    		if (instanceSupplier != null) {
    			return obtainFromSupplier(instanceSupplier, beanName);
    		}
    
    		if (mbd.getFactoryMethodName() != null) {
    			return instantiateUsingFactoryMethod(beanName, mbd, args);
    		}
    
    		// Shortcut when re-creating the same bean...
    		boolean resolved = false;
    		boolean autowireNecessary = false;
    		if (args == null) {
    			synchronized (mbd.constructorArgumentLock) {
    				if (mbd.resolvedConstructorOrFactoryMethod != null) {
    					resolved = true;
    					autowireNecessary = mbd.constructorArgumentsResolved;
    				}
    			}
    		}
    		if (resolved) {
    			if (autowireNecessary) {
    				return autowireConstructor(beanName, mbd, null, null);
    			}
    			else {
    				return instantiateBean(beanName, mbd);
    			}
    		}
    
    		// Candidate constructors for autowiring?
    		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
    				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
    			return autowireConstructor(beanName, mbd, ctors, args);
    		}
    
    		// No special handling: simply use no-arg constructor.
    		//无特殊处理:只需使用无参数构造函数。
    		return instantiateBean(beanName, mbd);
    	}
    

    这一部分是创建早期对象的代码,使用的是bean的构造器的方法,因为这个时候属性值还没赋值给bean所以叫做早期对象

    11.addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))

    源码:

    	/**
    	 * Add the given singleton factory for building the specified singleton
    	 * if necessary.
    	 * <p>To be called for eager registration of singletons, e.g. to be able to
    	 * resolve circular references.
    	 * @param beanName the name of the bean
    	 * @param singletonFactory the factory for the singleton object
    	 */
    	protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    		Assert.notNull(singletonFactory, "Singleton factory must not be null");
    		synchronized (this.singletonObjects) {
    			//判断缓存中没有就往缓存singletonFactories中放 这是三级缓存
    			if (!this.singletonObjects.containsKey(beanName)) {
    				this.singletonFactories.put(beanName, singletonFactory);
    				this.earlySingletonObjects.remove(beanName);
    				this.registeredSingletons.add(beanName);
    			}
    		}
    	}
    

    可以看出,这一段就是往三级缓存singletonFactories中放入bean,将bean暴露出来

    12.populateBean(beanName, mbd, instanceWrapper)

    这个的源码,我们需要关注的是下面这部分,这部分是依赖的关键

    if (pvs != null) {
    			//为属性赋值
    			applyPropertyValues(beanName, mbd, bw, pvs);
    		}
    

    applyPropertyValues的源码关注

    //给A中的属性B赋值的过程
    Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
    

    继续往里看
    resolveValueIfNecessary的源码片段

    // We must check each value to see whether it requires a runtime reference
    		// to another bean to be resolved.
    		//我们必须检查每个值,看看它是否需要解析另一个bean的运行时引用。
    		if (value instanceof RuntimeBeanReference) {
    			RuntimeBeanReference ref = (RuntimeBeanReference) value;
    			return resolveReference(argName, ref);
    		}
    

    resolveReference的源码

    	/**
    	 * Resolve a reference to another bean in the factory.
    	 */
    	@Nullable
    	private Object resolveReference(Object argName, RuntimeBeanReference ref) {
    		try {
    			Object bean;
    			String refName = ref.getBeanName();
    			refName = String.valueOf(doEvaluate(refName));
    			if (ref.isToParent()) {
    				if (this.beanFactory.getParentBeanFactory() == null) {
    					throw new BeanCreationException(
    							this.beanDefinition.getResourceDescription(), this.beanName,
    							"Can't resolve reference to bean '" + refName +
    									"' in parent factory: no parent factory available");
    				}
    				bean = this.beanFactory.getParentBeanFactory().getBean(refName);
    			}
    			else {
    				bean = this.beanFactory.getBean(refName);
    				this.beanFactory.registerDependentBean(refName, this.beanName);
    			}
    			if (bean instanceof NullBean) {
    				bean = null;
    			}
    			return bean;
    		}
    		catch (BeansException ex) {
    			throw new BeanCreationException(
    					this.beanDefinition.getResourceDescription(), this.beanName,
    					"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
    		}
    	}
    

    这个方法的源码之中,调用了getbean方法,我们继续往里面看

    	//---------------------------------------------------------------------
    	// Implementation of BeanFactory interface
    	//---------------------------------------------------------------------
    	//beanfactory接口的实现
    	@Override
    	public Object getBean(String name) throws BeansException {
    		return doGetBean(name, null, null, false);
    	}
    

    这个地方是不是和我们之前的一致,也就是说在这个populateBean方法里面会去获取依赖的bean。

    13.继续执行getSingleton(beanName,…)的方法

    执行

    if (newSingleton) {
    					addSingleton(beanName, singletonObject);
    				}
    

    这一部分的源码如下

    	/**
    	 * Add the given singleton object to the singleton cache of this factory.
    	 * <p>To be called for eager registration of singletons.
    	 * @param beanName the name of the bean
    	 * @param singletonObject the singleton object
    	 */
    	protected void addSingleton(String beanName, Object singletonObject) {
    		synchronized (this.singletonObjects) {
    			//加入一级缓存
    			this.singletonObjects.put(beanName, singletonObject);
    			//清除三级缓存数据
    			this.singletonFactories.remove(beanName);
    			//清除二级缓存数据
    			this.earlySingletonObjects.remove(beanName);
    			this.registeredSingletons.add(beanName);
    		}
    	}
    

    这部分把bean加入一级缓存之中,然后清除二三级缓存。

    创建总结

    以上就是创建bean的流程,总结一下就是
    1.判断缓存中是否存在bean,不存在就去创建
    2.根据bean的构造器方法创建无属性值的早期对象
    3.将早期对象暴露出来,存放入三级缓存singletonFactories
    4.早期对象赋属性值(包括依赖)
    5.初始化bean
    6.bean存入一级缓存singletonObjects,清空二三级缓存

    Bean的使用

    看一下源码的流转
    1.获取bean

    //获取bean  去容器的缓存中直接拿
    		InstantC instantC=(InstantC) ctx.getBean("ic");
    

    2.getBean(“ic”)
    源码:

    	//---------------------------------------------------------------------
    	// Implementation of BeanFactory interface
    	//---------------------------------------------------------------------
    
    	@Override
    	public Object getBean(String name) throws BeansException {
    		assertBeanFactoryActive();
    		return getBeanFactory().getBean(name);
    	}
    

    3.getBeanFactory().getBean(name);
    源码如下:

    	//---------------------------------------------------------------------
    	// Implementation of BeanFactory interface
    	//---------------------------------------------------------------------
    	//beanfactory接口的实现
    	@Override
    	public Object getBean(String name) throws BeansException {
    		return doGetBean(name, null, null, false);
    	}
    

    看到这一部分就不用再往下看了。因为上面创建bean的时候已经有了这个方法,只不过现在我们在缓存中可以拿到bean,就不会往下继续走了。

    Bean的销毁

    调用close

    ctx.close();
    

    close的源码

    	@Override
    	public void close() {
    		synchronized (this.startupShutdownMonitor) {
    			doClose();
    			// If we registered a JVM shutdown hook, we don't need it anymore now:
    			// We've already explicitly closed the context.
    			if (this.shutdownHook != null) {
    				try {
    					Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
    				}
    				catch (IllegalStateException ex) {
    					// ignore - VM is already shutting down
    				}
    			}
    		}
    	}
    

    doClose()方法源码

    	protected void doClose() {
    		// Check whether an actual close attempt is necessary...
    		if (this.active.get() && this.closed.compareAndSet(false, true)) {
    			if (logger.isInfoEnabled()) {
    				logger.info("Closing " + this);
    			}
    
    			LiveBeansView.unregisterApplicationContext(this);
    
    			try {
    				// Publish shutdown event.
    				publishEvent(new ContextClosedEvent(this));
    			}
    			catch (Throwable ex) {
    				logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
    			}
    
    			// Stop all Lifecycle beans, to avoid delays during individual destruction.
    			if (this.lifecycleProcessor != null) {
    				try {
    					this.lifecycleProcessor.onClose();
    				}
    				catch (Throwable ex) {
    					logger.warn("Exception thrown from LifecycleProcessor on context close", ex);
    				}
    			}
    
    			// Destroy all cached singletons in the context's BeanFactory.
    			destroyBeans();
    
    			// Close the state of this context itself.
    			closeBeanFactory();
    
    			// Let subclasses do some final clean-up if they wish...
    			onClose();
    
    			// Reset local application listeners to pre-refresh state.
    			if (this.earlyApplicationListeners != null) {
    				this.applicationListeners.clear();
    				this.applicationListeners.addAll(this.earlyApplicationListeners);
    			}
    
    			// Switch to inactive.
    			this.active.set(false);
    		}
    	}
    

    这个就不做仔细探寻了

    总结

    1. 三级缓存:第三级:singletonFactories 第二级:earlySingletonObjects 一级:singletonObjects
    2. bean的创建流程简述:
      1.判断缓存中是否存在bean,不存在就去创建
      2.根据bean的构造器方法创建无属性值的早期对象
      3.将早期对象暴露出来,存放入三级缓存singletonFactories
      4.早期对象赋属性值(包括依赖)
      5.初始化bean
      6.bean存入一级缓存singletonObjects,清空二三级缓存
    3. dependsOn指的是要先进行实例化的bean,也就是有beanA和beanB,如果用注解在beanB上加上@DependsOn(beanA),那么在创建 beanB之前一点更要先创建beanA,和依赖不同,依赖是指在创建beanB的过程中去创建beanA。
      最后,想要搭建源码阅读环境的可以联系我,手把手教学。
    展开全文
  • hibernate session清理缓存时间和持久化对象机制 和 java对象生命周期

    一、java对象生命周期

        1.在java中,使用new关键字,创建一个java对象,jvm就为这个对象分配一块内存空间。只要这个变量被引用,他就一直存在于内存中。如果没有被任何变量引用(包括间接引用),那么这个对象就会被垃圾回收器回收。下面用一段代码来解释:
    Customer c=new Customer();
    	  Order o1=new Order();
    	  Order 02=new Order();
    	  o1.setCustomer(c);
    	  c.getOrders().add(o1);
    	  o1=null;
    	  o2=null;
    	  c=null;
         第四行和第五行 分别建立了Customer和Order的双向关联关系。意味着c中有对o1的引用,o1有对c的引用。
    *java集合有一个重要特性:集合中存放的是java对象的引用
         当执行完o1=null时,尽管变量o1不再指向Order1对象,但是通过c.getOrders(),仍然可以导航到这个Order1对象,因此Order1对象并没有结束生命周期。
         当执行完o2=null时,Order2对象不再被任何引用变量引用,可以被回收。
         当执行完c=null时,Customer不在被任何变量引用,结束生命周期,相应的Order1对象也不会被任何引用变量引用,也结束了生命周期。
        如果希望一个java对象A一直处在生命周期中,就必须保证有一个变量引用他或者其他处于生命周期的对象B导航到这个对象A。

    二、Session缓存

         Session接口中实现包含了一系列的java集合,这些java集合构成了Session缓存,只要Session实例没有结束生命周期,存放在缓存中的对象也不会结束生命周期。
        当时用save()方法持久化一个Customer时,Customer对象被加入到缓存中,当Session的get方法视图加载一个Customer实例时,Session先判断缓存中是否已经存在了这个Customer对象。
        Session缓存的三大作用:
        1.减少数据库访问次数。
        2.当缓存中的持久化对象之间存在循环关联关系时,sess会保证不出现访问对象图的死循环。
        3.保证数据库中的相关记录与缓存中的相应对乡保持同步。

         在Session清理缓存的时候,会自动进行脏检查,如果发现Session缓存中的对象和数据库记录不一致,就会根据对象的最新属性去同步更新数据库。

    三、脏数据检查和清理缓存机制

    当一个Customer对象被加入到Session缓存中时,Session会为Customer对象的值类型属性复制一份快照,当清理缓存时,先进行脏检查来比较Customer对象的属性是否发生了变化,如果发生了变化就成这个对象为脏对象,从而同步更新数据库。下图显示了脏检查和同步数据库的过程。
                       
          清理缓存的时机:


    还有一点:经过我的测试,虽然在调用了Session的save方法之后立即打印出了insert语句,但是数据库中的数据并没有更新,也就是没有真正的执行insert

           我们还可以自己显示的指定清理缓存的时间:通过以下方法

     
    显示调用flush方法清理缓存一般用于以下场合:
         1.插入,删除,更新某个持久化对象会引发数据库中的触发器。
         2.在应用程序中,混合使用Hibernate 和jdbc
         3.JDBC驱动程序不够健壮,自动清理缓存模式下,不能正常工作。
    展开全文
  • vue.js生命周期钩子函数及缓存

    万次阅读 2017-06-26 14:31:44
    生命周期 在工作中用到最多的就是created,mounted,activated,deactivated. 由于系统需要缓存,使用了keep-alive [a-zA-Z]+/"> <router-view></router-view> </keep-alive>
  • Vue项目中created生命周期重复执行,未缓存下来,原因是什么呢?
  • 我有一个关于Hibernate的一级缓存生命期的疑问, 书上说hibernate的一级缓存是unit of work(可能是transaction?)级别的,但是又说一个persistence context(session)内有一个一级缓存。 1.但是我不明白unit ...
  • vue生命周期钩子,vue生命周期钩子,vue生命周期钩子

    千次阅读 多人点赞 2018-07-14 14:53:35
    vue 的生命周期11个钩子函数是按照以下的顺序来的 :(不可逆转哦,第11个除外) 一. 组件创建前后 1.beforeCreate 2.created 如,写一个子组件,然后挂在到父组件,在子组件中,console.log 子组件中的 data...
  • 随着对 vue 的不断了解,会越来越发现它生命周期的重要性,只有了解了它的生命周期,才能在开发项目的时候在逻辑上的很好的判断什么时候该发生什么事件,即很好的控制页面。 一、什么是 vue 生命周期 Vue 实例从...
  • Fragment Fragment生命周期 Fragment详解 Fragment生命周期详解
  • 是会在该应用的内存一直保存下去还是说当该应用退出后,图片即被回收 ?
  • 生命周期函数 beforeCreate created beforeMount mounted beforeUpdate updated beforeRouteEnter beforeRouteLeave activated deactivated beforeDestroy destroyed 一、 组件间函数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 194,924
精华内容 77,969
关键字:

缓存的生命周期