Java靜態工廠轉換（更新）

Question

在我的客戶端/服務器桌面應用程序上。我有這個問題，我應該如何正確編寫我的模型與我的JDBC類，以確保所有持久性請求可以支持併發。 i.e., multiple models want to request update to its peristence counterpart simultaneously [without atmost delay].

這種情況是這樣的。跟在服務器應用程序中的類之後。

Persitence套餐：

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

由於這是一個客戶機/服務器的applcation，來自客戶端的多個請求同時送到服務器。服務器處理將請求發送給適當客戶端的請求。 注意：客戶端之間發送的所有對象都是服務器java.io.Serializable的一個實例。

有了這種情景和尋找到的Server.ClientServer.update()塊，我們可以有一個性能問題或者我應該說，在處理N個客戶機的請求，由於Intrinsic Locks延遲。但由於我必須遵守規則concurrency和synchronization以確保Server.T1Service不會被N客戶端請求的隊列所困擾。這裏的有問題：

1. 根據有關Static Factory項目的Effective Java - Second Edition 1，這將讓我創建一個新類參考持久包中的類裏面的方法呢？
2. 會內部List<Client>每個Client元件將形成具有N個客戶端更新其message字段同時觸發​​其中，該觀測器的參考對象（一個或多個）僅在父類中的單個實例併發問題。 由於內存問題，我避免創建T1Service的多個實例。
3. 如果我們打算繼續閱讀Effective Java - Second Edition的內容，我該如何將persitence類以易於閱讀，易於實例化並支持concurreny的方式轉換？

注意：由於信息的不一致性，我更新了我的問題。

Answer 1

是我[項目1]靜態工廠的理論是否正確？

是的，您可以使用靜態工廠而不是構造函數。通常情況下，當您的構建邏輯非常複雜並且在各種子類型之間共享時，可以保證工廠模式。另外，工廠可以在DI框架之外提供用於依賴性注入的手段。

然後它會解決轉換的靜態工廠全局對象的併發問題嗎？

如果您需要同步施工，那麼靜態工廠運行良好，只需將​​添加到工廠方法的方法聲明中即可。如果你需要同步對象本身的方法，那麼這將無濟於事。

如果在處理對全局對象的併發訪問以及想要實時訪問每個全局對象的方法的情況下，建議將靜態工廠轉換爲靜態工廠？

正如我上面的回答，這取決於你想達到什麼。對於構造函數同步使用工廠。

Answer 2

您還可以查看演員，例如那些在行爲者在所有避免同步的Akka

基本思想，利用發送事件。 Akka將保證一個演員永遠不會被兩個線程並行調用。所以你可以定義actor，用全局變量做一些事情，然後簡單地發送一條消息給它。

的作品就像一個魅力通常:)