Java 坚实的原则。如何在高水平的课堂上不让所有的东西都被卡住？

我刚刚完成了一个主要使用实用类的java应用程序，然后我在周末阅读了有关SOLID原则的文章，所以我正在重构整个应用程序以遵循该原则。我在尝试时遇到了一个问题，因此，我一定是做错了，所以有人能引导我走上正确的道路吗？ 例如：

正如你所看到的，抽象的层次越高，对象越多，情况就越糟。你用什么方法来减少这种情况

---

我的第一个想法是有一个客户端，用于中间的接口，这些接口知道这些接口的具体类（类似于工厂类）的所有内容，然后类A将使用该客户端类，但问题仍然存在。类依赖于依赖于其他具体类的客户端类。我只是在做一条长链，而不是很多短链。

这个设计对我来说很不错。不需要在类A之上创建更多的抽象层，因为这样——正如您正确认识到的那样——它永远不会结束。系统必须有优势，抽象应该在某个地方得到解决。只要这个类只负责将其他对象连接在一起（因此您可以将类A称为“配置”），那么在类A中这样做就可以了

---

因此，只要您希望只使用普通java而不使用任何框架，就可以使用这种设计。对DI使用Spring（或任何其他依赖项注入库）可能是一个优势，但只有在您觉得需要时才引入它。顺便说一句，使用spring的JavaConfig进行依赖项注入将产生与当前类A几乎相同的代码，并带有一些注释。

这种设计对我来说很好。不需要在类A之上创建更多的抽象层，因为这样——正如您正确认识到的那样——它永远不会结束。系统必须有优势，抽象应该在某个地方得到解决。只要这个类只负责将其他对象连接在一起（因此您可以将类A称为“配置”），那么在类A中这样做就可以了

---

因此，只要您希望只使用普通java而不使用任何框架，就可以使用这种设计。对DI使用Spring（或任何其他依赖项注入库）可能是一个优势，但只有在您觉得需要时才引入它。顺便说一句，使用spring的JavaConfig进行依赖项注入将产生与您当前的类A几乎相同的代码，并带有一些注释。

这里的关键是类A只负责布线，不做其他事情，因此满足单一责任原则。出于好奇，如果没有DI库，类

B

如何访问类

a

中的对象，即如何注入bean？我不确定是否理解这个问题。

ibb=新的b（d，c）行是一个正确的构造函数注入，没有任何DI库，不是吗？是的，对不起。我想说的是，客户机类如何访问由
A
构造的对象
b
，即
A
如何在不使用DI库的情况下注入其bean？可能有些业务逻辑需要对象
b
。从业务逻辑到
A
，如何建立这种联系？哦，好吧，我误解了你的答案。我假设我走错了方向，因为顶级类（类A）将被各种各样的对象所阻塞，并且想知道其他人会怎么做。从你的评论和上面的评论者看来，最高的一层被物体堵塞似乎是可以的，最好是让合成根（边）尽可能靠近主入口点。谢谢。这里的关键是class
A
只负责布线，不做其他事情，因此满足单一责任原则。出于好奇，如果没有DI库，class
B
如何访问class
A
中的对象，即如何注入bean？我不确定是否理解这个问题。
ibb=新的b（d，c）行是一个正确的构造函数注入，没有任何DI库，不是吗？是的，对不起。我想说的是，客户机类如何访问由
A
构造的对象
b
，即
A
如何在不使用DI库的情况下注入其bean？可能有些业务逻辑需要对象
b
。从业务逻辑到
A
，如何建立这种联系？哦，好吧，我误解了你的答案。我假设我走错了方向，因为顶级类（类A）将被各种各样的对象所阻塞，并且想知道其他人会怎么做。从你的评论和上面的评论者看来，最高的一层被物体堵塞似乎是可以的，最好是让合成根（边）尽可能靠近主入口点。谢谢。所有应用程序都需要一个。它声明“尽可能靠近入口点”。应用程序的入口点（或入口点附近）有多个由多个较小对象递归组成的巨大对象（按空间划分）是正常的吗？是的，但您可能也想阅读。是的，我已经读过了，但一些评论者提出了很好的论据，比如在启动时加载一个巨大的对象，并使其在整个应用程序中都可用，而不是在需要时给每个对象赋予作用域，因为大多数应用程序在任何特定时间都只需要对象的一部分。所有应用程序都需要一个“尽可能靠近入口点”。应用程序的入口点（或入口点附近）有多个大型对象（按空间划分）是否正常这是由多个较小的对象递归组成的？是的，但你可能也想阅读。是的，我读过，但一些评论者提出了很好的论点，比如在启动时加载一个巨大的对象，并使其在整个应用程序中可用，而不是给每个对象赋予作用域
public interface ID { }

public class D implements ID {
  //this class has a lot of dependencies that I do not want in class B but at some point
 // I have to create it. When is that point?
}

public interface IC { }

public class C implements IC {
  //this class has a lot of dependencies that I do not want in class B
}

public interface IB { }

public class B implements IB {
  public IC c;
  public ID d; 

  // this class depends on the 2 (or more) interfaces IC and ID so 
  // it won't have dependencies on concrete classes. But if the 
  // concrete classes are not used, then they all start bubbling up to the          
  // higher level class (let say class A below), and class A would know about and have 
  // dependencies on way so many objects, doesn't it?
}

public class A {
   ID d = new D();
   IC c = new C();
   IB b = new B(d, c); // b could given to some other classes
}