Spring源碼之路-DefaulListableBeanFactory
DefaultSingletonBeanRegistry總結
- 這個類繼承了SimpleAliasRegistry並且實現了SingletonBeanRegistry，那麼說明此類擁有了給Bean起別名以及單例Bean註冊的相關功能，此類主要是實現了單例Bean註冊的功能
- 當前單例Bean在註冊的時候有幾個比較關鍵的屬性來做Bean的生命週期狀態的轉換
singletonObjects保存的是實力化過後的單例BeansingletonFactories保存的是單例的Bean的Bean工廠，在當前成員屬性中存在的，肯定在singletonObjects中沒有(解決循環依賴，通過它向外暴露)earlySingletonObjects這個成員屬性存放的是已經實例化後的Bean對象，但此時還沒有完全準備好，不能被外部使用的Bean。(解決循環依賴，通過它向外暴露)registeredSingletons已經註冊過的單例Bean的名字的集合
- 單例Bean實例化過程中，上面的4個成員屬性的變化，由如下方法影響:
protected void addSingleton(String beanName, Object singletonObject)這個方法是最終將實例化過後並且已經完全就緒的Bean添加到singletonObjects這個成員屬性中的方法，並且還會將Bean的名稱添加到registeredSingletons中，只要在這兩個成員變量中存在，那麼此時的Bean就是已經完全就緒，可以使用的Bean，這個方法的實現是可以被多次調用，如果兩個Bean的名字一樣，後面的Bean會覆蓋前面添加進來的Bean。但是這個protected的，應該來說提供給子類註冊使用的public void registerSingleton(String beanName, Object singletonObject)這個方法是SingletonBeanRegistry接口中的一個方法，但底層就是調用protected void addSingleton(String beanName, Object singletonObject)這個方法，只不過這裏面做了個判斷，就是如果相同的Bean名稱已經註冊過了，那麼這裏就會拋出異常protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory)這個方法是註冊一個ObjectFactory對象，他會將Bean的名稱和ObjectFactory對象存入到singletonFactories這個成員屬性中，並且也會向registeredSingletons這個成員屬性中將Bean的名稱加入進去。
- 先說下循環依賴的問題，比如說，如果我們當前正在創建一個BeanA，BeanA已經實例化結束了，那麼這個時候，他裏面有需要自動注入BeanB這個對象，這個時候又去實例化需要注入的BeanB，在實例化完BeanB以後，BeanB又需要注入的BeanA，這個時候BeanA和BeanB就產生了循環依賴的問題。
- spring的解決方案，當在容器中獲取BeanA的時候，會先去
singletonObjects中找，沒有，再去earlySingletonObjects裏面找，沒有，再去singletonFactories裏面找，這個裏面也沒有，那麼這個時候開始創建實例化BeanA，實例化完畢後，判斷如果當前BeanA正在創建，會調用這個方法將當前已經實例化過但是還沒有完全準備完畢的BeanA通過ObjectFactory接口的getObject()方法包裝，調用protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory)方法將這個對象存到singletonFactories這個屬性中，然後開始進行屬性裝配或者是實例化依賴的對象，假如這時候BeanA依賴於BeanB，這個時候會去容器中獲取BeanB，BeanB會執行相同的過程，會先去singletonObjects中找，沒有，然後去earlySingletonObjects中找，還沒有，再去singletonFactories裏面找，找到以後就調用getObject()方法獲取到BeanA對象，然後會刪除singletonFactories中的BeanA的ObjectFactory，將獲取到的BeanA對象引用存入earlySingletonObjects中，並返回BeanA對象引用，這個時候就會將已經實例化但是還沒有完全準備好的BeanA注入進來，等BeanB完全準備好以後，再將BeanB注入到BeanA中，這樣就解決了循環依賴的問題
- 上述的創建Bean前的查找過程，就是調用了當前類的
public Object getSingleton(String beanName)，這個方法又調用了protected Object getSingleton(String beanName, boolean allowEarlyReference)，這個方法裏面就是上面的查找的邏輯。
- 上面操作只要是註冊或者添加，都會向
registeredSingletons這個成員屬性寫入數據，則它保存的是所有單例Bean的名稱，不管是初始化好還是沒有初始化好的。
- 獲取單例Bean的入口方法是
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory)，如果子類要獲取單例的Bean則需要調用這個方法，因爲這個方法裏面有保存，對象在創建過程中的狀態。例如：上面說的解決循環依賴的問題的時候，判斷BeanA是否正在創建public boolean isSingletonCurrentlyInCreation(String beanName)的方法，其實是判斷當前類中的singletonsCurrentlyInCreation這個成員屬性的集合中是否包含BeanA這個名字，BeanA這個名字就是在public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory)這個入口方法中添加的
源碼註釋的大概翻譯
/**
* 共享bean實例的通用註冊表，實現
* {@link org.springframework.beans.factory.config.SingletonBeanRegistry}。
* 允許註冊應該由bean名稱獲得的所有註冊表調用者共享的單例實例。
* 還支持 {@link org.springframework.beans.factory.DisposableBean}實例
* （可能對應 或可能不對應已註冊的單例）的註冊，在註冊表關閉時銷燬。
* 可以註冊 bean 之間的依賴關係以強制執行適當的關閉命令。
*
* 此類主要用作{@link org.springframework.beans.factory.BeanFactory}
* 實現的基類，從而排除了單例bean實例的常見管理。請注意，
* {@link org.springframework.beans.factory.config.ConfigurableBeanFactory}
* 接口擴展了{@link SingletonBeanRegistry}接口。
*
* 請注意，與{{link AbstractBeanFactory}和{@link DefaultListableBeanFactory}
* （從其繼承）相比，該類既不假設beanDefinition概念也不爲bean實例指定創建過
* 程。也可以用作委託的嵌套助手。
* @author Juergen Hoeller
* @since 2.0
* @see #registerSingleton
* @see #registerDisposableBean
* @see org.springframework.beans.factory.DisposableBean
* @see org.springframework.beans.factory.config.ConfigurableBeanFactory
*/
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
/ **要保留的最大抑制異常數。 * /
private static final int SUPPRESSED_EXCEPTIONS_LIMIT = 100;
/ **單例對象的緩存：bean名稱到bean實例。 * /
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/ **單例工廠的高速緩存：Bean名稱爲ObjectFactory。 * /
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/ **早期的單例對象的高速緩存：bean名稱到bean實例。 * /
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
/ **已註冊的單例集，按註冊順序包含Bean名稱。 * /
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
/ **當前正在創建的bean的名稱。 * /
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
/ **當前在創建檢查中排除的bean名稱。 * /
private final Set<String> inCreationCheckExclusions =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
/ **收集抑制的異常，可用於關聯相關原因。 * /
@Nullable
private Set<Exception> suppressedExceptions;
/ **標誌，指示我們當前是否在destroySingletons中。 * /
private boolean singletonsCurrentlyInDestruction = false;
/ ** 需要被銷燬bean實例：Bean名稱到Bean實例。 * /
private final Map<String, Object> disposableBeans = new LinkedHashMap<>();
/ **在包含的bean名稱之間映射：bean name到bean包含的bean名稱集。 * /
private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);
/ **在依賴bean名稱之間映射：bean name到相關bean名稱的集合。 * /
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
/ **在相關的Bean名稱之間映射：Bean名稱到Bean依賴項的Bean名稱集。 * /
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
@Override
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
Assert.notNull(beanName, "Bean name must not be null");
Assert.notNull(singletonObject, "Singleton object must not be null");
synchronized (this.singletonObjects) {
Object oldObject = this.singletonObjects.get(beanName);
if (oldObject != null) {
throw new IllegalStateException("Could not register object [" + singletonObject +
"] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
}
addSingleton(beanName, singletonObject);
}
}
/**
* 將給定的單例對象添加到該工廠的單例緩存中。
* 被要求進行單例的Bean的登記。
* @param beanName Bean的名稱
* @param singletonObject 單例Bean的實例
*/
protected void addSingleton(String beanName, Object singletonObject) {
// ***** 這裏添加單例Bean的時候 跟當前Bean相關的狀態容器需要同步更新 ****
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
/**
* 如有必要，添加給定的單例工廠以構建指定的單例。
* 被要求進行單身者的緊急註冊，例如能夠解析循環引用。
* resolve circular references.
* @param beanName Bean的名稱
* @param singletonFactory 創建單例Bean的工廠
*/
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
}
@Override
@Nullable
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
/**
* 返回以給定名稱註冊的（原始）單例對象。
* <檢查已經實例化的單例，並且還允許對當前創建的單例的早期引用（解析循環引用）。
* @param beanName 要查找的bean的名稱
* @param allowEarlyReference 是否應創建早期引用
* @return 返回註冊的單例對象，如果找不到則返回{@code null}
*/
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
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;
}
/**
* 返回以給定名稱註冊的（原始）單例對象，
* 如果尚未註冊，則創建並註冊一個新對象。
* @param beanName bean的名稱
* @param singletonFactory 如果有必要的話，要懶惰地創建單例的ObjectFactory
* @return 返回註冊的單例對象
*/
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 + "'");
}
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
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;
}
}
/**
* 註冊一個在創建單例bean實例期間碰巧被抑制的異常，例如臨時循環參考解析問題。
* 默認實現保留此註冊表的抑制異常集合中的任何給定異常，最多100個異常，並將它
* 們作爲相關原因添加到最終的頂級{@link BeanCreationException}中。
* @param ex 表示要註冊的異常
* @see BeanCreationException#getRelatedCauses()
*/
protected void onSuppressedException(Exception ex) {
synchronized (this.singletonObjects) {
if (this.suppressedExceptions != null && this.suppressedExceptions.size() < SUPPRESSED_EXCEPTIONS_LIMIT) {
this.suppressedExceptions.add(ex);
}
}
}
/**
* 從該工廠的單例緩存中刪除具有給定名稱的Bean，
* 如果創建失敗，則能夠清理急於註冊的單例。
* @param beanName bean的名稱
* @see #getSingletonMutex()
*/
protected void removeSingleton(String beanName) {
synchronized (this.singletonObjects) {
this.singletonObjects.remove(beanName);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.remove(beanName);
}
}
@Override
public boolean containsSingleton(String beanName) {
return this.singletonObjects.containsKey(beanName);
}
@Override
public String[] getSingletonNames() {
synchronized (this.singletonObjects) {
return StringUtils.toStringArray(this.registeredSingletons);
}
}
@Override
public int getSingletonCount() {
synchronized (this.singletonObjects) {
return this.registeredSingletons.size();
}
}
public void setCurrentlyInCreation(String beanName, boolean inCreation) {
Assert.notNull(beanName, "Bean name must not be null");
if (!inCreation) {
this.inCreationCheckExclusions.add(beanName);
}
else {
this.inCreationCheckExclusions.remove(beanName);
}
}
public boolean isCurrentlyInCreation(String beanName) {
Assert.notNull(beanName, "Bean name must not be null");
return (!this.inCreationCheckExclusions.contains(beanName) && isActuallyInCreation(beanName));
}
protected boolean isActuallyInCreation(String beanName) {
return isSingletonCurrentlyInCreation(beanName);
}
/**
* 返回指定的單例bean當前是否在創建中在整個工廠內）
* @param beanName bean的名稱
*/
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
/**
* 創建單例之前的回調。默認實現將單例註冊爲當前正在創建中。
* @param beanName 要創建的單例的名稱
* @see #isSingletonCurrentlyInCreation
*/
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
/**
* 創建單例後的回調。
* 默認實現將單例標記爲不在創建中。
* @param beanName 已創建的單例的名稱
* @see #isSingletonCurrentlyInCreation
*/
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
/**
* 將給定的bean添加到此註冊表中的disposableBeans列表中。
* DisposableBean通常對應於註冊的單例，匹配Bean名稱，但可能是不同的實例
* 有一個適配類DisposableBeanAdapter，該Bean實例可以不直接實現DisposableBean接口
* 通過對DisposableBeanAdapte適配器模式，間接的實現DisposableBean接口
* @param beanName bean的名稱
* @param bean bean的實例
*/
public void registerDisposableBean(String beanName, DisposableBean bean) {
synchronized (this.disposableBeans) {
this.disposableBeans.put(beanName, bean);
}
}
/**
* 在兩個bean之間註冊一個包含關係，例如在內部bean及其包含的外部bean之間。
* 還根據破壞順序將包含的bean註冊爲依賴於包含的bean。
* @param containedBeanName 包含的（內部）bean的名稱
* @param containingBeanName 包含的（外部）bean的名稱
* @see #registerDependentBean
*/
public void registerContainedBean(String containedBeanName, String containingBeanName) {
synchronized (this.containedBeanMap) {
Set<String> containedBeans =
this.containedBeanMap.computeIfAbsent(containingBeanName, k -> new LinkedHashSet<>(8));
if (!containedBeans.add(containedBeanName)) {
return;
}
}
registerDependentBean(containedBeanName, containingBeanName);
}
/**
* 爲給定的bean註冊一個依賴的bean，
* 在給定的bean被銷燬之前被銷燬。
* @param beanName bean的名稱
* @param dependentBeanName 依賴的bean的名稱
*/
public void registerDependentBean(String beanName, String dependentBeanName) {
String canonicalName = canonicalName(beanName);
synchronized (this.dependentBeanMap) {
Set<String> dependentBeans =
this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
if (!dependentBeans.add(dependentBeanName)) {
return;
}
}
synchronized (this.dependenciesForBeanMap) {
Set<String> dependenciesForBean =
this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
dependenciesForBean.add(canonicalName);
}
}
/**
* 確定是否已將指定的依賴bean註冊爲依賴於給定bean或其任何傳遞依賴項。
* 簡單的就是說判斷給定的beanName 是否依賴於給定的dependentBeanName
* @param beanName 要檢查的bean的名稱
* @param dependentBeanName 依賴的bean的名稱
* @since 4.0
*/
protected boolean isDependent(String beanName, String dependentBeanName) {
synchronized (this.dependentBeanMap) {
return isDependent(beanName, dependentBeanName, null);
}
}
private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
if (alreadySeen != null && alreadySeen.contains(beanName)) {
return false;
}
String canonicalName = canonicalName(beanName);
Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
if (dependentBeans == null) {
return false;
}
if (dependentBeans.contains(dependentBeanName)) {
return true;
}
for (String transitiveDependency : dependentBeans) {
if (alreadySeen == null) {
alreadySeen = new HashSet<>();
}
alreadySeen.add(beanName);
if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
return true;
}
}
return false;
}
/**
* 確定是否已爲給定名稱的Bean註冊了依賴bean。
* @param beanName 要檢查的bean的名稱
*/
protected boolean hasDependentBean(String beanName) {
return this.dependentBeanMap.containsKey(beanName);
}
/**
* 如果有依賴的Bean，則返回依賴於指定bean的所有bean的名稱。
* @param beanName bean的名稱
* @return 返回依賴的bean名稱的數組，如果沒有則爲空數組
*/
public String[] getDependentBeans(String beanName) {
Set<String> dependentBeans = this.dependentBeanMap.get(beanName);
if (dependentBeans == null) {
return new String[0];
}
synchronized (this.dependentBeanMap) {
return StringUtils.toStringArray(dependentBeans);
}
}
/**
* 如果有依賴的Bean，返回指定bean所依賴的所有bean的名稱。
* @param beanName bean的名稱
* @return 返回bean所依賴的bean的名稱數組，如果沒有則爲空數組
*/
public String[] getDependenciesForBean(String beanName) {
Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(beanName);
if (dependenciesForBean == null) {
return new String[0];
}
synchronized (this.dependenciesForBeanMap) {
return StringUtils.toStringArray(dependenciesForBean);
}
}
public void destroySingletons() {
if (logger.isTraceEnabled()) {
logger.trace("Destroying singletons in " + this);
}
synchronized (this.singletonObjects) {
this.singletonsCurrentlyInDestruction = true;
}
String[] disposableBeanNames;
synchronized (this.disposableBeans) {
disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
}
for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
destroySingleton(disposableBeanNames[i]);
}
this.containedBeanMap.clear();
this.dependentBeanMap.clear();
this.dependenciesForBeanMap.clear();
clearSingletonCache();
}
/**
* 清除此註冊表中的所有緩存的單例實例
* @since 4.3.15
*/
protected void clearSingletonCache() {
synchronized (this.singletonObjects) {
this.singletonObjects.clear();
this.singletonFactories.clear();
this.earlySingletonObjects.clear();
this.registeredSingletons.clear();
this.singletonsCurrentlyInDestruction = false;
}
}
/**
* 銷燬給定的bean。如果找到相應的單例的Bean實例，則委託給
* {@code destroyBean}
* @param beanName bean的名稱
* @see #destroyBean
*/
public void destroySingleton(String beanName) {
// Remove a registered singleton of the given name, if any.
removeSingleton(beanName);
// Destroy the corresponding DisposableBean instance.
DisposableBean disposableBean;
synchronized (this.disposableBeans) {
disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
}
destroyBean(beanName, disposableBean);
}
/**
* 銷燬給定的bean。必須先銷燬依賴於給定bean的bean，
* 然後再銷燬bean。不應拋出任何異常。
* @param beanName bean的名稱
* @param bean 要銷燬的bean實例
*/
protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
// Trigger destruction of dependent beans first...
Set<String> dependencies;
synchronized (this.dependentBeanMap) {
// Within full synchronization in order to guarantee a disconnected Set
dependencies = this.dependentBeanMap.remove(beanName);
}
if (dependencies != null) {
if (logger.isTraceEnabled()) {
logger.trace("Retrieved dependent beans for bean '" + beanName + "': " + dependencies);
}
for (String dependentBeanName : dependencies) {
destroySingleton(dependentBeanName);
}
}
// Actually destroy the bean now...
if (bean != null) {
try {
bean.destroy();
}
catch (Throwable ex) {
if (logger.isWarnEnabled()) {
logger.warn("Destruction of bean with name '" + beanName + "' threw an exception", ex);
}
}
}
// Trigger destruction of contained beans...
Set<String> containedBeans;
synchronized (this.containedBeanMap) {
// Within full synchronization in order to guarantee a disconnected Set
containedBeans = this.containedBeanMap.remove(beanName);
}
if (containedBeans != null) {
for (String containedBeanName : containedBeans) {
destroySingleton(containedBeanName);
}
}
// Remove destroyed bean from other beans' dependencies.
synchronized (this.dependentBeanMap) {
for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
Map.Entry<String, Set<String>> entry = it.next();
Set<String> dependenciesToClean = entry.getValue();
dependenciesToClean.remove(beanName);
if (dependenciesToClean.isEmpty()) {
it.remove();
}
}
}
// Remove destroyed bean's prepared dependency information.
this.dependenciesForBeanMap.remove(beanName);
}
/**
* 將單例互斥對象公開給子類和外部協作者。
* 如果子類執行任何擴展的單例創建階段，則它們應在給定的對象上同步。
* 特別要注意的是，子類不應該具有自己的互斥體，以創建單例，以避免在
* 惰性初始化情況下出現死鎖的可能性。
*/
@Override
public final Object getSingletonMutex() {
return this.singletonObjects;
}
}
