java - 从同一基类的域类调用不同的服务

Question

这个问题主要是一个设计问题(与ddd有点相关)。抱歉这个人为的例子:

假设您有代表不同类型水果的(域)类:苹果、樱桃等。现在假设你必须实现一些榨汁的行为。调用者应该能够在不知道他得到的具体水果的情况下调用挤压。

我应该把这个行为放在哪里？

当然，可以定义一个水果接口(interface)/基类函数

Fruit#squeeze()

并让所有的子类实现它们自己的行为。现在调用者可以简单地做这样的事情:

Fruit f = new Cherry();
f.squeeze();

但是如果压榨不是那么简单并且涉及更复杂的行为，比如调用不同的外部服务，对于每个水果不同的行为，应该怎么办

AppleJuicerService#squeeze(Apple a)

和

CherryJuicerService#squeeze(Cherry c)

?从域类调用服务感觉不对。

我读过有关双分派(dispatch)模式的文章，它似乎不适合这里，因为每个子类都需要不同的服务。

我的问题是:在这里可以做些什么来获得“干净”的设计？

编辑:

感谢您到目前为止的所有回答。我会试着澄清一下这个问题。我将尝试给出另一个，希望不那么做作的例子来说明我想在这里陈述的问题:

考虑一个允许将其内容显示为字符串的消息基类。

interface Message {
    String showContent();
}

现在假设我们有不同类型的消息，例如 EMailMessage:

class EMailMessage implements Message {

    //some specific parameters for email
    private EmailAddress recipientEmail;

    public String showContent() {
        //here the content would be converted to string
        return "the content of an EMail" 
    }
}

另一种类型是 SMMSessage:

class SMSMessage implement SMSMessage {

    //some specific parameters for SMS
    private TelNumber recepientTelephoneNumber;

    public String showContent() {
        //here the content would be converted to string
        return "the content of a SMS"
    }
}

进一步假设，消息被建模为实体，因此可以持久保存在数据库中。尽管从技术上讲，假设使用某些依赖注入(inject)框架(如 Spring)来注入(inject)依赖项。

类似于水果示例，考虑我们必须实现一个将消息发送给接收者的 send() 行为。此外，假设发送 EMail 涉及与 SMS 不同的逻辑。现在，问题是:发送消息的逻辑应该放在哪里？

通常我会选择创建一个发送短信的服务，例如封装SMS 服务提供商的 API。此外，我将创建另一个服务来封装发送电子邮件。

interface SendMessageService<T extends Message> {
    void send(T message);
}

class SendEmailService extends SendMessageService<EMailMessage> {
    public void send(EMailMessage message) {
        //send the EMail
    }
}

class SendSMSService extends SendMessageService<SMSMessage> {
    public void send(SMSMessage message) {
        //send the SMS
    }
}

这种方法的缺点是你不能在没有确定其具体子类的情况下发送消息，即像下面这样的事情是不可能直接发生的

List<Message> messages = //Messages of different types 

SendMessageService service = //???

for (Message m : messages) {
    service.send(m);
}

当然可以创建一个工厂来根据特定类型的消息创建服务。但这在某种程度上意味着克隆 Message 的继承层次结构。有没有更好的方法来达到预期的结果？或者我错过了什么？或者以某种方式将服务注入(inject)实体会更好吗？

Answer 1

您可以将工作委托(delegate)给 SqueezeBehavior 接口(interface)，让每个实现定义如何挤压 Fruit 或特定的 Fruit。这是一个原始的想法(这意味着它可以改进，但作为第一步是好的):

interface SqueezeBehavior<T> {
    void squeeze(T squeezeMe);
}

interface FruitSqueezeBehavior<T extends Fruit> extends SqueezeBehavior<T> {
}

class FruitSqueezer implements FruitSqueezeBehavior<Fruit> {
    public void squeeze(Fruit fruit) {
        System.out.println("squizing any fruit");
    }
}

class AppleSqueezer implements FruitSqueezeBehavior<Apple> {
    public void squeeze(Apple apple) {
        System.out.println("squizing apple");
    }
}

class CherrySqueezer implements FruitSqueezeBehavior<Cherry> {
    public void squeeze(Cherry cherry) {
        System.out.println("squizing cherry");
    }
}

class FruitService {

    public void foo(Fruit fruit) {
        FruitSqueezeBehavior fruitSqueezer = ...
        fruitSqueezer.squeeze(fruit);
    }
}