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();
         // }
      } 
   } 
}

由于这是一个客户机/服务器应用程序，因此来自客户机的多个请求同时提供给服务器。服务器处理请求，向学徒客户端发送适当的答复。注意:在Client & Server之间发送的所有对象都是java.io.Serializable的实例。

有了这样的场景并查看了Server.ClientServer.update()块，我们可能会出现性能问题，或者我应该说，由于Intrinsic Locks，在处理N个客户机请求时出现了延迟。但是，由于我必须遵守规则concurrency和synchronization，以确保Server.T1Service不会被N个客户机请求的队列所迷惑。以下是一些问题：

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

Answer 1

我关于1项静态工厂的理论正确吗？

是的，您可以使用静态工厂而不是构造函数。通常情况下，构造逻辑是复杂的，并且在不同的子类型之间共享以保证一个工厂模式。此外，工厂可以提供DI框架之外的依赖注入方法。

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

如果需要同步构造，那么静态工厂运行良好，只需将synchronized添加到工厂方法的方法声明中即可。如果您需要同步对象本身上的方法，那么这不会有帮助。

如果在哪里处理对全局对象的并发访问，以及希望实时访问每个全局对象的方法，那么是否应该将其转换为静态工厂？

正如我上面所回答的，这取决于你在努力实现什么。对于构造函数同步，请使用工厂。

Answer 2

您还可能希望查看Actor，例如阿克卡中的Actor

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

工作起来就像一种魅力一般:)