使用 Go 泛型创建链式处理器

IT行业相对于一般传统行业，发展更新速度更快，一旦停止了学习，很快就会被行业所淘汰。所以我们需要踏踏实实的不断学习，精进自己的技术，尤其是初学者。今天golang学习网给大家整理了《使用 Go 泛型创建链式处理器》，聊聊，我们一起来看看吧！

我正在尝试在 go 中实现一种简单的处理管道，其中每个处理器都有确定的输入和输出类型，以及将当前处理器输出类型作为输入的后继处理器列表，并且可能具有其后继处理器拥有。

我遇到了如何将后继处理器添加到当前处理器的问题，无论其输出类型如何。我尝试使用 any 作为通配符类型，就像在 java 中使用 ? 一样，但 go 没有它。

我在 go 中拥有的是这样的：

type processor[inputtype any, outputtype any] struct {
    nextprocessors     []*processor[outputtype, any]
    processingfunction func(inputtype) outputtype
}

func (b *processor[inputtype, outputtype]) process(input inputtype) {
    result := b.processingfunction(input)
    for _, nextprocessor := range b.nextprocessors {
        nextprocessor.process(result)
    }
}

func (b *processor[inputtype, outputtype]) addoutputprocessor(p *processor[outputtype, any]) {
    b.nextprocessors = append(b.nextprocessors, p)
}

func main() {
    outputer := processor[int, string]{processingfunction: func(input int) string {
        print(input)
        return string(input)
    }}
    doubler := processor[int, int]{processingfunction: func(input int) int { return input * 2 }}
    rng := processor[int, int]{processingfunction: func(input int) int { return rand.intn(input) }}
    rng.addoutputprocessor(&doubler)
    doubler.addoutputprocessor(&outputer)
    rng.process(20)
}

这给了我一个编译错误：

不能将 &doubler （类型 *processor[int, int] 的值）用作类型 *processor[int, any]

有没有办法忽略后继处理器的输出类型？或者我应该采取不同的方式来解决这个问题？我只是想确保后续处理器可以接受正确类型的输入。

作为参考，这里是 java 中的接口定义，它按照我的预期方式工作。

public interface Processor<InputType, OutputType> {
    void addOutputProcessor(Processor<OutputType, ?> outputProcessor);
    void process(InputType input);
}

public class Pipeline {

    private abstract class BaseProcessor<InputType, OutputType>  implements Processor<InputType, OutputType> {

        List<Processor<OutputType, ?>> nextProcessors = new ArrayList<>();

        abstract OutputType processHelper(InputType input);

        @Override
        public void addOutputProcessor(Processor<OutputType, ?> outputProcessor) {
            nextProcessors.add(outputProcessor);
        }

        @Override
        public void process(InputType input) {
            OutputType result = processHelper(input);
            for (Processor<OutputType, ?> nextProcessor : nextProcessors) {
                nextProcessor.process(result);
            }
        }
    }

    private class RandomNumberGenerator extends BaseProcessor<Integer, Integer> {

        @Override
        Integer processHelper(Integer input) {
            int generatedNumber = new Random().nextInt(input);
            return generatedNumber;
        }
    }

    private class IncrementProcessor extends BaseProcessor<Integer, Integer> {

        @Override
        Integer processHelper(Integer input) {
            return input + 1;
        }
    }

    private class DoubleProcessor extends BaseProcessor<Integer, Integer> {

        @Override
        Integer processHelper(Integer input) {
            return input * 2;
        }
    }

    private class Outputer extends BaseProcessor<Integer, String> {

        String name;

        public Outputer(String name) {
            this.name = name;
        }

        @Override
        String processHelper(Integer input) {
            String output = String.format("Pipeline %s result: %d", name, input);
            System.out.println(output);
            return output;
        }
    }

    public void buildAndRunPipeline() {
        Processor<Integer, String> doublingOutputter = new Outputer("Doubling");
        Processor<Integer, String> incrementingOutputter = new Outputer("Incrementing");
        Processor<Integer, String> rngOutputter = new Outputer("Generating number");
        Processor<Integer, Integer> doubler = new DoubleProcessor();
        doubler.addOutputProcessor(doublingOutputter);
        Processor<Integer, Integer> incrementer = new IncrementProcessor();
        incrementer.addOutputProcessor(incrementingOutputter);
        Processor<Integer, Integer> starter = new RandomNumberGenerator();
        starter.addOutputProcessor(rngOutputter);
        starter.addOutputProcessor(doubler);
        starter.addOutputProcessor(incrementer);
        starter.process(20);
    }

    public static void main(String[] args) {
        Pipeline p = new Pipeline();
        p.buildAndRunPipeline();
    }
}

正确答案

没有。

在 go 中 any 只是一个静态类型（interface{} 的别名。它永远不能替代 java 的无界通配符 ?。所以 *processor[int, any] 与*processor[int, int] 并且您无法将一个分配给另一个，如错误消息所报告的那样。

为了构建任意长的链，您需要参数化 process 方法本身，但这在 go 1.18 中是不可能的。您必须在类型本身上声明所有类型参数。但是，即使您这样做，您仍会遇到不知道下一个处理器的输出类型的相同问题。

一般来说，使用 for 循环是行不通的，因为输入/输出值的静态类型不断变化。

我相信无需反思就能得到的最接近结果是通过顶级函数实现某种组合运算符 - 就像 haskell 中的 . 一样。但您必须手动嵌套调用。

一个简化的示例（processor 类型是多余的，但使其更接近您的代码）：

package main

import (
    "fmt"
    "strconv"
)

type Processor[In, Out any] func(In) Out

func Process[In, Out any](input In, processor Processor[In, Out]) Out {
    return processor(input)
}

func main() {
    parser := Processor[string, int](func(input string) int { s, _ := strconv.Atoi(input); return s })
    doubler := Processor[int, int](func(input int) int { return input * 2 })
    outputer := Processor[int, string](func(input int) string { return fmt.Sprintf("%d", input) })

    out := Process(Process(Process("20", parser), doubler), outputer)
    fmt.Println(out)
}

演示：https://go.dev/play/p/Iv-virKATyb

本篇关于《使用 Go 泛型创建链式处理器》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！