RMI avec Serializable

Les Interfaces :

Code:

1
2
3
4
5
6
7
Client.java
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface Client extends Remote{
    public BankManager getBanckManager()throws RemoteException;
    public String getName()throws RemoteException;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
Account.java
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface Account extends Remote{
    public BankManager getBanckManager()throws RemoteException;
    public Client getClient()throws RemoteException;
          public String getNumAcc()throws RemoteException;
    public long getBalance()throws RemoteException;
    public boolean deposit(long mnt)throws RemoteException;
    public boolean  getCash(long mnt)throws RemoteException;
}

Code:

1
2
3
4
5
6
7
8
BankManager.java
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface BankManager extends  Remote{
    public Account getAccount(String accountNumber)throws RemoteException;
    public Client getClient(String clientName)throws RemoteException;
    public boolean  addAccount(String clientName,String accountNumber)throws RemoteException;
}

Les Classes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
ClientImpl.java
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class ClientImpl extends UnicastRemoteObject implements Client{
    public String name;
    public BankManager bankMana;
    public ClientImpl(String name,BankManager bankMana)throws RemoteException
    {
        this.name=name;
        this.bankMana=bankMana;
    }
        public BankManager getBanckManager()
        {
            return bankMana;
        }
        public String getName()
        {
            return name;
        }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
AccountImpl.java
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class AccountImpl extends UnicastRemoteObject implements Account{
    public BankManager bankMana;
    public long balance;
    public Client clt;
            public String numAcc;
    public AccountImpl(long balance,BankManager bankMana,Client clt,String numAcc)throws RemoteException{
        this.balance=balance; this.bankMana=bankMana; this.clt=clt; this.numAcc=numAcc;
    }
    public BankManager getBanckManager() {
        return bankMana;}
    public Client getClient(){
        return clt;}
    public String getNumAcc(){
        return numAcc;}
    public long getBalance(){
        return balance;}
    public boolean deposit(long mnt){
        balance=balance+mnt; return true;}
    public boolean  getCash(long mnt) {
        if((balance-mnt)>0){
            balance=balance-mnt;return true;}
        else{return false;}}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
BanckManagerImpl.java
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.*;
public class BanckManagerImpl  extends UnicastRemoteObject implements BankManager{
    public String name;
    public BanckManagerImpl(String name)throws RemoteException{
        this.name=name;}    
    Vector <Client> Cl=new Vector<Client>();
    Vector <Account> ac=new Vector<Account>();
    public Account getAccount(String accountNumber) throws RemoteException{
              for (Account account : ac) {
                if (accountNumber.equals(account.getNumAcc())){
                    return account;}
              }
              return null;}
    public Client getClient(String clientName)throws RemoteException{
        for (Client client : Cl) {
                    if (clientName.equals(client.getName())){
                        return client;}
            }
                 return null;}
    public boolean  addAccount(String clientName,String accountNumber)throws RemoteException{
        if(getClient(clientName)==null&& getAccount(accountNumber)==null){
        BankManager bn=new BanckManagerImpl(name);
        Client clt=new ClientImpl(clientName,bn);
                    Account acc=new AccountImpl(0,bn,clt,accountNumber);
                    Cl.add(clt);
                    ac.add(acc);
                    return true;
                }
                return false;}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Server.java
import java.rmi.*;
import java.rmi.registry.Registry;
import java.rmi.registry.LocateRegistry;
public class Server {
    public static void main (String[] args) {
        try
        {
            BanckManagerImpl banck = new BanckManagerImpl("Biat");
            Registry reg= LocateRegistry.createRegistry(2000);
                //Registry reg= LocateRegistry.getRegistry(2000);
                reg.rebind("X",banck);
                System.out.println("server ok");
        }
        catch(Exception e){
            System.out.println("server non");
        }
}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
ClientS.java
import  java.rmi.registry.Registry;
import java.rmi.registry.LocateRegistry;
import java.rmi.*;
public class ClientS {
    public static void main (String[] args) {
        try{
             Registry reg= LocateRegistry.getRegistry(2000);
                BankManager bMan=(BankManager)reg.lookup("X");   
                  bMan.addAccount("Salima", "123Sa");
                    Client cl;
                 cl=bMan.getClient("Salima");
                 System.out.println(cl.getName());
        }
        catch(Exception e){
            System.out.println("erreur");}
}
}

j'ai developpé ce code en utilisant RemoteException
je veut une 2ème solution en utilisant les objets Serializable
pouvez vous m'aider???????????

Bonjour,

Je ne comprends pas quand tu dis que tu veux une deuxième méthode utilisant les objets serializable. Tu es entrain de faire du client/serveur avec RMI et en RMI il n’y a pas deux façon de faire que ce que tu as fais. La sérialisation intervient dans cette techno quand dans ton programme tu veux faire circuler dans le réseau un objet (instance d'une classe - autre que les choses comme des String, int, float...) partagé entre le serveur et les clients. La bonne chose à faire serait de sérialiser cet objet pour le rendre persistant et protéger pendant sa circulation dans le réseau (il faut donc mettre sur pied un mécanisme de sérialisation et de dé-sérialisation).

Exemple : tu as une classe Personne
Code:

1 2 3 4 5 6 public class personne{ public string name; public string preName; public int year; }
qui va contenir un ensemble de données qui vont circuler sur le réseau en un tout (ex: transmission d'un objet "personne" contenant toutes les données name, preName et year, d'un certain client C vers le serveur). Vaut mieux déclarer cette classe comme implémentant l'interface serializable pour la rendre persistant et protéger pendant sa circulation dans le réseau. Le serveur récupérera cet objet "personne", le dé-sérialisera et l'utilisera (c'est à toi de le réaliser par contre).

En espérant avoir contribuer à la résolution de ton problème.

Cordialement

oui merci bien :)