标签: software-design

我想构建一个简单的端点，它返回一个Order对象，我可以在其中通过单个查询参数或多个查询参数的组合来搜索此订单。所有这些查询参数都是可选的，原因是不同的人会根据不同的 Id 访问这些订单。

例如： /order/items?itemId={itemId}&orderId={orderId}&deliveryId={deliveryId}&packetId={packetId}

@GetMapping(path = "/order/items", produces = "application/json")
public Order getOrders(@RequestParam Optional<String> itemId,
                              @RequestParam Optional<String> orderId,
                              @RequestParam Optional<String> deliveryId,
                              @RequestParam Optional<String> packetId) { }

我当然也可以跳过 JavaOptional 并使用@RequestParam(required = false)，但这里的问题是如何避免检查查询参数是否为空的噩梦if-else？.isPresent()或者是否有一种优雅的方法，根据参数的组合，进一步传递到我的服务和 Spring Data JPA 存储库。

我正在尝试使用 Kotlin 实现干净的架构。该过程的流程将是：

usecase --> get rowresult from DB --> map rowresult to entity --> entity used by the usecase to check business rules

代码示例：

UserTable
------------------
id (varchar)
email (varchar)
password (varchar)
gender (varchar)
phone (varchar)
anotherAttribute1
anotherAttribute2
.
anotherAttributeN

class UserEntity {
    val id: String,
    val email: String,
    val password: String,
    //Business rules
    fun isUserAllowedToLogin(): Boolean {
        //validate password
    }
}

interface UserDataStore {
    fun getUser(email: String): User
}

class UserDataStoreImplementation {
    fun getUser(email: String): User {
        //query …

class A(SomeBaseClass):
    def __init__(self):
        super().__init__()
        self._attribute_0 = something_0
        self._attribute_1 = something_1
        # etc.

    def some_method(self) -> None:
        do_something()

现在假设您有类似的类B, C, D, etc.（并非所有类都继承自同一基类）。它们都具有一些各自的功能，并且从逻辑的角度来看，它们很好地封装在这些类中。关键的一点是，对于这些类中的每一个，一次总是只有一个实例存在。问题是，有时一个类需要访问另一个类的函数，即

if __name__ == "__main__":
    a = A()
    b = B(a)
    c = C()
    d = D(c, a)
    b.d = d
    etc.

假设存在多个 class 实例，这段代码对我来说是合理的A, B, etc.，但由于一次总是只有一个实例存在，因此总是在构造函数中传递它们似乎有点多余（实际上，这些类当然有更复杂的名称）并且“main”函数变得非常难以阅读......）。

尽管存在争议，但在其他语言中，一种解决方案是辛格尔顿模式。似乎有一些方法可以在Python中实现单例（参见这里），但它们似乎不被鼓励（即有些人甚至说Python中永远不需要它们）。

我的目标相当简单：我希望我的对象a,b,c, etc.可以在整个项目中访问，而不必在构造函数中传递它们或通过 等来一一设置它们b.d = d。

这在Python中可能吗？我有什么选择？

@blue_note 的回答插图

# objects.py
a = A()
b = B(a)
c = …

我使用内心有困难Iterator.

private List<List<? extends HasWord>> sentences = new ArrayList<List<? extends HasWord>>(); 
private Iterator<String> wordIterator = new Words();
private class Words implements Iterator<String> {

    int currSentence = 0;
    int currWord = 0;

    @Override
    public boolean hasNext() {
        return currSentence != sentences.size() - 1 && currWord != sentences.get(currSentence).size() - 1;
    }

    @Override
    public String next() {
        String nextWord = sentences.get(currSentence).get(currWord).word();
        currSentence++;
        currWord++;

        return nextWord;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();          
    }

}

然后,我尝试迭代它:

for (String s : …

我的班级有以下构造函数

 public MyClass(File f1, File f2, File f3, Class1 c1, Class2 c2, Class3 c3)
{
..........
}

可以看出,它有6个参数.看到这段代码后,我的一位老人说我不应该传递6个参数,而应该传递一个配置对象.

我用这种方式编写代码是因为最近我读到了"依赖注入",它说"类必须要求他们想要什么".所以我认为传递配置对象将违背原则.

我对"依赖注射"的解释是否正确？或者我应该接受老年人的建议吗？

嘿伙计们,我是一个软件工程师.我第三年的学生现在正在"软件设计"课程中学习设计模式,问题是这些东西真的很难知道你知道任何简化的指南或视频来理解这些概念吗？我的专业是考试是下周,我需要提前准备,我希望你能给出最简单的参考来理解它们

我了解到std :: vector是C++中原始数组的一个很好的包装器,所以我开始用它来管理我的CUDA应用程序中的主机数据[1].由于必须手动分配和复制东西会使代码更复杂,更不易读,我想扩展std :: vector.由于我不是很有经验,所以我想知道你对它的看法.特别是天气正确完成(例如std :: vector的析构函数是隐式调用的,对吧？)如果你认为它是个好主意.

我写了一个小例子来说明这一点

#include <vector>
#include <cuda.h>

#include <cstdio>

void checkCUDAError(const char *msg)
{
    cudaError_t err = cudaGetLastError();
    if( cudaSuccess != err) {
        fprintf(stderr, "Cuda error: %s: %s.\n", msg, cudaGetErrorString(err));
        exit(EXIT_FAILURE);
    }
}

// Wrapper around CUDA memory
template<class T>
class UniversalVector: public std::vector<T>
{
    T* devicePtr_;
    bool allocated;

public:

    // Constructor
    UniversalVector(unsigned int length)
        :std::vector<T>(length), 
         allocated(false)
    {}

    // Destructor
    ~UniversalVector()
     {
        if(allocated)
            cudaFree(devicePtr_);
     }

    cudaError_t allocateDevice()
    {
        if(allocated) free(devicePtr_);
        cudaError_t err = 
            cudaMalloc((void**)&devicePtr_, sizeof(T) …

你好任何一个有你的想法如何在Ubuntu操作系统中安装Photoshop？

我的项目只是用简单的html页面开发一个网站.要启动项目,我必须先做设计文档,因为我无法理解应该使用哪种UML图？

C ++ 20围绕合同提供了一些令人惊叹的新功能-对于模板来说，这将使生活变得更好-可以将围绕类型或其他编译时要求的约束放入模板定义中，并由编译器进行适当的诊断。好极了！

但是，我非常担心在发生运行时先决条件冲突时无条件终止的努力。

https://en.cppreference.com/w/cpp/language/attributes/contract

可以使用两种违规继续模式之一来翻译程序：

关（如果未选择任何连续模式，则为默认值）：违反处理程序的执行完成后，将调用std :: terminate; on：违反处理程序的执行完成后，将继续正常执行。鼓励实现不提供任何编程方式来查询，设置或修改构建级别或设置或修改违规处理程序。

我已经编写了广泛的面向用户的软件，该软件将所有异常捕获到一个核心执行循环中，在该循环中记录错误并通知用户有关失败的信息。

在许多情况下，用户最好尽可能地保存并退出，但在其他许多情况下，可以通过更改他们正在处理的设计/数据文件中的内容来解决错误。

这就是说，仅通过更改其设计（例如CAD设计），他们希望执行的操作即可成功。例如，代码执行时的公差可能过紧，从而无法根据该结果计算结果。更改容差后，只需重新运行该过程即可成功（不再违反基础代码中某个地方的违规前提条件）。

但是推动前提条件的努力简单地终止了，没有能力捕获这种错误并重试该操作吗？这听起来像是功能集的严重降级。诚然，在某些领域中确实需要这样做。快速失败，提早失败，并且对于先决条件或后置条件，问题出在编写代码的方式上，并且用户无法补救这种情况。

但是...这是一个很大的问题，但是...大多数软件都会针对运行时提供的未知数据集执行-声称所有软件都必须终止，并且无法期望用户纠正这种情况似乎很奇怪。

赫伯·萨特（Herb Sutter）在ACCU的讨论似乎与前提条件和后置条件违反仅仅是终止条件的观点紧密相关：

https://www.youtube.com/watch?v=os7cqJ5qlzo

我正在根据您的编码经验告诉您其他C ++专业人员在想什么？

我知道许多项目都不允许例外。如果您正在从事一个这样的项目，这是否意味着您编写代码以在发生无效输入时简单地终止？还是您使用错误状态回退到能够以某种方式继续的某些父代码点？

也许更重要的是-也许我误解了C ++ 20运行时合同的意图本质？

请保持这种文明的态度-如果您的建议是结束这种做法-也许您会友好地指向一个更合适的论坛进行讨论？

总的来说，我正在努力让我满意：

如何检查和处理违反先决条件的行为（使用最佳实践）？