क्या जावा ऑब्जेक्टपूल/पूल का उपयोग करने के तरीके पर कोई अच्छा ट्यूटोरियल या उदाहरण हैं?

Question

मैं कतार सर्वर के लिए चैनल/कनेक्शन का पूल बनाने की कोशिश कर रहा हूं और ऑब्जेक्टपूल का उपयोग करने की कोशिश कर रहा था लेकिन example से उनकी साइट पर इसका उपयोग करने में परेशानी हो रही है।

अभी तक मेरे पास धागे हैं जो काम करते हैं लेकिन मैं चाहता हूं कि उनमें से प्रत्येक पूल से एक चैनल पकड़ ले और फिर इसे वापस कर दें। मैं समझता हूं कि इसका उपयोग कैसे करें (उधार ऑब्जेक्ट/रिटर्नऑब्जेक्ट्स) लेकिन यह सुनिश्चित नहीं है कि इंटियल पूल कैसे बनाएं।

यहाँ कैसे चैनलों RabbitMQ में बना रहे हैं क्या है:

ConnectionFactory factory = new ConnectionFactory(); 
    factory.setHost("localhost"); 
    Connection connection = factory.newConnection(); 
    Channel channel = connection.createChannel(); 

और मेरे कोड सिर्फ सामान करने के लिए चैनल का उपयोग करता है। मैं उलझन में हूं, क्योंकि केवल उदाहरण मैं (अपनी साइट पर) मिल सकता है इस तरह यह शुरू होता है:

private ObjectPool<StringBuffer> pool; 

    public ReaderUtil(ObjectPool<StringBuffer> pool) { 
     this.pool = pool; 
    } 

कौन सा मेरे लिए कोई मतलब नहीं है। मुझे एहसास हुआ कि डेटाबेस कनेक्शन स्थापित करना आम है इसलिए मैंने डेटाबेस और ऑब्जेक्टपूल का उपयोग करके ट्यूटोरियल ढूंढने की कोशिश की लेकिन वे डीबीसीपी का उपयोग करने लगते हैं जो डेटाबेस के लिए विशिष्ट है (और मैं अपने कतार सर्वर के लिए तर्क का उपयोग नहीं कर सकता)।

इसका उपयोग करने के तरीके पर कोई सुझाव? या जावा में पूल के लिए एक और दृष्टिकोण इस्तेमाल किया जाता है?

Answer 1

वे एक वर्ग बनाते हैं जो ऑब्जेक्ट बनाता है & जानता है कि उन्हें वापस आने पर क्या करना है। यही कारण है कि आप के लिए कुछ इस तरह हो सकता है:

public class PoolConnectionFactory extends BasePoolableObjectFactory<Connection> { 

    private final ConnectionFactory factory; 
    public PoolConnectionFactory() { 
     factory = new ConnectionFactory(); 
     factory.setHost("localhost"); 
    } 

    // for makeObject we'll simply return a new Connection 
    public Connection makeObject() { 
     return factory.newConnection(); 
    } 

    // when an object is returned to the pool, 
    // we'll clear it out 
    public void passivateObject(Connection con) { 
     con.I_don't_know_what_to_do(); 
    } 

    // for all other methods, the no-op 
    // implementation in BasePoolableObjectFactory 
    // will suffice 
} 

अब आप एक ObjectPool<Connection> कहीं बनाएँ:

ObjectPool<Connection> pool = new StackObjectPool<Connection>(new PoolConnectionFactory()); 

तो आप pool अपने सूत्र के अंदर की तरह

Connection c = pool.borrowObject(); 
c.doSomethingWithMe(); 
pool.returnObject(c); 

लाइनों का उपयोग कर सकते है कि डॉन आपको समझ में नहीं आता कि पूल ऑब्जेक्ट को एक अलग वर्ग में पारित करने का एक तरीका है। अंतिम पंक्ति देखें, वे पाठक बनाते समय पूल बनाते हैं।

new ReaderUtil(new StackObjectPool<StringBuffer>(new StringBufferFactory())) 

Answer 2

आप बनाने के लिए मान्य है, और नष्ट करने के लिए वस्तुओं आप पूल करने के लिए चाहता हूँ PoolableObjectFactory के एक कस्टम कार्यान्वयन की आवश्यकता होगी। फिर ऑब्जेक्टपूल के निर्माता को अपने कारखाने का एक उदाहरण पास करें और आप उधार वस्तुओं को शुरू करने के लिए तैयार हैं।

यहां कुछ नमूना कोड है। आप कॉमन्स-डीबीसीपी के लिए स्रोत कोड भी देख सकते हैं, जो कॉमन्स-पूल का उपयोग करता है।

import org.apache.commons.pool.BasePoolableObjectFactory; 
import org.apache.commons.pool.ObjectPool; 
import org.apache.commons.pool.PoolableObjectFactory; 
import org.apache.commons.pool.impl.GenericObjectPool; 

public class PoolExample { 
    public static class MyPooledObject { 
     public MyPooledObject() { 
      System.out.println("hello world"); 
     } 

     public void sing() { 
      System.out.println("mary had a little lamb"); 
     } 

     public void destroy() { 
      System.out.println("goodbye cruel world"); 
     } 
    } 

    public static class MyPoolableObjectFactory extends BasePoolableObjectFactory<MyPooledObject> { 
     @Override 
     public MyPooledObject makeObject() throws Exception { 
      return new MyPooledObject(); 
     } 

     @Override 
     public void destroyObject(MyPooledObject obj) throws Exception { 
      obj.destroy(); 
     } 
     // PoolableObjectFactory has other methods you can override 
     // to valdiate, activate, and passivate objects. 
    } 

    public static void main(String[] args) throws Exception { 
     PoolableObjectFactory<MyPooledObject> factory = new MyPoolableObjectFactory(); 
     ObjectPool<MyPooledObject> pool = new GenericObjectPool<MyPooledObject>(factory); 

     // Other ObjectPool implementations with special behaviors are available; 
     // see the JavaDoc for details 

     try { 
      for (int i = 0; i < 2; i++) { 
       MyPooledObject obj; 

       try { 
        obj = pool.borrowObject(); 
       } catch (Exception e) { 
        // failed to borrow object; you get to decide how to handle this 
        throw e; 
       } 

       try { 
        // use the pooled object 
        obj.sing(); 

       } catch (Exception e) { 
        // this object has failed us -- never use it again! 
        pool.invalidateObject(obj); 
        obj = null; // don't return it to the pool 

        // now handle the exception however you want 

       } finally { 
        if (obj != null) { 
         pool.returnObject(obj); 
        } 
       } 
      } 
     } finally { 
      pool.close(); 
     } 
    } 
}