网络编程——第一部分

 

新博客地址：Temi

第一讲，第二讲：Java基础第23天-01-网络编程(概述)，第23天-02-网络编程(概述2)

一，网络通信步骤：

1. 1. 找到对方（通过IP）。
   2. 数据要发送到对方指定的应用程序上，为了标识这些应用程序，所以给这些网络应用程序都用数字进行标识。====端口（逻辑端口）====
   3. 定义通信规则，这个规则成为协议。国际标准化组织定义了TCP/IP协议。======有效端口：0 ~65535，系统使用或保留的端口是：0~ 1024。======

第三讲：(网络模型)

 

一，各个层次的协议   (通常用户操作的是应用层，而编程人员需要做的是传输层和网际层)：

1. 1. 网际层：IP协议。
   2. 传输层：TCP/UDP协议。
   3. 应用层：HTTP/FTP 协议。（web开发）。

二，网络通讯要素：

1. IP地址：
   1. 网络中设备的标识。
   2. 不易记忆，可用主机名。
   3. 本地回环地址。127.0.0.1  。主机名：localhost
2. 端口号：
   1. 用于表示进程的逻辑地址。不同进程的标识。
   2. 有效端口：0-65535，其中1-1024系统使用或保留端口。

三，涉及到的类：

1. 1. public class InetAddress extends Object implements Serializable       此类表示互联网协议 (IP) 地址。   ====注：此类没有构造方法=====
   2. 方法：public static InetAddress  getByName (String host)  throws UnknownHostException   在给定主机名的情况下确定主机的 IP 地址。
   3. 方法：public static InetAddress[] getAllByName(String host) throws UnknownHostException      在给定主机名的情况下，根据系统上配置的名称服务返回其 IP 地址所组成的数组。
   4. 方法：public static InetAddress getByAddress(byte[] addr) throws UnknownHostException      在给定原始 IP 地址的情况下，返回 InetAddress 对象。
   5. 方法：public String getHostName()    获取此 IP 地址的主机名。
   6. 方法：public String getHostAddress()  返回 IP 地址字符串（以文本表现形式）。

四，代码练习：

import java.net.*;

public class IPDemo {
             public static void main(String[] args) throws UnknownHostException {
                             //声明地址类，表示本地主机
                             InetAddress i = InetAddress.getLocalHost();
                             
                             //输出本地主机的IP地址
                             System.out.println(i.getHostAddress());
                             
                             //已主机名的方式找到主机
                             InetAddress my = InetAddress.getByName("Lenovo-PC");
                             
                             //输出主机地址
                             System.out.println(my.getHostAddress());
                             
                             
                             //获取百度所有主机
                             InetAddress[] ia = InetAddress.getAllByName("www.baidu.com");
                             
                             //输出百度主机地址
                             for(InetAddress inet : ia){
                                 
                                 System.out.println(inet.getHostName()+"::"+inet.getHostAddress());
                             }
                              
            }
}

第四讲：网络编程(IP地址)

第五讲：网络编程(TCP和UDP)

一，TCP 和 UDP 简介：

1. UDP（面向无连接，明确了对方的端口，无论在不在网上，只管传输，不在就会丢失数据。只求速度，应用于网络视频会议和聊天等应用程序中。）
   1. 将数据及源和目的封装在数据包中，不需要建立连接。
   2. 每个数据包的大小限制在64k内。
   3. 因为无连接，是不可靠协议。
   4. 不需要建立连接，所以速度快。
2. TCP( 是面向连接的，必须连接成功才能传输数据，应用于下载等程序上)
   1. 建立连接形成传输数据的通道。
   2. 可在连接中进行大数据量传输。
   3. 通过三次握手完成数据连接，是可靠协议。===注：三次握手：第一次本方发送请求，第二次对方确认连接，第三次本方再次确认连接成功。====
   4. 必须建立连接，效率稍低。

第六讲，第七讲：网络编程(Socket)，网络编程(Udp-发送端)

一，Socket 简介：

1. 1. Socket 是为网络服务提供的一种机制。
   2. 通信的两段都有Socket。
   3. 网络通信其实就是Socket之间的通信。
   4. 数据在两个Socket之间通过IO传输。

二，DatagramSocket 类简介：

1. 1. public class DatagramSocketextends Object   此类表示用来发送和接收数据报包的套接字。   ===注：在 DatagramSocket 上总是启用 UDP 广播发送。====
   2. 构造方法：public DatagramSocket() throws SocketException   构造数据报套接字并将其绑定到本地主机上任何可用的端口。
   3. 构造方法：public DatagramSocket(int port) throws SocketException   创建数据报套接字并将其绑定到本地主机上的指定端口。
   4. 方法：public InetAddress getInetAddress()       返回此套接字连接的地址。如果套接字未连接，则返回 null。
   5. 方法：public int getPort()     返回此套接字的端口。如果套接字未连接，则返回 -1。
   6. public void send (DatagramPacket p) throws IOException 从此套接字发送数据报包。

三，DatagramPacket 类简介（DatagramPacket 包含的信息指示：将要发送的数据、其长度、远程主机的 IP 地址和远程主机的端口号。）：

1. 1. public final class DatagramPacketextends Object           此类表示数据报包。
   2. 构造方法：public DatagramPacket(byte[] buf, int offset, int length, InetAddress address,int port)  构造数据报包，用来将长度为 length 偏移量为 offset 的包发送到指定主机上的指定端口号。
   3. 方法:public InetAddress getAddress()  返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。
   4. 方法：public int getPort()                    返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。
   5. 方法：public byte[] getData()             返回数据缓冲区。接收到的或将要发送的数据从缓冲区中的偏移量 offset 处开始，持续 length 长度。
   6. 方法：public int getOffset()                返回将要发送或接收到的数据的偏移量。
   7. 方法：public int getLength()               返回将要发送或接收到的数据的长度。

四，代码练习：

import java.net.*;

public class UdpSend {
             public static void main(String[] args) throws Exception {
                 
                             //创建Udp服务
                           DatagramSocket ds = new DatagramSocket();
                           
                           //获得发送数据
                           byte[] b = "这是发送信息".getBytes();
                           
                           //构造数据包
                           DatagramPacket dp = new DatagramPacket(b, b.length,InetAddress.getByName("localhost"),8080);
                           
                           //发送数据
                           ds.send(dp);
                           
                           //关闭资源
                           ds.close();
            }
}

第八讲：网络编程(Udp-接收端)

一，Udp 的 Socket 服务建立步骤。

1. 1. 建立DatagramSocket和DatagramPacket对象。
   2. 建立发送端（建立UDPSocket服务，在此无需指定端口，也可以将端口加入。如果不指定的话，系统会随机分配一个端口，如第一次运行时端口为1093，那么第二次就会顺延为1094，再运行会一直顺延，因为之前的端口还没有得到释放，所以会顺延端口号值。），接受端（定义UDPSocket服务。通常会监听一个端口，其实就是给这个接收网路应用程序定义数字标识，方便于明确哪些数据过来该应用程序可以处理。）。
   3. 建立数据包。
   4. 调用Socket发送接收方法。
   5. 关闭Socket。

二，代码练习：

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpRece {
            public static void main(String[] args) throws Exception{
                            
                            //定义接受端套接字
                            DatagramSocket ds = new DatagramSocket(10000);
                            
                            //定义字节数组，保存接受内瓤
                            byte buf[] = new byte[1024];
                            
                            //定义数据包，接受数据
                            DatagramPacket dp = new DatagramPacket(buf,buf.length);
                            
                            //接受数据
                            ds.receive(dp);
                            
                            //将字节构造成字符
                            String revece = new String(buf);
                            
                            //标记发送端的端口
                            int port = dp.getPort();
                            
                            //标记发送端的地址
                            String address =dp.getAddress().getHostAddress();
                            
                            //输出内容
                            System.out.println("address:"+address+"port"+port+"revece"+revece);
                            
            }
}

第九讲：网络编程(UDP-键盘录入方式数据)

一，一个特殊的IP地址: 192.168.1.255   广播地址。

二代码练习：

import java.net.*;
import java.io.*;


public class UpdSend2 {
             public static void main(String[] args) throws Exception {
                         
                             //创建套接字对象
                             DatagramSocket ds = new DatagramSocket();
                             
                             //创建数组接收对象
                             byte b[] = new byte[1024];
                             
                             //接受键盘输入
                             System.in.read(b);
                             
                             //构建数据包
                             DatagramPacket dp = new DatagramPacket(b,b.length,InetAddress.getByName("127.0.0.1"),10001);
                             
                             //发送数据包
                             ds.send(dp);
                             
                             //关闭资源
                             ds.close();
            }
}

第十讲：网络编程(UDP-聊天)

 一，需求分析：

二，思路分析：

1. 接收端和发送端需要同时完成收发功能。
2. 接受数据，发送数据应当封装到两个线程中。

三，代码练习：

import java.io.*;
import java.net.*;


//创建线程类，此类启动一个线程，执行在端口10001接受网络数据操作
class MyRece implements Runnable{
    
    //覆盖run()方法
    @Override
    public void run(){
        
        //循环接受数据
        while (true){
           try {
               
               //创建套接字对象，在端口10001接受网络数据
                DatagramSocket ds = new DatagramSocket(10001);
            
                //存储接受内容
                byte b[] = new byte[1024];
            
                //创建数据包对象
                DatagramPacket dp = new DatagramPacket(b,b.length);
            
                //接受数据
                ds.receive(dp);
                
                //打印接受到的数据
                System.out.println("主机："+dp.getAddress()+"发来："+new String(dp.getData(),0,dp.getLength()));
                
                //判断是否关闭程序
                if(dp.getData().toString().trim().equals("886"))
                    //当对放发送886程序结束
                    break;
            } catch (SocketException e) {
                System.out.println("网络错误"+e.toString());
            }catch (IOException e){
                 System.out.println("IO错误"+e.toString());
            } 
            
        }
    }
}


//创建一个类启动一个线程，该线程实现发送用户从键盘输入的内容
class MySend implements Runnable{
    
        //覆盖方法
        @Override
        public void run(){
            //循环接受发送
            while(true){
                
                try{
                    //创建套接字对象
                     DatagramSocket ds = new DatagramSocket();
                    
                    //创建缓冲输入流，从键盘接受数据
                    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                    
                    //存储键盘输入的一行数据
                    String line = null;
                    
                    //如果用户输入886 ，发送数据，并结束程序运行
                    if((line=br.readLine()).trim().equals("886")){
                        DatagramPacket dp = new DatagramPacket(line.getBytes(),line.getBytes().length,InetAddress.getByName("127.0.0.1"),10001);
                        
                        ds.send(dp);
                        break;
                    }
                    
                    //发送数据
                    DatagramPacket dp = new DatagramPacket(line.getBytes(),line.getBytes().length,InetAddress.getByName("127.0.0.1"),10001);
                    
                    ds.send(dp);
                        
                }catch(IOException e){
                    System.out.println("IO异常"+e.toString());
                } 
                
            }
        }
}
public class ChatDemo {
                public static void main(String[] args) {
                    
                    
                       //创建线程对象
                       Thread t1 = new Thread(new MyRece());
                       Thread t2 = new Thread(new MySend());
                       
                       //启动线程
                       t1.start();
                       t2.start();
                }
}

第十一讲：网络编程(TCP传输)

一，TCP传输过程。

1. 1. 建立，Socket（客户端） 和ServerSocket（服务端，服务端需要明确它要处理的数据是从哪个端口进入的。）。=====因为TCP是面向连接的，所以在建立Socket服务时，就要有服务端存在，并连接成功，形成通路后，再通过该通道进行数据的传输。===
   2. 通过Socket中的IO流进行数据的传输。
   3. 关闭Socket。
   4. 客户端和服务器端是两个独立的应用程序。

二，涉及道的类了解：

1. Socket: 
   1. 定义：public class Socket extends Object    此类实现客户端套接字（也可以就叫“套接字”）。套接字是两台机器间通信的端点。
   2. 构造方法：public Socket()          通过系统默认类型的 SocketImpl 创建未连接套接字                ==注：创建空参数的客户端对象，一般用于服务端接收数据==
   3. 构造方法：public Socket(String host, int port) throws UnknownHostException, IOException     创建一个流套接字并将其连接到指定主机上的指定端口号。
   4. 方法：public void bind(SocketAddress bindpoint) throws IOException    将套接字绑定到本地地址。如果地址为 null，则系统将挑选一个临时端口和一个有效本地地址来绑定套接字。
   5. 方法：public InetAddress getInetAddress()     返回套接字连接的地址。
   6. 方法：public int getPort()                               返回此套接字连接到的远程端口。
   7. 方法：public InetAddress getLocalAddress()   获取套接字绑定的本地地址。
   8. 方法：public int getLocalPort()                      返回此套接字绑定到的本地端口。
   9. 方法：public InputStream getInputStream() throws IOException  返回此套接字的输入流。
   10. 方法：public OutputStream getOutputStream() throws IOException   返回此套接字的输出流。
2. ServerSocket:
   1. 类的定义：public class ServerSocket extends Object    此类实现服务器套接字。服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。
   2. 构造方法：public ServerSocket() throws IOException   创建非绑定服务器套接字。
   3. 构造方法：public ServerSocket(int port) throws IOException   创建绑定到特定端口的服务器套接字。
   4. 方法：public Socket accept() throws IOException    侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。
   5. 方法：public void bind(SocketAddress endpoint) throws IOException   将 ServerSocket 绑定到特定地址（IP 地址和端口号）。
   6. 方法：public InetAddress getInetAddress()         返回此服务器套接字的本地地址。将此套接字绑定到的地址；如果套接字是未绑定的，则返回 null。
   7. 方法：public int getLocalPort()                           返回此套接字在其上侦听的端口。此套接字侦听的端口号；如果尚未绑定套接字，则返回 -1。

三，思路分析：

客户端：

        通过查阅Socket对象的API文档，发现在该对象在建立时，就可去连接指定主机，因为TCP是面向连接的，所以在建立Socket服务时，就要有服务端存在，并连接成功，形成通路后，再通过该通道进行数据的传输。

         1）创建Socket服务，并指定要连接的主机端口。通路一建立，就会产生Socket流（包括输入流和输出流），通过方法获取。========注：如果连接失败，会出现异常。连接成功，说明客户端与服务端建立了通道，之后即可以通过IO流交换数据。==========

         2）为了发送数据，应获取Socket中的输出流，如果要接收服务端的反馈信息，还需要获取Socket的输入流

         3）通过输出流的write()方法将要发送的数据写入到流中

         4）关闭Socket流资源

服务端：

        服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。需监听一个端口。

         1）建立服务端的Socket服务，并监听一个端口。通过ServerSocet带端口参数的构造函数

         2）获取连接过来的客户对象，通过ServerSocket的accept()方法，此方法是阻塞式的，如果服务端没有连接到就会一直等待

         3）客户端如果发过来数据，则服务端要使用对应的客户端对象，并获取到该客户端对象的读取流读取发过来的数据，并输出到指定目的地。当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，并通过该对象与客户端通过IO流进行数据传输。

         4）关闭服务端（可选）。一般服务端是常开的，因为在实际应用中，随时有客户端在请求连接和服务。但这里需要定时关闭客户端对象流，避免某一个客户端长时间占用服务器端。

四，代码练习：

服务器端：

import java.io.*;
import java.net.*;


//创建TCP服务器端，接受消息
public class TCPServ {
                public static void main(String[] args) {
                            
                        try {
                            
                            //创建服务器端套接字，在指定端口监听
                            ServerSocket ss = new ServerSocket(20000);
                            
                            //获得接收到的套接字的输入流
                            InputStream is = ss.accept().getInputStream();
                            
                            //存储数据
                            byte b[] = new byte[1024];
                            
                            //读入数据
                            is.read(b);
                            s.close();
                            //打印
                            System.out.println(new String(b,0,b.length));
                            
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        } 
                }
}

客户端：

import java.io.*;
import java.net.*;


//创建客户端，以TCP方式连接到远程服务器
class TCPClient {
            public static void main(String[] args) {
                
                
                try {
                    
                    //创建客户端套接字，连接到制定主机的20000端口上
                    Socket s = new Socket(InetAddress.getByName("202.206.154.123"), 20000);
                    
                    //获得到远端主机的输出流
                    OutputStream out = s.getOutputStream();
                    
                    //输出数据
                    out.write("您好".getBytes());
                    //关闭资源
                    s.close();
                } catch (UnknownHostException e) {
                    System.out.println("为找到主机"+e.toString());
                } catch (IOException e) {
                    System.out.println("IO异常"+e.toString());
                }
            }
}

第十二讲：网络编程(TCP传输2)

一，练习：需求分析：客户端给服务端发送数据，服务端收到后，给客户端反馈信息

二，代码练习：

客户端：

import java.io.*;
import java.net.*;


//创建客户端，以TCP方式连接到远程服务器
class TCPClient {
            public static void main(String[] args) {
                
                
                try {
                    
                    //创建客户端套接字，连接到制定主机的20000端口上
                    Socket s = new Socket(InetAddress.getByName("202.206.154.123"), 20000);
                    
                    //获得到远端主机的输出流
                    OutputStream out = s.getOutputStream();
                    
                    //输出数据
                    out.write("您好".getBytes());
                    
                    
                    //接受服务端消息
                    byte b[] = new byte[1024];
                    
                    //获取输入流
                    InputStream in = s.getInputStream();
                    
                    //标记接受数据量
                    int len=0;
                    
                    //读入数据
                    len=in.read(b);
                    
                    //输出数据
                    System.out.println(new String(b,0,len));
                    //关闭资源
                    s.close();
                } catch (UnknownHostException e) {
                    System.out.println("为找到主机"+e.toString());
                } catch (IOException e) {
                    System.out.println("IO异常"+e.toString());
                }
            }
}

服务器端：

import java.io.*;
import java.net.*;


//创建TCP服务器端，接受消息
public class TCPServ {
                public static void main(String[] args) {
                            
                        try {
                            
                            //创建服务器端套接字，在指定端口监听
                            ServerSocket ss = new ServerSocket(20000);
                            
                            Socket s = ss.accept();
                            //获得接收到的套接字的输入流
                            InputStream is = s.getInputStream();
                            
                            //存储数据
                            byte b[] = new byte[1024];
                            
                            //读入数据
                            is.read(b);
                            
                            //打印
                            System.out.println(new String(b,0,b.length));
                            
                            //获取输出流
                            OutputStream out = s.getOutputStream();
                            
                            //向客户端写入数据
                            out.write("客户端你也好".getBytes());
                            
                            //关闭资源
                            s.close();
                            
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        } 
                }
}

第一十三讲：网络编程(TCP练习)

一，需求分析：

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

二，操作步骤：

1. 1. 建立服务。
   2. 获取键盘输入。
   3. 将数据发给服务端。
   4. 接受服务端返回的数据。
   5. 关闭资源。

==============特别注意：如果使用字符缓冲区，写入完毕后，需要加入换行和刷新====================

三，代码练习：

 客户端：

import java.net.*;
import java.io.*;
public class TCPClient {
                public static void main(String[] args) {
                            
                            //创建套接字连接服务器
                            Socket s = null;
                            
                            //获取输出流
                            OutputStream out = null;
                            
                            //获取输入流
                            InputStream is = null;
                            
                            
                            try {
                                s = new Socket(InetAddress.getByName("127.0.0.1"),10000);
                                
                                out = s.getOutputStream();
                                
                                is = s.getInputStream();
                            } catch (UnknownHostException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                            
                             
                            
                            //字符缓冲流增加效率
                            BufferedReader brr = new BufferedReader(new InputStreamReader(is));
                            
                            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out));
                            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                            
                            try{
                            //循环发送数据接收数据
                            while(true){
                                
                                //接收读入内容
                                 String line = null;
                                 
                                 //读入数据
                                 line = br.readLine();
                                 
                                 //写出数据
                                 bw.write(line);
                                 
                                 //换行
                                 bw.newLine();
                                 
                                 //刷新
                                 bw.flush();
                                 
                                 if("over".equals(line))
                                     break;
                                 line=brr.readLine();
                                
                                 System.out.println(line);
                            }
                            s.close();
                            }catch (Exception e){
                                System.out.println(e.toString());
                            }
                }
}            

服务器端：

import java.io.*;
import java.net.*;

public class TCPServ {
            public static void main(String[] args)   {
                
                        //创建服务器端套接字，在端口10000监听
                        ServerSocket ss = null;
                        
                        //获取与客户端关联的 Socket
                        Socket s = null;
                        
                        //获取到客户端的输入流
                        InputStream is = null;
                        
                        OutputStream out =null;
                        
                        try {
                            ss = new ServerSocket(10000);
                            
                            s = ss.accept();
                            
                            out = s.getOutputStream();
                            is = s.getInputStream();
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        
                        
                        
                        
                        
                        //使用字符缓冲流提高效率
                        BufferedReader br = new BufferedReader(new InputStreamReader(is));
                        
                        //字符缓冲流
                        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out));
                        
                        
                    try{
                        //循环接受客户端消息
                        while(true){
                            
                            //接受客户端内容
                            String line = null;
                            
                            //读入数据
                            line = br.readLine();
                            
                            //判断是否结束
                            if("over".equals(line))
                                break;
                            
                            //向客户端写入数据
                            bw.write(line.toUpperCase());
                            
                            //换行
                            bw.newLine();
                            
                            //刷新
                            bw.flush();
                        }
                        ss.close();
                    }catch(Exception e){
                        System.out.println(e.toString());
                    }
            }
}

第一十四讲：网络编程(TCP复制文件)

一，注意的问题：

1. 1. 因为客户端将数据发送完毕后，服务端仍然在等待这读取数据，并没有收到结束标记，就会一直等待读取。 
   2. 上个问题解决后，收到的不是指定信息而是null，是因为服务端写入数据后，需要刷新，才能将信息反馈给客服端。

二，解决办法：

1. 1. 定义结束标记，先将结束标记发送给服务端，让服务端接收到结束标记，然后再发送上传的数据。但是这样定义可能会发生定义的标记和文件中的数据重复，而导致提前结束。
   2. 定义时间戳，由于时间是唯一的，在发送数据前，先获取时间，发送完后在结尾处写上相同的时间戳，在服务端，接收数据前先接收一个时间戳，然后在循环中判断时间戳以结束标记。
   3. 通过socket方法中的shutdownOutput()，关闭输入流资源，从而结束传输流，以给定结束标记。通常用这个方法。 

三，代码练习

客户端软件：

import java.io.*;
import java.net.*;

public class TextClient {
                public static void main(String[] args) {
                                
                    
                                //创建客户端套接字
                                Socket s = null;
                                
                                //输出流，输入流对象声明
                                InputStream is = null;
                                
                                OutputStream os = null;
                                
                                FileInputStream fis = null;
                                
                                //标识文件
                                String filename = "E:/sysinfo.txt";
                                
                                File file = new File(filename);
                                
                                
                                //实例化对象引用
                                try{
                                    s = new Socket(InetAddress.getLocalHost(),10000);
                                    
                                    is = s.getInputStream();
                                    
                                    os = s.getOutputStream();
                                    
                                    
                                    //判断文件是否存在
                                    if(!file.exists())
                                        System.out.println("文件不存在");
                                    else {
                                        fis = new FileInputStream(file);
                                    }
                                }catch(Exception e){
                                    System.out.println(e.toString());
                                }
                                
                                
                                //字符缓冲刘提高操作效率
                                BufferedReader br_file = new BufferedReader(new InputStreamReader(fis));
                                BufferedReader br_net = new BufferedReader(new InputStreamReader(is));
                                
                                //获得服务端输出流
                                BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
                                
                                try{
                                    String line = null;
                                    
                                    //循环读取文件并发送到服务器端
                                    while ((line=br_file.readLine())!=null){
                                        
                                        //写入一行字符
                                        bw.write(line);
                                        
                                        //写入换行符
                                        bw.newLine();
                                        
                                        //刷新输出流
                                        bw.flush();
                                    }
                                    
                                    //写入结束标志
                                    bw.write("end");
                                    bw.newLine();
                                    bw.flush();
                                    
                                    //获取服务端响应
                                    line = br_net.readLine();
                                    
                                    System.out.println(line);
                                }catch(IOException e){
                                    System.out.println(e.toString());
                                }
                }
}

 

服务端代码:

 

import java.io.*;
import java.net.*;

public class TextServ {
                public static void main(String[] args) {
                            
                            //创建服务端套接字
                            ServerSocket ss = null;
                            
                            //接受客户端
                            Socket s = null;
                            
                            ////客户端输入流
                            InputStream is = null;
                            
                            //客户端输出流
                            OutputStream os = null;
                            
                            //定义文件
                            File file = new File("E:/rever.txt");
                            
                            //定义文件输入流
                            FileOutputStream fos = null;
                            
                            //实例化对象
                            try{
                                ss = new ServerSocket(10000);
                                
                                s = ss.accept();
                                
                                is = s.getInputStream();
                                
                                os = s.getOutputStream();
                                
                                fos = new FileOutputStream(file);
                            }catch(Exception e){
                                System.out.println(e.toString());
                            }
                            
                            //字符缓冲刘提高效率
                            BufferedReader br = new BufferedReader(new InputStreamReader(is));
                            
                            //缓冲输出流。提高效率
                            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
                            
                            
                            BufferedWriter bw_file = new BufferedWriter(new OutputStreamWriter(fos));
                            
                            //异常处理
                            try{
                                
                                //接受读入一行字符串
                                String line = null;
                                
                                //循环读取
                                while((line=br.readLine())!=null){
                                    //判断是否结束
                                    if("end".equals(line))
                                        break;
                                    
                                    //保存到本地文件
                                      bw_file.write(line);
                                      
                                      //写入换行符
                                      bw_file.newLine();
                                      
                                      //刷新输出流
                                      bw_file.flush();
                                }
                                
                                //给出提示
                                bw.write("写入成功");
                                
                                //写入换行符
                                  bw.newLine();
                                  
                                  //刷新
                                  bw.flush();
                            }catch(Exception e){
                                System.out.println(e.toString());
                            }
                            
                }
}