Pizzeria Ordinazioni

Classe Ordinazioni

import java.io.Serializable;
 
public class OrdinazioneT implements Serializable
{
   private final double Margherita = 3.99;
   private final double Capricciosa = 4.50;
   private final double Birra = 1.99;
   private final double CocaCola = 1.50;
   private final double Pannolini = 5.99;
 
   private int quantità;
   private String ordine;
   double prezzo;
 
 public  OrdinazioneT(int num, String ord)
   {
    quantità = num;
    ordine = ord;
   }
 
     public int getQuantità()
         {
         return quantità;
         }
     public String getOrdine()
         {
         return ordine;
         }
 
         public double Calcola()
             {    
                 if(ordine.equalsIgnoreCase("Margherita"))        prezzo = Margherita * quantità;
                 if(ordine.equalsIgnoreCase("Margherite"))        prezzo = Margherita * quantità;
                 if(ordine.equalsIgnoreCase("Capricciose"))        prezzo = Capricciosa * quantità;
                 if(ordine.equalsIgnoreCase("Capricciosa"))         prezzo = Capricciosa * quantità;
                 if(ordine.equalsIgnoreCase("Birra"))             prezzo = Birra * quantità;
                 if(ordine.equalsIgnoreCase("Birre"))            prezzo = Birra * quantità;
                 if(ordine.equalsIgnoreCase("CocaCola"))         prezzo = CocaCola * quantità;
                 if(ordine.equalsIgnoreCase("Pannolini"))         prezzo = Pannolini * quantità;
                 if(ordine.equalsIgnoreCase("Pannolino"))        prezzo = Pannolini * quantità;
                 return prezzo;
             }
}

Classe Server Principale

import java.io.*;
import java.net.*;
import java.util.*;
 
public class ServerGT extends Thread implements Serializable
{
    public static void main(String[] args) throws Exception
    {
        class impS implements Runnable
        {
            private Socket server;
            impS(Socket server)
            {
                this.server = server;
            }
            public void run()
            {
                try
                {
                    ArrayList<OrdinazioneT> ClientOrd = new ArrayList<OrdinazioneT>();
                    ArrayList<OrdinazioneT> PizzeriaP = new ArrayList<OrdinazioneT>();
                    ArrayList<OrdinazioneT> PannoliniQ = new ArrayList<OrdinazioneT>();
 
                    double prezzoTotale = 0;
                    double prezzoP=0;
                    double prezzoQ=0;
                    Socket clientSocketP = new Socket ("localhost", 2900);
                    Socket clientSocketQ = new Socket ("localhost", 2901);
 
                     //Costruisco il flusso di oggetti da mandare al ServerP
                    ObjectOutputStream outToServerP = new ObjectOutputStream (clientSocketP.getOutputStream());
                     //Costruisco il flusso di oggetti da mandare al ServerQ
                    ObjectOutputStream outToServerQ = new ObjectOutputStream (clientSocketQ.getOutputStream());
 
                    //Costruisco il flusso di ricezione dal ServerP
                    ObjectInputStream inFromServerP = new ObjectInputStream(clientSocketP.getInputStream());
                  //Costruisco il flusso di ricezione dal ServerG
                    ObjectInputStream inFromServerQ = new ObjectInputStream(clientSocketQ.getInputStream());
 
                    ObjectInputStream inFromClient = new ObjectInputStream(server.getInputStream());
                    ObjectOutputStream outToClient = new ObjectOutputStream(server.getOutputStream());
 
                    ClientOrd =(ArrayList<OrdinazioneT>) inFromClient.readObject();
 
                    for(OrdinazioneT a : ClientOrd)
                    {
                        if(a.getOrdine().equalsIgnoreCase("Pannolini")) PannoliniQ.add(a);
                        else{
                            PizzeriaP.add(a);
                            }
                    }
                    //Invio al ServerP l'ArrayList PizzeriaP
                    outToServerP.writeObject(PizzeriaP);
                    //Invio al ServerQ l'ArrayList PannoliniQ
                    outToServerQ.writeObject(PannoliniQ);
 
                    //acquisisco il prezzo del ServerP e dal ServerQ
                    prezzoP = (Double) inFromServerP.readObject();
                    prezzoQ = (Double) inFromServerQ.readObject();
 
                    prezzoTotale= prezzoP + prezzoQ;
 
                    //invio al clientC il flusso di dato contenenti il prezzoTotale
                    outToClient.writeObject(prezzoTotale);
                    server.close();
                }
                catch(Exception e){}        
            }
        }
 
        ServerSocket  welcomeSocket = new ServerSocket(2899);
        Socket server;
        while(true)
        {
            server = welcomeSocket.accept();
            impS nuova = new impS(server);
            Thread s = new Thread(nuova);
            s.start();
 
        }
    }
}

Classe Server Pizzeria

import java.io.*;
import java.net.*;
import java.util.*;
 
public class ServerPT extends Thread implements Serializable
{
 
    public static void main (String [] args) throws Exception
    {
 
        class impSock implements Runnable
        {
            private Socket server;
 
            impSock(Socket server)
            {
                this.server=server;
            }
            public void run()
            {
                try{
                    //dichiarazione ArrayList
                    ArrayList<OrdinazioneT> pizzeria = new ArrayList<OrdinazioneT>();
                    //dichiarazione variabile prezzo
                    double prezzoP = 0;
 
                    //Flussi per il ServerG
                    ObjectInputStream inFromServerG = new ObjectInputStream(server.getInputStream());
                    ObjectOutputStream outToServerG = new ObjectOutputStream(server.getOutputStream());
 
                    pizzeria = (ArrayList<OrdinazioneT>)inFromServerG.readObject();
 
                    for (OrdinazioneT a: pizzeria)
                    {
                        prezzoP += a.Calcola(); 
                    }
 
                    outToServerG.writeObject(prezzoP);
                    server.close();
 
                   }
                catch(Exception e)
                {}
            }
        }
        try{
        ServerSocket  welcomeSocketP = new ServerSocket(2900);
        Socket server;
        while (true)
        {
            server = welcomeSocketP.accept();
            impSock connect = new impSock(server);
            Thread t = new Thread(connect);
            t.start();
 
           }
        }catch(Exception e){}
    }
}

Classe Server Pannolini

import java.io.*;
import java.net.*;
import java.util.*;
 
public class ServerQT implements Serializable
{
    public static void main (String [] args) throws Exception
    {
        class impServ implements Runnable
        {
            private Socket server;
 
            impServ(Socket server)
            {
                this.server=server;
            }
            public void run()
            {
                try{
                    //dichiarazione ArrayList
                    ArrayList<OrdinazioneT> pannolini = new ArrayList<OrdinazioneT>();
                    //dichiarazione variabile prezzo
                    double prezzoQ = 0;
                    //Flussi per il ServerG
                    ObjectInputStream inFromServerG = new ObjectInputStream(server.getInputStream());
                    ObjectOutputStream outToServerG = new ObjectOutputStream(server.getOutputStream());
 
                    pannolini = (ArrayList<OrdinazioneT>)inFromServerG.readObject();
 
                    for (OrdinazioneT a: pannolini)
                    {
                        prezzoQ += a.Calcola(); 
                    }
                    outToServerG.writeObject(prezzoQ);
                    server.close();
                   }
                catch(Exception e){}
            }
        }
        ServerSocket  welcomeSocketQ = new ServerSocket(2901);
        Socket server;
        while (true)
        {
            server = welcomeSocketQ.accept();
            impServ connection = new impServ(server);
            Thread v = new Thread(connection);
            v.start();
 
        }
    }
}

Classe Client

import java.io.*;
import java.net.*;
import java.util.*;
 
public class ClientT implements Serializable
{
public static void main (String[] args) throws Exception
  {
    //Costruisco la socket per poter comunicare con il serverG sulla 2899
    Socket clientSocket = new Socket ("localhost", 2899);
 
    //Costruisco il flusso di oggetti da mandare al ServerG
    ObjectOutputStream outToServer = new ObjectOutputStream (clientSocket.getOutputStream());    
 
    //Costruisco il flusso di oggetti che ricevo dal ServerG
    ObjectInputStream inFromServer = new ObjectInputStream  (clientSocket.getInputStream());
    Scanner in = new Scanner(System.in);
    System.out.println("inserire l'ordinazione:  ");
    System.out.println("Premere 0 per terminare l'ordinazione...\n");
 
    int a ;
    String b;
    double prezzoT = 0;//inizializzo la variabile prezzo che poi mi darà la somma totale dell'ordinazione.
    ArrayList<OrdinazioneT> OrdNro = new ArrayList<OrdinazioneT>();
 
        for(int j = 0;j<10;j++)
        {
            a = in.nextInt();
            if(a==0) break;
            b = in.next();
            OrdinazioneT nuovaOrd = new OrdinazioneT(a,b);
            OrdNro.add(nuovaOrd);
        }
        //Invio al ServerG il mio ArrayList ordinazione
        outToServer.writeObject(OrdNro);
        //Ricevo dal ServerG il risultato delle sue operazioni.
        prezzoT = (Double) inFromServer.readObject();
        System.out.println("Il prezzo totale dell'ordinazione e': "+prezzoT);
        //Chiudo la socket
        clientSocket.close();
  }
}
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License