operaciones de la API Java ZooKeeper

• crear sesión

1 paquete org.zln.zk; 
 2 
 3 importación org.apache.zookeeper.WatchedEvent; 
 4 importación org.apache.zookeeper.Watcher; 
 5 importación org.apache.zookeeper.ZooKeeper; 
 6 
 7 importación java.io.IOException; 
 8 
 9 / ** 
10 * Creado por jerez en 16/8/27. 
* 11/ 
12 TestZooKeeperClientApi public class { 
13 
14 estática privada ZooKeeper ZOOKEEPER; 
15 
16 public static void Main (args String []) throws IOException, InterruptedException { 
17 createSession (); 
18} 
19 
20 / ** 
21 *创建会话
22 * /
estática privada ZooKeeper la createSession 23 es () throws IOException, InterruptedException { 
24 // proceso de creación de instancias, sino también el proceso conectado a establecer ZooKeeper, Parámetro: ip: tiempo de espera de puerto receptor (interfase agua implementado para recibir una notificación oyente) 
la ZooKeeper ZooKeeper nueva nueva = 25 ( "127.0.0.1:2181", 5000, nuevo nuevo Vigilante () { 
26 es @Override 
27 Proceso pública vacío (watchedEvent watchedEvent) { 
28 System.out.println ( "ocurre el evento:" + watchedEvent); // reciben evento: estado WatchedEvent: tipo SyncConnected: Ninguno camino: null 
29 
30 
31 es el TODO // 
32} 
33 se}); 
34 es System.out.println ( "Verificar estado:" + zooKeeper.getState ()); // Ver estado: CONEXIÓN 
35 
36 // si se mantiene durante algún tiempo, a continuación, el oyente no escucha con recibida, el método ha sido retirado
37 Thread.sleep (5000);  
38 es
39 ZOOKEEPER retorno; 
40 
41 
42} 
43}

 

• La creación de nodos

1 paquete org.zln.zk; 
 2 
 org.apache.zookeeper 3 importación. *; 
 4 importación org.apache.zookeeper.data.ACL; 
 5 importación org.slf4j.Logger; 
 6 importación org.slf4j.LoggerFactory; 
 7 
 8 importación java.io.IOException; 
 9 importación java.io.UnsupportedEncodingException; 
10 importación java.util.ArrayList; 
11 
12 / ** 
13 * Creado por jerez en 16/8/27. 
* 14/ 
15 TestZooKeeperClientApi public class { 
16 
17 estática privada de registrador = LoggerFactory.getLogger (TestZooKeeperClientApi.class); 
18 
19 estática privado ZooKeeper ZOOKEEPER; 
20
public static void main 21 es (args String []) throws IOException, InterruptedException { 
22 es el createSession (); 
23 es} 
24 
25 / ** 
26 es crear una sesión * 
27 * / 
28 privado del ZooKeeper la estática createSession () throws IOException, InterruptedException { 
29 // ejemplos del proceso, sino también el establecimiento de la conexión con ZooKeeper, parámetro: tiempo de espera de oyente puerto (interfaz agua aplicado para la recepción de un oyente notificación): IP 
30 ZooKeeper ZOOKEEPER nuevos nuevos = ( "127.0.0.1:2181", 5000 , nuevo nuevo Vigilante () { 
31 es @ Override 
32 Proceso public void (watchedEvent watchedEvent) { 
interactúan con ZooKeeper 33 // TODO, generalmente se colocan aquí 
34 si (watchedEvent.getState () == Event.KeeperState.SyncConnected ) {/ / conectado
35 logger.info ( "el conectado"); 
36 
37 [{el try 
38 es // Parámetros: matriz de bytes nodo autoridad modelo de trayectoria de datos creado por el nodo 
39 Cadena nodePath = CreateNode (ZOOKEEPER, "/ nodo_1", "123". los getBytes ( "UTF-8"), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); 
40 logger.info ( "Crear nodo:" + NodePath); 
41 es la captura} (UnsupportedEncodingException | KeeperException | InterruptedException E) { 
42 es e.printStackTrace (); 
43 es} 
44 es 
45} 
46 es} 
47}); 
48 logger.info ( "Verificar estado:" + zooKeeper.getState ()); // Verificar estado:CONEXIÓN 
49
50 // parada si un período de tiempo, entonces el oyente no escucha con recibida, un método ha sido retirado de 
51 es la Thread.sleep (5000); 
52 es 
53 está retorno ZooKeeper; 
54 es 
55 
56 es} 
57 es 
58 / ** 
59 * Crear nodo ZooKeeper 
60 * @param ZOOKEEPER ZooKeeper conexión 
61 * camino nodo @return 
62 es * / 
63 es la public static CreateNode String (el camino ZooKeeper ZooKeeper, String, byte [] bytes, el ArrayList <la ACL> ACL y, createMode createMode) lanza UnsupportedEncodingException, KeeperException, InterruptedException { 
64 // parámetros: matriz de bytes nodo autoridad modelo de trayectoria de datos creados por el nodo 
65 de retorno zooKeeper.create (path, bytes, ACL y, createMode); 
66} 
67}

modo de creación

PERSISTENT 　　　　　　　　 nodo duradera
PERSISTENT_SEQUENTIAL 　orden duración de nodos
efímero 　　　　　　　　 nodo temporal
EPHEMERAL_SEQUENTIAL 　  orden provisional de los nodos

 

Este código es parte de la creación de sincronización

 

1 / * 
 2 * Crear nodos asíncronos 
 . 3 * @param ZooKeeper 
 . 4 camino @param * 
 . 5 * @param bytes 
 . 6 ACL * @param y 
 . 7 * createMode @param 
 . 8 * @throws KeeperException 
 . 9 @throws InterruptedException * 
10 * / 
. 11 public static vacío asCreateNode (el camino ZooKeeper ZooKeeper, String, byte [] bytes, el ArrayList <las ACL> ACL y, createMode createMode) lanza KeeperException, {InterruptedException 
12 es 
13 es la necesidad de aumentar AsyncCallback.StringCallback // Crear clase de implementación de interfaz asíncrona y un contexto parámetros de objeto 
14 ZOOKEEPER .Create (path, bytes, ACL y, createMode, nuevo nuevo AsyncCallback.StringCallback () { 
15 / ** 
16 *
17 * @param rc nodo de crear nodo 0- resultados vuelven código para crear un exitoso 
camino real 18 * @param nodo de ruta 
último parámetro que 19 * @param contexto ctx llamada al método asíncrono es crear una llamada local 
20 Nombre * @param 
21 * / 
22 @ Override 
23 es processResult public void (int RC, trayectoria String, Object CTX, String name) { 
24 = la StringBuilder StringBuilder la StringBuilder New nueva (); 
25 StringBuilder.Append ( "\ NRC =" + RC + "\ n-" + 
26 es "Path = "camino + +" \ n - "+ 
27" CTX = "+ CTX +" \ n - "+ 
28" name = "+ nombre +" \ n- "); 
29 logger.info (StringBuilder.ToString ());
30}
31}, "Asynchronous Crear"); 
32}

 

• Obtener nodos hijos

1 / * 
 * adquisición de sincronización nodo sub-modo 2 
 3 * @param ZOOKEEPER conector 
 4 * rutas de acceso primarias @param parentPath 
 . 5 * @return 
 . 6 * @throws KeeperException 
 . 7 * @throws InterruptedException 
 . 8 * / 
 . 9 Lista public static <String> getChildList ( Zookeeper del ZooKeeper, cadena parentPath) lanza KeeperException, InterruptedException { 
10 // parámetros: path nodo padre requieren atención a los cambios en el nodo secundario 
. 11 List <String> = zooKeeper.getChildren Childs (parentPath, false); 
12 es el retorno de Childs; 
13 es}

forma asíncrona para llamar la atención a los cambios en el nodo hijo y nodos secundarios

1 / * 
 2 * de forma asíncrona adquirido nodo subnodo niño que haya de cambio 
 3 * @param ZOOKEEPER conector 
 4 * caminos @param parentPath padres 
 . 5 * / 
 . 6 asGetChildListAndWatch public static void (la ZooKeeper ZooKeeper, Cadena parentPath) { 
 . 7 zooKeeper.getChildren (parentPath , true, nueva nueva AsyncCallback.Children2Callback () { 
 8 @ Override. 
 9 processResult public void (int RC, String path, CTX objeto, List <String> Niños, Stat STAT) {. 
10 logger.info ( "nodo hijo después del cambio:" ); 
11 para (nombre de la secuencia:. niños) { 
12 es logger.info ( "nodos hijo:" + nombre); 
13 es} 
14} 
15}, "nodo hijo de cambio interés");
dieciséis }

Hasta ahora, esta regla se puede encontrar, la función de devolución de llamada se invoca de forma asíncrona, la función de devolución de llamada no es sincrónica

Q: Ambiente de llamadas síncronas y asíncronas son llamadas? ? ?

R: Las siguientes operaciones dependen del resultado de tiempo de llamada, es necesario llamar al método de sincronización

 

 

 

  1 paquete org.zln.zk; 
  2 
  org.apache.zookeeper 3 importación. *; 
  4 importación org.apache.zookeeper.data.ACL; 
  5 importación org.apache.zookeeper.data.Stat; 
  6 importación org.slf4j.Logger; 
  7 importación org.slf4j.LoggerFactory; 
  8 
  9 importación java.io.IOException; 
 10 importación java.io.UnsupportedEncodingException; 
 11 java.util.ArrayList importación; 
 12 importación java.util.List; 
 13 
 14 / ** 
 15 * Creado por jerez en 16/8/27. 
 * 16/ 
 17 TestZooKeeperClientApi public class { 
 18 
 19 estática privada de registrador = LoggerFactory.getLogger (TestZooKeeperClientApi.class); 
 20
 estática privada ZooKeeper la ZooKeeper 21 es; 
 22 es 
 23 es void Main (args String []) public static throws IOException, InterruptedException { 
 24 del createSession (); 
 25 
 26 es el Thread.sleep (Integer.MAX_VALUE); 
 27} 
 28 
 29 / ** 
 30 * Crear sesión 
 * 31 es / 
 32 la ZooKeeper la createSession estática privada () throws IOException, InterruptedException { 
 33 es // proceso de instanciación, sino también el proceso de establecer una conexión con el ZooKeeper, parámetros: tiempo de espera de oyente puerto (interfaces de agua aplicadas, para los oyentes: ip recibir notificaciones) 
 34 es la ZooKeeper ZOOKEEPER nuevos nuevos = ( "127.0.0.1:2181", 5000, nuevo nuevo Vigilante () { 
 35 @ Override 
 36 pública Proceso void (watchedEvent watchedEvent) {
 interacción 37 // TODO con ZooKeeper, generalmente se colocan aquí 
 38 si (watchedEvent.getState () == Event.KeeperState.SyncConnected ) {// conectado 
 39 logger.info ( "el conectado"); 
 40 el try { 
 41 // crear un nodo síncrono 
 42 es NodePath // String = sysCreateNode (ZooKeeper, "/ nodo_1", "123" .getBytes ( "UTF-8".), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); 
 43 es // Logger .info ( "Crear nodo:" + NodePath); 
 44 es 
 45 // creado de forma asíncrona nodo 
 46 //asCreateNode(zooKeeper,"/node_2","234".getBytes("UTF-8 "), ZooDefs.Ids.OPEN_ACL_UNSAFE , CreateMode.PERSISTENT);
 47 
 48
 49 // niño nodo de cambio de modo de adquisición de sincronización nodo hijo de interés 
 50 // List <String> Lista = getChildListNoWatch (ZooKeeper, "/"); 
 51 es para // (String name: Lista) { 
 52 es logger.info // ( " nodos hijo: "+ nombre); 
 53 es //} 
 54 es 
 55 // nodo hijo de forma asíncrona adquirido de cambio interés 
 56 es asGetChildListAndWatch // (ZooKeeper," / "); 
 57 es 
 58 datos // nodo adquiridas de una manera sincronizada sysGetNodeData 
 59 
 60 byte [ ] bytes = sysGetNodeDataNoWatch (ZooKeeper, "/ nodo_1"); 
 61 es logger.info ( "Obtener datos de nodo" + nueva cadena (bytes, " UTF-8"));
 62 
 63 deleteNode (ZOOKEEPER, "/ nodo_1", 0);
 } La captura 64 (KeeperException | InterruptedException | UnsupportedEncodingException E) { 
 65 e.printStackTrace (); 
 66} 
 67 
 68} 
 69} 
 70}); 
 71 es logger.info ( "Comprobar estado:" + zooKeeper.getState ()); // Verificar estado: Conexión de los 
 72 
 73 es el retorno ZooKeeper; 
 74 
 75 
 76} 
 77 
 78 / ** 
 79 * Crear nodo de sincronización 
 80 * @param ZOOKEEPER conector 
 81 * ruta nodo camino @param 
 82 * @param bytes de bytes de datos de matrices 
 83 ACL * @param permisos 
 modo de creación de @param createMode 84 *
 @Return * 85 
 86 * @throws UnsupportedEncodingException 
 87 * @throws KeeperException 
 88 @throws InterruptedException * 
 89 * / 
 90 public static cadena sysCreateNode (el camino ZooKeeper ZooKeeper, String, byte [] bytes, el ArrayList <las ACL> ACL y, CreateMode createMode) tiros UnsupportedEncodingException , KeeperException, {InterruptedException 
 91 es el retorno zooKeeper.create (path, bytes, ACL y, createMode); 
 92} 
 93 
 94 
 95 / ** 
 96 * Crear nodo asíncrono 
 97 * @param ZOOKEEPER conector 
 98 * camino nodo camino @param 
 99 * @param matriz de bytes de bytes de datos 
100 * permisos ACL @param
101 modo de creación * @param createMode 
102 * @throws KeeperException 
103 @throws InterruptedException * 
104 * / 
105 public static asCreateNode void (la ZooKeeper ZooKeeper, trayectoria String, byte [] bytes, el ArrayList <la ACL> ACL y, CreateMode createMode) lanza KeeperException, InterruptedException { 
106 
107 // crear una necesidad de aumentar parámetro clase de implementación interfaz asíncrona AsyncCallback.StringCallback y un objeto de contexto 
108 zooKeeper.create (path, bytes, ACL y, createMode, nuevo nuevo AsyncCallback.StringCallback () { 
109 / ** 
110 * 
111 * @ parámetro rc nodo de crear nodo 0- resultados vuelven código se crea con éxito 
112 * @ param nodo camino verdadero camino 
último argumento que 113 * @ param contexto ctx llamada al método asíncrono es crear una llamada local
114 * nombre @param 
115 * / 
116 @ Override 
117 público processResult void (int rc, trayectoria String, ctx Object, String name) { 
118 StringBuilder StringBuilder = new StringBuilder (); 
119 stringBuilder.append ( "\ NRC =" + rc + "\ n" + 
120 "path =" + camino + "\ n" + 
121 "ctx =" + ctx + "\ n" + 
122 "name =" + nombre + "\ norte"); 
123 logger.info (stringBuilder.toString ()); 
124} 
125}, "异步创建");
131 * @ param ZOOKEEPER conector 
132 * @ param caminos parentPath padres 
133 @ return * 
134 * @throws KeeperException 
135 @throws InterruptedException * 
136 * / 
137 Lista public static <String> sysGetChildListNoWatch (el ZooKeeper ZooKeeper, Cadena parentPath) lanza KeeperException, InterruptedException { 
138 // parámetros: preocupación si el nodo padre después de nodo de cambio de trayecto niño si cierto, entonces los cambios de nodo secundario, se genera un evento NodeChildrenChanged 
139 List <String> = zooKeeper.getChildren Childs (parentPath, a false); 
140 retorno Childs; 
141} 
142 
143 / ** 
144 * asíncrona adquirida nodo subnodo niño que haya cambios 
145 * @param ZOOKEEPER conector 
146 * @ param parentPath rutas de acceso primarias
* 147/ 
148 asGetChildListAndWatch public void estática (la ZooKeeper ZooKeeper, Cadena parentPath) { 
149 zooKeeper.getChildren (parentPath, true, nueva nueva AsyncCallback.Children2Callback () { 
150 @ Override 
151 processResult pública vacío (int RC, String path, CTX Objeto, Lista <String> Niños, Stat STAT) { 
"nodo hijo después del cambio:" 152 logger.info (); 
153 para (nombre de la secuencia: niños) { 
154 logger.info ( "nodos hijo:" + nombre); 
155} 
156 } 
157}, "preocupado por el cambio nodo hijo");
158} 
159 
160 / ** 
161 * adquisición de datos modo síncrono 
162 * @param ZooKeeper 
163 * camino @param
* @Return 164 es 
165 * @throws KeeperException 
166 * @throws InterruptedException 
167 se * / 
168 bytes public static [] sysGetNodeDataNoWatch (el ZooKeeper ZooKeeper, String path) lanza KeeperException, InterruptedException { 
169 // estado de cambio de ruta de datos de enfoque está 
170 de retorno zooKeeper.getData (path, a falso, nuevo nuevo Stat ()); 
171 es} 
172 
173 / ** 
174 * nodos de borrado 
175 * @param ZooKeeper 
176 * @param NodePath 
177 * @param Version 
178 @throws KeeperException * 
179 * @throws InterruptedException 
180 [* /
181 deleteNode público static void (ZooKeeper ZOOKEEPER, Cadena nodePath, versión int) throws KeeperException, InterruptedException { 
182 zooKeeper.delete (nodePath, versión); 
183} 
184 
185 
186}

 

 

Además de la API de Java ZooKeeper proporcionado, hay dos clientes, ZKClient y curador ambos clientes están API nativa del paquete, lo que hace la operación más conveniente

"Principios y Práctica de consistencia de PAXOS distribuidos a ZOOKEEPER" puede referirse al libro