Para criar um subclasse de uma classe principal utiliza-se a seguinte sintaxe java public class PlaceManager extends UnicastRemoteObject para implementar a interface java public class PlaceManager extends UnicastRemoteObject implements PlacesListInterface

``` @Test void test() { PlacesListManagerInterface plm; PlacesListManagerInterface plmret; PlacesListInterface pli; ObjectRegistryInterface ori;

    try{
        System.out.println("Localizar ReplicaManager...");
        plm  = (PlacesListManagerInterface) Naming.lookup("rmi://localhost:2024/replicamanager");

        Place p1 = new Place("3510", "Viseu");
        System.out.println("Invocar addPlace() no ReplicaManager para 3510...");
        plm.addPlace(p1);

        Place p2 = new Place("1000", "Lisboa");
        System.out.println("Invocar addPlace() no ReplicaManager para 1000...");
        plm.addPlace(p2);

        Place p3 = new Place("4000", "Lisboa");
        System.out.println("Invocar addPlace() no ReplicaManager para 4000...");
        plm.addPlace(p3);

        System.out.println("Obter o endereço do ReplicaManager no Registry() para o ObjectID 1000 ...");
        ori = (ObjectRegistryInterface) Naming.lookup("rmi://localhost:2023/registry");
        String addrRM = ori.resolve("1000");

        System.out.println("Pedir ao ReplicaManager para devolver um PlaceManager para o ObjectID 1000 ...");
        plm = (PlacesListManagerInterface) Naming.lookup(addrRM);
        boolean pl1done = false;
        boolean pl2done = false;
        boolean pl3done = false;
        String plAddress = null;
        for(int i=0; i<10 ; i++) {
            plAddress = plm.getPlaceListAddress("1000");
            System.out.println("\tDevolveu " + plAddress);
            if(plAddress.equals("rmi://localhost:2025/placelist")) pl1done=true;
            else if(plAddress.equals("rmi://localhost:2026/placelist")) pl2done=true;
                 else if(plAddress.equals("rmi://localhost:2027/placelist")) pl3done=true;
        }

        if(!(pl1done==pl2done==pl3done==true)) fail("Não está a devolver um PlaceManager aleatório...");

        System.out.println("Invocar getPlace() no PlaceManager");
        pli  = (PlacesListInterface) Naming.lookup(plAddress);
        String locality = pli.getPlace("1000").getLocality();

        System.out.println("\tDevolveu " + locality);
        assertEquals("Lisboa", locality);


    } catch(Exception e) { fail("Erro\n" + e.getMessage()); }
}

```

java class PlaceManager extends UnicastRemoteObject implements PlacesListInterface{ ... }

Cenário de Teste 1 -> Msg 2 -> Msg 3 -> Msg 5 -> waitingfor,4 6 -> waitingfor,4 8 -> waitingfor,4 9 -> waitingfor,4 4 -> waitingfor,7 7 -> Msg

Person p = (Person) ois.readObject(); String loc = p.getPlace().getLocality();

Person ret = (Person) ois.readObject();

Algoritmo principal receber a mensagem M se M estiver em ordem processar M processar mensagens seguintes da lista, se houver senão colocar M na lista temporária a comunicação é request->reply (não pode haver vários replies para um request), logo reply = "waitingfor,x" se a lista tiver elementos ou reply = "última mensagem processada" para lista vazia

Documentação do Hashmap https://www.w3schools.com/java/java_hashmap.asp

Código de teste utilizado pelo Break.IT para validar a implementação ``` @Test public void test() throws IOException {

    DatagramSocket aSocket = null;

    //try {

        aSocket = new DatagramSocket();  
        aSocket.setSoTimeout(5000);
        int nMessage=1;

        String m= "vou enviar esta mensagem ao servidor";

        InetAddress aHost = InetAddress.getByName("localhost");

        int serverPort = 6789;
        while(nMessage < 10) {
            if(nMessage == 4 || nMessage == 7) nMessage++;
            byte[] mb= (String.valueOf(nMessage).concat(",").concat(m)).getBytes();

            DatagramPacket reply = sendDatagramAndWaitForResponse(aSocket, aHost, serverPort, mb);
            if(nMessage > 4)
                assertEquals("waitingfor,"+4, new String(reply.getData()).trim());
            else
                assertEquals(m, new String(reply.getData()).trim());
            nMessage++;
        }

        byte[] mb= (String.valueOf(4).concat(",").concat(m)).getBytes();            
        DatagramPacket reply = sendDatagramAndWaitForResponse(aSocket, aHost, serverPort, mb);
        assertEquals("waitingfor,"+7, new String(reply.getData()).trim());

        mb= (String.valueOf(7).concat(",").concat(m)).getBytes();           
        reply = sendDatagramAndWaitForResponse(aSocket, aHost, serverPort, mb);
        assertEquals(m, new String(reply.getData()).trim());

        mb= (String.valueOf(10).concat(",").concat(m)).getBytes();          
        reply = sendDatagramAndWaitForResponse(aSocket, aHost, serverPort, mb);
        assertEquals(m, new String(reply.getData()).trim());

    //}catch (SocketException e){System.out.println("Socket: " + e.getMessage()); fail("");

    //}catch (IOException e){System.out.println("IO: " + e.getMessage()); fail("");

//  }finally {if(aSocket != null) aSocket.close();}

}

private DatagramPacket sendDatagramAndWaitForResponse(DatagramSocket aSocket, InetAddress aHost, int serverPort, byte[] mb) throws IOException { DatagramPacket request = new DatagramPacket(mb, mb.length, aHost, serverPort);

    aSocket.send(request);

    byte[] buffer = new byte[1000];

    DatagramPacket reply = new DatagramPacket(buffer, buffer.length);

    aSocket.receive(reply);
    System.out.println("Enviei/recebi a mensagem: " + new String(reply.getData()));
    return reply;
}

```

do lado do cliente, é necessário concatenar o número da mensagem com o texto da mensagem java msgEnviada = i + "," + "vou enviar esta ...."; do lado do servidor é necessário fazer o split da mensagem de forma a obter o número da mesma e o texto, separadamente java numero = msgRecebida.split(",")[0] msg = msgRecebida.split(",")[1] Código utilizado para validar a solução: ```java public void test() {

DatagramSocket aSocket = null;

try {

    aSocket = new DatagramSocket();
    aSocket.setSoTimeout(5000);
    int nMessage=1;

    String m= "vou enviar esta mensagem ao servidor";

    InetAddress aHost = InetAddress.getByName("localhost");
    int serverPort = 6789;
    while(nMessage < 10) {
        if(nMessage == 4 || nMessage == 7) nMessage++;
        byte[] mb= (String.valueOf(nMessage).concat(",").concat(m)).getBytes();

        DatagramPacket request = new DatagramPacket(mb,  mb.length, aHost, serverPort);

        aSocket.send(request);

        byte[] buffer = new byte[1000];

        DatagramPacket reply = new DatagramPacket(buffer, buffer.length);

        aSocket.receive(reply);
        System.out.println("Enviei/recebi a mensagem: " + new String(reply.getData()));
        if(nMessage >= 5)
            assertEquals("waitingfor,"+ 4, new String(reply.getData()).trim());
        else
            assertEquals(m, new String(reply.getData()).trim());
        nMessage++;
    }

}catch (SocketException e){System.out.println("Socket: " + e.getMessage()); fail("");

}catch (IOException e){System.out.println("IO: " + e.getMessage()); fail("");

}finally {if(aSocket != null) aSocket.close();}

} ```

```java import static org.junit.jupiter.api.Assertions.*;

import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.PrintStream;

import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test;

import com.es2.decorator.Auth; import com.es2.decorator.AuthException; import com.es2.decorator.AuthInterface; import com.es2.decorator.CommonWordsValidator; import com.es2.decorator.End; import com.es2.decorator.Logging;

class TestDecorator { private static final ByteArrayOutputStream outContent = new ByteArrayOutputStream();

@BeforeEach
void setUp() throws Exception {
}

@BeforeAll
public static void setUpStreams() {
    System.setOut(new PrintStream(outContent));
}

@AfterAll
public static void tearDownAfterClass() {
    System.setOut(System.out);
    End e = new End();
}

@DisplayName("Test if authentication is performed correctly using admin/admin")
@Test
void testRightAuthWithoutDecorators() throws AuthException, IOException {
    AuthInterface auth = new Auth();

    auth.auth("admin", "admin");
}

@DisplayName("Test if authentication exception is thrown for bad authentication")
@Test
void testWrongAuthWithoutDecorators() throws AuthException, IOException {
    AuthInterface auth = new Auth();

    assertThrows(AuthException.class, ()->{
        auth.auth("admin1", "admin1");
    });
}

@DisplayName("Test if Logging is decorating correctly the authentication")
@Test
void testLoggingDecorator() throws AuthException, IOException {
    AuthInterface auth = new Logging(new Auth());

    auth.auth("admin", "admin");
    assertTrue(outContent.toString().contains("auth()"));
}

@DisplayName("Test if CommonWordsValidator is decorating correctly the authentication")
@Test
void testCommonWordsValidatorDecorator() throws AuthException, IOException {
    AuthInterface auth = new CommonWordsValidator(new Auth());

    auth.auth("admin", "admin");
}

@DisplayName("Test if CommonWordsValidator is decorating correctly the authentication")
@Test
void testCommonWordsValidatorDecoratorIfFalse() throws AuthException, IOException {
    AuthInterface auth = new CommonWordsValidator(new Auth());

    assertThrows(AuthException.class,()->{
        auth.auth("admin1", "admin1");
    });
}

@DisplayName("Test if Logging and CommonWordsValidator is decorating correctly the authentication")
@Test
void testLoggingCommonWordsValidatorDecorator() throws AuthException, IOException {
    AuthInterface auth = new CommonWordsValidator(new Logging(new Auth()));

    auth.auth("admin", "admin");
}

} ```

``` java import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test;

import com.es2.bridge.APIMoodle; import com.es2.bridge.APIRequest; import com.es2.bridge.APIRequestContentAggregator; import com.es2.bridge.ServiceNotFoundException;

class BridgePatternTest { APIRequest req;

@BeforeEach
void setUp() throws Exception {
}

@DisplayName("Test if the exception is thrown for not existing services")
@Test
void testServiceNotFoundExceptionThrown() {
    req= new APIRequest();
    assertThrows(ServiceNotFoundException.class,
            ()->{
                    req.getContent("abc", "12");
            });
}

@DisplayName("Test if the request returns null for not existing content")
@Test
void testRequestReturnsNull() throws ServiceNotFoundException {
    req= new APIRequest();
    String idService = req.addService(new APIMoodle());
    assertNull(req.getContent(idService, "12"));
}

@DisplayName("Test if the request returns the content previously added")
@Test
void testContentPreviouslyAdded() throws ServiceNotFoundException {
    req= new APIRequest();
    String idService = req.addService(new APIMoodle());
    String idContent = req.setContent(idService, "12");
    assertEquals(req.getContent(idService,idContent),"12");
}

@DisplayName("Test if the aggregated content of one service is returned correctly")
@Test
void testAggregatedContent() throws ServiceNotFoundException {
    req= new APIRequestContentAggregator();
    String idService = req.addService(new APIMoodle());
    req.setContent(idService, "Eu vou");
    req.setContent(idService, " a Viseu");
    req.setContent(idService, " estudar");
    assertEquals(req.getContent(idService,"0"),"Eu vou a Viseu estudar");
}

} ```

```java import static org.junit.jupiter.api.Assertions.*;

import java.io.IOException; import java.lang.reflect.Modifier; import java.net.HttpURLConnection; import java.util.ArrayList;

import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test;

import com.es2.objectpool.ObjectNotFoundException; import com.es2.objectpool.PoolExhaustedException; import com.es2.objectpool.ReusablePool;

class ObjectPoolTest { @BeforeEach void setUp() throws Exception { }

@Test
@DisplayName("Test whether important methods are synchronized")
void testSynchronized() throws NoSuchMethodException, SecurityException {
    if( ! Modifier.isSynchronized(ReusablePool.class.getMethod("acquire").getModifiers()) || 
        ! Modifier.isSynchronized(ReusablePool.class.getMethod("release",HttpURLConnection.class).getModifiers()) ||
        ! Modifier.isSynchronized(ReusablePool.class.getMethod("resetPool").getModifiers())
    ){
        fail("Methods are not thread safe!!! Don't forget that you are moving connections between two lists!!!");   
    }
}

@Test
@DisplayName("Test if constructor is not public")
void testPrivateConstructor() throws NoSuchMethodException, SecurityException{
    if(Modifier.isPublic(ReusablePool.class.getDeclaredConstructor().getModifiers())){
        fail("Singleton objects should protect their constructor!!!");  
    }
}

@Test
@DisplayName("Test maximum number of connections for acquiring")
void testMaxConnectionsWithoutInitMaxConnections() throws IOException, PoolExhaustedException, ObjectNotFoundException {
    ArrayList<HttpURLConnection> conns = new ArrayList<HttpURLConnection>();
    ReusablePool.getInstance().setMaxPoolSize(11);
    for(int i =0; i< 11; i++)
        conns.add(ReusablePool.getInstance().acquire());
    for(int i =0; i< 11; i++)
        ReusablePool.getInstance().release(conns.get(i));

    ReusablePool.getInstance().resetPool();
}

@Test
@DisplayName("Test if max connections are initialized")
void testInitMaxConnections() throws IOException, PoolExhaustedException, ObjectNotFoundException {
    ArrayList<HttpURLConnection> conns = new ArrayList<HttpURLConnection>();
    for(int i =0; i< 10; i++)
        conns.add(ReusablePool.getInstance().acquire());
    for(int i =0; i< 10; i++)
        ReusablePool.getInstance().release(conns.get(i));
    ReusablePool.getInstance().resetPool();
}

@Test
@DisplayName("Test if PoolExhaustedException is thrown")
void testThrowsPoolExhaustedException() throws ObjectNotFoundException {
    ArrayList<HttpURLConnection> conns = new ArrayList<HttpURLConnection>();
    assertThrows(PoolExhaustedException.class,
            ()->{
                for(int i =0; i< 11; i++)
                    conns.add(ReusablePool.getInstance().acquire());
            });

    ReusablePool.getInstance().resetPool();
}

@Test
@DisplayName("Test if ObjectNotFoundException is thrown when object released not exists in the pool")
void testThrowsObjectNotFoundException() {
    assertThrows(ObjectNotFoundException.class,
            ()->{
                    HttpURLConnection conn = ReusablePool.getInstance().acquire();
                    ReusablePool.getInstance().release(conn);
                    ReusablePool.getInstance().release(conn);
            });
    ReusablePool.getInstance().resetPool();
}

} ```

``` import static org.junit.jupiter.api.Assertions.*;

import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.EOFException; import java.io.IOException; import java.io.ObjectOutputStream; import java.net.Socket; import java.net.UnknownHostException;

import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test;

class TCP003 { static Thread t;

@BeforeAll
public static void runServer() throws InterruptedException {
        t = (new Thread() {
            public void run() {
                TCPServer.main(new String[0]);
                }
                });
        t.start();
        Thread.sleep(1000);
}

@AfterAll
public static void stopServer() {
    t.interrupt();
}

@Test
void test() {
        int idPlace1 = Integer.parseInt(sendAndReceive(new Request(new Place("3510","Viseu")))); 
        int idPlace2 = Integer.parseInt(sendAndReceive(new Request(new Place("2000","Viseu"))));

        assertEquals("Viseu",sendAndReceive(new Request(idPlace1,"getLocality")));
        assertEquals("2000",sendAndReceive(new Request(idPlace2,"getPostalCode")));
        assertEquals("invalid objectid",sendAndReceive(new Request(idPlace2+1,"getPostalCode")));
        assertEquals("invalid method",sendAndReceive(new Request(idPlace2,"getPostalCode2")));
}

String sendAndReceive(Request o) {
    Socket s = null;

    try{

        int serverPort = 7896; //porto do servidor
        s = new Socket("localhost", serverPort);
        s.setSoTimeout(5000);
        DataInputStream in = new DataInputStream( s.getInputStream());
        DataOutputStream out = new DataOutputStream( s.getOutputStream());
        ObjectOutputStream oos = new ObjectOutputStream(out);

        oos.writeObject(o);
        return in.readUTF();
    }catch (UnknownHostException e){
        fail("Sock:"+e.getMessage());
    }catch (EOFException e){
        fail("IO:" + e.getMessage());
    }catch (IOException e){
        fail("IO:"+e.getMessage());
    }finally {
        if(s!=null)
            try {
                s.close();
            }catch (IOException e){
                fail("close:"+e.getMessage());}

    }
    return null;

}

} ```

``` @Test @DisplayName("Test if the server returns to the initial server state") void testAddReturnInitialServerState() throws ExistingStudentException, NotExistingSnapshotException { Server s = new Server(); BackupService backup = new BackupService(s); backup.takeSnapshot(); s.addStudent("Maria José"); s.addStudent("Manuel António");

    assertEquals(s.getStudentNames().size(), 2);

    backup.restoreSnapshot(0);      
    assertEquals(s.getStudentNames().size(), 0);
}

@Test
@DisplayName("Test if the server returns to a previous snapshot")
void testAddReturnToPreviousSnapshot() throws ExistingStudentException, NotExistingSnapshotException {
    Server s = new Server();
    BackupService backup =  new BackupService(s);
    backup.takeSnapshot();
    s.addStudent("Maria José");
    backup.takeSnapshot();
    s.addStudent("Manuel António");

    assertEquals(2, s.getStudentNames().size());

    backup.restoreSnapshot(1);      
    assertEquals(1, s.getStudentNames().size());
}

@Test
@DisplayName("Test if the server ExistingStudentException is thrown")
void testExistingStudentExceptionThrown() throws ExistingStudentException {
    Server s = new Server();
    s.addStudent("Maria José");
    assertThrows(ExistingStudentException.class,()->{
        s.addStudent("Maria José");
    });
}

@Test
@DisplayName("Test if the server NotExistingSnapshotException is thrown")
void testNotExistingSnapshotException() throws ExistingStudentException {
    Server s = new Server();
    BackupService backup =  new BackupService(s);
    backup.takeSnapshot();
    s.addStudent("Maria José");
    backup.takeSnapshot();
    s.addStudent("Manuel António");

    assertThrows(NotExistingSnapshotException.class,()->{
        backup.restoreSnapshot(2);
    });
}

```

PlacesListInterface l1 = null;
        try{
            System.out.println("Localizar servidor de Objetos...");
            l1  = (PlacesListInterface) Naming.lookup("rmi://localhost:2022/placelist");

            Place p = new Place("3510", "Viseu");
            System.out.println("Invocar addPlace() ...");
            l1.addPlace(p);

            System.out.println("Obter o endereço do servidor no Registry() ...");
            ObjectRegistryInterface l2;
            PlacesListInterface l3;
            try {
                l2 = (ObjectRegistryInterface) Naming.lookup("rmi://localhost:2023/registry");
                String addr = l2.resolve("3510");

                System.out.println("Invocar getPlace() no servidor de objetos...");
                l3  = (PlacesListInterface) Naming.lookup(addr);
                assertEquals("Viseu", l3.getPlace("3510").getLocality());
            } catch (MalformedURLException | NotBoundException e) {
                fail(e.getCause());
            }

        } catch(Exception e) { fail("Problemas de Comunicação\n" + e.getMessage()); }

Estrutura dos componentes da aplicação

https://i.stack.imgur.com/jVbBJ.png

    @DisplayName("Test if the exception is thrown for not existing services")
    @Test
    void testServiceNotFoundExceptionThrown() {
        req= new APIRequest();
        assertThrows(ServiceNotFoundException.class,
                ()->{
                        req.getContent("abc", "12");
                });
    }

    @DisplayName("Test if the request returns null for not existing content")
    @Test
    void testRequestReturnsNull() throws ServiceNotFoundException {
        req= new APIRequest();
        String idService = req.addService(new APIMoodle());
        assertNull(req.getContent(idService, "12"));
    }

    @DisplayName("Test if the request returns the content previously added")
    @Test
    void testContentPreviouslyAdded() throws ServiceNotFoundException {
        req= new APIRequest();
        String idService = req.addService(new APIMoodle());
        String idContent = req.setContent(idService, "12");
        assertEquals(req.getContent(idService,idContent),"12");
    }

    @DisplayName("Test if the aggregated content of one service is returned correctly")
    @Test
    void testAggregatedContent() throws ServiceNotFoundException {
        req= new APIRequestContentAggregator();
        String idService = req.addService(new APIMoodle());
        req.setContent(idService, "Eu vou");
        req.setContent(idService, " a Viseu");
        req.setContent(idService, " estudar");
        assertEquals(req.getContent(idService,"0"),"Eu vou a Viseu estudar");
    }

cluster parameters

algorithm for traversing the graph

Time Connectivity and frequency to measure relation between pages

consider full pages without states?

clustering algorithms

criação de um identificador UUID

resolução do problema de consenso em sistemas distribuídos assíncronos

propriedades de um algoritmo de consenso

o problema de consenso em sistemas assíncronos

o problema de consenso em sistemas distribuídos assíncronos é impossível de resolver

modelos de falha considerados

interesse apenas em sistemas assíncronos

Porque é que as partições de rede criam condições de falha difíceis de diagnosticar

Resume a lógica do teorema CAP

Descreve propriedades fundamentais de um sistema distribuído.

questões importantes na gestão do grupo

A complexidade da eventual consistency pode inviabilizar a sua adoção

semânticas ACID e BASE

//...

PlacesListInterface l1 = null;

         try{
            System.out.println("Localizar servidor de Objetos...");         
          l1  = (PlacesListInterface) Naming.lookup("rmi://localhost:2022/placelist");

            Place p = new Place("3510", "Viseu");
            System.out.println("Invocar addPlace() ...");
            l1.addPlace(p);

            System.out.println("Obter o endereço do servidor no Registry() ...");
            ObjectRegistryInterface l2;
            PlacesListInterface l3;
            try {
                l2 = (ObjectRegistryInterface) Naming.lookup("rmi://localhost:2023/registry");
                String addr = l2.resolve("3510");

                System.out.println("Invocar getPlace() no servidor de objetos...");
                l3  = (PlacesListInterface) Naming.lookup(addr);
                System.out.println(l3.getPlace("3510").getLocality()));
            } catch (MalformedURLException | NotBoundException e) {
                e.printStackTrace();
            }

        } catch(Exception e) { e.printStackTrace(); }

AdicionaEncomenda

 Utilizador u = new Utilizador("Manuel","Ativo");
        PropostaAquisicao propostaAquisicao = new PropostaAquisicao(LocalDate.now(),u, "Alice no Pais das Maravilhas");
        Livro l = new Livro("Programar em Java", "FCA");
        RequisicaoCompraCopia requisicaoCompraCopia = new RequisicaoCompraCopia("pendente", LocalDate.now(), "Oficio",l,u);
        Encomenda encomenda = new Encomenda(LocalDate.now(),requisicaoCompraCopia);
        repo.adicionaEncomenda(encomenda);

EntradaNovoLivro

Utilizador u = new Utilizador("Manuel","Ativo");
        PropostaAquisicao propostaAquisicao = new PropostaAquisicao(LocalDate.now(),u,"Alice no Pais das Maravilhas");
        Livro l = new Livro("Programar em Java", "FCA");
        Copia c = new Copia(1, l);
        RequisicaoCompraCopia requisicaoCompraCopia = new RequisicaoCompraCopia("pendente", LocalDate.now(), "Oficio",l,u);
        Encomenda encomenda = new Encomenda(LocalDate.now(),requisicaoCompraCopia);
        EntradaNovoLivro entradaNovoLivro = new EntradaNovoLivro(LocalDate.now(),encomenda,c);
        repo.adicionaEntradaNovoLivro(entradaNovoLivro);

//devolve true se o construtor for Public Modifier.isPublic(Registry.class.getDeclaredConstructor().getModifiers()

Testar APIRequest

APIRequest req= new APIRequest();
String idService = req.addService(new APIMoodle());
String idContent = req.setContent(idService, "12");
        System.out.println(req.getContent(idService,idContent));

Testar APIRequestContentAggregator

APIRequestContentAggregator req= new APIRequestContentAggregator();
String idService = req.addService(new APIMoodle());
req.setContent(idService, "Eu vou");
req.setContent(idService, " a Viseu");
req.setContent(idService, " estudar");
System.out.println(req.getContent(idService,"0"));

Código para testar o padrão com um menu de 3 níveis

SubMenu m = new SubMenu();
m.setLabel("Inserir");

SubMenu client = new SubMenu();
client.setLabel("Cliente");
m.addChild(client);

Link enterprise = new Link();
enterprise.setLabel("Empresarial");

enterprise.setURL("http://www.abc.pt/empresarial");
client.addChild(enterprise);

SubMenu particular = new SubMenu();
particular.setLabel("Particular");
client.addChild(particular);

Link withVat = new Link();
withVat.setLabel("Particular com contribuinte");
withVat.setURL("http://www.abc.pt/pcc");
particular.addChild(withVat);

m.showOptions();

static Thread t1;

t1 = (new Thread() {
            public void run(){
                RMIRegistry.main(new String[0]);
                RMIReplicaManager.main(new String[0]);              
                RMIServer.main(new String[]{"2028"});
                RMIServer.main(new String[]{"2030"});
                RMIServer.main(new String[]{"2029"});
            }});
        t1.start();

        Thread.sleep(1000);

    PlacesListManagerInterface plm;
    PlacesListManagerInterface plmret;
    PlacesListInterface pli;
    ObjectRegistryInterface ori;


    try{
        System.out.println("SE DER ERROS DE CONCORRÊNCIA, É NECESSÁRIO TENTAR OUTRA VEZ!!!");
        System.out.println("Localizar ReplicaManager...");
        plm  = (PlacesListManagerInterface) Naming.lookup("rmi://localhost:2024/replicamanager");
        Thread.sleep(1000);
        Place p1 = new Place("3510", "Viseu");
        System.out.println("Invocar addPlace() no ReplicaManager para 3510...");
        plm.addPlace(p1);

        Place p2 = new Place("1000", "Lisboa");
        System.out.println("Invocar addPlace() no ReplicaManager para 1000...");
        plm.addPlace(p2);

        Place p3 = new Place("4000", "Lisboa");
        System.out.println("Invocar addPlace() no ReplicaManager para 4000...");
        plm.addPlace(p3);

        System.out.println("Obter o endereço do ReplicaManager no Registry() para o ObjectID 1000 ...");
        ori = (ObjectRegistryInterface) Naming.lookup("rmi://localhost:2023/registry");
        String addrRM = ori.resolve("1000");

        System.out.println("Destruir uma das réplicas ...");
        LocateRegistry.getRegistry(2029).unbind("placelist");
        Thread.sleep(2000);


        System.out.println("Pedir ao ReplicaManager para devolver um PlaceManager para o ObjectID 1000 ...");
        plm = (PlacesListManagerInterface) Naming.lookup(addrRM);
        boolean pl1done = false;
        boolean pl2done = false;
        boolean pl3done = false;
        String plAddress = null;
        for(int i=0; i<10 ; i++) {
            plAddress = plm.getPlaceListAddress("1000");
            invokeGetPlacePlaceManager(plAddress);
            System.out.println("\tPara o Endereço " + plAddress);
            if(plAddress.equals("rmi://localhost:2028/placelist")) pl1done=true;
            else if(plAddress.equals("rmi://localhost:2029/placelist")) pl2done=true;
                 else if(plAddress.equals("rmi://localhost:2030/placelist")) pl3done=true;
        } 

        if(!(pl1done==pl2done==pl3done==true)) fail("Não está a devolver um PlaceManager aleatório...");

    } catch(Exception e) {
        e.printStackTrace();
        fail("Erro\n" + e.getMessage()); }
}

private void invokeGetPlacePlaceManager(String plAddress)
        throws NotBoundException, MalformedURLException, RemoteException {
    PlacesListInterface pli;
    System.out.println("Invocar getPlace() no PlaceManager");
    pli  = (PlacesListInterface) Naming.lookup(plAddress);
    String locality = pli.getPlace("1000").getLocality();

    System.out.println("\tDevolveu " + locality);
    assertEquals("Lisboa", locality);
}

        t = (new Thread() {
            public void run() {
                RMIRegistry.main(new String[0]);
                RMIReplicaManager.main(new String[0]);
                RMIServer.main(new String[]{"2028"});
                RMIServer.main(new String[]{"2029"});
                RMIServer.main(new String[]{"2030"});
                }
                });
        t.start();

        Thread.sleep(1000);

    PlacesListManagerInterface plm;
    PlacesListManagerInterface plmret;
    PlacesListInterface pli;
    ObjectRegistryInterface ori;


    try{
        System.out.println("Localizar ReplicaManager...");
        plm  = (PlacesListManagerInterface) Naming.lookup("rmi://localhost:2024/replicamanager");

        Place p1 = new Place("3510", "Viseu");
        System.out.println("Invocar addPlace() no ReplicaManager para 3510...");
        plm.addPlace(p1);

        Place p2 = new Place("1000", "Lisboa");
        System.out.println("Invocar addPlace() no ReplicaManager para 1000...");
        plm.addPlace(p2);

        Place p3 = new Place("4000", "Lisboa");
        System.out.println("Invocar addPlace() no ReplicaManager para 4000...");
        plm.addPlace(p3);

        System.out.println("Obter o endereço do ReplicaManager no Registry() para o ObjectID 1000 ...");
        ori = (ObjectRegistryInterface) Naming.lookup("rmi://localhost:2023/registry");
        String addrRM = ori.resolve("1000");

        System.out.println("Pedir ao ReplicaManager para devolver um PlaceManager para o ObjectID 1000 ...");
        plm = (PlacesListManagerInterface) Naming.lookup(addrRM);
        boolean pl1done = false;
        boolean pl2done = false;
        boolean pl3done = false;
        String plAddress = null;
        for(int i=0; i<10 ; i++) {
            plAddress = plm.getPlaceListAddress("1000");
            System.out.println("\tDevolveu " + plAddress);
            if(plAddress.equals("rmi://localhost:2028/placelist")) pl1done=true;
            else if(plAddress.equals("rmi://localhost:2029/placelist")) pl2done=true;
                 else if(plAddress.equals("rmi://localhost:2030/placelist")) pl3done=true;
        } 

        if(!(pl1done==pl2done==pl3done==true)) fail("Não está a devolver um PlaceManager aleatório...");        

        System.out.println("Invocar getPlace() no PlaceManager");
        pli  = (PlacesListInterface) Naming.lookup(plAddress);
        String locality = pli.getPlace("1000").getLocality();

        System.out.println("\tDevolveu " + locality);
        assertEquals("Lisboa", locality);


    } catch(Exception e) { }
}

elemento raíz

Cenário de Validação https://www.dropbox.com/s/4gncnwveu9jx11h/Cenario%20UDP002.txt?dl=0

se for necessário incluir um grupo dentro de outro

https://www.w3schools.com/xml/schema_example.asp

não existe limite máximo para a escolha

obriga a fazer pelo menos uma escolha

O conteúdo do elemento email pode ter texto com elementos misturados dentro do mesmo, tal como aparece no XML anterior.

Como o Product tem outros elementos dentro dele, não vai ter um atributo type="....". Em vez disso, contém um complexType que define os elementos interiores do Product.

Indica que este ficheiro XML é validado pelo ficheiro Produto.xsd

Um atributo é sempre declarado dentro do complexType, mas fora da sequência

Apesar de ter outras alternativas, o elemento sequence aparece quase sempre dentro do complexType. Dentro desta sequence estão os elementos interiores do Product.

Split da String

String stringComVirgulas="1,xxxx";

stringComVirgulas.split(",")[0] -- Devolve "1" stringComVirgulas.split(",")[1] -- Devolve "0"

o servidor bloqueia aqui à espera de um pedido do cliente

conversão do array de bytes enviado pelo servidor para String, de forma a que possa ser visualizado na consola

o cliente bloqueia aqui à espera da resposta do servidor

criação do datagrama que vai receber os dados do servidor

criação de um buffer para colocar a resposta do servidor

envio do datagrama através do socket

datagrama com a mensagem a enviar para o servidor

porto do servidor

objeto que representa o endereço do servidor para onde vamos enviar a mensagem

a mensagem tem de ser convertida para array de bytes antes de ser enviada

criação do socket de comunicação

checksums errados dão origem a mensagens descartadas

Wikipédia

prefixo que representa o nome do namespace

nome do namespace

elemento raiz