标签: solid-principles

我试图理解单一责任原则。我有以下问题。

1. 单一职责原则 (SRP) 规定，类的更改不应有多个原因。通常我们的Resource、Service和Repository类都有create、read、update和delete方法。我们正在更改每个类以修改任何这些操作的代码。是否违反SRP？我们需要为每个动作单独的类吗？

2. 当我运行声纳 lint 时，我看到了以下消息。

   类不应该与太多其他类耦合。

   这里我使用 spring DI 注入其他类。依赖项数量有限制吗？

我可能错过了这个概念的关键。请推荐一个很好的资源，通过示例更好地理解这个概念

我将在我的作业中使用接口，并在作业类中获取它的上下文实现。

我读了所有的啧啧声。

我注册它：

class AppServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app
            ->when(SendinBlueJob::class)
            ->needs(MessageProviderInterface::class)
            ->give(SendinBlueService::class);
    }
}

我派遣工作：

class MessageObserver
{
    public function created(MessageInterface $message)
    {
        SendinBlueJob::dispatch($message);
    }
}

在工作类别中，我想获得绑定服务：

class SendinBlueJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

     public $message;
     public $messageProvider;

    public function __construct(MessageInterface $message, MessageProviderInterface $messageProvider)
    {
        $this->message = $message;
        $this->messageProvider = $messageProvider;
        $this->handle();
     }

    public function handle()
    {
        dd($this->messageProvider);
    }
}

我无法调度作业，因为服务器抛出错误：

函数 App\Jobs\SendinBlueJob::__construct() 的参数太少，第 16 行 /var/www/vendor/laravel/framework/src/Illuminate/Foundation/Bus/Dispatchable.php 中传递了 1 个参数，预计正好有 2 个参数

我理解它，但我不明白为什么 …

我最近在看书，第一次Java Concurrency in Practice接触到这个方法。Collections.unmodifiableMap(...)该方法围绕现有的创建一个只读包装器Map，任何修改返回值的尝试Map（根据Javadocs）都会导致UnsupportedOperationException抛出异常。其他集合类也存在类似的方法。

这让我非常担心，因为 anunmodifiableMap()仍然返回 a Map，但不支持所有相关方法。事实上，它还会在写入操作上引发异常，这意味着它无法Map在大多数应用程序中替代“正确的”异常。

我是一名学生，对自己识别设计缺陷的能力还没有信心，但是这些不是分别违反了Interface segregation和Liskov substitution原则吗？

我想将 SOLID 原则应用于处理太多“用例”的反应组件。举个例子，假设我有一个组件，它的主要职责是渲染一个像这样的表：

return (
   <Table dataSource="" name={tableName} />
)

这是该表的非常简单的表示。但主要的复杂点是 prop dataSource。在这个<Table>组件内部，我实际上有很多逻辑/if-else 条件来满足dataSource组件中散落的标志，因为它们dataSource可以采用许多不同的形状/对象结构。有些非常相似，可以抽象出来，而有些则非常具体（甚至可能只是一个键不同）。

例如：

const tableName = `${
    dataSource === 'dataSourceA'
        ? dataSourceName
        : dataSourceName.name
}`;

这只是一个例子。想象一下，一些dataSource有其name财产嵌套深3个级别。然后其他dataSource键甚至会有不同的名称（尽管我需要渲染的结果数据实际上是相同的）。不仅如此，根据dataSource，我可能需要调用不同的端点来执行某些功能（同样，该函数具有相同的目的，只是端点可以不同）。因此，在同一个组件中，我将具有如下功能：

const exportTable = () => {
    if(dataSource === 'dataSourceA') {
        // use endpoint A
    } else if (dataSource=== 'dataSourceB') {
        // use endpoint B
    } else {
         // use endpoint C
    }
}

重构此类组件并使其更易于维护的最佳方法是什么？稍后，我们可以有 10 种类型，dataSources …

我最近正在阅读这个博客https://blog.cleancoder.com/uncle-bob/2021/03/06/ifElseSwitch.html这段让我很困惑：

小心那个令牌 x。不要试图使它成为一个枚举或任何需要在红线上方声明的东西。整数或字符串是更好的选择。它可能不是类型安全的。事实上，它不可能是类型安全的。但它将允许您保留架构的组件结构。

如果我们在高层模块中声明一个枚举，那么低层模块不仍然依赖于高层模块吗？如果是这样，那么在这种情况下使用枚举有什么问题？

我正在使用Web Api,并且客户端每n秒发送一次心跳通知.有一个心跳对象是在POST而不是PUT中发送的,因为我看到它们正在创建一个新的心跳而不是更新现有的心跳.

此外,客户端要求他们检索所有其他当前在线客户端以及单个客户端具有的未读消息数.在我看来,我有两个选择:

1. 执行POST后跟GET,从纯粹的REST角度来看,这似乎更清晰.我正在进行创建和检索,我认为SOLID原则更愿意相应地拆分它们.但是,这种方法意味着两次往返.
2. 让POST返回一个对象,该对象包含与GET原本相同的信息.这将所有内容整合到一个请求中,但我担心这种方法会被认为是不明智的.这不是一个纯粹的POST.

选项#2 stubped out看起来像这样:

public HeartbeatEcho Post(Heartbeat heartbeat)
    {
    }

HeartbeatEcho是一个类,其中包含其他在线客户端的属性和未读消息的数量.

Web Api当然支持选项#2,但仅仅因为我可以做某事并不意味着我应该这样做.选项#2是憎恶,过早优化还是实用主义？

情况就是这样.我们有两台来自不同供应商(制造商)的打印机.我们希望顶级代码不会意识到有关提供程序的详细信息,只需使用统一的API.所以我开始提取界面.

public interface IPrinterProvider {
    bool Connect(string comPort);
    bool IsConnected();
}

好.现在,我意识到一台打印机需要Password属性,但另一台则不需要.所以我该怎么做？

再一次.据我所知,我将有一个或几个接口和几个实现者.但是呼叫者将如何工作？我应该创建一个单独的类,它可能不实现任何接口？例如:

public class CommonPrinterProvider {
    private IPrinterProvider printerProvider;
    public CommonPrinterProvider(IPrinterProvider printerProvider) {
        this.printerProvider= printerProvider;
    }
}

所以,总共有两个问题.

我正在尝试以正确的方式学习OOP和OOD原则.我想对Liskov替换原则及其PRE和POST条件做一些澄清.我在这里阅读了一些主题,一些文章来自http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod等地方.

我已经编写了一个简单的基类和几个示例子类,我的假设是关于它们的前后条件,我想知道它们是否正确.注释行是我的想法:是否违反了PRE和POST条件.

public abstract class BaseClass
{
    public virtual int GetResult(int x, int y)
    {
        if (x > 10 && y < 20)
        {
            return y - x;
        }
        throw new Exception();
    }
}

public class LSPExample1 : BaseClass
{
    public override int GetResult(int x, int y)
    {
        // PRE: weakened pre condition is ok
        if (x > 10 && y <= 15)
        {
            // POST: Is it ok? because the available result range is narrowed by y …

这是在接受采访时向我询问的.

我回答他说,对于同一组输入,父母和孩子都应该产生相同的输出.如果孩子想要扩展父母的功能,它应该只对父母支持范围之外的新输入做.通过这种方式,孩子将保持其父母的合同.

我给了他一个例子,api可能正在使用像这样的父母

if(parent.getOutput(10) == 5){/*do something */}

如果孩子在这里产生了不同的输出,那么那个孩子已经违反了它的父母所做的合同.

他对我的回答并不满意,并告诉我这是简单的重写,并不违反LSP.所以,我只是想确认,如果我理解这是正确的.

我有一个MyClass要实例化的类，该类包含一个私有属性ObjectRepository，该私有属性在MyClass调用的构造函数时要实例化。

public MyClass
{
    private ObjectRepository _objectRepository;

    public MyClass()
    {

    }
}

MyClass 实例化以添加到列表中：

objects.Add(new MyClass());

遵循SOLID原则，最干净的方法是什么？

- - 编辑 - -

我还忘了提到的是，当我编写单元测试时，MyClass我希望能够进行模拟ObjectRepository。ObjectRepository从的构造函数实例化时，这是不可能的MyClass，因为测试中没有对的引用_objectRepository。