Java Spring的refresh方法你知道吗

Java Spring的refresh方法你知道吗

目录spring的refresh方法前置知识创建 Bean 容器前的准备工作创建 Bean 容器，加载并注册 Bean总结

spring的refresh方法

前置知识

方法入口

// org.springframework.context.support.AbstractApplicationContext#refresh

类的结构图

BeanDefinition 接口定义

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

// 我们可以看到，默认只提供 sington 和 prototype 两种，

// 很多读者可能知道还有 request, session, globalSession, application, websocket 这几种，

// 不过，它们属于基于 web 的扩展。

String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;

String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

// 比较不重要，直接跳过吧

int ROLE_APPLICATION = 0;

int ROLE_SUPPORT = 1;

int ROLE_INFRASTRUCTURE = 2;

// 设置父 Bean，这里涉及到 bean 继承，不是 java 继承。请参见附录的详细介绍

// 一句话就是：继承父 Bean 的配置信息而已

void setParentName(String parentName);

// 获取父 Bean

String getParentName();

// 设置 Bean 的类名称，将来是要通过反射来生成实例的

void setBeanClassName(String beanClassName);

// 获取 Bean 的类名称

String getBeanClassName();

// 设置 bean 的 scope

void setScope(String scope);

String getScope();

// 设置是否懒加载

void setLazyInit(boolean lazyInit);

boolean isLazyInit();

// 设置该 Bean 依赖的所有的 Bean，注意，这里的依赖不是指属性依赖(如 @Autowire 标记的)，

// 是 depends-on="" 属性设置的值。

void setDependsOn(String... dependsOn);

// 返回该 Bean 的所有依赖

String[] getDependsOn();

// 设置该 Bean 是否可以注入到其他 Bean 中，只对根据类型注入有效，

// 如果根据名称注入，即使这边设置了 false，也是可以的

void setAutowireCandidate(boolean autowireCandidate);

// 该 Bean 是否可以注入到其他 Bean 中

boolean isAutowireCandidate();

// 主要的。同一接口的多个实现，如果不指定名字的话，Spring 会优先选择设置 primary 为 true 的 bean

void setPrimary(boolean primary);

// 是否是 primary 的

boolean isPrimary();

// 如果该 Bean 采用工厂方法生成，指定工厂名称。对工厂不熟悉的读者，请参加附录

// 一句话就是：有些实例不是用反射生成的，而是用工厂模式生成的

void setFactoryBeanName(String factoryBeanName);

// 获取工厂名称

String getFactoryBeanName();

// 指定工厂类中的 工厂方法名称

void setFactoryMethodName(String factoryMethodName);

// 获取工厂类中的 工厂方法名称

String getFactoryMethodName();

// 构造器参数

ConstructorArgumentValues getConstructorArgumentValues();

// Bean 中的属性值，后面给 bean 注入属性值的时候会说到

MutablePropertyValues getPropertyValues();

// 是否 singleton

boolean isSingleton();

// 是否 prototype

boolean isPrototype();

// 如果这个 Bean 是被设置为 abstract，那么不能实例化，

// 常用于作为 父bean 用于继承，其实也很少用......

boolean isAbstract();

int getRole();

String getDescription();

String getResourceDescription();

BeanDefinition getOriginatingBeanDefinition();

}

refresh 这里简单说下为什么是 refresh()，而不是 init() 这种名字的方法。因为 ApplicationContext 建立起来以后，其实我们是可以通过调用 refresh() 这个方法重建的，refresh() 会将原来的 ApplicationContext 销毁，然后再重新执行一次初始化操作。

@Override

public void refresh() throws BeansException, IllegalStateException {

// 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛

synchronized (this.startupShutdownMonitor) {

// 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符

prepareRefresh();

// 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，

// 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，

// 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean

// 这块待会会展开说

prepareBeanFactory(beanFactory);

try {

// 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，

// 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】

// 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化

// 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事

postProcessBeanFactory(beanFactory);

// 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法

invokeBeanFactoryPostProcessors(beanFactory);

// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别

// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization

// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化

registerBeanPostProcessors(beanFactory);

// 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了

initMessageSource();

// 初始化当前 ApplicationContext 的事件广播器，这里也不展开了

initApplicationEventMulticaster();

// 从方法名就可以知道，典型的模板方法(钩子方法)，

// 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）

onRefresh();

// 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过

registerListeners();

// 重点，重点，重点

// 初始化所有的 singleton beans

//（lazy-init 的除外）

finishBeanFactoryInitialization(beanFactory);

// 最后，广播事件，ApplicationContext 初始化完成

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.

// 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源

destroyBeans();

// Reset 'active' flag.

cancelRefresh(ex);

// 把异常往外抛

throw ex;

}

finally {

// Reset common introspection caches in Spring's core, since we

// might not ever need metadata for singleton beans anymore...

resetCommonCaches();

}

}

}

创建 Bean 容器前的准备工作

// 准备工作

protected void prepareRefresh() {

// 记录启动时间，

// 将 active 属性设置为 true，closed 属性设置为 false，它们都是 AtomicBoolean 类型

this.startupDate = System.currentTimeMillis();

this.closed.set(false);

this.active.set(true);

if (logger.isInfoEnabled()) {

logger.info("Refreshing " + this);

}

// Initialize any placeholder property sources in the context environment 初始化上下文环境中的任何占位符属性源。

initPropertySources();

// 校验 xml 配置文件

getEnvironment().validateRequiredProperties();

// 初始化事件集合

this.earlyApplicationEvents = new LinkedHashSet();

}

创建 Bean 容器，加载并注册 Bean

// 最重要的方法之一，这里将会初始化 BeanFactory、加载 Bean、注册 Bean 等等。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

// 关闭旧的 BeanFactory (如果有)，创建新的 BeanFactory，加载 Bean 定义、注册 Bean 等等

refreshBeanFactory();

// 返回刚刚创建的 BeanFactory

ConfigurableListableBeanFactory beanFactory = getBeanFactory();

if (logger.isDebugEnabled()) {

logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

}

return beanFactory;

}

// refreshBeanFactory

@Override

protected final void refreshBeanFactory() throws BeansException {

// 如果 ApplicationContext 中已经加载过 BeanFactory 了，销毁所有 Bean，关闭 BeanFactory

// 注意，应用中 BeanFactory 本来就是可以多个的，这里可不是说应用全局是否有 BeanFactory，而是当前

// ApplicationContext 是否有 BeanFactory

if (hasBeanFactory()) {

destroyBeans();

closeBeanFactory();

}

try {

// 初始化一个 DefaultListableBeanFactory，为什么用这个，我们马上说。

DefaultListableBeanFactory beanFactory = createBeanFactory();

// 用于 BeanFactory 的序列化，我想大部分人应该都用不到

beanFactory.setSerializationId(getId());

// 下面这两个方法很重要，别跟丢了，具体细节之后说

// 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用

customizeBeanFactory(beanFactory);

// 加载 Bean 到 BeanFactory 中

loadBeanDefinitions(beanFactory);

synchronized (this.beanFactoryMonitor) {

this.beanFactory = beanFactory;

}

}

catch (IOException ex) {

throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);

}

}

// customizeBeanFactory 配置是否允许 BeanDefinition 覆盖、是否允许循环引用。

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {

if (this.allowBeanDefinitionOverriding != null) {

// 是否允许 Bean 定义覆盖 在配置文件中定义 bean 时使用了相同的 id 或 name，默认情况下，allowBeanDefinitionOverriding 属性为 null，如果在同一配置文件中重复了，会抛错，但是如果不是同一配置文件中，会发生覆盖。

beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);

}

if (this.allowCircularReferences != null) {

// 是否允许 Bean 间的循环依赖 如:A 依赖 B，而 B 依赖 A。或 A 依赖 B，B 依赖 C，而 C 依赖 A。

beanFactory.setAllowCircularReferences(this.allowCircularReferences);

}

}

// loadBeanDefinitions 加载bean,放入 BeanFactory 中 org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)

/** 我们可以看到，此方法将通过一个 XmlBeanDefinitionReader 实例来加载各个 Bean。*/

@Override

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {

// 给这个 BeanFactory 实例化一个 XmlBeanDefinitionReader

XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

// Configure the bean definition reader with this context's

// resource loading environment.

beanDefinitionReader.setEnvironment(this.getEnvironment());

beanDefinitionReader.setResourceLoader(this);

beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

// 初始化 BeanDefinitionReader，其实这个是提供给子类覆写的，

// 我看了一下，没有类覆写这个方法，我们姑且当做不重要吧

initBeanDefinitionReader(beanDefinitionReader);

// 重点来了，继续往下

loadBeanDefinitions(beanDefinitionReader);

}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {

Resource[] configResources = getConfigResources();

if (configResources != null) {

// 往下看

reader.loadBeanDefinitions(configResources);

}

String[] configLocations = getConfigLocations();

if (configLocations != null) {

// 2

reader.loadBeanDefinitions(configLocations);

}

}

// 上面虽然有两个分支，不过第二个分支很快通过解析路径转换为 Resource 以后也会进到这里

@Override

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {

Assert.notNull(resources, "Resource array must not be null");

int counter = 0;

// 注意这里是个 for 循环，也就是每个文件是一个 resource

for (Resource resource : resources) {

// 继续往下看

counter += loadBeanDefinitions(resource);

}

// 最后返回 counter，表示总共加载了多少的 BeanDefinition

return counter;

}

// XmlBeanDefinitionReadehttp://r 303

@Override

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {

return loadBeanDefinitions(new EncodedResource(resource));

}

// XmlBeanDefinitionReader 314

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());

}

// 用一个 ThreadLocal 来存放配置文件资源

Set currentResources = this.resourcesCurrentlyBeingLoaded.get();

if (currentResources == null) {

currentResources = new HashSet(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();

}

}

}

// 还在这个文件中，第 388 行

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

throws BeanDefinitionStoreException {

try {

// 这里就不看了，将 xml 文件转换为 Document 对象

Document doc = doLoadDocument(inputSource, resource);

// 继续

return registerBeanDefinitions(doc, resource);

}

catch (...

}

// 还在这个文件中，第 505 行

// 返回值：返回从当前配置文件加载了多少数量的 Bean

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {

BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

int countBefore = getRegistry().getBeanDefinitionCount();

// 这里

documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

return getRegistry().getBeanDefinitionCount() - countBefore;

}

// DefaultBeanDefinitionDocumentReader 90

@Override

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {

this.readerContext = readerContext;

logger.debug("Loading bean definitions");

Element root = doc.getDocumentElement();

// 从 xml 根节点开始解析文件

doRegisterBeanDefinitions(root);

}

// doRegisterBeanDefinitions 经过漫长的链路，一个配置文件终于转换为一颗 DOM 树了，注意，这里指的是其中一个配置文件，不是所有的，读者可以看到上面有个 for 循环的。下面开始从根节点开始解析：

// DefaultBeanDefinitionDocumentReader 116

protected void doRegisterBeanDefinitions(Element root) {

// 我们看名字就知道，BeanDefinitionParserDelegate 必定是一个重要的类，它负责解析 Bean 定义，

// 这里为什么要定义一个 parent? 看到后面就知道了，是递归问题，

// 因为 内部是可以定义 的，所以这个方法的 root 其实不一定就是 xml 的根节点，也可以是嵌套在里面的 节点，从源码分析的角度，我们当做根节点就好了

BeanDefinitionParserDelegate parent = this.delegate;

this.delegate = createDelegate(getReaderContext(), root, parent);

if (this.delegate.isDefaultNamespace(root)) {

// 这块说的是根节点 中的 profile 是否是当前环境需要的，

// 如果当前环境配置的 profile 不包含此 profile，那就直接 return 了，不对此 解析

// 不熟悉 profile 为何物，不熟悉怎么配置 profile 读者的请移步附录区

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); // 钩子 preProcessXml(root) 和 postProcessXml(root) 是给子类用的钩子方法，鉴于没有被使用到，也不是我们的重点，我们直接跳过。

// 往下看

parseBeanDefinitions(root, this.delegate);

postProcessXml(root); // 钩子

this.delegate = parent;

}

// default namespace 涉及到的就四个标签 、、 和 ，

// 其他的属于 custom 的

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)) {

// 解析 default namespace 下面的几个元素

parseDefaultElement(ele, delegate);

}

else {

// 解析其他 namespace 的元素

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);

}

}

// DefaultBeanDefinitionDocumentReader 298

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

// 将 节点中的信息提取出来，然后封装到一个 BeanDefinitionHolder 中，细节往下看

BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

// 下面的几行先不要看，跳过先，跳过先，跳过先，后面会继续说的

if (bdHolder != null) {

bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

try {

// Register the final decorated instance.

BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

}

catch (BeanDefinitionStoreException ex) {

getReaderContext().error("Failed to register bean definition with name '" +

bdHolder.getBeanName() + "'", ele, ex);

}

// Send registration event.

getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));

}

}

// BeanDefinitionParserDelegate 428

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {

return parseBeanDefinitionElement(ele, null);

}

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {

String id = ele.getAttribute(ID_ATTRIBUTE);

String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

List aliases = new ArrayList();

// 将 name 属性的定义按照 “逗号、分号、空格” 切分，形成一个 别名列表数组，

// 当然，如果你不定义 name 属性的话，就是空的了

// 我在附录中简单介绍了一下 id 和 name 的配置，大家可以看一眼，有个20秒就可以了

if (StringUtils.hasLength(nameAttr)) {

String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);

aliases.addAll(Arrays.asList(nameArr));

}

String beanName = id;

// 如果没有指定id, 那么用别名列表的第一个名字作为beanName

if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {

beanName = aliases.remove(0);

if (logger.isDebugEnabled()) {

logger.debug("No XML 'id' specified - using '" + beanName +

"' as bean name and " + aliases + " as aliases");

}

}

if (containingBean == null) {

checkNameUniqueness(beanName, aliases, ele);

}

// 根据 ... 中的配置创建 BeanDefinition，然后把配置中的信息都设置到实例中,

// 细节后面细说，先知道下面这行结束后，一个 BeanDefinition 实例就出来了。

AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

// 到这里，整个 标签就算解析结束了，一个 BeanDefinition 就形成了。

if (beanDefinition != null) {

// 如果都没有设置 id 和 name，那么此时的 beanName 就会为 null，进入下面这块代码产生

// 如果读者不感兴趣的话，我觉得不需要关心这块代码，对本文源码分析来说，这些东西不重要

if (!StringUtils.hasText(beanName)) {

try {

if (containingBean != null) {// 按照我们的思路，这里 containingBean 是 null 的

beanName = BeanDefinitionReaderUtils.generateBeanName(

beanDefinition, this.readerContext.getRegistry(), true);

}

else {

// 如果我们不定义 id 和 name，那么我们引言里的那个例子：

// 1. beanName 为：com.javadoop.example.MessageServiceImpl#0

// 2. beanClassName 为：com.javadoop.example.MessageServiceImpl

beanName = this.readerContext.generateBeanName(beanDefinition);

String beanClassName = beanDefinition.getBeanClassName();

if (beanClassName != null &&

beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&

!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {

// 把 beanClassName 设置为 Bean 的别名

aliases.add(beanClassName);

}

}

if (logger.isDebugEnabled()) {

logger.debug("Neither XML 'id' nor 'name' specified - " +

"using generated bean name [" + beanName + "]");

}

}

catch (Exception ex) {

error(ex.getMessage(), ele);

return null;

}

}

String[] aliasesArray = StringUtils.toStringArray(aliases);

// 返回 BeanDefinitionHolder

return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);

}

return null;

}

看到这里的时候，我觉得读者就应该站在高处看 ApplicationContext 了，ApplicationContext 继承自 BeanFactory，但是它不应该被理解为 BeanFactory 的实现类，而是说其内部持有一个实例化的 BeanFactory（DefaultListableBeanFactory）。以后所有的 BeanFactory 相关的操作其实是委托给这个实例来处理的。

我们说说为什么选择实例化 DefaultListableBeanFactory ？前面我们说了有个很重要的接口 ConfigurableListableBeanFactory，它实现了 BeanFactory 下面一层的所有三个接口，我把之前的继承图再拿过来大家再仔细看一下：

我们可以看到 ConfigurableListableBeanFactory 只有一个实现类DefaultListableBeanFactory，而且实现类 DefaultListableBeanFactory 还通过实现右边的 AbstractAutowireCapableBeanFactory 通吃了右路。所以结论就是，最底下这个家伙 DefaultListableBeanFactory 基本上是最牛的 BeanFactory 了，这也是为什么这边会使用这个类来实例化的原因。

循环依赖

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注我们的更多内容!

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。