前言

最近在接手別人的專案，看人家的程式碼是痛苦的，尤其是寫的不怎麼樣的程式碼。想到之前看了一本《程式碼整潔之道》，對我影響深遠，便想作此文舒緩一下心情。

如果你是大牛請忽略本文。

什麼是好程式碼

書中說：好的程式碼就是它恰好為解決某一問題而存在。
聽人說：好的程式碼就是給一個應屆畢業生也可以看懂。

我現在深深的秉承 單一職責原則，就這一條足以寫出我認為漂亮的程式碼。
作為一個無名小卒，為了夢想，就算為了後人能看懂，必須好好寫程式碼。

好程式碼是什麼樣子的

舉個抽象的例子，如果程式碼寫成這樣，把所有的邏輯按照順序都堆砌在這個方法中，那麼這段程式碼或許思路清晰，路徑考慮周全，效率非常高，但是這並不算好的程式碼。

public class MechandiseManager{
    private static final Integer TYPE_ONE = 1;
    private static final String CODE_EXAMPLE_DELICIOUS = "delicious";
    private static final String MAP_KEY_EXAMPLE = "key";
    private static volatile boolean running = false;
    @Autowired
    private static SomeService someService;

public
 
 static GoodsParam setGoodParam(String code,Integer id, Float price, Integer type) throws Exception{
        GoodsParam goodParam = new FoodParam();
        goodParam.setCode(code);
        goodParam.setXXId(id);  
        if(type.equals("1")){
            if(){
            //shit mass
            }else
 
{
            //shit mass
            }
            for(int i=0;i<SOME;i++){
                map.get("field1");
            }
        }else{
            String val = someDataMap.get(obj.getSomeField());
            if(val==SOME || ((CONDITION2)&&(CONDITION3))){
                //shit mass
                Data data = someService.selectSomeData();
                for(){
                }
            }else{
            //shit mass
                if(){
                }
            }
        }
        if(){
        //businsess
        }
        return goodParam ;
    }
}

分析程式碼

程式碼中if條件語義不是非常人性化，分支混亂，本來是處理Goods的引數的，混雜太多條件，寫的人或許過一段時間再來，就看的雲裡霧裡，更別指望別人來給他改BUG。不過，該程式碼值得參考的地方在於設定了一些可讀性強的常量。

改進程式碼

public static GoodsParam setGoodParam(String code,Integer id, Float price, Integer type) throws Exception{
        GoodsParam goodParam = new FoodParam();
        goodParam.setCode(code);
        goodParam.setXXId(id);  
        if(type.equals(TYPE_ONE)){
            processSomething(goodParam);
        }else{
            String val = someDataMap.get(MAP_KEY_EXAMPLE);
            processAnotherThing(goodsParam,val);
        }
        if(){
        //businsess
        }
        return goodParam ;
}

再次改進

public static GoodsParam setGoodParam(String code,Integer id, Float price, Integer type) throws Exception{
        GoodsParam goodParam = new FoodParam();
        goodParam.setCode(code);
        goodParam.setXXId(id);  
        if(isTypeONE(type)){
            processSomething(goodParam);
        }else{
            processAnotherThing(goodsParam,val);
        }
        thenProcessSomeThing();
        return goodParam ;
}

public static boolean isTypeONE(Integer type){
    return type.equals(TYPE_ONE);
}

終極改進

public static GoodsParam setGoodParam(String code,Integer id, Float price, Integer type) throws Exception{
        GoodsParam goodParam = new FoodParam();
        goodParam.setCode(code);
        goodParam.setXXId(id);  
        processType(goodParam );
        thenProcessSomeThing();
        return goodParam ;
}

多學習開源專案

以下節選自Spring框架的內部原始碼：

public void refresh() throws BeansException, IllegalStateException {  
        synchronized (this.startupShutdownMonitor) {  
            // Prepare this context for refreshing.  
            prepareRefresh();  

            // Tell the subclass to refresh the internal bean factory.  
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  

            // Prepare the bean factory for use in this context.  
            prepareBeanFactory(beanFactory);  

            try {  
                // Allows post-processing of the bean factory in context subclasses.  
                postProcessBeanFactory(beanFactory);  

                // Invoke factory processors registered as beans in the context.  
                invokeBeanFactoryPostProcessors(beanFactory);  

                // Register bean processors that intercept bean creation.  
                registerBeanPostProcessors(beanFactory);  

                // Initialize message source for this context.  
                initMessageSource();  

                // Initialize event multicaster for this context.  
                initApplicationEventMulticaster();  

                // Initialize other special beans in specific context subclasses.  
                onRefresh();  

                // Check for listener beans and register them.  
                registerListeners();  

                // Instantiate all remaining (non-lazy-init) singletons.  
                finishBeanFactoryInitialization(beanFactory);  

                // Last step: publish corresponding event.  
                finishRefresh();  
            }  

            catch (BeansException ex) {  
                // Destroy already created singletons to avoid dangling resources.  
                destroyBeans();  

                // Reset 'active' flag.  
                cancelRefresh(ex);  

                // Propagate exception to caller.  
                throw ex;  
            }  
        }  

再看一個DispatcherServlet的原始碼：

    protected void onRefresh(ApplicationContext context) throws BeansException {  
        initStrategies(context);  
    }  

    /** 
     * Initialize the strategy objects that this servlet uses. 
    * <p>May be overridden in subclasses in order to initialize 
    * further strategy objects. 
    */  
    protected void initStrategies(ApplicationContext context) {  
        initMultipartResolver(context);  
        initLocaleResolver(context);  
        initThemeResolver(context);  
        initHandlerMappings(context);  
        initHandlerAdapters(context);  
        initHandlerExceptionResolvers(context);  
        initRequestToViewNameTranslator(context);  
        initViewResolvers(context);  
    }  

有沒有覺得非常清晰，一步一步，非常震撼，當時見到的時候真的覺得自己寫的程式碼寫的就是Shit…

總結

個人總結：寫程式碼並不是一下子就能寫出那麼漂亮而簡潔的程式碼，在寫的過程中，要像寫文章一樣思考，而不是記流水賬一樣，想到哪裡就寫到哪裡，先把邏輯寫完，然後回顧程式碼，看看能不能把那些分支，迴圈儘可能簡化，例如把每一個判斷都儘可能讓人看懂，用一個函式表達他的含義，這樣函式呼叫函式，層次分明，看著就知道哪一步是做什麼，哪一步又需要處理什麼，一目瞭然。以後再檢視自己的程式碼或者別人維護你的程式碼時，自頂向下，由主幹要枝葉，條理清晰，神清氣爽。

在下無名小卒，但願能 make you impressive.