2. 程式人生 > >Spring開閉原則的表現-BeanPostProcessor擴充套件點-1

Spring開閉原則的表現-BeanPostProcessor擴充套件點-1

阿新 • • 發佈：2019-01-07

http://jinnianshilongnian.iteye.com/blog/1489787

上接繼續分析，在分析上篇的問題之前，我們需要了解下BeanPostProcessor概念和Spring容器建立Bean的流程。

一、BeanPostProcessor是什麼

介面定義

Java程式碼  收藏程式碼
  1. package org.springframework.beans.factory.config;  
  2. public interface BeanPostProcessor {  
  3.     Object postProcessBeforeInitialization(Object bean, String beanName) throws
     BeansException;  
  4.     Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;  
  5. }  

BeanPostProcessor是Spring容器的一個擴充套件點，可以進行自定義的例項化、初始化、依賴裝配、依賴檢查等流程，即可以覆蓋預設的例項化，也可以增強初始化、依賴注入、依賴檢查等流程，其javadoc有如下描述：

    e.g. checking for marker interfaces or wrapping them with proxies.

    大體意思是可以檢查相應的標識介面完成一些自定義功能實現，如包裝目標物件到代理物件。

我們可以看到BeanPostProcessor一共有兩個回撥方法postProcessBeforeInitialization和postProcessAfterInitialization，那這兩個方法會在什麼Spring執行流程中的哪個步驟執行呢？還有目前Spring提供哪些相應的實現呢？

Spring還提供了BeanPostProcessor一些其他介面實現，來完成除例項化外的其他功能，後續詳細介紹。

二、通過原始碼看看建立一個Bean例項的具體執行流程：


 

AbstractApplicationContext內部使用DefaultListableBeanFactory，且DefaultListableBeanFactory繼承AbstractAutowireCapableBeanFactory，因此我們此處分析AbstractAutowireCapableBeanFactory即可。

一、AbstractAutowireCapableBeanFactory的createBean方法程式碼如下：

Java程式碼  收藏程式碼
  1. protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) throws BeanCreationException {  
  2.     resolveBeanClass(mbd, beanName); /1解析Bean的class  
  3.     mbd.prepareMethodOverrides(); //2 方法注入準備  
  4.     Object bean = resolveBeforeInstantiation(beanName, mbd); //3 第一個BeanPostProcessor擴充套件點  
  5.     if (bean != null) { //4 如果3處的擴充套件點返回的bean不為空，直接返回該bean，後續流程不需要執行  
  6.         return bean;  
  7.     }   
  8.     Object beanInstance = doCreateBean(beanName, mbd, args); //5 執行spring的建立bean例項的流程啦  
  9.     return beanInstance;  
  10. }  

 0.3 第一個BeanPostProcessor擴充套件點（只有InstantiationAwareBeanPostProcessor介面的實現才會被呼叫）

二、AbstractAutowireCapableBeanFactory的resolveBeforeInstantiation方法程式碼如下：

Java程式碼  收藏程式碼
  1. protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {  
  2.         Object bean = null;  
  3.         if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {  
  4.             // Make sure bean class is actually resolved at this point.  
  5.             if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {  
  6.                 //3.1、執行InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation回撥方法  
  7.                 bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);  
  8.                 if (bean != null) {  
  9.                     //3.2、執行InstantiationAwareBeanPostProcessor的postProcessAfterInitialization回撥方法  
  10.                     bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);  
  11.                 }  
  12.             }  
  13.             mbd.beforeInstantiationResolved = (bean != null);  
  14.         }  
  15.         return bean;  
  16. }   

通過如上程式碼可以進行例項化的預處理（自定義例項化bean，如建立相應的代理物件）和後處理（如進行自定義例項化的bean的依賴裝配）。

三、AbstractAutowireCapableBeanFactory的doCreateBean方法程式碼如下：

Java程式碼  收藏程式碼
  1. // 6、通過BeanWrapper例項化Bean   
  2. BeanWrapper instanceWrapper = null;  
  3. if (mbd.isSingleton()) {  
  4.     instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);  
  5. }  
  6. if (instanceWrapper == null) {  
  7.     instanceWrapper = createBeanInstance(beanName, mbd, args);  
  8. }  
  9. final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);  
  10. Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);  
  11. //7、執行MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition流程  
  12. synchronized (mbd.postProcessingLock) {  
  13.     if (!mbd.postProcessed) {  
  14.         applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);  
  15.         mbd.postProcessed = true;  
  16.     }  
  17. }  
  18. // 8、及早暴露單例Bean引用，從而允許setter注入方式的迴圈引用  
  19. boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&  
  20.         isSingletonCurrentlyInCreation(beanName));  
  21. if (earlySingletonExposure) {  
  22.     //省略log  
  23.     addSingletonFactory(beanName, new ObjectFactory() {  
  24.         public Object getObject() throws BeansException {  
  25.             //8.1、呼叫SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference返回一個需要暴露的Bean（例如包裝目標物件到代理物件）  
  26.             return getEarlyBeanReference(beanName, mbd, bean);  
  27.         }  
  28.     });  
  29. }  
  30. Object exposedObject = bean;  
  31. try {  
  32.     populateBean(beanName, mbd, instanceWrapper); //9、組裝-Bean依賴  
  33.     if (exposedObject != null) {  
  34.         exposedObject = initializeBean(beanName, exposedObject, mbd); //10、初始化Bean  
  35.     }  
  36. }  
  37. catch (Throwable ex) {  
  38.     //省略異常  
  39. }  
  40. //11如果是及早暴露單例bean，通過getSingleton觸發3.1處的getEarlyBeanReference呼叫獲取要及早暴露的單例Bean  
  41.     if (earlySingletonExposure) {  
  42.     Object earlySingletonReference = getSingleton(beanName, false);  
  43.     if (earlySingletonReference != null) {  
  44.         if (exposedObject == bean) {  
  45.             exposedObject = earlySingletonReference;  
  46.         }  
  47.         else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {  
  48.             String[] dependentBeans = getDependentBeans(beanName);  
  49.             Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);  
  50.             for (String dependentBean : dependentBeans) {  
  51.                 if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {  
  52.                     actualDependentBeans.add(dependentBean);  
  53.                 }  
  54.             }  
  55.             if (!actualDependentBeans.isEmpty()) {  
  56.                 throw new BeanCurrentlyInCreationException(beanName,  
  57.                         "Bean with name '" + beanName + "' has been injected into other beans [" +  
  58.                         StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +  
  59.                         "] in its raw version as part of a circular reference, but has eventually been " +  
  60.                         "wrapped. This means that said other beans do not use the final version of the " +  
  61.                         "bean. This is often the result of over-eager type matching - consider using " +  
  62.                         "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");  
  63.             }  
  64.         }  
  65.     }  
  66. }  
  67. //12、註冊Bean的銷燬回撥  
  68. try {  
  69.     registerDisposableBeanIfNecessary(beanName, bean, mbd);  
  70. }  
  71. catch (BeanDefinitionValidationException ex) {  
  72.     throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);  
  73. }  

四、AbstractAutowireCapableBeanFactory的populateBean方法程式碼如下：

Java程式碼  收藏程式碼
  1. //9、組裝-Bean  
  2. protected void populateBean(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw) {  
  3.     PropertyValues pvs = mbd.getPropertyValues();  
  4.     //省略部分程式碼  
  5.     //9.1、通過InstantiationAwareBeanPostProcessor擴充套件點允許自定義裝配流程（如@Autowired支援等）  
  6.     //執行InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation  
  7.     boolean continueWithPropertyPopulation = true;  
  8.     if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {  
  9.         for (BeanPostProcessor bp : getBeanPostProcessors()) {  
  10.             if (bp instanceof InstantiationAwareBeanPostProcessor) {  
  11.                 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  
  12.                 if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {  
  13.                     continueWithPropertyPopulation = false;  
  14.                     break;  
  15.                 }  
  16.             }  
  17.         }  
  18.     }  
  19.     if (!continueWithPropertyPopulation) {  
  20.         return;  
  21.     }  
  22.     if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||  
  23.             mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  
  24.         MutablePropertyValues newPvs = new MutablePropertyValues(pvs);  
  25.         // 9. 2、自動裝配（根據name/type）  
  26.         if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {  
  27.             autowireByName(beanName, mbd, bw, newPvs);  
  28.         }  
  29.         if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  
  30.             autowireByType(beanName, mbd, bw, newPvs);  
  31.         }  
  32.         pvs = newPvs;  
  33.     }  
  34.     boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();  
  35.     boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);  
  36.     //9. 3、執行InstantiationAwareBeanPostProcessor的postProcessPropertyValues  
  37.     if (hasInstAwareBpps || needsDepCheck) {  
  38.         PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw);  
  39.         if (hasInstAwareBpps) {  
  40.             for (BeanPostProcessor bp : getBeanPostProcessors()) {  
  41.                 if (bp instanceof InstantiationAwareBeanPostProcessor) {  
  42.                     InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  
  43.                     pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);  
  44.                     if (pvs == null) {  
  45.                         return;  
  46.                     }  
  47.                 }  
  48.             }  
  49.         }  
  50.         //9. 4、執行依賴檢查  
  51.         if (needsDepCheck) {  
  52.             checkDependencies(beanName, mbd, filteredPds, pvs);  
  53.         }  
  54.     }  
  55.     //9. 5、應用依賴注入  
  56.     applyPropertyValues(beanName, mbd, bw, pvs);  
  57. }  

五、AbstractAutowireCapableBeanFactory的initializeBean方法程式碼如下：

Java程式碼  收藏程式碼
  1.      //10、例項化Bean  
  2.      protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {  
  3. //10.1、呼叫Aware介面注入（BeanNameAware、BeanClassLoaderAware、BeanFactoryAware）  
  4. invokeAwareMethods(beanName, bean);//此處省略部分程式碼  
  5. //10.2、執行BeanPostProcessor擴充套件點的postProcessBeforeInitialization進行修改例項化Bean  
  6. Object wrappedBean = bean;  
  7. if (mbd == null || !mbd.isSynthetic()) {  
  8.     wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);  
  9. }  
  10. //10.3、執行初始化回撥（1、呼叫InitializingBean的afterPropertiesSet  2、呼叫自定義的init-method）  
  11. try {  
  12.     invokeInitMethods(beanName, wrappedBean, mbd);  
  13. }  
  14. catch (Throwable ex) {  
  15.     //異常省略  
  16. }  
  17. //10.4、執行BeanPostProcessor擴充套件點的postProcessAfterInitialization進行修改例項化Bean  
  18. if (mbd == null || !mbd.isSynthetic()) {  
  19.     wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);  
  20. }  
  21. return wrappedBean;  

三、建立一個Bean例項的執行流程簡化：

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args); 建立Bean

（1、resolveBeanClass(mbd, beanName); 解析Bean class，若class配置錯誤將丟擲CannotLoadBeanClassException；

（2、mbd.prepareMethodOverrides(); 準備和驗證配置的方法注入，若驗證失敗丟擲BeanDefinitionValidationException

（3、Object bean = resolveBeforeInstantiation(beanName, mbd); 第一個BeanPostProcessor擴充套件點，此處只執行InstantiationAwareBeanPostProcessor型別的BeanPostProcessor Bean；

（3.1、bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);執行InstantiationAwareBeanPostProcessor的例項化的預處理回撥方法postProcessBeforeInstantiation（自定義的例項化，如建立代理）；

（3.2、bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);執行InstantiationAwareBeanPostProcessor的例項化的後處理回撥方法postProcessAfterInitialization（如依賴注入），如果3.1處返回的Bean不為null才執行；

（4、如果3處的擴充套件點返回的bean不為空，直接返回該bean，後續流程不需要執行；

（5、Object beanInstance = doCreateBean(beanName, mbd, args); 執行spring的建立bean例項的流程；

（6、createBeanInstance(beanName, mbd, args); 例項化Bean

（6.2.1、如果之前已經解析過構造器

（6.2.1.1 autowireConstructor：有參呼叫autowireConstructor例項化

（6.2.1.2、instantiateBean：無參呼叫instantiateBean例項化；

（6.2.2、如果之前沒有解析過構造器：

（6.2.2.1、通過SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors回撥方法解析構造器，第二個BeanPostProcessor擴充套件點，返回第一個解析成功（返回值不為null）的構造器組，如AutowiredAnnotationBeanPostProcessor實現將自動掃描通過@Autowired/@Value註解的構造器從而可以完成構造器注入，請參考【第十二章】零配置 之 12.2 註解實現Bean依賴注入 ——跟我學spring3 ；

（6.2.2.2、autowireConstructor：如果（6.2.2.1返回的不為null，且是有參構造器，呼叫autowireConstructor例項化；

（6.2.2.3、instantiateBean：否則呼叫無參構造器例項化；

（7、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);第三個BeanPostProcessor擴充套件點，執行Bean定義的合併；

（7.1、執行MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition回撥方法，進行bean定義的合併；

（8、addSingletonFactory(beanName, new ObjectFactory() {

                            public Object getObject() throws BeansException {

                                   return getEarlyBeanReference(beanName, mbd, bean);

                            }

                     }); 及早暴露單例Bean引用，從而允許setter注入方式的迴圈引用

（8.1、SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference；第四個BeanPostProcessor擴充套件點，當存在迴圈依賴時，通過該回調方法獲取及早暴露的Bean例項；

（9、populateBean(beanName, mbd, instanceWrapper);裝配Bean依賴

（9.1、InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation；第五個BeanPostProcessor擴充套件點，在例項化Bean之後，所有其他裝配邏輯之前執行，如果false將阻止其他的InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation的執行和從（9.2到（9.5的執行，通常返回true；

（9.2、autowireByName、autowireByType：根據名字和型別進行自動裝配，自動裝配的知識請參考3.3.3  自動裝配；

（9.3、InstantiationAwareBeanPostProcessor的postProcessPropertyValues：第六個BeanPostProcessor擴充套件點，完成其他定製的一些依賴注入，如AutowiredAnnotationBeanPostProcessor執行@Autowired註解注入，CommonAnnotationBeanPostProcessor執行@Resource等註解的注入，PersistenceAnnotationBeanPostProcessor執行@ PersistenceContext等JPA註解的注入，RequiredAnnotationBeanPostProcessor執行@ Required註解的檢查等等，請參考【第十二章】零配置 之 12.2 註解實現Bean依賴注入 ——跟我學spring3；

（9.5、applyPropertyValues：應用明確的setter屬性注入，請參考【第三章】 DI 之 3.1 DI的配置使用 ——跟我學spring3 ；

（10、exposedObject = initializeBean(beanName, exposedObject, mbd); 執行初始化Bean流程；

（10.1、invokeAwareMethods（BeanNameAware、BeanClassLoaderAware、BeanFactoryAware）：呼叫一些Aware標識介面注入如BeanName、BeanFactory；

（10.2、BeanPostProcessor的postProcessBeforeInitialization：第七個擴充套件點，在呼叫初始化之前完成一些定製的初始化任務，如BeanValidationPostProcessor完成JSR-303 @Valid註解Bean驗證，InitDestroyAnnotationBeanPostProcessor完成@PostConstruct註解的初始化方法呼叫，ApplicationContextAwareProcessor完成一些Aware介面的注入（如EnvironmentAware、ResourceLoaderAware、ApplicationContextAware），其返回值將替代原始的Bean物件；

（10.3、invokeInitMethods ： 呼叫初始化方法；

（10.3.1、InitializingBean的afterPropertiesSet ：呼叫InitializingBean的afterPropertiesSet回撥方法；

（10.3.2、通過xml指定的自定義init-method ：呼叫通過xml配置的自定義init-method

（10.3.3、BeanPostProcessor的postProcessAfterInitialization ：第八個擴充套件點，AspectJAwareAdvisorAutoProxyCreator（完成xml風格的AOP配置(<aop:config>)的目標物件包裝到AOP代理物件）、AnnotationAwareAspectJAutoProxyCreator（完成@Aspectj註解風格（<aop:aspectj-autoproxy> @Aspect）的AOP配置的目標物件包裝到AOP代理物件），其返回值將替代原始的Bean物件；

（11、if (earlySingletonExposure) {

                     Object earlySingletonReference = getSingleton(beanName, false);

……

      } ：如果是earlySingleExposure，呼叫getSingle方法獲取Bean例項；

earlySingleExposure =(mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName))

只要單例Bean且允許迴圈引用（預設true）且當前單例Bean正在建立中

（11.1、如果是earlySingletonExposure呼叫getSingleton將觸發【8】處ObjectFactory.getObject()的呼叫，通過【8.1】處的getEarlyBeanReference獲取相關Bean（如包裝目標物件的代理Bean）；（在迴圈引用Bean時可能引起Spring事務處理時自我呼叫的解決方案及一些實現方式的風險）；

（12、registerDisposableBeanIfNecessary(beanName, bean, mbd) ： 註冊Bean的銷燬方法（只有非原型Bean可註冊）；

（12.1、單例Bean的銷燬流程

（12.1.1、DestructionAwareBeanPostProcessor的postProcessBeforeDestruction ： 第九個擴充套件點，如InitDestroyAnnotationBeanPostProcessor完成@PreDestroy註解的銷燬方法註冊和呼叫；

（12.1.2、DisposableBean的destroy：註冊/呼叫DisposableBean的destroy銷燬方法；

（12.1.3、通過xml指定的自定義destroy-method ：註冊/呼叫通過XML指定的destroy-method銷燬方法；

（12.1.2、Scope的registerDestructionCallback：註冊自定義的Scope的銷燬回撥方法，如RequestScope、SessionScope等；其流程和【12.1 單例Bean的銷燬流程一樣】，關於自定義Scope請參考【第三章】 DI 之 3.4 Bean的作用域 ——跟我學spring3

（13、到此Bean例項化、依賴注入、初始化完畢可以返回建立好的bean了。

從上面的流程我們可以看到BeanPostProcessor一個使用了九個擴充套件點，其實還一個擴充套件點（SmartInstantiationAwareBeanPostProcessor的predictBeanType在下一篇介紹），接下來我們看看BeanPostProcessor這些擴充套件點都主要完成什麼功能及常見的BeanPostProcessor。

我將在下一帖子中使用例子來解析這八個擴充套件點的主要功能，及一些Spring預設提供的BeanPostProcessor主要作用。


上接繼續分析，在分析上篇的問題之前，我們需要了解下BeanPostProcessor概念和Spring容器建立Bean的流程。


相關推薦

Spring開閉原則的表現-BeanPostProcessor擴充套件點-1

http://jinnianshilongnian.iteye.com/blog/1489787 上接繼續分析，在分析上篇的問題之前，我們需要了解下BeanPostProcessor概念和Spring容器建立Bean的流程。 一、BeanPostProcessor是什麼

Spring開閉原則的表現-BeanPostProcessor擴充套件點-2

四、BeanPostProcessor介面及回撥方法圖  從圖中我們可以看出一共五個介面，共十個回撥方法，即十個擴充套件點，但我們之前的文章只分析了其中八個，另外兩個稍候也會解析一下是幹什麼的。 ==================================

Python 裝飾器@，對函式進行功能擴充套件，開閉原則

裝飾器可以對原函式進行功能擴充套件，但還不需要修改原函式的內容(開閉原則)，也不需要修改原函式的呼叫。   demo.py（裝飾器，@）： # 閉包 def w1(func): def inner(): # 對原函式進行功能擴充套件 pr

設計模式六大原則（6）：開閉原則

思考 外部 編程人員 恰恰 單一職責 何事 適應 擴展 分享 開閉原則 定義：一個軟件實體如類、模塊和函數應該對擴展開放，對修改關閉。 問題由來：在軟件的生命周期內，因為變化、升級和維護等原因需要對軟件原有代碼進行修改時，可能會給舊代碼中引入錯誤，也可能會使我們不得不對

“開-閉”原則 （Open-Closed principle, OCP）

sof 般的 方法 mod 關閉 man nbsp 接口 這一 “開-閉”原則 （Open-Closed principle, OCP） 一個軟件實體應當對擴展開放，對修改關閉。 Software entities should be open for extensio

11設計模式六大原則——開閉原則

職責 art 並不是 錯誤 接口 屬於 倒置 編程 探討 定義：一個軟件實體如類、模塊和函數應該對擴展開放，對修改關閉。 問題由來：在軟件的生命周期內，因為變化、升級和維護等原因需要對軟件原有代碼進行修改時，可能會給舊代碼中引入錯誤，也可能會使我們不得不對整個功能進行重構，

開閉原則

通過 活性 sed 金庸 pri 歸納 pla out none 定義： 一個軟件實體如類，模塊和函數應該對擴展開放，對修改關閉。 什麽是開閉原則 開閉原則明確的告訴我們：軟件實現應該對擴展開放，對修改關閉，其含義是說一個軟件實體應該通過擴展來實現變化，而不是通過修改已有的

面向對象設計原則二：開閉原則（OCP）

name 返回 展開 打開 設計原則 data turn acl int 開閉原則（OCP）定義：對擴展開發，對修改關閉。好處： 適應性和靈活性。 穩定性和延續性。 可復用性與可維護性。 解釋說明：開閉原則指的是兩方面：對功能擴展開發，對修改進

【大話設計模式讀書筆記——開閉原則】

等等 使用方式 價值 log 變更 重用 中間 多種實現 過程 開閉原則 在面向對象編程領域中，開閉原則規定“軟件中的對象（類，模塊，函數等等）應該對於擴展是開放的，但是對於修改是封閉的”[1]，這意味著一個實體是允許在不改變它的源代碼的前提下變更它的行為。該特性在產品化

[轉]設計模式六大原則[6]：開閉原則

說了 一點 模塊 活性 問題 單一職責原則 就是 認識 適應 定義：一個軟件實體如類、模塊和函數應該對擴展開放，對修改關閉。 問題由來：在軟件的生命周期內，因為變化、升級和維護等原因需要對軟件原有代碼進行修改時，可能會給舊代碼中引入錯誤，也可能會使我們不得不對整個功能進行

裏氏替換/開閉原則

官方 自己 需求 per 一個 lin bsp 思想 mui 官方定義：程序中的對象應該是可以在不改變程序正確性的前提下被它的子類所替換，也就是說所有引用基類的地方必須能透明地使用其子類的對象。通俗的來說，子類可以擴展父類的功能，但不能改變父類原有的功能。 自己理解：一個實

學習設計模式 - 六大基本原則之開閉原則

裏氏替換 成對 五個 jsp 導致 業務邏輯 關聯 影響 引入 　　設計模式總共有六大基本原則，統稱為SOLID （穩定）原則，分別是S-單一職責原則(Single Responsibility Principle)， O-開閉原則(Open closed Principl

【學習筆記】慕課網—Java設計模式精講 第3章 軟體設計七大原則-3-2 開閉原則

/** * 軟體設計七大原則-開閉原則 * @author cnRicky * @date 2018.11.7 */ 開閉原則 定義：一個軟體實體如類、模組和函式應該對擴充套件開放，對修改關閉 強調的是用抽象構建框架，用實現擴充套件細節 優點：提高軟體系統的可複用性及可維護性 開閉原則

第2章 面向物件的設計原則（SOLID）：6_開閉原則

6. 開閉原則（Open Closed Principle，OCP） 6.1 定義 （1）一個類應該對擴充套件開放，對修改關閉。要求通過擴充套件來實現變化，而且是在不修改己有的程式碼情況下進行擴充套件，也不必改動己有的原始碼或二進位制程式碼。 （2）在軟體生命週期內，變化是一個既定的事實

又見開閉原則

開閉原則是Java世界裡最基礎的設計原則，它指導我們如何建立一個穩定的、靈活的系統，先來看開閉原則的定義： Software entities like classes,modules and functions should be open for extension but closed for

java設計六大原則之開閉原則(OCP)

抽象化是關鍵 定義抽象類或介面，使其可以有很多的具體實現(openfor extension) 預見所有的需要，在任何情況下都不再修改上層商業邏輯(closedfor modification)   對可變性的封裝原則 一種可變性不應當散落在程式碼的很多角落裡，應當將其

設計模式六大原則之開閉原則

1.定義： 開閉原則是設計模式裡面最基礎的設計原則，它指導我們如何建立一個穩定，靈活的系統。開閉原則定義如下： 一個軟體實體。如類/模組/函都應該對擴充套件開放，對修改關閉。 2.為什麼要有開閉原則或者說開閉原則的好處具體體現在哪裡？ 在軟體的生命週期內，因為升級和維護或者要增加需求

設計模式 開閉原則

設計模式 - 開閉原則 即 對立與統一原則 什麼是開閉原則 軟體實體應該對擴充套件開放，對修改關閉，即實體應當通過擴充套件實現變化，而不是修改程式碼實現變化 什麼是軟體實體，專案或軟體中按照一定邏輯規劃劃分的模組 抽象 類 方法 書店銷售書籍 然後書寫程式碼如下 // 書籍介面 pub

設計模式之軟體開發原則（1）開閉原則和依賴倒置原則

開閉原則 定義 所謂開閉原則就是一個軟體實體如類、模組和函式應該對擴充套件開放、對修改關閉。 強呼叫抽象構建框架，實現實現拓展細節。 有優點是提高軟體的複用性和易維護展性。是面向物件的最基本原則。 依賴倒置原則 定義 高層模組不應該依賴底層模組，二者都應該依賴其抽象。 抽象不應該依賴細節：細節應該

設計模式基礎之開閉原則

設計模式 設計模式23式 （一）瞭解設計模式給程式設計帶來的好處 （二）建立型模式：熟練掌握（簡單工廠，工廠方法，抽象，單利模式，建造者模式，原型模式） （三）結構性模式：介面卡模式，裝飾器模式，代理模式，外觀模式，橋接模式，組合模式，享元模式， （四）行為模式：策略模式，模板方