基于udp的服务器消息转发（群发）

客户端通过服务器转发消息给其他客户端

转载地址：http://medicine.iteye.com/blog/1912231
上面实现的是固定ip和端口的客户端之间的转发消息，主要是字符串消息。接下来，我对上面的代码改写，通过服务器给的ip和端口，客户端去连接，服务器根据连接的客户端获取其ip和端口放进一个list集合里，最后循环进行转发。
服务器端

public class Server {
	private static final int SERVER_PORT=1234;//服务器端口
	private static final int BUFFER_SIZE=1024;//缓冲区字节
	private static final List clientAddressList=new LinkedList();//用于存放客户端的ip和端口
	
	public static void main(String[] args) throws IOException {
		System.out.println("服务器已经启动，监听端口："+SERVER_PORT);
		int clientPort=0;
		String ip="";
		String str="";
		@SuppressWarnings("resource")
		DatagramSocket socket=new DatagramSocket(SERVER_PORT);
		while(true){
			//从客户端接收到的内容（客户端请求）
			DatagramPacket packet=new DatagramPacket(new byte[BUFFER_SIZE],0, BUFFER_SIZE);
			SocketAddress socketAddress=null;
			InetSocketAddress inetSocketAddress=null;
			socket.receive(packet);//接收客户端数据包
			String msg=new String(packet.getData(),0,packet.getLength());//数据包数据转为字符串
			System.out.println("收到客户端消息："+msg);
			socketAddress=packet.getSocketAddress();//由连接的客户端数据包来获得客户端socket地址
			inetSocketAddress=(InetSocketAddress) socketAddress;
			clientPort=inetSocketAddress.getPort();//获得连接的客户端端口号
			ip=inetSocketAddress.getAddress().getHostAddress();//获得连接的客户端ip地址
			if(msg.startsWith("getIp")){//利用接收到getIp字符串来获取客户端ip和端口
				clientAddressList.add(new InetSocketAddress(ip,clientPort));//将客户端ip和端口放到一个list集合，为后面做转发准备
				str=ip+":"+clientPort;
				byte buff[]=str.getBytes();
				packet.setData(buff,0,buff.length);
				socket.send(packet);//把连接的客户端ip和端口号发送回给客户端，表示两者联通
				System.out.println(ip+":"+clientPort);
			}
			if("shutdown server".equals(msg)){
				System.out.println("服务器已经被关闭！");//客户端输入shutdown server来关闭服务器
				break;
			}else{
				//clientAddressList.remove(new InetSocketAddress(ip,clientPort));
				sendToClients(msg, packet.getSocketAddress());
			}
			
		}
	}
	//服务器向所有客户端群发消息
	private static void sendToClients(String msg,SocketAddress fromAddress) throws IOException{
		DatagramSocket socket=new DatagramSocket();
		if(!msg.equals("getIp")){
			byte[] bytes=msg.getBytes();
			for(InetSocketAddress clientAddress:clientAddressList){//遍历客户端，然后转发消息
				System.out.println(clientAddress);
				DatagramPacket packet=new DatagramPacket(bytes, 0,bytes.length,clientAddress);
				//可以进行判断是否是发送者，若是，可以跳过转发，根据ip地址判断
				socket.send(packet);
			}
		}
		socket.close();
	}
}

客户端

public class Client {  
  
    private static final int BUFFER_SIZE = 1024;  
    private static final String SERVER_IP = "192.168.11.157"; 
    private static final int SERVER_PORT = 1234;	
   
  
    public static void main(String[] args) throws IOException {  
    	SocketAddress server = new InetSocketAddress(SERVER_IP, SERVER_PORT);		
		DatagramSocket ds= new DatagramSocket();		
		String str="getIp";		
		byte buff[]=str.getBytes();		
		byte buffer[]=new byte[8*1024];		
		DatagramPacket dp=new DatagramPacket(buff,0,buff.length,server);				
		Scanner sc=new Scanner(System.in); 		
		ds.send(dp);//发送信息到服务器		
		dp.setData(buffer,0,8*1024);		
		ds.receive(dp);		
		String message=new String(dp.getData(),0,dp.getLength());		
		System.out.println("本机端口和IP信息:"+message);	
		int clientListenPort=Integer.valueOf(message.split(":")[1]);
		System.out.println(clientListenPort);
        new Thread(new ReceiveMsgThread(ds)).start();  
  
        try {  
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
            while(true) {  
                String msg = br.readLine();  
                if ("shutdown".equals(msg)) {  
                    System.out.println("客户端已退出！");  
                    System.exit(-1);  
                }  
                sendToServer(msg);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
    
    /** 
     * 客户端向服务端发送消息 
     * @param msg 
     * @throws IOException 
     */  
    private static void sendToServer(String msg) throws IOException {  
    	SocketAddress server = new InetSocketAddress(SERVER_IP, SERVER_PORT);
        DatagramSocket ds = new DatagramSocket();  
        byte[] bytes = msg.getBytes();  
        ds.send(new DatagramPacket(bytes, bytes.length, new InetSocketAddress(SERVER_IP, UDPServer.SERVER_PORT)));  
        ds.close();  
    }  
  
    /** 
     * 用来监听服务器端发送的信息 
     */  
    private static class ReceiveMsgThread implements Runnable {  
    	DatagramSocket ds=null;
    	DatagramPacket dp=null;
    	String message="";
        private ReceiveMsgThread(DatagramSocket ds) {  
            this.ds = ds;  
        }  
  
        @Override  
        public void run() {  
            //System.out.println("客户端已经启动，监听端口："+clientListenPort);  
            try {  
            	byte buffer[]=new byte[1024];			
    			dp=new DatagramPacket(buffer,0,buffer.length);			
    			byte buff[]=new byte[1024];	
                while (true) {  
                	dp.setData(buff,0,1024);				
    				System.out.println("准备接收");				
    				ds.receive(dp);				
    				message=new String(dp.getData(),0,dp.getLength());	
    				System.out.println("接收到:"+message);	  
                }  
            } catch (SocketException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
}  

如果觉得有帮助，点个赞呗。本人也在学习当中，有很多需要改进的地方，如果有什么好的建议和意见，可以指导下我，谢谢！