Java 静态工厂转换

Question

在我的客户端/服务器桌面应用程序上。我有这个问题，我应该如何使用我的模型正确编码我的 JDBC 类，以确保所有持久性请求都可以支持并发。 i.e., multiple models want to request update to its persistence counterpart simultaneously [without atmost delay].

剧情是这样的。遵循位于服务器应用程序中的类。

持久性包：

abstract class AbstractService {
  // other fields
  private final String tName, tId;
  private final String sqlStatement;
  public AbstractService(final String tName, final String tId) {
    this.tName = tName;
    this.tId = tId;
    this.sqlStatement = ""; // SELECT statement
  }
  // java.sql.Connection() createConnection()
  // methods
}
public class T1Service extends AbstractService {
  private final String sqlDMLStatements;
  public T1Service() {
    super("t1", "t1Id");
    this.sqlDMLStatements = ""; // other DML statements
  }      
  // methods having return types of List<E>, Object, Boolean, etc.
  // i.e., public List<E> listAll()
}

通信类[客户端类]

import java.net.*;
import java.io.*;
public class Client extends Observable{
  private Socket socket;
  private ObjectInputStream input;
  private ObjectOutputStream output;
  private Object message;
  // Constructor
  // Getters/Setters
  // Other methods like open or close input/output
  private class ReceiverRunnable implements Runnable
    @Override
    public void run() {
       while(running) { // if socket is still open and I/O stream are open/initialized
          try { message = input.readObject(); } 
          catch(Exception e) {}
          finally { setChanged(); notifyObservers(); }  
       } 
    }
  }
}

主类[服务器类]

import java.net.*;
public class Server {
   private List<Client> clientList; // holds all active connections with the server
   private T1Service    t1Service
   private class ConnectionRunnable implements Runnable {
      @Override public void run() {
         while(running) { // serverSocket is open
           Client client = new Client(ServerSocket.accept(), /* other parameters */);
           client.addObserver(new ClientObserver(client));
           clientList.add(client);
         }
      } 
   }
   private class ClientObserver implements Observer {
      private Client client;
      // Constructor
      public void update(Observable o, Object arg) {
         // Check the contents of 'message' to determine what to reply
         // i.e., message.equals("Broadcast") {
         // synchronized(clientList) {
         //   for(Client element : clientList) {
         //     element.getOutput().writeObject(replyObject);
         //     element.getOutput()..flush();
         //   }
         // }
         // i.e., message.equals("T1") {
         // synchronized(t1Service) {
         //     client.getOutput().writeObject(t1.findAll());
         //     client.getOutput().flush();
         // }
      } 
   } 
}

由于这是一个客户端/服务器应用程序，来自客户端的多个请求同时馈送到服务器。服务器处理请求，将适当的回复发送给适当的客户端。 注意：客户端和服务器之间发送的所有对象都是 java.io.Serializable 的实例。

遇到这种情况并查看Server.ClientServer.update() 的块，我们可能会遇到性能问题，或者我应该说由于Intrinsic Locks 而导致处理N 个客户端请求的延迟。但是由于我必须遵守规则 concurrency 和 synchronization 以确保 Server.T1Service 不会对 N 个客户端请求的队列感到困惑。以下是问题：

1. 根据Effective Java - Second Edition 中关于Static Factory 的第1 项，这是否可以让我创建一个对Persistence 包类中的方法的新类引用？
2. List<Client> 中的每个 Client 元素是否会形成并发问题，让 N 个客户端更新它们的 message 字段同时触发 ClientObsver.update()，其中此观察者的引用对象只是父类。 由于内存问题，我避免创建多个 T1Service 实例。
3. 如果我们要按照 Effective Java - Second Edition 的内容，我如何将我的持久性类转换为易于阅读、易于实例化并支持并发的方式？

Answer 1

您可能还想查看演员，例如Akka 中的演员

actor 的基本思想是完全避免同步，使用发送事件。 Akka 将保证一个参与者永远不会被两个线程并行调用。所以你可以定义actor，它对全局变量做一些事情，然后简单地向它发送消息。

通常像魅力一样工作:)

Answer 2

我的 [Item 1] 静态工厂理论正确吗？

是的，您可以使用静态工厂代替构造函数。通常这是当您的构造逻辑很复杂并且在各种子类型之间共享以保证工厂模式时。此外，工厂可以提供在 DI 框架之外进行依赖注入的方法。

那它会解决转换后的静态工厂全局对象的并发问题吗？

如果您需要同步构造，那么静态工厂效果很好，只需在工厂方法的方法声明中添加synchronized。如果您需要同步对象本身的方法，那么这将无济于事。

如果在哪里处理对全局对象的并发访问，并且在哪里需要实时访问每个全局对象的方法，我是否建议转换为静态工厂？

正如我上面回答的那样，这取决于您要达到的目标。对于构造函数同步，请使用工厂。