Advertisement
Dals

Server

Oct 30th, 2012
84
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 3.46 KB | None | 0 0
  1. package se.dalsit.net;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.net.ServerSocket;
  7. import java.net.Socket;
  8. import java.util.ArrayList;
  9. import java.util.Iterator;
  10.  
  11. import se.dalsit.net.Packet.NewConnection;
  12.  
  13. public class Server {
  14.    
  15.     private final static String SERVERSTRING = "[SERVER]: ";
  16.     private ServerSocket server;
  17.    
  18.  
  19.     private ArrayList<ObjectOutputStream> connectionsList = new ArrayList<ObjectOutputStream>();
  20.     private ArrayList<Player> playersList  = new ArrayList<Player>();
  21.    
  22.    
  23.     public static void main(String[] args) {
  24.         new Server();
  25.        
  26.  
  27.     }
  28.    
  29.    
  30.     public Server() {
  31.        
  32.        
  33.         startNetworking();
  34.  
  35.        
  36.     }
  37.  
  38.  
  39.     private void startNetworking() {
  40.        
  41.         try {
  42.             server = new ServerSocket(4242);
  43.             System.out.println(SERVERSTRING + "Server started at port 4242");
  44.            
  45.             while (true) {
  46.                
  47.                 //Accepts the incoming connection!
  48.                 Socket clientSocket =   server.accept();
  49.                
  50.                 //Creates a objectWriter and adds it to the objectWriterList
  51.                 ObjectOutputStream objectWriter = new ObjectOutputStream (clientSocket.getOutputStream());
  52.                 ObjectInputStream reader = new ObjectInputStream (clientSocket.getInputStream());
  53.                 connectionsList.add(objectWriter);
  54.                
  55.                
  56.                 // Logger
  57.                 System.out.println(SERVERSTRING + "Got a connection from: "
  58.                         + clientSocket.getInetAddress());
  59.                
  60.                
  61.                 System.out.println(SERVERSTRING + "Creating player");
  62.                
  63.                 //Creates the player and sents it to the CLient
  64.                
  65.                 createPlayer(objectWriter);
  66.                
  67.                 // Logger
  68.                 System.out.println(SERVERSTRING + "Player sent");
  69.                
  70.                 // sends the arrayList of players to the connecting client!
  71.                 objectWriter.writeObject(playersList);
  72.  
  73.                 // Logger
  74.                 System.out.println(SERVERSTRING + "List sent!");
  75.                
  76.                 //Sends the arraylist to all the connected clients!
  77.                 Thread t = new Thread (new ClientHandler(connectionsList.size(),reader),"Client" + connectionsList.size());
  78.                 t.start();
  79.                
  80.            
  81.                
  82.             }
  83.            
  84.            
  85.            
  86.         }catch (Exception e) {
  87.             e.printStackTrace();
  88.         }
  89.  
  90.        
  91.        
  92.     }
  93.  
  94.  
  95.     private void sendToAll() {
  96.         Iterator<ObjectOutputStream> it = connectionsList.iterator();
  97.         while (it.hasNext()) {
  98.             try {
  99.                 ObjectOutputStream writer =it.next();
  100.                 writer.writeObject(this.playersList);
  101.                 System.out.println(SERVERSTRING +"SEND TO ALL CLIENTS SIZE: " + this.playersList.size());
  102.                
  103.             }catch (Exception ex) {
  104.                 ex.printStackTrace();
  105.                
  106.                 }
  107.             }
  108.         }
  109.    
  110.  
  111.    
  112.    
  113.  
  114.     private void createPlayer(ObjectOutputStream currentConnection) {
  115.        
  116.         Player p = new Player(connectionsList.size());
  117.         playersList.add(p);
  118.         try {
  119.             currentConnection.writeObject(p);
  120.        
  121.         } catch (IOException e) {
  122.            
  123.             e.printStackTrace();
  124.         }
  125.        
  126.  
  127.        
  128.     }
  129.    
  130.    
  131.     private class ClientHandler implements Runnable {
  132.         int id;
  133.         ObjectInputStream reader;
  134.         Object o;
  135.        
  136.         private ClientHandler (int id,ObjectInputStream reader) {
  137.             this.reader = reader;
  138.             this.id = id;
  139.         }
  140.        
  141.        
  142.        
  143.         public void run () {
  144.            
  145.            
  146.             try {
  147.                 while ((o = reader.readObject()) !=  null) {
  148.                    
  149.                     if (o instanceof Packet.NewConnection) {
  150.                         System.out.println("New Connection!");
  151.                         sendToAll();
  152.                        
  153.                        
  154.                     }
  155.                    
  156.                    
  157.                    
  158.                    
  159.                    
  160.                    
  161.                    
  162.                 }
  163.             } catch (ClassNotFoundException e) {
  164.  
  165.                 e.printStackTrace();
  166.             } catch (IOException e) {
  167.    
  168.                 e.printStackTrace();
  169.             }
  170.            
  171.            
  172.            
  173.            
  174.            
  175.    
  176.         }
  177.  
  178.     }
  179.  
  180. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement