摘要：本文首發(fā)于泊浮目的簡(jiǎn)書(shū)前言一個(gè)風(fēng)和日麗的下午我看著日?？创a做重構(gòu)遷移看到這么段代碼突然我看到了這樣的代碼看了這段代碼我整個(gè)人都不好了首先是那火箭式的三個(gè)嵌套循環(huán)再者就是那些變量聲明語(yǔ)句為了迭代他們我們不得不聲明它一遍使用這樣看起來(lái)似

本文首發(fā)于泊浮目的簡(jiǎn)書(shū):https://www.jianshu.com/u/204...

一個(gè)風(fēng)和日麗的下午,我看著日常看代碼做重構(gòu)遷移,看到這么段代碼:

突然,我看到了這樣的代碼:

    private void getTopicsDiskSizeForSomeBroker(int brokerID, AdminClient admin, Map topicsSizeMap) throws ExecutionException, InterruptedException {
        DescribeLogDirsResult ret = admin.describeLogDirs(Collections.singletonList(brokerID));
        Map> tmp = ret.all().get();
        for (Map.Entry> entry : tmp.entrySet()) {
            Map tmp1 = entry.getValue();
            for (Map.Entry entry1 : tmp1.entrySet()) {
                DescribeLogDirsResponse.LogDirInfo info = entry1.getValue();
                Map replicaInfoMap = info.replicaInfos;
                for (Map.Entry replicas : replicaInfoMap.entrySet()) {
                    String topic = replicas.getKey().topic();
                    Long topicSize = topicsSizeMap.get(topic);
                    if (topicSize == null) {
                        topicsSizeMap.put(topic, replicas.getValue().size);
                    } else {
                        topicsSizeMap.put(topic, replicas.getValue().size + topicSize);
                    }
                }
            }
        }
    }

看了這段代碼我整個(gè)人都不好了!

首先是那火箭式的三個(gè)嵌套for循環(huán),再者就是那些變量聲明語(yǔ)句.為了迭代他們,我們不得不聲明它一遍...

    public List getTopicDiskSize() {
        return getTopicPartitionReplicaInfo().entrySet().stream()
                .map(e -> new KafkaTopicInfoBO(e.getKey().topic(), e.getValue().size))
                .collect(Collectors.toList());

    }

    protected Map getTopicPartitionReplicaInfo() {
        Properties globalConf = zkConfigService.getProperties(ZkPathUtils.GLOBAL_CONFIG);
        Properties adminConfig = new Properties();
        adminConfig.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, globalConf.getProperty((ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG)));
        AdminClient adminClient = AdminClient.create(adminConfig);
        List brokerIds = zkConfigService.getChildByPath(kafkaIdsPath);
        return  brokerIds.stream()
                .map(Integer::valueOf)
                .map(Collections::singletonList)
                .map(adminClient::describeLogDirs)
                .map(DescribeLogDirsResult::all)
                .map(mapKafkaFuture -> {
                    try {
                        return mapKafkaFuture.get();
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                })
                .map(Map::values)
                .flatMap(Collection::stream)
                .map(Map::values)
                .flatMap(Collection::stream)
                .map(e -> e.replicaInfos)
                .map(Map::entrySet)
                .flatMap(Collection::stream)
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    }

這樣看起來(lái)似乎好了一點(diǎn).但是對(duì)于不熟悉函數(shù)式編程的同學(xué)來(lái)說(shuō),理解以上代碼還是有點(diǎn)困難的.

接下來(lái),先來(lái)簡(jiǎn)單講一講函數(shù)式編程.

就像來(lái)自數(shù)學(xué)中的代數(shù)

f(x)=5x^2+4x+3
g(x)=2f(x)+5=10x^2+8x+11
h(x)=f(x)+g(x)=15x^2+12x+14

函數(shù)式編程定義輸入數(shù)據(jù)和輸出數(shù)據(jù)相關(guān)的關(guān)系——數(shù)學(xué)表達(dá)式里面其實(shí)是在做一種映射(Mapping),輸入的數(shù)據(jù)和輸出的數(shù)據(jù)關(guān)系是什么樣的,就是用來(lái)函數(shù)定義的.

public class Quint{
    public static void main (String args[]){
        for (int i=0; i<25; i++){
            System.out.println(i*i);
        }
    }
}

(println (take 25 (map (fn [x] (*x x) (range)))))

簡(jiǎn)單解釋一下上段Lisp代碼:

range函數(shù)回返回一個(gè)從0開(kāi)始的整數(shù)無(wú)窮列表

然后該列表會(huì)被傳入map,針對(duì)列表中的每個(gè)元素,調(diào)用平方值的匿名函數(shù),產(chǎn)生了一個(gè)無(wú)窮多的,包含平方值的列表

將列表傳入take函數(shù),僅僅返回前25個(gè)

println將接入的參數(shù)輸出

    protected fun getTopicPartitionReplicaInfo(): Map {
        val globalConf = zkConfigService.getProperties(ZkPathUtils.GLOBAL_CONFIG)
        val adminConfig = Properties()
        adminConfig.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, globalConf.getProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG))
        val adminClient = AdminClient.create(adminConfig)
        val brokerIds = zkConfigService.getChildByPath(kafkaIdsPath)
        return brokerIds.stream()
                .mapToInt {
                    Integer.valueOf(it)
                }.let { intStream ->
                    adminClient.describeLogDirs(intStream.boxed().collect(Collectors.toList()))
                }.let { describeLogDirsResult ->
                    describeLogDirsResult.all()
                }.let { mapKafkaFutrue ->
                    mapKafkaFutrue.get()
                }.let { mapStream ->
                    mapStream.values
                }.let {
                    it.stream().map { e -> e.values }.flatMap { e -> e.stream() }.collect(Collectors.toList())
                }.flatMap {
                    it.replicaInfos.entries.toList()
                }.let { it ->
                    it.associateBy({ it.key }, { it.value })
                }
    }

代碼看起來(lái)大差不差.但Kotlin的這些關(guān)鍵字寫(xiě)起來(lái)更方便.我們看下Java中map函數(shù)和Kotlin中let函數(shù)的簽名:

     * Returns a stream consisting of the results of applying the given
     * function to the elements of this stream.
     *
     * 
This is an intermediate
     * operation.
     *
     * @param  The element type of the new stream
     * @param mapper a non-interfering,
     *               stateless
     *               function to apply to each element
     * @return the new stream
     */
     Stream map(Function mapper);

/**
 * Calls the specified function [block] with `this` value as its argument and returns its result.
 *
 * For detailed usage information see the documentation for [scope functions](https://kotlinlang.org/docs/reference/scope-functions.html#let).
 */
@kotlin.internal.InlineOnly
public inline fun  T.let(block: (T) -> R): R {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block(this)
}

我們可以看到Java中的map是被限制在Stream API中的,而Kotlin的let并沒(méi)有這種限制.

同時(shí),我們也可以感受到,對(duì)于函數(shù)式編程的支持,明顯是Kotlin更好一些——在Kotlin中,我們用一個(gè)()就可以表示函數(shù),而Java則需要Interface來(lái)表示(在Java中,對(duì)象是一等公民).

如果讀者有興趣的話,可以嘗試一下Haskell或Lisp(JVM上叫Clojure).這些都是純函數(shù)式語(yǔ)言.

類似,Kotlin還有很多這種函數(shù),被稱為作用域函數(shù),在這里羅列一下常用的函數(shù):

let

run

also

apply

takeIf

takeUnless

repeat

在《架構(gòu)整潔之道》中,有這么一個(gè)總結(jié):

結(jié)構(gòu)化編程是對(duì)程序控制權(quán)的直接轉(zhuǎn)移的限制

面向?qū)ο缶幊淌菍?duì)程序控制權(quán)的間接轉(zhuǎn)移的限制

函數(shù)式編程是對(duì)程序賦值操作的限制

如果說(shuō)面向?qū)ο缶幊淌菍?duì)數(shù)據(jù)進(jìn)行抽象,那么函數(shù)式編程則是對(duì)行為進(jìn)行抽象.

Map

Reduce

Filter

舉個(gè)例子,面包和蔬菜map到切碎的操作上,再reduce成漢堡.

我們可以看到map和reduce不關(guān)心輸入數(shù)據(jù),它們只控制,并不是業(yè)務(wù).控制是描述怎么干,而業(yè)務(wù)描述要干什么.

在本文中,我們只看到了map的身影——上面提到了,map對(duì)流中的每一個(gè)元素進(jìn)行操作.

可能會(huì)有讀者問(wèn)let是啥,在本文的代碼例子中,let針對(duì)整個(gè)流進(jìn)行操作.

簡(jiǎn)單來(lái)說(shuō), Map && Reduce 對(duì)應(yīng)了我們?nèi)粘Ｖ杏玫?b>循環(huán),而Filter對(duì)應(yīng)了If

優(yōu)勢(shì)

無(wú)狀態(tài)

并發(fā)無(wú)傷害

函數(shù)執(zhí)行沒(méi)有順序上的問(wèn)題

劣勢(shì)

數(shù)據(jù)復(fù)制嚴(yán)重

Python的裝飾器模式

事件溯源:不記錄最終狀態(tài),而是記錄每一個(gè)事件.需要時(shí),通過(guò)追溯(重新計(jì)算)事件來(lái)得出當(dāng)前的狀態(tài).如:

數(shù)據(jù)庫(kù)事務(wù)日志

版本控制器

比特幣