17：网络编程

/*  
 * 需求：定义一个应用程序，用于接收udp协议传输的数据并处理  
 *   
 * 定义udp接收端口  
 * 思路：  
 * 1、定义udp的socket服务，通常会监听一个端口。其实就是给这个接收网络应用程序定义一个数字标识，  
 *    明确哪些数据过来该应用程序可以处理  
 * 2、定义一个数据包，用于存储接收到的字节数据，可以方便提取数据中的信息  
 * 3、通过socket的receive方法将接收到的数据存入以定义好的数据包中  
 * 4、通过数据包中特有功能，将不同的数据取出  
 * 5、关闭资源  
 */
publicclassUDPReceive{
publicstaticvoid main(String[] args)throwsException{
// 1、建立udp的socket服务，并指定端点
DatagramSocket ds =newDatagramSocket(1000);

// 2、定义数据包，用于存储数据
byte[] buf =newbyte[1024];
DatagramPacket dp =newDatagramPacket(buf, buf.length);

// 3、通过socket服务的receive方法将接收到的数据存入数据包中
		ds.receive(dp);// 阻塞式方法 ，不发送就一直接收

// 4、通过数据包的方法获取其中的数据
// String getHostAddress()：返回IP地址字符串文本形式，以这个为主，即以IP地址为主。
String ip = dp.getAddress().getHostAddress();// 获取ip
String data =newString(dp.getData(),0, dp.getLength());// dp.getData()获取数据，不需要获取1024，获取指定长度就行
int port = dp.getPort();// 获取端口号，这里的端口和ip是发送端的，他是随机的，可以在套接字中指定，不指定系统随机分配
System.out.println(ip +"::"+ data +"::"+ port);

// 5、关闭资源
		ds.close();
}
}

/*  
 * 发送键盘录入信息  
 */  
public class UDPSend2 {  
    public static void main(String[] args) throws Exception {  
        DatagramSocket ds = new DatagramSocket();  
        BufferedReader bfr = new BufferedReader(  
                new InputStreamReader(System.in));  //转换流，转成字节
        String line = null;  
      
       byte[] buf = null;  
        DatagramPacket dp = null;  
        while ((line = bfr.readLine()) != null) {  
            buf = line.getBytes();  
            dp = new DatagramPacket(buf, buf.length,  
                    InetAddress.getByName("192.168.229.1"), 10000);
//192.168.1.255广播地址，在这个频段里的所有ip都可以接收，聊天室  
            ds.send(dp);  
              
            if("886".equals(line)){  
                break;  
            }  
        }  
        ds.close();  
        buf.clone();  
    }  
}  

public class UDPChatDemo {  
    public static void main(String[] args) throws IOException {  
        DatagramSocket sendSocket = new DatagramSocket();  
        DatagramSocket ReceiveSocket = new DatagramSocket(10002);  
          
        new Thread(new ChatSend(sendSocket)).start();  
        new Thread(new ChatReceive(ReceiveSocket)).start();  
    }  
}  
/*  
 * 聊天的发送端  
 */  
public class ChatSend implements Runnable{  
      
    private DatagramSocket ds;  
      
    public ChatSend(DatagramSocket ds){  
        this.ds = ds;  
    }  
  
    @Override  
    public void run() {  
        BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));  
        byte[] buf = null;  
        String line = null;  
        try {  
            while((line=bfr.readLine()) != null){  
                buf = line.getBytes();  
                DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getByName("192.168.1.255"), 10002);  
                ds.send(dp);  
            }  
        } catch (UnknownHostException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }finally{  
            ds.close();  
            try {  
                bfr.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
      
}  
/*  
 * 聊天，接收端  
 */  
public class ChatReceive implements Runnable{  
      
    private DatagramSocket ds;  
      
    public ChatReceive(DatagramSocket ds){  
        this.ds = ds;  
    }  
  
    @Override  
    public void run() {  
        while(true){  
            byte[] buf = new byte[1024];  
            DatagramPacket dp = new DatagramPacket(buf, buf.length);  
            try {  
                ds.receive(dp);  
                String ip = dp.getAddress().getHostAddress();  
                String data = new String(dp.getData(),0,dp.getLength());  
                int port = dp.getPort();  
                System.out.println(ip + "::" + data + "::" + port);  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
}  

publicclassTCPServerDemo{
publicstaticvoid main(String[] args)throwsIOException{
// 建立服务端的socket服务，并监听一个端口
ServerSocket ss =newServerSocket(10003);
// 通过accept方法获取连接过来的客户端对象
Socket socket = ss.accept();
String ip = socket.getInetAddress().getHostAddress();
System.out.println(ip +"......connected");
// 获取客户端发过来的数据，那么要使用客户端对象的读取流来获取数据
InputStream in = socket.getInputStream();
byte[] buf =newbyte[1024];
int len = in.read(buf);
System.out.println(newString(buf,0, len));
socket.close();// 关闭客户端
ss.close();// 关闭服务端，可选的操作
}
}

publicclassTCPClientDemo{
publicstaticvoid main(String[] args)throwsException{
//1、创建客户端的socket服务，指定目的主机和端口
Socket socket =newSocket("192.168.229.1",10003);
//2、获取socket的输出流，用于发送数据
OutputStream out = socket.getOutputStream();
//3、发送数据
out.write("tcp client send message come on".getBytes());
socket.close();
}
}

/*  
 * 需求：建立一个文本转换服务器。  
 * 客户端给服务端发送文本，服务单会将文本转成大写在返回给客户端。  
 * 而且客户度可以不断的进行文本转换。当客户端输入over时，转换结束。  
 *   
 * 分析：  
 * 客户端  
 * 既然是操作设备上的数据，那就可以使用IO技术，并按照io操作规律来思考  
 * 源：键盘录入  
 * 目的：网络设备，网络输出流  
 * 而且操作的是文本数据，可以用字符流  
 *   
 * 步骤： 
 * 1、建立服务  
 * 2、获取键盘输入  
 * 3、将数据发给客户端  
 * 4、获取服务端返回的数据  
 * 5、结束，关闭资源  
 */  
class TransClient {  
    public static void main(String[] args) throws UnknownHostException,  
            IOException {  
        Socket s = new Socket(InetAddress.getLocalHost(), 10005);  
        BufferedReader bfrb = new BufferedReader(new InputStreamReader(  
                System.in));  
  
        // 定义目的，将数据写入socket输出流，发给服务器  
        OutputStream out = s.getOutputStream();  
        OutputStreamWriter ow = new OutputStreamWriter(out);  
        BufferedWriter bfw = new BufferedWriter(ow);  
  
        // 定义读取流  
        InputStream in = s.getInputStream();  
        InputStreamReader is = new InputStreamReader(in);  
        BufferedReader bfr = new BufferedReader(is);  
  
        String line = null;  
        while ((line = bfrb.readLine()) != null) {  
            bfw.write(line);  
            bfw.newLine();  
            bfw.flush();  
  
            // 读取数据  
            String data = bfr.readLine();  
            System.out.println(data);  
        }  
  
        bfrb.close();  
        s.close();  
    }  
}  
  
/*  
 * 服务端： 源：socket读取流 目的：socket输出流。  
 */  
class TransServer {  
    public static void main(String[] args) throws IOException {  
        ServerSocket ss = new ServerSocket(10005);  
        Socket s = ss.accept();  
  
        String ip = s.getInetAddress().getHostAddress();  
        System.out.println(ip + "....connected");  
  
        InputStream in = s.getInputStream();  
        InputStreamReader isr = new InputStreamReader(in);  
        BufferedReader bfr = new BufferedReader(isr);  
  
        // 目的。socket输出流。将大写数据写入到socket输出流，并发送给客户端。  
        BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(  
                s.getOutputStream()));  
          
        String line = null;  
        while((line=bfr.readLine()) != null){  
            bufOut.write(line.toUpperCase());  
            bufOut.newLine();  
            bufOut.flush();  
        }  
        s.close();  
        ss.close();  
    }  
}  
  
public class TCPTransText{  
    public static void main(String[] args) {  
        new TransClient();  
        new TransServer();  
    }  
} 

/*  
 * 客户端  
 */  
class TextClient {  
    public static void main(String[] args) throws UnknownHostException,  
            IOException {  
        Socket s = new Socket(InetAddress.getLocalHost(), 10007);  
  
        File file = new File("AwtDemo.java");  
  
        BufferedReader bfr = new BufferedReader(new FileReader(file));  
  
        // 将数据写入到socket流中  
        PrintWriter out = new PrintWriter(s.getOutputStream(), true);  
  
        String line = null;  
        while ((line = bfr.readLine()) != null) {  
            out.println(line);  
        }  
        // 关闭客户端的输出流。相当于给流中加入一个结束标记-1.  
        // 结束标记很重要，不然TCP中程序停不下来  
        s.shutdownOutput();  
  
        // 接收服务端发过来的数据  
        BufferedReader bfrs = new BufferedReader(new InputStreamReader(  
                s.getInputStream()));  
  
        String data = bfrs.readLine();  
        System.out.println(data);  
  
        bfr.close();  
        s.close();  
    }  
}  
  
class TextServer {  
    public static void main(String[] args) throws IOException {  
        ServerSocket ss = new ServerSocket(10007);  
        Socket s = ss.accept();// 接收客户端的socket流  
        String ip = s.getInetAddress().getHostAddress();  
        System.out.println(ip + "....connected");  
  
        //建立读取客户端数据的流  
        BufferedReader bfr = new BufferedReader(new InputStreamReader(  
                s.getInputStream()));  
        //建立文件，关联流  
        PrintWriter out = new PrintWriter(new FileWriter("server.java"),true);  
          
        String line = null;  
        while((line=bfr.readLine()) != null){  
            out.println(line);  
        }  
          
        //建立给客户端回馈机制  
        PrintWriter outToC = new PrintWriter(s.getOutputStream(),true);  
        outToC.println("上传成功");  
          
        out.close();  
        s.close();  
        ss.close();  
    }  
}  

/*  
 * 客户端  
 */  
class PicCilent2 {  
    public static void main(String[] args) throws UnknownHostException,  
            IOException {  
        File file = new File(args[0]);  
        Socket s = new Socket("192.168.229.1", 10010);  
        // 读取文件数据  
        BufferedInputStream bfr = new BufferedInputStream(new FileInputStream(  
                file));  
        // 将数据写到socket流中，传递给服务端  
        BufferedOutputStream out = new BufferedOutputStream(s.getOutputStream());  
  
        byte[] buf = new byte[1024];  
        int len = 0;  
        while ((len = bfr.read(buf)) != -1) {  
            out.write(buf, 0, len);  
        }  
        s.shutdownInput();// 结束标记  
  
        // 接收服务端反馈数据  
        InputStream in = s.getInputStream();  
        byte[] bufin = new byte[1024];  
        int num = in.read(bufin);  
        System.out.println(new String(bufin, 0, num));  
  
        bfr.close();  
        s.close();  
    }  
}  
  
/*  
 *   
 * 服务端:  
 */  
class PicThread implements Runnable {  
  
    private Socket s;  
  
    PicThread(Socket s) {  
        this.s = s;  
    }  
  
    @Override  
    public void run() {  
        int count = 1;  
        String ip = s.getInetAddress().getHostAddress();  
        try {  
            System.out.println(ip + "....connected");  
  
            InputStream in = s.getInputStream();  
  
            File dir = new File("c:\\");  
  
            File file = new File(dir, ip + "(" + (count) + ")" + ".jpg");  
  
            while (file.exists())  
                file = new File(dir, ip + "(" + (count++) + ")" + ".jpg");  
  
            FileOutputStream fos = new FileOutputStream(file);  
  
            byte[] buf = new byte[1024];  
  
            int len = 0;  
            while ((len = in.read(buf)) != -1) {  
                fos.write(buf, 0, len);  
            }  
  
            OutputStream out = s.getOutputStream();  
  
            out.write("上传成功".getBytes());  
  
            fos.close();  
  
            s.close();  
        } catch (Exception e) {  
            throw new RuntimeException(ip + "上传失败");  
        }  
    }  
  
}  
  
class Picserver2 {  
    public static void main(String[] args) throws IOException {  
        ServerSocket ss = new ServerSocket(10011);  
        while (true) {  
            Socket s = ss.accept();  
  
            new Thread(new PicThread(s)).start();  
        }  
    }  
}