程序博客网 > 北邮人文学院知乎

Java基础之网络编程知识点总结

来源：互联网 发布：北邮人文学院知乎 编辑：程序博客网 时间：2024/04/29 12:48
Java语言涵盖的领域很广，对于网络方面，java也是相当棒的，java也是可以完成网络通讯的功能的。想想看，原来我们写出来的java代码都是单机版的，只能一个人在操作，而现在我们想实现这样一个功能，从我的机器上发出一条信息到张三的机器上，然后，张三再给我回复一条信息发到我的机器上。实际上我们知道数据通讯的原理就是数据的传输的过程。   网络模型：      1.OSI参考模型      2.TCP/IP参考模型   网络通信要素：      1.  IP地址      2.  端口号      3.  传输协议试想，要想给张三通讯首要要做的就是找到张三的那台主机，那么怎么找，通过什么方法完成两台机器的通讯呢？步骤：1）找到对方的IP          2）数据要发送到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识，为了方便称呼这个数字，就叫做端口。         注意：这里的端口不是物理机器上的实际的端口，而是逻辑端口。          3）定义一个通讯规则。这个通讯规则称为协议。国际组织定义了一个通用的协议--TCP/IP协议。
网络通信的要素：IP地址：InetAddress   特点：       网络中的设备标识。       不易记忆，但是可用主机名。       本地回环地址127.0.0.1  主机名localhost。

例子1：获得本机的IP地址和主机名。
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.net.InetAddress;  
  3. import java.net.UnknownHostException;  
  4. public class IPDemo {  
  5.     public static void main(String[] args) throws UnknownHostException {  
  6.         InetAddress i = InetAddress.getLocalHost();   //getLocalHost()返回本地主机  
  7.         //System.out.println(i.toString());  
  8.         //System.out.println("address::"+i.getHostAddress());  //获取IP地址  
  9.         //System.out.println("name::"+i.getHostName());  //获取主机名  
  10.         InetAddress ia = InetAddress.getByName("127.0.0.1");  
  11.         System.out.println("address::"+ia.getHostAddress());  //获取IP地址  
  12.         System.out.println("name::"+ia.getHostName());  //获取主机名  
  13.     }  
  14. }  
端口号：   特点：     用于标识进程的逻辑地址。     有效端口号：0—65535，其中0—1024系统使用或保留端口。传输协议：通讯的规则。常见协议：TCP、UDP。TCP和UDP两者之间的区别：   UDP：1）将数据及源和目的封装成数据包中，不需要建立连接。             2）每个数据包的大小要限制在64k内             3）因无连接，是不可靠协议的。             4）不需要建立连接，速度快。        UDP就像生活中去寄包裹类似：物品—包装—贴物流单（填写发送信息：IP+端口）--但是填写的地址可能不存在，所以有可能就丢弃了。        UDP：飞秋聊天、凌波桌面共享、网络视频会议   TCP：1）建立连接，形成传输数据的通道。            2）在连接中进行大数据量传输。            3）通过三次握手完成连接，是可靠协议。            4）必须建立连接，效率会稍低。        TCP就像生活中的打电话：拨号—连接（发连接请求）--连接通路，然后双方说话。        TCP：在线下载、打电话Socket:  Scoket就是为网络服务提供的一种机制。通信的两端都有Socket。网络通信其实就是Socket间的通信。  数据在两个Socket间通过IO传输。UDP传输（建立UDP的Socket服务方法）：      1）DatagramSocket与DatagramPacket.      2）建立发送端，接收端。      3）建立数据包。      4）调用Socket的发送接收方法。      5）关闭Socket。注意：发送端和接收端是两个独立的运行程序。
例子2.定义一个Socket的发送端和接收端，用于实现两个程序间的发送消息。  定义了一个udp的发送端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.IOException;  
  3. import java.net.DatagramPacket;  
  4. import java.net.DatagramSocket;  
  5. import java.net.InetAddress;  
  6. /** 
  7.  * 通过udp传输方式，讲一段文字数据发送出去。 
  8.  * 定义了一个udp的发送端。 
  9.  * @author wl-pc 
  10.  * 思路：1.建立udpsocket服务。 
  11.  *       2.要提供数据，并将数据封装到数据包中。 
  12.  *       3.通过socket服务的发送功能，将数据包发送出去。 
  13.  *       4.关闭资源 
  14.  */  
  15. public class UdpSendDemo {  
  16.     public static void main(String[] args) throws IOException {  
  17.         //1.创建udp服务，通过DatagramScoket对象。  
  18.         DatagramSocket ds = new DatagramSocket(8888);  
  19.         //2.确定数据，并且封装成数据包  
  20.         byte[] buf = "itheima,hello!".getBytes();  
  21.         DatagramPacket dp =new DatagramPacket(buf, buf.length,InetAddress.getByName("127.0.0.1"),10000);  
  22.         //3.通过socket服务，将已有的数据包发送出去，通过send()方法  
  23.         ds.send(dp);  
  24.         //关闭资源  
  25.         ds.close();  
  26.     }  
  27. }  

定义了一个udp的接收端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.IOException;  
  3. import java.net.DatagramPacket;  
  4. import java.net.DatagramSocket;  
  5. /** 
  6.  * 定义一个应用程序，用于接收Udp协议传输的数据并处理数据。 
  7.  * @author wl-pc 
  8.  * 思路： 
  9.  *     1.定义udpsocket服务。（注意：在定义udp的接收端）通常 
  10.  *     都会监听一个端口，其实就是给这个接收网络应用程序定义 
  11.  *     一个数字标识，方便与明确哪些数据过来，该应用程序可以处理。 
  12.  *     2.定义一个数据包，因为要存储接收到的字节数据，因为数据 
  13.  *       包对象中，有更多功能可以提取字节数据中的不同数据信息 
  14.  *     3.通过socket服务的receive()方法接收到数据存入已定义好 
  15.  *       的数据包中。 
  16.  *     4.通过数据包对象的特有的功能，将这些不同的数据取出，打 
  17.  *       印到控制台上 
  18.  *     5.关闭资源。 
  19.  */  
  20. public class UdpReceDemo {  
  21.     public static void main(String[] args) throws IOException {  
  22.         //1.创建udp的socket服务，建立端点  
  23.         DatagramSocket ds = new DatagramSocket(10000);  
  24.         //2.定义数据包，用于存储数据。  
  25.         byte[] buf = new byte[1024];  
  26.         DatagramPacket dp =new DatagramPacket(buf, buf.length);  
  27.         //3.通过服务的的receive()方法将接收到的数据存入数据包中  
  28.         ds.receive(dp);  
  29.         //4.通过数据包中的方法获取其中的数据。  
  30.         String ip = dp.getAddress().getHostAddress();  
  31.         String data = new String(dp.getData(),0,dp.getLength());  
  32.         int port = dp.getPort();  
  33.         System.out.println(ip+"::"+data+"::"+port);  
  34.         //5.关闭资源  
  35.         ds.close();  
  36.     }  
  37. }  
例子3：聊天小程序定义了一个udp的发送端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.BufferedReader;  
  3. import java.io.IOException;  
  4. import java.io.InputStreamReader;  
  5. import java.net.DatagramPacket;  
  6. import java.net.DatagramSocket;  
  7. import java.net.InetAddress;  
  8. /** 
  9.  * 记着一个规律：在程序中只要用到了java.net包，通常都会用到java.io包。 
  10.  * @author wl-pc*/  
  11. public class UdpSendDemo2 {  
  12.     public static void main(String[] args) throws IOException {  
  13.         DatagramSocket ds = new DatagramSocket();  
  14.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
  15.         String line = null;  
  16.         //readLine()方法是阻塞式方法，如果没有数据，会等  
  17.         while((line=br.readLine())!=null){     
  18.             if("886".equals(line))  
  19.                 break;  
  20.             byte[] buf = line.getBytes();  
  21.             DatagramPacket dp = new DatagramPacket(buf, buf.length,InetAddress.getByName("127.0.0.1"),10003);  
  22.             ds.send(dp);  
  23.         }  
  24.         ds.close();  
  25.     }  
  26. }  
定义了一个udp的接收端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.IOException;  
  3. import java.net.DatagramPacket;  
  4. import java.net.DatagramSocket;  
  5. public class UdpReceDemo2 {  
  6.     public static void main(String[] args) throws IOException {  
  7.         DatagramSocket ds = new DatagramSocket(10003);  
  8.         while(true){  
  9.             byte[] buf = new byte[1024];  
  10.             DatagramPacket dp = new DatagramPacket(buf, buf.length);  
  11.             ds.receive(dp);  //receive()方法是阻塞式方法，如果没有数据，会等  
  12.             String ip = dp.getAddress().getHostAddress();  
  13.             String data = new String(dp.getData(),0,dp.getLength());  
  14.             int port = dp.getPort();  
  15.             System.out.println(ip+"::"+data+"::"+port);  
  16.         }  
  17.     }  
  18. }  
例子3：使用多线程的技术完成聊天小程序。（1个进程多个线程）
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.BufferedReader;  
  3. import java.io.InputStreamReader;  
  4. import java.net.DatagramPacket;  
  5. import java.net.DatagramSocket;  
  6. import java.net.InetAddress;  
  7. import java.net.SocketException;  
  8. /** 
  9.  * 编写一个聊天程序： 
  10.  * 有一个接收数据的部分和发送数据的部分， 
  11.  * 这两个部分需要同时执行，那就要使用到了 
  12.  * 多线程技术了，一个线程控制接收数据， 
  13.  * 另一个线程负责发送数据。 
  14.  * @author wl-pc 
  15.  * 因为收和发数据的动作时不一致的，所以 
  16.  * 要定义两个run()方法，而且这两个run() 
  17.  * 方法要封装到不同的类中。 
  18.  */  
  19. class Send implements Runnable{  
  20.     private DatagramSocket ds;  
  21.     Send(DatagramSocket ds) {  
  22.         this.ds = ds;  
  23.     }  
  24.     @Override  
  25.     public void run() {  
  26.         try {  
  27.             BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
  28.             String line = null;  
  29.             while((line=br.readLine())!=null){  
  30.                 if("886".equals(line))  
  31.                     break;  
  32.                 byte[] buf = line.getBytes();  
  33.                 DatagramPacket dp =new DatagramPacket(buf, buf.length,InetAddress.getByName("127.0.0.1"),10005);  
  34.                 ds.send(dp);  
  35.             }  
  36.         } catch (Exception e){  
  37.             throw new RuntimeException("发送端失败！");  
  38.         }  
  39.     }  
  40. }  
  41. class Rece implements Runnable{  
  42.     private DatagramSocket ds;  
  43.     Rece(DatagramSocket ds) {  
  44.         this.ds = ds;  
  45.     }  
  46.     @Override  
  47.     public void run() {  
  48.         try {  
  49.             while(true){  
  50.                 byte[] buf = new byte[1024];  
  51.                 DatagramPacket dp = new DatagramPacket(buf, buf.length);  
  52.                 ds.receive(dp);  
  53.                 String ip =dp.getAddress().getHostAddress();  
  54.                 String data = new String(dp.getData(),0,dp.getLength());  
  55.                 int port = dp.getPort();  
  56.                 System.out.println(ip+"::"+data+"::"+port);  
  57.             }  
  58.         } catch (Exception e) {  
  59.             throw new RuntimeException("接收端失败！");  
  60.         }  
  61.     }  
  62. }  
  63. public class ChatDemo {  
  64.     public static void main(String[] args) throws SocketException {  
  65.           
  66.          DatagramSocket sendSocket = new DatagramSocket();  
  67.          DatagramSocket receSocket = new DatagramSocket(10005);  
  68.          new Thread(new Send(sendSocket)).start();  
  69.          new Thread(new Rece(receSocket)).start();  
  70.     }  
  71. }  
TCP传输：    1）Socket和ServerSocket    2）建立客服端和服务器端    3）建立连接后，通过Socket中的IO流进行数据的传输。    4）关闭socket同样，客户端与服务器端是两个独立的应用程序。
例子4：客户端向服务端发送数据信息。定义了一个TCP的服务器端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.net.ServerSocket;  
  5. import java.net.Socket;  
  6.   
  7. /** 
  8.  * 服务端需求：定义端点接收数据，并且打印到控制台上。 
  9.  *  步骤： 
  10.  *      1）建立服务端的socket的服务，通过ServerSocket()来建立， 
  11.  *         并监听一个端口。 
  12.  *      2）获取连接过来的客户端对象，通过ServerSocket的accept() 
  13.  *         方法来完成。所以这个方法是阻塞式的，没有连接，就会等。 
  14.  *      3）客户端如果发过来数据，那么服务端要使用对应的客户端对象 
  15.  *         并获取到该客户端对象的读取流来读取的发过来的数据。并打印 
  16.  *         在控制台上。 
  17.  *      4）（可选操作）关闭服务端。 
  18.  */  
  19. public class TcpServer {  
  20.     public static void main(String[] args) throws IOException{  
  21.         //1.建立服务端的socket服务，并监听一个端口  
  22.         ServerSocket ss = new ServerSocket(10006);  
  23.         //2.通过accept()方法获取连接过来的客户端对象。  
  24.         Socket s = ss.accept();  
  25.         String ip = s.getInetAddress().getHostAddress();  
  26.         System.out.println(ip+"::连接成功！");  
  27.         //3.获取客户端发送过来的数据，那么要使用客户  
  28.         //端对象的读取流来读取数据  
  29.         InputStream in = s.getInputStream();   //源是网络流  
  30.         byte[] buf = new byte[1024];  
  31.         int len = in.read(buf);  
  32.         System.out.println(new String(buf,0,len));  
  33.         s.close();  
  34.         ss.close();  
  35.     }  
  36. }  
定义了一个TCP的客户端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.IOException;  
  3. import java.io.OutputStream;  
  4. import java.net.Socket;  
  5. import java.net.UnknownHostException;  
  6. /** 
  7.  * 演示TCP传输： 
  8.  * @author wl-pc 
  9.  * 1.tcp分为客户端和服务器端 
  10.  * 2.客服端对应的对象是socket 
  11.  *   服务器端对应的对象是serverSocket 
  12.  */  
  13. /** 
  14.  * 客户端：通过查阅socket对象，发现在该 
  15.  * 对象建立时，就可以连接指定的主机。 
  16.  * 因为tcp是面向连接的。所以在建立socket服务 
  17.  * 时，就要有服务端存在，并且连接成功，形成 
  18.  * 通路后，再在该通道进行数据的传输。 
  19.  * @author wl-pc 
  20.  * 步骤： 
  21.  *    1）创建socket服务，并指定要连接的主机和端口 
  22.  *    2）为了发送数据，应该获取socket流中的输出流 
  23.  *    3）往输入流中写数据 
  24.  *    4）关闭资源 
  25.  */  
  26. /** 
  27.  * 需求：给服务端发送一个文本数据 
  28.  */  
  29. public class TcpClient {  
  30.     public static void main(String[] args) throws UnknownHostException, IOException {  
  31.         //1.创建客户端的socket服务，指定目的主机以及端口  
  32.         Socket s = new Socket("127.0.0.1",10006);  
  33.         //2.为了发送数据，应该获取socket流中的输出流  
  34.         OutputStream out = s.getOutputStream();  
  35.         //3.往流中写数据  
  36.         out.write("itheima,hello!".getBytes());  
  37.         //4.关闭资源  
  38.         s.close();    
  39.     }  
  40. }  
例子5：演示tcp的传输的客户端和服务器端的互访。定义了一个TCP的服务器端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.io.OutputStream;  
  5. import java.net.ServerSocket;  
  6. import java.net.Socket;  
  7. /** 
  8.  * 演示tcp的传输的客户端和服务器端的互访。 
  9.  * @author wl-pc 
  10. */  
  11. public class TcpServer2 {  
  12.     public static void main(String[] args) throws IOException {  
  13.         ServerSocket ss = new ServerSocket(10007);  
  14.         Socket s = ss.accept();  
  15.         String ip = s.getInetAddress().getHostAddress();  
  16.         System.out.println(ip+"......conneted");  
  17.         InputStream in = s.getInputStream();  
  18.         byte[] buf = new byte[1024];  
  19.         int len = in.read(buf);  
  20.         System.out.println(new String(buf,0,len));  
  21.         OutputStream out = s.getOutputStream();  
  22.         out.write("收到数据,你也好！".getBytes());  
  23.         s.close();  
  24.         ss.close();  
  25.     }  
  26. }  
定义了一个TCP的客户端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.io.OutputStream;  
  5. import java.net.Socket;  
  6. import java.net.UnknownHostException;  
  7. /** 
  8.  * 演示tcp的传输的客户端和服务器端的互访。 
  9.  * @author wl-pc 
  10.  * 需求是：客户端给服务端发送数据，服务器 
  11.  * 端收到数据后，给客户端反馈信息 
  12.  */  
  13. /** 
  14.  * 客户端步骤： 
  15.  *    1）建立socket服务，指定要连接的主机和端口 
  16.  *    2）获取socket流中输出流，将数据写到该流中 
  17.  *       通过网络发送到服务器端 
  18.  *    3）获取socket流中输入流，将服务端反馈的数 
  19.  *       据获取到并打印到控制台上 
  20.  *    4）关闭客户端资源 
  21. */  
  22. public class TcpClient2 {  
  23.     public static void main(String[] args) throws UnknownHostException, IOException {  
  24.         Socket s = new Socket("127.0.0.1",10007);  
  25.         OutputStream out =s.getOutputStream();  
  26.         out.write("服务端，你好".getBytes());  
  27.         InputStream in = s.getInputStream();  
  28.         byte[] buf = new byte[1024];  
  29.         int len = in.read(buf);  
  30.         System.out.println(new String(buf,0,len));  
  31.         s.close();  
  32.     }  
  33. }  
例子6：建立一个文本转换服务器，客户端给服务器端发送文本，然后服务器端将文件转成大写，再返回给客户端，而且客服端可以不断的进行文本转换，当客户端输入over时转换就结束了。定义了一个TCP的服务器端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.BufferedReader;  
  3. import java.io.BufferedWriter;  
  4. import java.io.IOException;  
  5. import java.io.InputStreamReader;  
  6. import java.io.OutputStreamWriter;  
  7. import java.net.ServerSocket;  
  8. import java.net.Socket;  
  9. /** 
  10.  * 服务端： 
  11.  * 源：socket读取流 
  12.  * 目的：socket输出流 
  13.  * @author wl-pc 
  14.  * 都是文本数据并且需要装饰 
  15.  */  
  16. public class TransServer {  
  17.     public static void main(String[] args) throws IOException {  
  18.         ServerSocket ss = new ServerSocket(4002);  
  19.         Socket s = ss.accept();  
  20.         String ip = s.getInetAddress().getHostAddress();  
  21.         System.out.println(ip+"....conneted");  
  22.         //读取socket读取流中的数据  
  23.         BufferedReader bufIn =new BufferedReader(new InputStreamReader(s.getInputStream()));  
  24.         //socket输出流中，并且要转换成大写字母再写入到socket输出流，并发送给客户端  
  25.         BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
  26.         String line = null;  
  27.         while((line=bufIn.readLine())!=null){  //readLine()阻塞式方法  
  28.             bufOut.write(line.toUpperCase());  
  29.             bufOut.newLine();  //跨平台换行  
  30.             bufOut.flush();  //刷新数据  
  31.         }  
  32.         s.close();  
  33.         ss.close();  
  34.     }  
  35. }  
定义了一个TCP的客户端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.BufferedReader;  
  3. import java.io.BufferedWriter;  
  4. import java.io.IOException;  
  5. import java.io.InputStreamReader;  
  6. import java.io.OutputStreamWriter;  
  7. import java.net.Socket;  
  8. /** 
  9.  * 需求：建立一个文本转换服务器 
  10.  * 客户端给服务器端发送文本，然后服务器端将文件转成大写 
  11.  * 再返回给客户端，而且客服端可以不断的进行文本转换，当 
  12.  * 客户端输入over时转换就结束了 
  13.  * @author wl-pc 
  14.  * 分析： 
  15.  * 客服端： 
  16.  * 既然是操作设备上的数据，就可以使用IO技术，按照IO的操作 
  17.  * 规律来思考，对于客服端来讲，源：键盘录入。 
  18.  * 目的：网络设备（网络输出流），而且操作的是文本数据， 
  19.  * 是文本数据可以选择字符流， 
  20.  * 步骤： 
  21.  *    1）建立服务。 
  22.  *    2）获取键盘录入。 
  23.  *    3）将数据发给服务端。（重复操作） 
  24.  *    4）获取服务端返回的大写数据。（重复操作） 
  25.  *    5）结束，关闭资源。 
  26.  * 都是文本数据，可以用字符流进行操作。 
  27.  * 同时为了提高效率，加入了缓冲技术 
  28.  */  
  29. public class TransClient {  
  30.     public static void main(String[] args) throws IOException {  
  31.          Socket s = new Socket("127.0.0.1",4002);  
  32.          //定义读取键盘数据的流对象  
  33.          BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
  34.          //定义目的，将数据写入到socket输出流中，发给服务端  
  35.          BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
  36.          //定义一个socket读取流，读取服务端反馈的大写信息  
  37.          BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
  38.          String line = null;   
  39.          while((line=bufr.readLine())!=null){  
  40.              if("over".equals(line))  
  41.                  break;  
  42.              //往服务器端写入要转换的信息  
  43.              bufOut.write(line);  
  44.              bufOut.newLine();  
  45.              bufOut.flush();  //刷新数据  
  46.              //读出转换后的大写信息  
  47.              String str = bufIn.readLine();  
  48.              System.out.println("server::"+str);  
  49.          }  
  50.          bufr.close();  
  51.          s.close();     
  52.     }  
  53. }  
  54. /** 
  55.  * 该例子出现的问题。 
  56.  * 现象：客户端和服务端都在莫名的等待，这是为什么？ 
  57.  * 因为客户端和服 务器端都有阻塞式的方法，这些方法没有 
  58.  * 读到结束标记，那么就一直等，而导致两端，都在等待， 
  59.  * 解决方法：就查看阻塞式方法的地方，因为这个地方时 
  60.  * 容易出错的地方。 
  61.  */  
例子7：上传文件到一个文件夹下。定义了一个TCP的服务器端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.BufferedReader;  
  3. import java.io.FileWriter;  
  4. import java.io.IOException;  
  5. import java.io.InputStreamReader;  
  6. import java.io.PrintWriter;  
  7. import java.net.ServerSocket;  
  8. import java.net.Socket;  
  9. public class TextServer {  
  10.     public static void main(String[] args) throws IOException {  
  11.          ServerSocket ss = new ServerSocket(4006);  
  12.          Socket s = ss.accept();  
  13.          String ip = s.getInetAddress().getHostAddress();  
  14.          System.out.println(ip+".....conneted");  
  15.          BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
  16.          PrintWriter out = new PrintWriter(new FileWriter("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day06\\server.txt"),true);  
  17.          String line = null;  
  18.          while((line=bufIn.readLine())!=null){  
  19.              out.println(line);  
  20.          }  
  21.          s.shutdownOutput();  //关闭客户端的输出流，相当于给流中加一个结束标记  ：-1  
  22.          PrintWriter pw = new PrintWriter(s.getOutputStream(),true);  
  23.          pw.println("上传成功！");  
  24.          out.close();  
  25.          s.close();  
  26.          ss.close();  
  27.     }  
  28. }  
定义了一个TCP的客户端：
[java] view plain copy
 
  1. package cn.itheima.day06;  
  2. import java.io.BufferedReader;  
  3. import java.io.FileReader;  
  4. import java.io.IOException;  
  5. import java.io.InputStreamReader;  
  6. import java.io.PrintWriter;  
  7. import java.net.Socket;  
  8. import java.net.UnknownHostException;  
  9. public class TextClient {  
  10.     public static void main(String[] args) throws UnknownHostException, IOException {  
  11.         Socket s = new Socket("127.0.0.1",4006);  
  12.         BufferedReader bufr = new BufferedReader(new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day06\\client.txt"));  
  13.         PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
  14.         //out.println(time);  
  15.         String line = null;  
  16.         while((line = bufr.readLine())!=null){  
  17.             out.println(line);  
  18.         }  
  19.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
  20.         String str = bufIn.readLine();  
  21.         System.out.println(str);  
  22.         bufr.close();  
  23.         s.close();  
  24.     }  
  25. }  
例子8：上传图片。定义了一个TCP的服务器端：
[java] view plain copy
 
  1. package cn.itheima.day07;  
  2. import java.io.FileOutputStream;  
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.io.OutputStream;  
  6. import java.net.ServerSocket;  
  7. import java.net.Socket;  
  8. public class PicServer {  
  9.     public static void main(String[] args) throws IOException {  
  10.         ServerSocket ss = new ServerSocket(4007);  
  11.         Socket s = ss.accept();  
  12.         InputStream in = s.getInputStream();  
  13.         FileOutputStream fos = new FileOutputStream("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day07\\server.jpg");  
  14.         byte[] buf = new byte[1024];  
  15.         int len = 0;  
  16.         while((len=in.read(buf))!=-1){  
  17.             fos.write(buf,0,len);  
  18.         }  
  19.         OutputStream out = s.getOutputStream();  
  20.         out.write("上传成功！".getBytes());  
  21.         fos.close();  
  22.         s.close();  
  23.         ss.close();  
  24.     }  
  25. }  
定义了一个TCP的客户端：
[java] view plain copy
 
  1. package cn.itheima.day07;  
  2. import java.io.FileInputStream;  
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.io.OutputStream;  
  6. import java.net.Socket;  
  7. import java.net.UnknownHostException;  
  8. /** 
  9.  * 需求：上传图片 
  10.  */  
  11. /** 
  12.  * 客户端： 
  13.  * 步骤： 
  14.  *    1）服务端点 
  15.  *    2）读取客户端已有的一个图像数据 
  16.  *    3）通过socket输出流将数据发给服务端 
  17.  *    4）读取服务器端的反馈信息 
  18.  *    5）关闭资源 
  19.  */  
  20. public class PicClient {  
  21.     public static void main(String[] args) throws UnknownHostException, IOException {  
  22.         Socket s = new Socket("127.0.0.1",4007);  
  23.         FileInputStream fis = new FileInputStream("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day07\\1.jpg");  
  24.         OutputStream out = s.getOutputStream();  
  25.         byte[] buf = new byte[1024];  
  26.         int len = 0;  
  27.         while((len=fis.read(buf))!=-1){  
  28.             out.write(buf,0,len);  
  29.         }  
  30.         s.shutdownOutput(); //告诉客户端数据已经写完  
  31.         InputStream in =s.getInputStream();  
  32.         byte[] bufIn = new byte[1024];  
  33.         int num = in.read(bufIn);  
  34.         System.out.println(new String(bufIn,0,num));  
  35.         fis.close();  
  36.         s.close();  
  37.     }  
  38. }  
例子9:改写例子8中的程序，要求多人可以上传图片到服务器端。定义了一个TCP的服务器端：
[java] view plain copy
 
  1. package cn.itheima.day07;  
  2. import java.io.File;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.io.OutputStream;  
  7. import java.net.ServerSocket;  
  8. import java.net.Socket;  
  9. /** 
  10.  * 这个服务端有个局限性：当A客户连接上时，被服务端获取到， 
  11.  * 服务端执行具体执行流程，这时B客户连接时，连不上，只有 
  12.  * 等待，因为服务器端还没有处理完A的请求，还没有循环回来 
  13.  * 执行下一次的accept()方法，所以暂时获取不到B客户对象。 
  14.  * @author wl-pc 
  15.  * 那么为了可以让多个客户端同时并发访问服务端，那么服务端 
  16.  * 最好是将每个客户端封装到一个单独的线程中，这样，就可以 
  17.  * 同时处理多个客户端请求。 
  18.  *  
  19.  * 那么如何定义线程呢？ 
  20.  * 只要明确了每一个客户端要在服务端执行的代码即可，将代码 
  21.  * 写在run()方法中即可。 
  22.  */  
  23. class PicThread implements Runnable{  
  24.     private Socket s;  
  25.     PicThread(Socket s) {  
  26.         this.s=s;  
  27.     }  
  28.     @Override  
  29.     public void run() {  
  30.         int count = 1;  
  31.         String ip = s.getInetAddress().getHostAddress();  
  32.         try {  
  33.             System.out.println(ip+".....connected");  
  34.             InputStream in = s.getInputStream();  
  35.             File file = new File("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day07\\"+ip+"("+(count)+")"+".jpg");  
  36.             while(file.exists()){  
  37.                 file = new File("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day07\\"+ip+"("+(count++)+")"+".jpg");  
  38.             }  
  39.             FileOutputStream fos = new FileOutputStream(file);  
  40.             byte[] buf = new byte[1024];  
  41.             int len = 0;  
  42.             while((len=in.read(buf))!=-1){  
  43.                 fos.write(buf,0,len);  
  44.                 fos.flush();  
  45.             }  
  46.             OutputStream out = s.getOutputStream();  
  47.             out.write("上传成功！".getBytes());  
  48.             fos.close();  
  49.             s.close();  
  50.         } catch (Exception e) {  
  51.             throw new RuntimeException(ip+"上传失败！");  
  52.         }   
  53.     }  
  54. }  
  55. public class PicServer {  
  56.     public static void main(String[] args) throws IOException {  
  57.         ServerSocket ss = new ServerSocket(4008);  
  58.         while(true){  //本意要实现多人上传图片到服务器端（但是此种方法是不可取的）  
  59.            Socket s = ss.accept(); //accept()是阻塞式方法  
  60.            new Thread(new PicThread(s)).start();   //利用多线程实现同时上传的功能。  
  61.         }  
  62.         //ss.close();  
  63.     }  
  64. }  
定义了一个TCP的客户端：
[java] view plain copy
 
  1. package cn.itheima.day07;  
  2. import java.io.File;  
  3. import java.io.FileInputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.io.OutputStream;  
  7. import java.net.Socket;  
  8. import java.net.UnknownHostException  
  9. /** 
  10.  * 需求：上传图片 
  11.  */  
  12. /** 
  13.  * 客户端： 
  14.  * 步骤： 
  15.  *    1）服务端点 
  16.  *    2）读取客户端已有的一个图像数据 
  17.  *    3）通过socket输出流将数据发给服务端 
  18.  *    4）读取服务器端的反馈信息 
  19.  *    5）关闭资源 
  20.  */  
  21. public class PicClient {  
  22.     public static void main(String[] args) throws UnknownHostException, IOException {  
  23.         if(args.length!=1){  
  24.             System.out.println("请选择一个jpg格式的图片");  
  25.             return;  
  26.         }  
  27.         File file = new File(args[0]);  
  28.         if(!file.exists()&&file.isFile()){  
  29.             System.out.println("该文件有问题，要么是不存在，要么是有问题！");  
  30.             return;  
  31.         }  
  32.         if(!file.getName().endsWith(".jpg")){  
  33.             System.out.println("图片格式错误，请重新选择！");  
  34.             return;  
  35.         }  
  36.         if(file.length()>1024*1024*5){  
  37.             System.out.println("上传的文件过大！");  
  38.             return;  
  39.         }  
  40.         Socket s = new Socket("127.0.0.1",4008);  
  41.         FileInputStream fis = new FileInputStream(file);  
  42.         OutputStream out = s.getOutputStream();  
  43.         byte[] buf = new byte[1024];  
  44.         int len = 0;  
  45.         while((len=fis.read(buf))!=-1){  
  46.             out.write(buf,0,len);  
  47.         }  
  48.         s.shutdownOutput(); //告诉客户端数据已经写完  
  49.         InputStream in =s.getInputStream();  
  50.         byte[] bufIn = new byte[1024];  
  51.         int num = in.read(bufIn);  
  52.         System.out.println(new String(bufIn,0,num));  
  53.         fis.close();  
  54.         s.close();  
  55.     }  
  56. }  

例子10：用户登录的小例子。需求：客户端通过键盘录入用户名，服务器端对这个用户名进行校验。如果该用户名存在，在服务器端显示xxxx，已登录。并在客户端显示xxx，欢迎光临。如果该用户不存在，在服务器端显示xxxx，尝试登陆。并在客户端显示xxxx，该用户不存在。最多登陆3次，3次后结束。定义服务器端：
[java] view plain copy
 
  1. package cn.itheima.day07;  
  2. import java.io.BufferedReader;  
  3. import java.io.FileReader;  
  4. import java.io.IOException;  
  5. import java.io.InputStreamReader;  
  6. import java.io.PrintWriter;  
  7. import java.net.ServerSocket;  
  8. import java.net.Socket;  
  9. class UserThread implements Runnable{  
  10.     private Socket s;  
  11.     UserThread(Socket s){  
  12.         this.s = s;  
  13.     }  
  14.     @Override  
  15.     public void run() {  
  16.         String ip =s.getInetAddress().getHostAddress();  
  17.         System.out.println(ip+"....conneted");  
  18.         try {  
  19.             for(int i=0;i<3;i++){  
  20.                 BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
  21.                 String name = bufIn.readLine();  
  22.                 if(name==null)  
  23.                     break;  
  24.                 BufferedReader bufr = new BufferedReader(new FileReader("F:\\Javajichu\\JavaLianXi\\src\\cn\\itheima\\day07\\user.txt"));  
  25.                 PrintWriter out =new PrintWriter(s.getOutputStream()，true);  
  26.                 String line = null;  
  27.                 boolean flag = false;  
  28.                 while((line=bufr.readLine())!=null){  
  29.                     if(line.equals(name)){  
  30.                         flag = true;  
  31.                         break;  
  32.                     }  
  33.                 }  
  34.                 if(flag){  
  35.                     System.out.println(name+",已经登陆！");  
  36.                     out.println(name+",欢迎光临");  
  37.                     break;  
  38.                 }else{  
  39.                     System.out.println(name+",尝试登陆！");  
  40.                     out.println(name+",该用户名不存在！");  
  41.                 }  
  42.             }  
  43.             s.close();  
  44.         } catch (Exception e) {  
  45.             throw new RuntimeException(ip+"校验失败！");  
  46.         }  
  47.     }  
  48.       
  49. }  
  50. public class LoginServer {  
  51.     public static void main(String[] args) throws IOException {  
  52.         ServerSocket ss = new ServerSocket(4013);  
  53.         while(true){  
  54.             Socket s = ss.accept();  
  55.             new Thread(new UserThread(s)).start();  
  56.         }  
  57.     }  
  58. }  
定义客户端：
[java] view plain copy
 
  1. package cn.itheima.day07;  
  2. import java.io.BufferedReader;  
  3. import java.io.IOException;  
  4. import java.io.InputStreamReader;  
  5. import java.io.PrintWriter;  
  6. import java.net.Socket;  
  7. import java.net.UnknownHostException;  
  8. /** 
  9.  * 客户端通过键盘录入用户名 
  10.  * 服务器端对这个用户名进行校验。 
  11.  * 如果该用户名存在，在服务器端显示xxxx，已登录。 
  12.  * 并在客户端显示xxx，欢迎光临。 
  13.  * 如果该用户不存在，在服务器端显示xxxx，尝试登陆。 
  14.  * 并在客户端显示xxxx，该用户不存在。 
  15.  * 最多登陆3次，3次后结束。 
  16.  * @author wl-pc 
  17. */  
  18. public class LoginClient {  
  19.     public static void main(String[] args) throws UnknownHostException, IOException {  
  20.          Socket s = new Socket("127.0.0.1",4013);  
  21.          //用于接收客户端的输入的信息  
  22.          BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
  23.          PrintWriter out =new PrintWriter(s.getOutputStream(),true);  
  24.          //反馈服务器端发来的反馈信息  
  25.          BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
  26.          for(int i=0;i<3;i++){  
  27.              String line = bufr.readLine();  
  28.              if(line==null)  
  29.                  break;  
  30.              out.println(line);  
  31.              String info = bufIn.readLine();  
  32.              System.out.println("info:"+info);  
  33.              if(info.contains("欢迎"))  //包含欢迎字符，就停止  
  34.                  break;  
  35.          }  
  36.          bufr.close();  
  37.          s.close();  
  38.     }  
  39. }  
例子11. 客服端用本机上的浏览器，而服务端是自己定义的。
[java] view plain copy
 
  1. package cn.itheima.day07;  
  2. import java.io.IOException;  
  3. import java.io.PrintWriter;  
  4. import java.net.ServerSocket;  
  5. import java.net.Socket;  
  6. /** 
  7.  * 演示：客户端和服务端 
  8.  * 1.客服端浏览器 
  9.  *   服务端自定义 
  10.  * @author wl-pc 
  11.  */  
  12. public class ServerDemo {  
  13.     public static void main(String[] args) throws IOException {  
  14.          ServerSocket ss = new ServerSocket(4016);  
  15.          Socket s = ss.accept();  
  16.          String ip = s.getInetAddress().getHostAddress();  
  17.          System.out.println(ip+".....connected");  
  18.          PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
  19.          out.println("客户端你好！");  
  20.          s.close();  
  21.          ss.close();  
  22.     }  
  23. }  

例子12.自定义IE浏览器。

[java] view plain copy
  1. package cn.itheima.day07;  
  2. import java.io.BufferedReader;  
  3. import java.io.IOException;  
  4. import java.io.InputStreamReader;  
  5. import java.io.PrintWriter;  
  6. import java.net.Socket;  
  7. import java.net.UnknownHostException;  
  8. public class MyIE {  
  9.     public static void main(String[] args) throws UnknownHostException, IOException {  
  10.          Socket s = new Socket("127.0.0.1",8080);  
  11.          PrintWriter out = new PrintWriter(s.getOutputStream(),true);  
  12.          out.println("GET /myweb/demo.html HTTP/1.1");  
  13.          out.println("Accept: */*");  
  14.          out.println("Accept-Language: zh-CN");  
  15.          out.println("Host: 127.0.0.1:4016");  
  16.          out.println("Connection: Keep-Alive");  
  17.          out.println();  
  18.          out.println();  
  19.          BufferedReader bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));  
  20.          String line = null;  
  21.          while((line = bufr.readLine())!=null){  
  22.              System.out.println(line);  
  23.          }  
  24.          s.close();  
  25.     }  
  26. }  

例子13.URL链接对象
[java] view plain copy
 
  1. package cn.itheima.day07;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.net.URL;  
  5. import java.net.URLConnection;  
  6. public class URLConnetctionDemo {  
  7.     public static void main(String[] args) throws IOException {  
  8.         URL url = new URL("http://127.0.0.1:8080/myweb/demo.html");  
  9.         URLConnection conn = url.openConnection();//打开连接。其实内部封装就是Socket  
  10.         System.out.println(conn);  
  11.         InputStream in = conn.getInputStream();//其实使用就是Socket类中的getInputStream  
  12.         byte[] buf = new byte[1024];  
  13.         int len = in.read(buf);  
  14.         System.out.println(new String(buf,0,len));  
  15.     }  
  16. }  
例子14.自定义GUI的IE浏览器。
[java] view plain copy
 
  1. import java.awt.*;  
  2. import java.awt.event.*;  
  3. import java.io.*;  
  4. import java.net.*;  
  5. class MyWindow  
  6. {  
  7.     private Frame f;  
  8.     private TextField tf;  
  9.     private Button but;  
  10.     private TextArea ta;  
  11.     MyWindow()  
  12.     {  
  13.         init();  
  14.     }  
  15.     public void init()  
  16.     {  
  17.         f = new Frame("my window");  
  18.         f.setSize(500,500);  
  19.         f.setLocation(400,100);  
  20.         f.setLayout(new FlowLayout());  
  21.         tf = new TextField(40);  
  22.         but = new Button("转 到");  
  23.         ta = new TextArea(25,60);  
  24.         f.add(tf);  
  25.         f.add(but);  
  26.         f.add(ta);  
  27.         myEvent();  
  28.         f.setVisible(true);  
  29.     }  
  30.     private void myEvent()  
  31.     {  
  32.         tf.addKeyListener(new KeyAdapter()  
  33.         {  
  34.             public void keyPressed(KeyEvent e)  
  35.             {  
  36.                 if(e.getKeyCode()==KeyEvent.VK_ENTER)  
  37.                     showWeb();  
  38.             }  
  39.         });  
  40.         but.addActionListener(new ActionListener()  
  41.         {  
  42.             public void actionPerformed(ActionEvent e)  
  43.             {  
  44.                 showWeb();  
  45.             }  
  46.         });  
  47.         f.addWindowListener(new WindowAdapter()  
  48.         {  
  49.             public void windowClosing(WindowEvent e)  
  50.             {  
  51.                 System.exit(0);  
  52.             }  
  53.         });  
  54.     }  
  55.     private void showWeb()  
  56.     {  
  57.         String str_url = tf.getText();  
  58.         try  
  59.         {  
  60.          //URI要比URL的范围大  
  61.         URL url = new URL(str_url);  
  62.         URLConnection conn = url.openConnection();//打开连接。其实内部封装就是Socket  
  63.         //System.out.println(conn);  
  64.         ta.setText("");  
  65.     InputStream in = conn.getInputStream();//其实使用就是Socket类中的getInputStream  
  66.         byte[] buf = new byte[1024];  
  67.         int len = in.read(buf);  
  68.         ta.append(new String(buf,0,len));  
  69.         /* 
  70.         String host = url.getHost(); 
  71.         int port = url.getPort(); 
  72.         String path = url.getPath(); 
  73.         Socket s = new Socket(host,port); 
  74.         PrintWriter out = new PrintWriter(s.getOutputStream(),true); 
  75.         out.println("GET "+path+" HTTP/1.1"); 
  76.         out.println("Accept: *"); 
  77.         out.println("Host: 192.168.54.9:8080"); 
  78.         out.println("Connection: close"); 
  79.         out.println(); 
  80.         ta.setText(""); 
  81.         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream())); 
  82.         String line = null; 
  83.         while((line=bufIn.readLine())!=null) 
  84.         { 
  85.             ta.append(line+"\r\n"); 
  86.         } 
  87.         s.close(); 
  88.         */  
  89.         }  
  90.         catch (Exception e)  
  91.         {  
  92.             e.printStackTrace();  
  93.         }  
  94.     }  
  95. }  
  96. class MyIEByGUI   
  97. {  
  98.     public static void main(String[] args)   
  99.     {  
  100.         new MyWindow();  
  101.     }  
  102. }  
  103. //http://192.168.54.9:8080/myweb/1.html  
阅读全文
0 0
北邮人文学院知乎 北邮人文学院知乎
原创粉丝点击
热门IT博客
清纯又妩媚的长相知乎清纯又妩媚的长相知乎
淘宝如何申请售后淘宝如何申请售后
nfc软件读取银行卡
淘宝美工兼职招聘
cnc编程教学下载
java 判断类型相同
如何设置淘宝分流
淘宝联盟pid怎么获取
java final 修饰类
东莞东莞菲凡网络
淘宝双十一红包不中
好工长之家 知乎
ubuntu中查看文件夹
美工做好图怎么上传
gvim python
商标图案设计软件
mac上类似美图秀秀
海康网络监控安装教程
linux 数据库
欧文16年总决赛数据
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 改装雾灯 汽车前雾灯标志 雾灯总成 科鲁兹雾灯怎么开 新宝来雾灯 捷达车雾灯怎么开 前雾灯开关 新轩逸雾灯怎么开 奥德赛雾灯 福克斯雾灯怎么开 雾灯是哪个 汽车前后雾灯标志 桑塔纳雾灯怎么开 哪个是雾灯 英朗雾灯 汽车防雾灯标志 雾灯在哪 如何开雾灯 欧司朗雾灯 夏利n3雾灯 除雾灯 车雾灯 颐达雾灯 雾灯怎么打开 新宝来前雾灯 雨燕雾灯 开雾灯 雾灯颜色 福美来三代雾灯 汽车雾灯电路图 雾灯在哪里 怎样开启雾灯 逸致前雾灯 威驰加装雾灯 雾灯怎么开启 桑塔纳雾灯 polo雾灯怎么开 凯美瑞雾灯改装 途观雾灯 荣威350前雾灯 三菱翼神雾灯

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里