Spring 용기 초기 화 프로 세 스
136843 단어 Spring
1. 절차 입구
BeanFactory 를 만 드 는 절 차 는 refresh 방법의 두 번 째 단계 에서 시작 되 며, obtain FreshBeanFactory 방법 을 호출 하여 절 차 를 완성 합 니 다.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
2. 절차 분석
BeanFactory 를 만 드 는 절 차 는 두 번 째 단계 에서 시 작 됩 니 다. AbstractApplication Context 클래스 의 obtainFreshBeanFactory 방법 을 호출 합 니 다.
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// IoC
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
AbstractRefreshable Application Context 의 refreshBeanFactory 방법 을 호출 합 니 다:
protected final void refreshBeanFactory() throws BeansException {
// IoC ，
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
// IoC ， DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
// ： BeanDefinition
customizeBeanFactory(beanFactory);
// BeanDefinition ， loadBeanDefinitions ，
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
그 중에서 createBeanFactory 방법 을 호출 하여 IoC 용 기 를 만 듭 니 다.여기 서 만 든 것 은 Default Listable Bean Factory 입 니 다. Bean 인 스 턴 스 와 Bean Defeation 을 관리 하 는 공장 입 니 다.
2. BeanDefeation 프로 세 스 불 러 오기
1. 절차 입구
이 프로 세 스 는 AbstractRefreshable Application Context 의 refreshBean Factory 방법 에서 시 작 된 것 으로 코드 는 위 와 같이
loadBeanDefinitions(beanFactory) 을 통 해 BeanDefeation 을 불 러 옵 니 다. loadBeanDefinitions(beanFactory);
2. 흐름 도
이곳 의 호출 은 비교적 복잡 하 므 로 아래 절차 도 를 통 해 설명 할 수 있다.
AbstractRefreshabl AbstractXmlApp XmlBeanDefi loadBeanDefinitions(DefaultListableBeanFactory) loadBeanDefinitions(XmlBeanDefinitionReader) loadBeanDefinitions(Resource) loadBeanDefinitions(EncodedResource) doLoadBeanDefinitions() registerBeanDefinitions() AbstractRefreshabl AbstractXmlApp XmlBeanDefi
3. 절차 분석
Ioc 용 기 를 만 든 후 AbstractXmlapplicationContext 의 loadBeanDefinitions 를 호출 하여 beanDefeation 을 불 러 옵 니 다. 코드 는 다음 과 같 습 니 다.
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// BeanDefinition ， XML ， BeanDefinition
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
initBeanDefinitionReader(beanDefinitionReader);
// BeanDefinition BeanDefinition
loadBeanDefinitions(beanDefinitionReader);
}
다시 불 러 오 는 방법 loadBeanDefinitions 를 호출 합 니 다. 코드 는 다음 과 같 습 니 다.
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
//
// getConfigResources ，
// ：ClassPathXmlApplicationContext ， FileSystemXmlApplicationContext
Resource[] configResources = getConfigResources();
if (configResources != null) {
// XML Bean AbstractBeanDefinitionReader
reader.loadBeanDefinitions(configResources);
}
// ， FileSystemXmlApplicationContext setConfigLocations
String[] configLocations = getConfigLocations();
if (configLocations != null) {
// XML Bean AbstractBeanDefinitionReader
reader.loadBeanDefinitions(configLocations);
}
}
재 호출 방법, 코드 는 다음 과 같 습 니 다.
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
// XML
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<>(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
try {
// InputStream IO
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
// InputStream XML
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();
}
}
}
구체 적 인 읽 기 과정 은 doLoadBeanDefinitions 방법 에서 진행 되 며 읽 은 beanDefinition 정 보 를 등록 합 니 다.
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
// DOM4J XML ， Document
Document doc = doLoadDocument(inputSource, resource);
// Document ， BeanDefinition
return registerBeanDefinitions(doc, resource);
}
// 。。。
}
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
// BeanDefinitionDocumentReader Document ， BeanDefinition
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
// BeanDefinition
int countBefore = getRegistry().getBeanDefinitionCount();
// ，BeanDefinitionDocumentReader ， DefaultBeanDefinitionDocumentReader
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
// BeanDefinition
return getRegistry().getBeanDefinitionCount() - countBefore;
}
위의 registerBean Definitions 방법 에서 두 가지 방법 을 주목 합 니 다.
public XmlReaderContext createReaderContext(Resource resource) {
return new XmlReaderContext(resource, this.problemReporter, this.eventListener, this.sourceExtractor, this, getNamespaceHandlerResolver());
}
public NamespaceHandlerResolver getNamespaceHandlerResolver() {
if (this.namespaceHandlerResolver == null) {
this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
}
return this.namespaceHandlerResolver;
}
protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
return new DefaultNamespaceHandlerResolver(cl);
}
이 세 가지 방법 을 통 해 NamespaceHandler Resolver 를 초기 화 하 는 데 성 공 했 습 니 다.
DefaultBeanDefinitionDocumentReader 의 registerBeanDefinitions 방법 을 보십시오. 코드 는 다음 과 같 습 니 다.
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
logger.debug("Loading bean definitions");
// Document
Element root = doc.getDocumentElement();
// BeanDefinition
doRegisterBeanDefinitions(root);
}
이곳 의 doRegister Bean Definitions 는 Bean Definition 분석 과 등록 작업 을 진정 으로 진행 합 니 다.
protected void doRegisterBeanDefinitions(Element root) {
// ， BeanDefinition BeanDefinitionParserDelegate
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);
// http://www.springframework.org/schema/beans
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;
}
}
}
// Bean ， ，
preProcessXml(root);
// BeanDefinitionParserDelegate, Document BeanDefinition
parseBeanDefinitions(root, this.delegate);
// Bean ， ，
postProcessXml(root);
this.delegate = parent;
}
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
// Document Spring XML （beans ）
if (delegate.isDefaultNamespace(root)) {
// Document （bean 、import 、alias context、aop ）
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;
// bean 、import 、alias ，
if (delegate.isDefaultNamespace(ele)) {
parseDefaultElement(ele, delegate);
}
else {// context 、aop 、tx ，
delegate.parseCustomElement(ele);
}
}
}
}
else {
// ，
delegate.parseCustomElement(root);
}
}
기본 네 임 스페이스 와 태그 에 따라 처리 할 지 여부 에 따라 기본 처리 에 관심 을 가 집 니 다.
다음 과 같이 parseDefaultElement 에서 기본 탭 을 분석 합 니 다.
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);
}
}
여기 서 bean 태그 의 해석 에 중점 을 두 고 있 습 니 다. 예 를 들 어 processBean Definition 방법 을 호출 합 니 다.
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// ， BeanDefinition
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// ， BeanDefinition
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
// BeanDefinition BeanDefinitionRegistry（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));
}
}
여기 서 bean 에 대한 분석 을 통 해 BeanDefinition 대상 을 가 져 오고 장식 을 한 다음 에 BeanDefinition 을 Default Listable BeanFactory 에 등록 하고 Map 집합 방식 으로 저장 합 니 다.
여기 서 BeanDefinition ParserDelegate 의 세 가지 재 부팅 방법 인 parseBeanDefinitionElement 방법 을 호출 하여 bean 라벨 을 분석 합 니 다. 코드 는 다음 과 같 습 니 다.
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
// ， BeanDefinition
return parseBeanDefinitionElement(ele, null);
}
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
// bean id
String id = ele.getAttribute(ID_ATTRIBUTE);
// bean name
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
List<String> aliases = new ArrayList<>();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
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) {
// bean id name
checkNameUniqueness(beanName, aliases, ele);
}
// ， BeanDefinition
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
if (!StringUtils.hasText(beanName)) {
try {
if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
beanName = this.readerContext.generateBeanName(beanDefinition);
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null &&
beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
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);
// BeanDefinition BeanName BeanDefinitionHolder
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
// bean class
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
String parent = null;
// bean parent
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
// BeanDefinition GenericBeanDefinition
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
//
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
/** --- begin**/
//
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
//
parseMetaElements(ele, bd);
//
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
//
parseConstructorArgElements(ele, bd);
//
parsePropertyElements(ele, bd);
//
parseQualifierElements(ele, bd);
/** --- end**/
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
// 。。。
return null;
}
3. Bean 프로 세 스 만 들 기
1. 절차 입구
빈 을 만 드 는 프로 세 스 는 refresh 방법의 11 단계 입 니 다.
// bean（ ）
// ：Bean IoC、DI AOP
finishBeanFactoryInitialization(beanFactory);
2. 흐름 도
AbstractAppli DefaultListab AbstractBeanFactory AbstractAutowireC preInstantiateSingletons getBean doGetBean createBean doCreateBean AbstractAppli DefaultListab AbstractBeanFactory AbstractAutowireC
3. 절차 분석
먼저 finishBeanFactory Initialization 방법 을 통 해 DefaultListableBeanFactory 의 preInstantiateSingletons 방법 에 들 어가 면 코드 는 다음 과 같 습 니 다.
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// bean
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// bean ， ， ，
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// bean bean，
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);
}
}
}
여 기 는 주로 일반 bean 의 생 성 에 관심 을 가지 고 있 으 며, AbstractBean Factory 에 들 어 가 는 getBean 방법:
public Object getBean(String name) throws BeansException {
// Bean
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// bean
final String beanName = transformedBeanName(name);
Object bean;
// bean
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) { // bean，
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 FactoryBean Bean ， FactoryBean 。
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {// bean，
// 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);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// bean BeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// BeanDefinition Bean
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
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);
}
}
}
// Bean，
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
// Bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
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;
}
}
여 기 는 주로 하나의 Bean 의 생 성 에 관심 을 가지 고 있 습 니 다. Abstract AutowireCapableBean Factory 에 들 어 가 는 createBean 방법 입 니 다. doCreate Bean 방법 으로 이동 합 니 다. 여 기 는 bean 이 만 든 핵심 코드 입 니 다.
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
//
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// BeanPostProcessor
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// Bean （ 、 、 ）
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// bean ： Bean
// ，
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// Bean
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;
}
}
//
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
// Bean， Bean
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
// bean singleFactories(key beanName，value FactoryBean)
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// bean ： （DI ）
populateBean(beanName, mbd, instanceWrapper);
// bean ： ， bean （AOP ）
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, "...");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
여기 서 3 단 계 를 통 해 빈 의 창 조 를 실현 하고 구체 적 인 실현 은 다음 글 에서 설명 할 것 이다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
[MeU] Hashtag 기능 개발➡️ 기존 Tag 테이블에 존재하지 않는 해시태그라면 Tag , tagPostMapping 테이블에 모두 추가 ➡️ 기존에 존재하는 해시태그라면, tagPostMapping 테이블에만 추가 이후에 개발할 태그 기반 ...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
