Oracle SOA and more: Enabling Coherence with example

Que tal,

Veamos como habilitar el nodo de Coherence en el cual viene integrado con Weblogic, en esta ocasión usare la versión 11.1.1.5 del producto.

Primero nos dirigirnos al siguiente archivo de coherence en la siguiente ruta:

`1`	`cd` `/u01/orasoa/middleware/coherence_3.X/bin`

Bien, ahora modificamos el archivo "coherence.sh" usando el comando:

`1`	`vi` `coherence.sh`

Dentro del archivo buscamos la linea que dice "STORAGE_ENABLED=false"

Hay que modificar el valor "false" por el valor "true".

Nota: Después de actualizar el archivo hay que reiniciar Weblogic.

Vamos a ver un ejemplo en Java de como usar Coherence.

01import com.tangosol.net.CacheFactory;
02import com.tangosol.net.NamedCache;
03 
04import com.eddosoa.coherence.persistence.DataVO;
05import com.eddosoa.coherence.persistence.HeaderVO;
06import com.eddosoa.coherence.utils.CoherenceUtil;
07 
08import java.util.ArrayList;
09import java.util.List;
10 
11public class CoherenceSample {  
12    /**
13     * Atributo para ser utilizado por patron de diseño de la instancia
14     */
15    private static CoherenceEJBBean instance = null;
16     
17    /**
18     *  CONSTANTE con el nomre de la cache a utilizar.
19     */
20    private static final String CACHE_NAME = "TestCache";  
21     
22    /**
23     * 
24     */
25    private static NamedCache cache;
26   
27    /**
28     * Bloque que inicializa por unica vez la cache almacenada en Coherence
29     */
30    static {
31        try {
32            if (cache == null) {
33                CacheFactory.ensureCluster();
34                cache = CacheFactory.getCache( CACHE_NAME );
35            }
36        } catch(Exception ex) {
37          System.out.println("Error --> " + ex.getMessage());
38        }
39    }
40 
41       
42    /**
43    * Metodo que almacena un elemento en Coherence.
44    * @param data
45    * @return
46    */
47    public void putCacheValue(DataVO data) {
48  
49  String key = CoherenceUtil.createKey(data.getHeader()); //Metodo createKey: genera una cadena para crear la llave (usar cualquier nombre)
50  cache.put(key , data.getDataInfo());
51    }
52     
53    /**
54    *   Metodo que retorna un objeto dado otro objeto para la busqueda
55    *   @param data
56    *   @return
57    */
58    public Object getCacheValue(HeaderVO header) {
59        ResponseVO result = new ResponseVO();
60        if(header != null) {
61              if(CoherenceUtil.checkHeaderValues(header)) {                
62                String key = CoherenceUtil.createKey(header);
63                if(cache.containsKey(key)) {
64                  result.setResponse(cache.get(key));
65                }                
66 
67        }
68        return result;
69    }      
70     
71     
72    /**
73       * Metodo que elimina un objeto almacenado en la cache de coherence dado un header
74       * @param header
75       * @return
76       */
77    public void deleteSegment(HeaderVO header){
78      ResponseVO result = new ResponseVO();
79      if(header != null) {
80            if(CoherenceUtil.checkHeaderValues(header)) {
81              String key = CoherenceUtil.createKey(header);
82              cache.remove(key);
83          }
84      }
85    }
86           
87  }

Estos son ejemplos de como construir los DTO para coherence en el cual implementamos la interface para los POF(Portable Object Format.

01package com.eddosoa.coherence.persistence;
02 
03import com.tangosol.io.pof.PofReader;
04import com.tangosol.io.pof.PofWriter;
05import com.tangosol.io.pof.PortableObject;
06 
07import java.io.IOException;
08import java.io.Serializable;
09 
10public class HeaderVO implements Serializable, PortableObject{
11     
12  private String docKindOf;
13  private String currentPart;
14  private String totalParts;
15  private String store;
16  private String date;
17     
18     
19 
20    public void readExternal(PofReader reader) throws IOException {
21      docKindOf   = reader.readString(0);
22      currentPart = reader.readString(1);
23      totalParts  = reader.readString(2);
24      store       = reader.readString(3);
25      date        = reader.readString(4);
26    }
27 
28    public void writeExternal(PofWriter writer) throws IOException {
29      writer.writeString(0, docKindOf);
30      writer.writeString(1, currentPart);
31      writer.writeString(2, totalParts);
32      writer.writeString(3, store);
33      writer.writeString(4, date);
34    }
35 
36 
37    public void setDocKindOf(String docKindOf) {
38        this.docKindOf = docKindOf;
39    }
40 
41    public String getDocKindOf() {
42        return docKindOf;
43    }
44 
45    public void setCurrentPart(String currentPart) {
46        this.currentPart = currentPart;
47    }
48 
49    public String getCurrentPart() {
50        return currentPart;
51    }
52 
53    public void setTotalParts(String totalParts) {
54        this.totalParts = totalParts;
55    }
56 
57    public String getTotalParts() {
58        return totalParts;
59    }
60 
61    public void setStore(String store) {
62        this.store = store;
63    }
64 
65    public String getStore() {
66        return store;
67    }
68 
69    public void setDate(String date) {
70        this.date = date;
71    }
72 
73    public String getDate() {
74        return date;
75    }
76}

01package com.eddosoa.coherence.persistence;
02 
03import com.tangosol.io.pof.PofReader;
04import com.tangosol.io.pof.PofWriter;
05import com.tangosol.io.pof.PortableObject;
06 
07import com.eddosoa.coherence.utils.EnumType;
08 
09import java.io.IOException;
10import java.io.Serializable;
11 
12public class DataVO implements Serializable, PortableObject {
13           
14    private HeaderVO header;
15    private String dataInfo;
16    private EnumType type;
17 
18    public void readExternal(PofReader reader) throws IOException {
19      header   = (HeaderVO)reader.readObject(0);
20      dataInfo = reader.readString(1);
21      type     = (EnumType)reader.readObject(2);
22    }
23 
24    public void writeExternal(PofWriter writer) throws IOException {
25      writer.writeObject(0, header);
26      writer.writeString(1, dataInfo);
27      writer.writeObject(2, type);
28    }
29 
30 
31    public void setHeader(HeaderVO header) {
32        this.header = header;
33    }
34 
35    public HeaderVO getHeader() {
36        return header;
37    }
38 
39    public void setDataInfo(String dataInfo) {
40        this.dataInfo = dataInfo;
41    }
42 
43    public String getDataInfo() {
44        return dataInfo;
45    }
46 
47    public void setType(EnumType type) {
48        this.type = type;
49    }
50 
51    public EnumType getType() {
52        return type;
53    }
54}

gl hf!

Oracle SOA and more

Advertisements

Monday, February 4, 2013

Enabling Coherence with example

No comments:

Post a Comment