Java之网络编程

最新推荐文章于 2025-07-02 16:47:19 发布

GarfieldEr007

最新推荐文章于 2025-07-02 16:47:19 发布

阅读量1.3k

点赞数

分类专栏： Java 文章标签： Java 网络编程

Java 专栏收录该内容

673 篇文章

订阅专栏

概述

网络编程其实是为了实现不同主机上的数据通信，而要实现通讯则需要首先知道对方的IP和端口号，同时明确双方使用的通信规则，或传输协议。

Ip地址、端口号和传输协议，即是网络通讯的三要素

IP地址：主机在网络的地址，或者在网上的唯一标识。

127.0.0.1，本地回环地址，用它可以测试网卡是否损坏；还有些IP地址保留了，不用于广域网，只用于局域网，例如：192.168.0.1~255,192.168.1.1~255等。

端口号：数据要发送到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识，为了方便称呼这个数字，就这个数组叫为“端口”，或“逻辑端口”，它并没有物理实体与之对应。有效端口好从0~65535，其中0~1024是系统保留的。一些常用程序的默认端口：浏览器80端口，TomCat服务器8080端口，MySQL的3306端口。

通信规则：即传输协议，国际组织定义的通用协议是TCP/IP。TCP/IP既能用于局域网，也能用于广域网。除了TCP/IP，还有其他的协议,例如UDP、FTP、HTTP等。

网络模型

主要由两个OSI和TCP/IP模型，其分层情况如下：

TCP和UDP在传输层。IP协议在网络层。FTP协议、HTTP协议在应用层。

数据封包：数据从应用层开始，每经过一层都加入该层的标识信息，直到物理层，这个过程就叫数据封包。之后变成二进制01数据从物理设备上传输。

数据拆包：与封包过程正好相反，指去掉每层的标识信息，获取数据的过程。

网络编程：现阶段主要是在网际层和传输层。而javaWeb开发主要是在应用层。

Java中，对各个层都创建了有对象与之对应，以方便我们的开发使用。下边主要学习传输层的一些对象，比如InetAddress、Socket、DatagramSocket。

IP地址

IP地址是数字，使用时不容易记忆，所以有与这个地址名想对应的主机名。主机名与IP地址相对应。

体系结构：

|----InetAddress

|----Inet4Address,

|----Inet6Address

InetAddress中没有提供构造函数，但它提供了多种静态方法，以获取本类对象。

Socket地址

装的是带端口号的IP地址

|——SocketAddress

|———InetSocketAddress

程序示例：

[java]view plaincopy 
   
print?
 import java.net.*;    
 class  IPDemo    
 {    
     public static void main(String[] args) throws Exception    
     {    
 /*  
  *      //下边这句话会报未知主机异常  
  *      //获取本地主机IP地址  
         InetAddress i= InetAddress.getLocalHost();  
           
         System.out.println(i.toString());  
         String adr = i.getHostAddress();  
         String name = i.getHostName();  
         sop("adr="+adr+" name="+name);  
 */          
         //获取其他主机IP地址    
         //通过主机名获取IP地址，需要解析，所以较慢，而且对于百度、新浪这样的主机名，获得的IP地址可能不唯一。    
         InetAddress i= InetAddress.getByName("www.sina.com");    
             
         System.out.println(i.toString());    
         String adr = i.getHostAddress();//获得IP地址的字符串表现形式    
         String name = i.getHostName();//获取主机名    
         sop("adr="+adr+" name="+name);    
     
     
     }    
     public static void sop(Object obj)    
     {    
         System.out.println(obj);    
     }    
 }   

TCP和UDP

TCP和UDP都是在网络传输层

TCP和UDP的区别【重要】

UDP：是面向无连接的，它将数据集源和目的封装成数据包中，不需要建立连接；它的每个数据报（Datagram）的大小限制在64k以内；因为无连接，是不可靠的协议；同样因为不需要建立里连接，所以速度快。

应用特点：只求速度快，数据丢失对程序影响不大。

应用程序实例：聊天室工具、视频、网络会议等。

TCP：需要建立连接，形成传输数据的通道；在连接中进行大量数据传输；通过三次握手协议完成连接，是可靠的协议；因为必须建立连接，所以效率会稍低。（TCP不像UDP需要封包，而且每个包不能超过64k，它可以大量的传输数据）。

应用特点：适合对数据完整性要求高的程序。

应用程序实例：下载程序。

Socket

网络编程其实就Socket编程，Socket是为网络服务的一种机制。（Socket，中文意思为插座）

每个应用程序都有一个socket信端点，可以把Socket想象为每个应用程序上的码头。

通信的两端都有Socket，网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。

UDP传输

UDP两端是发送端和接受端。

DatagramSocket：UDP传输专用的程序通信端点，既能发送也能接受。
DatagramPacket：数据报包，封装了UDP传输的数据报。里边可以设置要发送的目的地IP地址、端口及要发送的数据。

广播地址：每个网段尾数为255的IP地址，例如192.168.1.255

代码示例：

1、发送端

[java]view plaincopy 
   
print?
 /* 
 需求：通过Udp传输方式，将一段文字数据发送出去。 
 定义一个udp发送端。 
 思路： 
 1。建立UDPsocket服务。 
 2.提供数据，并将数据封装到数据包中。 
 3.通过socket服务的发送功能，将数据包发出去。 
 4.关闭资源。 
 */  
 import java.net.*;  
 class UdpSend   
 {  
     public static void main(String[] args) throws Exception  
     {  
         //1.创建UDP服务，通过DatagramSocket对象。  
         DatagramSocket ds = new DatagramSocket(8888);  
         //2.确定数据，并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress address, int port)   
         byte[] buf = "这是通过UDP发送的数据!".getBytes();  
         DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),10000);  
         //3.通过socket服务，将已有的数据包发送出去，通过send方法。      
         ds.send(dp);  
         //4.关闭资源。它使用了底层的资源，所以要关闭资源。  
         ds.close();  
   
     }  
 }  

2、接收端

[java]view plaincopy 
   
print?
 /* 
 需求； 
 定义一个应用程序，用于接收并处理数据。 
  
 定义udp接收端 
 思路： 
 1.定义socket服务，通常会监听一个端口，其实就是给这个接受网络应用程序定义一个数字标示。 
     方便与明确哪些数据过来该应用程序可以处理。 
 2.定义一个数据包，因为要存储要接受到的字节数据， 
 因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。 
 3.通过socket服务的receive方法将收到的数据存入已定义的数据包中。 
 4.通过数据包对象的特有功能，将这些不同的数据取出，打印在控制台上。 
 5.关闭资源。 
 */  
 import java.net.*;  
 class UdpRece  
 {  
     public static void main(String[] args) throws Exception  
     {  
         //1.创建udpsocket，建立端点。这里必须定义监听的端口，其实就是给网络应用程序定义数字标识。  
         DatagramSocket ds = new DatagramSocket(10000);  
         //2.定义数据包，用于存储数据。  
         byte [] buf = new byte[1024];         
         DatagramPacket dp = new DatagramPacket(buf,buf.length);  
         //3.通过服务的receive方法，将收到的数据存入到数据包中。     
         ds.receive(dp);//receive是一个阻塞式方法没有接受到数据，会一直等待  
         //4.获取数据包中的方法获取其中的数据。  
         InetAddress  i= dp.getAddress();  
         String ip = i.getHostAddress();  
         String  data = new String(dp.getData(),0,dp.getLength());  
         int port = dp.getPort();  
         System.out.println(ip+"::"+data+"::"+port);  
         //5、关闭资源  
         ds.close();  
     }  
 }  

改进：让接收端始终处于接收状态，发送端可以发送多条数据并以“over”结束

发送端：

[java]view plaincopy 
   
print?
 package tan;  
 import java.io.*;  
 import java.net.*;  
 public class UDPSend2 {  
     public static void main(String[] args) throws Exception{  
         DatagramSocket socket=new DatagramSocket();//可以不填写端口保持默认  
         //读取键盘录入···  
         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
       
         DatagramPacket dp=null;  
         String line=null;  
         while((line=br.readLine())!=null){  
             //聊天中输入over结束聊天  
             if("over".equals(line)){  
                 break;  
             }  
             byte[]buf=("sender:"+line).getBytes();  
              //192.168.1.255是这个网段的广播地址，用它就能实现局域网群聊。    
             InetAddress ip=InetAddress.getByName("127.0.0.1");  
             //打包数据  
             dp=new DatagramPacket(buf, buf.length,ip,10001);  
             //发送数据  
             socket.send(dp);  
         }  
           
         socket.close();  
           
           
           
     }  
 }  

接收端：

[java]view plaincopy 
   
print?
 package tan;  
 import java.io.*;  
 import java.net.*;  
 public class UDPRec2 {  
     public static void main(String[] args) throws Exception {  
         DatagramSocket ds=new DatagramSocket(10001);  
         byte []buf=new byte[64];  
         DatagramPacket dp=new DatagramPacket(buf, buf.length);  
         //无限循环，始终处于接收状态  
         while(true){  
             ds.receive(dp);  
             String ip=dp.getAddress().getHostAddress();  
             int port=dp.getPort();  
             String data=new String(dp.getData(),0,dp.getLength());  
             System.out.println("IP"+ip+":"+port+":"+data);  
         }  
     }  
 }  

UDP练习：聊天程序

[java]view plaincopy 
    
print?
 package tan;  
 import java.io.*;  
 import java.net.*;  
   
 class Send implements Runnable{  
     private DatagramSocket ds;  
     public Send(DatagramSocket ds) {  
         this.ds=ds;  
     }  
     @Override  
     public void run() {  
         try {  
             ds=new DatagramSocket();  
             BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));  
             String line=null;  
             while((line=bufr.readLine())!=null){  
                 if("over".equals(line)){  
                     break;  
                 }  
                 byte []buf=line.getBytes();  
                 DatagramPacket dp=new DatagramPacket(buf, 0,buf.length,InetAddress.getByName("127.0.0.1"),10002);  
                 ds.send(dp);  
                   
             }  
             ds.close();  
         } catch (Exception e) {  
             throw new RuntimeException("发送端发送失败！");  
         }  
           
     }  
 }  
   
   
 class Receive implements Runnable{  
     private DatagramSocket ds;  
     public Receive(DatagramSocket ds) {  
         this.ds=ds;  
     }  
     @Override  
     public void run() {  
         try {  
             while(true){  
                 byte []buf=new byte[1024];  
                 DatagramPacket dp=new DatagramPacket(buf, buf.length);  
                 ds.receive(dp);  
                 String ip=dp.getAddress().getHostAddress();  
                 String data=new String(dp.getData(),0,dp.getLength());  
                   
                 System.out.println("ip："+ip+" data:"+data);  
                   
                   
             }  
         } catch (Exception e) {  
             throw new RuntimeException("接收端失败！");  
         }  
           
     }  
 }  
   
   
 public class chatDemo {  
     public static void main(String[] args) throws Exception {  
         DatagramSocket sendSocket=new DatagramSocket();  
         new Thread(new Send(sendSocket)).start();  
           
         DatagramSocket receSocket=new DatagramSocket(10002);  
         new Thread(new Receive(receSocket)).start();  
     }  
 }  

TCP传输

TCP的两端对应的是客户端和服务端。

Socket：TCP传输客户端通信端点。

SeverSocket：TCP传输服务端通信端点。

因为TCP需要建立连接，所有Socket客户端一建立就要指定服务端的IP和端口。而在服务端建立时，要设置监听的端口。

TCP连接成功后，在客户端和服务端就会产生网络流。

客户端Socket提供对网络流进行读写的输入流和输出流对象。

服务端操作网络流时，先获取客户端Socket对象，然后利用该Socket的字节输入输出流进行读写操作。

客户端与服务端进行多次交互时，注意阻塞式方法对程序的影响。

ServerSocket(int port, int backlog),这个构造函数中backlog用于指定客户端的最大连接数。

TCP传输中的两个问题

一、客户端与服务端交互时同时阻塞

在示例代码3中，当客户端和服务端中都都有多个阻塞式方法时，如果使用缓冲区读取每行，没有刷新并加入换行符时，会导致客户端与服务端同时处于阻塞等待状态。

二、定义文件结束标记

在示例代码4中，当上传文件时，客户端把本地文件变成了IO流，并写入网络输出流时，因为去掉了去掉了window加入的结束标记，使得该IO流没有结束标记，导致服务端读取流中数据时，无法结束。这就需要自定义标记。
自定义标记有三种方法：

1.定义”over”这样的字符结束标记；

2.盖时间戳。

3.使用Socket的shutdownOutput( )和shutdownInput()方法。

示例代码1------给服务器发送一个文本

建立TCP客户端

[java]view plaincopy 
   
print?
 /*   
 客户端：   
 通过查阅Socket对象，发现在该对象建立时，就可以连接指定的主机。   
 因为TCP是面向连接的，所以在建立Socket服务时，就要有服务端存在，   
 并连接成功，形成通路后，在该通道进行数据的传输。   
    
 需求：给服务段发送一个文本数据。   
 步骤：   
 1.创建Socket服务，并指定要连接的主机和端口。   
    
 */    
 package TCP;  
 import java.io.*;  
 import java.net.*;  
 public class TCPClient {  
     public static void main(String[] args) throws Exception, IOException {  
         //1.创建客户端的Socket服务，指定目的主机和端口    
         Socket s=new Socket("127.0.0.1", 10003);  
         //2.为了发送数据，应该获取Socket流中的输出流。    
         OutputStream out=s.getOutputStream();  
         //3.获取输出流后写入数据  
         out.write("我是客户端~~".getBytes());  
          //socket关闭客户端Socket服务，也就关闭了网络流资源。    
         s.close();  
           
           
     }  
 }  

建立服务端：

[java]view plaincopy 
   
print?
 /*   
 服务端:   
 需求：定义端点，接受数据，并打印在控制台上。   
    
 服务端：   
 1.建立服务端的Socket服务，通过SeverSocket();并监听一个端口。   
 2. 获取连接过了的客户端对象。   
     通过SeverSocket的accept方法。没有就会等，所以这个方法是阻塞式的。   
 3.客户端如果发过了数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流读取发过了的数据。并打印在控制台上。   
 4.关闭服务。（可选操作，服务端一般是一直开着的）。   
 */    
 package TCP;  
 import java.io.*;  
 import java.net.*;  
   
 public class TCPServer {  
     public static void main(String[] args) throws Exception{  
     //1.建立服务端的Socket服务，通过SeverSocket();并监听一个端口。  
         ServerSocket ss=new ServerSocket(10003);  
     //2. 获取连接过了的客户端对象。 通过SeverSocket的accept方法。没有就会等，所以这个方法是阻塞式的。  
         Socket s=ss.accept();  
     //3.获取客户端发过来的数据，那么要使用客户端对象的读取流方法读取对象。这个流是网络流    
         InputStream is=s.getInputStream();  
         byte[]buf=new byte[1024];  
         int len=is.read(buf);  
         System.out.println(new String(buf, 0, buf.length));  
       
     //4.关闭客户端，服务端（可选）  
         s.close();  
           
         ss.close();//关闭服务端（可选）  
           
           
     }  
 }  
   
 //服务端接收到客户端的信息后并没有反馈信息  

示例代码2-------完成客户端与服务端的一次交互

演示tcp的传输的的客户端和服务端的互访。

需求：客户端给服务端发送数据，服务端收到数据后，给客户端反馈信息。

建立客户端程序：

[java]view plaincopy 
   
print?
 /*   
 客户端：   
 1.建立socket服务，指定要连接的主机和端口   
 1.获取Socket流中的输出流，将数据写入到该流中，通过网络发送给服务端。   
 3.获取socket流中的输入流，将服务端反馈的数据获取到，并打印，   
 4.关闭客户端资源。   
    
 */    
     
 package TCP;  
 import java.io.*;  
 import java.net.*;  
 public class TCPClient2 {  
     public static void main(String[] args) throws Exception {  
         Socket s=new Socket("127.0.0.1", 10004);  
         //利用输出流向服务器发出数据  
         OutputStream out=s.getOutputStream();  
         out.write("服务端你好！我是客户端".getBytes());  
         //利用输入流接收服务器返回的数据  
         InputStream in=s.getInputStream();  
         byte[]buf=new byte[1024];  
         int len=in.read(buf);//阻塞式方法，等待服务端返回信息  
         System.out.println(new String(buf,0,len));  
         s.close();  
           
     }  
 }  

建立服务端程序：

[java]view plaincopy 
   
print?
 package TCP;  
 import java.io.*;  
 import java.net.*;  
 public class TCPServer2 {  
     public static void main(String[] args) throws Exception {  
         ServerSocket ss=new ServerSocket(10004);  
         Socket s=ss.accept();  
         //获取客户端ip  
         String ip=s.getInetAddress().getHostAddress();  
         System.out.println(ip+"......is connected!");  
         //利用输入流接收客户端发送的信息  
         InputStream in=s.getInputStream();  
         byte []buf=new byte[1024];  
         int len=in.read(buf);  
         System.out.println(new String(buf, 0, len));  
         //利用输出流向客户端发送反馈信息  
         OutputStream out=s.getOutputStream();  
         out.write("你好客户端！我是服务端，已经接收到了你发送的数据".getBytes());  
           
         s.close();//关闭socket连接    
     }  
 }  

示例代码3------键盘录入数据通过服务端转成大写形式。

需求：建立一个文本转换服务器。
客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端。
而且，客户端可以不断的进行文本转换。当客户端输入over，转换就结束。

分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照IO的操作规律来思考。
源：键盘录入
目的：网络设备，也就是网络输出流，
而且操作的是文本数据，可以选择字符流。

步骤：
1，建立服务
2.获取键盘录入
3，将数据发给服务端。
4.获取服务端返回的大写数据。
5.结束，关闭资源。

都是文本数据，可以使用字符流进行操作。同时提高效率，要加入缓冲。

客户端代码：

[java]view plaincopy 
   
print?
 package TCP;  
 import java.io.*;  
 import java.net.*;  
   
 public class TransClient {  
     public static void main(String[] args) throws Exception {  
         //1.建立socket服务  
         Socket s=new Socket("127.0.0.1", 10005);  
         //2.读取键盘数据（获取键盘录入）  
         BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));  
         //3.定义目的，将数据写入socket输出流，发给服务器。  
         //BufferedWriter bufout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
         //代码简化：如下···  
         PrintWriter out=new PrintWriter(s.getOutputStream(),true);  
         //4.定义一个socket读取流，读取服务端返回的信息  
         BufferedReader bufin=new BufferedReader(new InputStreamReader(s.getInputStream()));  
         String line=null;  
         while((line=bufr.readLine())!=null){//阻塞位置1，等待键盘录入，没有数据则等待    
             if("over".equals(line)){  
                 break;  
             }  
 //          bufout.write(line);//写到缓冲区中去了  
 //          bufout.newLine();//换行，没有这一句，则阻塞2的readline不会返回字符，  
 //          bufout.flush();//没有这一句，则数据留在缓冲区中，阻塞2同样阻塞。  
               
             out.println(line);//打印流的println()方法可以实现自动刷新  
               
             String str=bufin.readLine();//阻塞位置3  
             System.out.println("server:"+str);  
               
         }  
         //5.关闭资源  
         bufr.close();  
         s.close();//给socket在加入结束标记（-1）  
           
     }  
 }  

服务端代码：

[java]view plaincopy 
   
print?
 /*  
 服务端：  
 源.socket读取流。  
 目的：socket输出流  
 都是文本，装饰  
 */   
 package TCP;  
 import java.io.*;  
 import java.net.*;  
 public class TransServer {  
     public static void main(String[] args) throws Exception {  
         ServerSocket ss=new ServerSocket(10005);  
         Socket s=ss.accept();  
         String ip=s.getInetAddress().getHostAddress();  
         System.out.println(ip+"....已经连接！");  
           
         BufferedReader bufin=new BufferedReader(new InputStreamReader(s.getInputStream()));  
           
 //      BufferedWriter bufout=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));  
         //简化书写：  
         PrintWriter out=new PrintWriter(s.getOutputStream(), true);  
       
         String line=null;//定义字符串来接收输出的数据  
           
 //      阻塞位置2，没有数据+换行符（win中是“\r\n”）则等待,尤其注意换行符    
         while((line=bufin.readLine())!=null){  
 //          bufout.write(line.toUpperCase());  
 //          bufout.newLine();  
 //          bufout.flush();  
             System.out.println(line);  
             out.println(line.toUpperCase());//小写转大写  
               
         }  
           
         s.close();  
         ss.close();   
     }  
 }  
 /*  
 该例子出现的问题：  
 现象：客户端和服务端都在莫名的等待。  
 为什么呢？  
 因为客户端和服务端都有阻塞式的方法，这些方法没有读到结束标记，那么就一直等。  
 而导致两端，都在等待。  
 */    

示例代码4------TCP上传文件（使用IO字符流）

把文件从客户端传到服务器端上。

容易出现的问题：没有客户端上传完后，文件结束标记，服务器无法停止连接Socket连接。

客户端代码：

[java]view plaincopy 
   
print?
 package TCP;  
 import java.io.*;  
 import java.net.*;  
 public class TextClient {  
     public static void main(String[] args) throws Exception {  
         Socket s=new Socket("127.0.0.1", 10006);  
           
         //源：封装成文件对象  
         BufferedReader bufr=new BufferedReader(new FileReader("TCPClient.java"));  
           
         //目的：通过打印流将文件写入到socket输出流中以便于服务端接收  
         //Attention:在上传文件前，最好先把文件名发给服务端   
         PrintWriter out=new PrintWriter(s.getOutputStream(), true);  
         String line=null;  
         while((line=bufr.readLine())!=null){  
             out.println(line);  
         }  
           
         s.shutdownOutput();//关闭客户端的输出流，相当于给流中加入一个结束标记 -1；   
           
         //读取来自服务端的socket输入流  
         BufferedReader bufin=new BufferedReader(new InputStreamReader(s.getInputStream()));  
         String str=bufin.readLine();  
         System.out.println("server:"+str);  
           
         //勿忘记关闭资源  
         bufr.close();  
         s.close();  
           
     }  
 }  

服务端代码：

[java]view plaincopy 
   
print?
 package TCP;  
 import java.io.*;  
 import java.net.*;  
 public class TextServer {  
     public static void main(String[] args) throws Exception {  
         ServerSocket ss=new ServerSocket(10006);  
         Socket s=ss.accept();  
           
         String ip=s.getInetAddress().getHostAddress();  
         System.out.println(ip+".....is connected ！");  
           
         //源：来自客户端发送的socket输入流  
         BufferedReader bufin=new BufferedReader(new InputStreamReader(s.getInputStream()));  
           
         //目的：将文字写入到server.txt中  
         PrintWriter out=new PrintWriter(new FileWriter("server.txt"),true);  
         String line=null;  
         while((line=bufin.readLine())!=null){  
             out.println(line);  
         }  
           
           
         //向客户端发送消息  
         PrintWriter pw=new PrintWriter(s.getOutputStream(),true);  
         pw.println("文件上传成功！");  
           
           
         //别忘了关闭资源  
         out.close();  
         s.close();  
         ss.close();  
     }  
 }  

示例代码5------TCP上传图片使用IO字符流）

客户端代码：

[java]view plaincopy 
    
print?
 /*客户端：  
 1.建立服务端点 
 2.读取客户端已有的图片数据  
 3.通过socket的输出流将数据发给服务端。  
 4.读取服务端反馈信息。  
 5.关闭。*/  

[java]view plaincopy 
    
print?
 package TCP;  
 import java.io.*;  
 import java.net.*;  
 public class PicClient {  
     public static void main(String[] args) throws Exception{  
         //建立socket服务  
         Socket s=new Socket("127.0.0.1", 10007);  
           
         //读取数据-->字节流  
         FileInputStream fis=new FileInputStream("1.jpg");  
         //输出数据-->获取socket输出流向服务端写数据  
         OutputStream out=s.getOutputStream();  
         byte []buf=new byte[1024];//定义缓冲区  
         int len=0; //字节长度  
         while((len=fis.read(buf))!=-1){  
             out.write(buf, 0, len);  
         }  
         s.shutdownOutput(); //告诉服务端已写完数据   
   
           
         //接受服务器发送的反馈信息  
         InputStream in=s.getInputStream();  
         byte[]bufin=new byte[1024];  
         int inLen=in.read(buf);  
         System.out.println("From Server:"+new String(buf, 0, inLen));  
           
           
         //关闭资源  
         fis.close();  
         s.close();  
   
     }  
 }  

服务端：

[java]view plaincopy 
    
print?
 package TCP;  
 import java.io.*;  
 import java.net.*;  
 public class PicServer {  
     public static void main(String[] args) throws Exception{  
         ServerSocket ss=new ServerSocket(10007);  
         Socket s=ss.accept();  
           
         String ip=s.getInetAddress().getHostAddress();  
         System.out.println(ip+"...... is connected!");  
           
         InputStream in=s.getInputStream();  
         FileOutputStream fos=new FileOutputStream("server.jpg");  
         byte[]buf=new byte[1024];  
         int len=0;  
         while((len=in.read())!=-1){  
             fos.write(buf, 0, len);  
         }  
           
         //向客户端发送消息（socket输出流）  
         OutputStream out=s.getOutputStream();  
         out.write("图片上传成功！".getBytes());  
           
         //关闭资源  
         fos.close();  
         s.close();  
         ss.close();  
           
           
           
           
     }  
 }  

TCP客户端并发访问

客户端并发访问服务器时，把服务端的处理代码封装在Runnable实现子类的run方法中，并把服务器获的的Socket对象传给该实现子类的构造函数。服务端通过while循环启动多个线程，对多个客户端请求进行并发处理。这也是一般服务器的基本原理。

示例代码6：上传图片（多客户端并发访问）

[java]view plaincopy 
    
print?
 /*客户端：  
 1.建立服务端点 
 2.读取客户端已有的图片数据  
 3.通过socket的输出流将数据发给服务端。  
 4.读取服务端反馈信息。  
 5.关闭。*/  
 package TCP;  
 import java.io.*;  
 import java.net.*;  
 public class PicClient {  
     public static void main(String[] args) throws Exception{  
     //过滤连接(演示要用DOS窗口)  
         //限定java命令传入的参数只有一个（主函数录入）  
         if(args.length!=1){  
             System.out.println("请选择一个jpg格式的图片");  
             return;  
         }  
         //判断是否是文件而不是目录  
         File file=new File(args[0]);  
         if(!(file.exists()&& file.isFile())){  
             System.out.println("该文件有问题，不存在或者不是文件");  
             return;  
         }  
         //判断这个文件的 后缀名是不是JPG  
         if(!file.getName().endsWith(".jpg")){  
             System.out.println("图片格式错误");  
             return;  
         }  
         //限定图片大小为5MB以内  
         if(file.length()>1024*1024*5){  
             System.out.println("图片过大，应在5M以内");  
             return ;  
         }  
           
           
           
     //建立socket服务  
           
         Socket s=new Socket("127.0.0.1", 10007);  
           
         //读取数据-->字节流  
         FileInputStream fis=new FileInputStream("1.jpg");  
         //输出数据-->获取socket输出流向服务端写数据  
         OutputStream out=s.getOutputStream();  
         byte []buf=new byte[1024];//定义缓冲区  
         int len=0; //字节长度  
         //记得要将buf数组传进去，你咋老是记不住呢？？？  
         while((len=fis.read(buf))!=-1){  
             out.write(buf, 0, len);  
         }  
         s.shutdownOutput(); //告诉服务端已写完数据   
   
           
         //接受服务器发送的反馈信息  
         InputStream in=s.getInputStream();  
         byte[]bufin=new byte[1024];  
         int inLen=in.read(buf);  
         System.out.println("From Server:"+new String(buf, 0, inLen));  
           
           
         //关闭资源  
         fis.close();  
         s.close();  
   
     }  
 }  

服务端代码演示：

示例5服务端有个局限性，当A客户端连接上以后，被服务端获取到，服务端执行具体流程。
这时B客户端连接，只有等待。因为服务端还没有处理完A客户端的请求。还没有循环回来
执行下次accept方法。所以，暂时获取不到B客户端对象。那么为了可以让多个客户端
同时并发访问服务端。那么服务端最好就是将每个客户端封装到一个单独的线程中去。这
样就可以同时处理多个客户端请求。如何定义线程？只要明确了每一个客户端要在服务端
执行的代码即可。将该代码存入run方法中。

[java]view plaincopy 
   
print?
 package TCP;  
 import java.io.*;  
 import java.net.*;  
 public class PicServer {  
     public static void main(String[] args) throws Exception{  
         ServerSocket ss=new ServerSocket(10007);  
           
         while(true){  
             Socket s=ss.accept();  
             new Thread(new PicThread(s)).start();  
         }  
           
     }  
 }  
 class PicThread implements Runnable{  
     private Socket s;  
       
     public PicThread(Socket s) {  
         this.s=s;  
     }  
       
     @Override  
     public void run() {  
         String ip=s.getInetAddress().getHostAddress();  
         int count=0;  
         try {  
         System.out.println(ip+"......is connnected!");  
         InputStream in = s.getInputStream();  
           
           
           
         File file=new File(ip+"("+(count)+")"+".jpg");  
         while(file.exists()){  
             file=new File(ip+"("+(count++)+")"+".jpg");  
         }  
           
         FileOutputStream fos=new FileOutputStream(file);  
         byte[]buf=new byte[1024];  
         int len=0;  
         //又在这犯错误了！要记得将buf传进去，不然输出的肯定是空  
         while((len=in.read(buf))!=-1){  
             fos.write(buf, 0, len);  
         }  
           
         //向客户端发送消息（socket输出流）  
         OutputStream out=s.getOutputStream();  
         out.write("图片上传成功！".getBytes());  
           
         //关闭资源  
         fos.close();  
         s.close();  
           
         } catch (Exception e) {  
             throw new RuntimeException(ip+"上传失败!");  
         }  
           
           
     }  
 }  

示例代码7：------客户端并发登陆

客户端通过键盘录入用户，服务端对这个用户名进行校验。如果该用户存在，在服务端显示xxx，已登陆。并在客户端显示 xxx，欢迎光临。如果该用户不存在，在服务端显示xxx，尝试登陆。并在客户端显示 xxx，该用户不存在。最多登录三次。登陆成功、登录三次都直接断开Socket

客户端代码：

[java]view plaincopy 
   
print?
 package tan;  
 import java.io.*;  
 import java.net.*;  
 class LoginClient {  
     public static void main(String[] args) throws Exception {  
         Socket s = new Socket("127.0.0.1", 10008);  
         //读取键盘录入  
         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));  
         //客户端发送所读取的数据  
         PrintWriter out = new PrintWriter(s.getOutputStream(), true);  
         //读服务端发送的socket流（反馈信息）  
         BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
         //只能发送三次  
         for (int x = 0; x < 3; x++) {  
             //先读取键盘录入的数据  
             String line = bufr.readLine();  
             //读取的有可能为空，要判断发送的信息是否为空  
             if (line == null)  
                 break;  
             //发送这一行：line  
             out.println(line);  
             //读服务端发送的反馈信息（一行）  
             String info = bufIn.readLine();  
             System.out.println("info:" + info);  
             if (info.contains("欢迎")){  
                 break;    
             }  
         }  
         //关闭资源  
         bufr.close();  
         s.close();  
     }  
 }  

服务端代码：

[java]view plaincopy 
   
print?
 package tan;  
 import java.io.*;  
 import java.net.*;  
 public class LoginServer {  
     public static void main(String[] args) throws Exception {  
         ServerSocket ss=new ServerSocket(10008);  
         while(true){  
             Socket s=ss.accept();  
             new Thread(new UserThread(s)).start();  
         }  
     }  
 }  
   
   
 //定义用户线程类  
 class UserThread implements Runnable {  
     private Socket s;  
     UserThread(Socket s) {  
         this.s = s;  
     }  
     public void run() {  
         String ip = s.getInetAddress().getHostAddress();  
         System.out.println(ip + "....connected");  
          
         try {  
              //校验3次  
             for (int x = 0; x < 3; x++) {  
                 //获取客户端发送的socket流-->利用到转换流  
                 BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));  
                 //用户名  一个  
                 String name = bufIn.readLine();  
                 if (name == null){  
                     break;  
                 }  
                 //服务端读取user.txt文件  
                 BufferedReader bufr = new BufferedReader(new FileReader("user.txt"));  
                 //想客户端发送信息  
                 PrintWriter out = new PrintWriter(s.getOutputStream(), true);  
                       
                 String line = null;  
                 boolean flag = false;//定义标记 记录判断的结果 ，默认false  
                 //一行行的读 可以读到结尾（操作的是文件）  
                 while ((line = bufr.readLine()) != null) {  
                     //怎么判断呢？判断有了怎样？没有又怎样？要根据循环判断的结果来判断  
                     if (line.equals(name)) {  
                         flag = true;//如果找到了数据则直接跳出  
                         break;  
                     }  
                 }  
                 //根据循环后的结果来判断  
                 if (flag) {  
                     //结果为真，则服务端输出name  
                     System.out.println(name + ",已登录");  
                     //服务端写出去告诉客户端  
                     out.println(name + ",欢迎光临");  
                     //已经校验成功，则直接break  
                     break;  
                 } else {  
                     System.out.println(name + ",尝试登录");  
                     out.println(name + ",用户名不存在");  
                 }  
             }  
             s.close();  
         } catch (Exception e) {  
              
             throw new RuntimeException(ip + "校验失败");  
         }  
     }  
 }  

URL

URL-：代表一个统一资源定位符，它是指向互联网“资源”的指针。资源可以是简单的文件或目录，也可以是对更为复杂的对象的引用，例如对数据库或搜索引擎的查询。

URI 是统一资源标识符，而 URL是统一资源定位符。因此，笼统地说，每个 URL都是 URI，但不一定每个 URI都是 URL。这是因为 URI还包括一个子类，即统一资源名称 (URN)，它命名资源但不指定如何定位资源。

常用方法示例：

intgetDefaultPort() ：获取与此 URL关联协议的默认端口号。

String getFile() ：获取此 URL的文件名。

String getHost() ：获取此 URL的主机名（如果适用）。

String getPath() ：获取此 URL的路径部分。

int getPort() ：获取此 URL的端口号。

String getProtocol()：获取此 URL的协议名称。

String getQuery() ：获取此 URL的查询部分。

[java]view plaincopy 
   
print?
 import java.net.*;    
 class  URLDemo    
 {    
     public static void main(String[] args) throws Exception    
     {    
         //URL url=new URL("http://192.168.1.13:11000/myweb/demo.html");    
         URL url=new URL("http://192.168.1.13:11000/myweb/demo.html?name=haha&age=30");    
         System.out.println("getProtocol():"+url.getProtocol()); //http              
         System.out.println("getHost():"+url.getHost());//192.168.1.13    
         System.out.println("getDefaultPort():"+url.getDefaultPort());//80，如果关联的协议没有默认的端口，则值为-1；    
         System.out.println("getPort():"+url.getPort()); //  11000,如果没有设置则为-1；    
         System.out.println("getPath():"+url.getPath());// /myweb/demo.html    
         System.out.println("getFile():"+url.getFile());///myweb/demo.html?name=haha&age=30    
         System.out.println("getQuery():"+url.getQuery());//name=haha&age=30    
     
     /*  int port = url.getPort();  
         if(port==-1)  
             port =80;  
         getPort（） = -1  
     */    
     }    
 }    

URLConnection

它的作用于Socket类似，其实它内部封装了Socket，所以可以获取网络输入输出流。通过URL和URLConnection可以方便地对应用层网络数据进行读取和操作。

URLConnection———应用层

Socket-————传输层

方法示例：

[java]view plaincopy 
   
print?
 import java.net.*;    
 import java.io.*;    
     
 class URLConnectionDemo     
 {    
     public static void main(String[] args) throws Exception    
     {    
         URL url=new URL("http://192.168.1.13:8080/myweb/demo.html");    
         URLConnection conn = url.openConnection();    
         System.out.println(conn);    
         InputStream in = conn.getInputStream();    
         byte [] buf =new byte[1024];    
         int len = in.read(buf);    
         System.out.println(new String(buf,0,len));    
     
     }    
 }    

改写MyIEByGUI中的showWebPage()方法。

示例：

[java]view plaincopy 
   
print?
 private void showWebPage() throws Exception    
 {    
     //使用URL和URLConnection对showWebPage改写。    
     //很明显，这两个封装的应用层对象使用起来更方便简洁    
     ta.setText("");         
     String urlPath =tf.getText();           
     URL url=new URL(urlPath);    
     URLConnection conn = url.openConnection();    
     //System.out.println(conn);    
     InputStream in = conn.getInputStream();    
     byte [] buf =new byte[1024];    
     int len = in.read(buf);    
     ta.setText(new String(buf,0,len));    
 }   