JAVASE基础 Item -- 网络编程_客户端输入信息之前就结束 java(1)

public static void main(String[] args) throws IOException {
    // 创建发送端Socket对象
    // DatagramSocket()
    DatagramSocket ds = new DatagramSocket();

    // 创建数据，并把数据打包
    // DatagramPacket(byte[] buf, int length, InetAddress address, int port)
    // 创建数据
    byte[] bys = "hello,udp,我来了".getBytes();
    // 长度
    int length = bys.length;
    // IP地址对象
    InetAddress address = InetAddress.getByName("192.168.12.92");
    // 端口
    int port = 10086;
    DatagramPacket dp = new DatagramPacket(bys, length, address, port);

    // 调用Socket对象的发送方法发送数据包
    // public void send(DatagramPacket p)
    ds.send(dp);

    // 释放资源
    ds.close();
}

}

package cn.itcast_02;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/*
* UDP协议接收数据：
* A:创建接收端Socket对象
* B:创建一个数据包(接收容器)
* C:调用Socket对象的接收方法接收数据
* D:解析数据包，并显示在控制台
* E:释放资源
*/
public class ReceiveDemo {
public static void main(String[] args) throws IOException {
// 创建接收端Socket对象
// DatagramSocket(int port)
DatagramSocket ds = new DatagramSocket(10086);

    // 创建一个数据包(接收容器)
    // DatagramPacket(byte[] buf, int length)
    byte[] bys = new byte[1024];
    int length = bys.length;
    DatagramPacket dp = new DatagramPacket(bys, length);

    // 调用Socket对象的接收方法接收数据
    // public void receive(DatagramPacket p)
    ds.receive(dp); // 阻塞式

    // 解析数据包，并显示在控制台
    // 获取对方的ip
    // public InetAddress getAddress()
    InetAddress address = dp.getAddress();
    String ip = address.getHostAddress();
    // public byte[] getData():获取数据缓冲区
    // public int getLength():获取数据的实际长度
    byte[] bys2 = dp.getData();
    int len = dp.getLength();
    String s = new String(bys2, 0, len);
    System.out.println(ip + "传递的数据是:" + s);

    // 释放资源
    ds.close();
}

}

**1. UDP传输-发送端思路**


* 1:建立udp的socket服务
* 2:将要发送的数据封装成数据包
* 3:通过udp的socket服务,将数据包发送出
* 4:关闭资源


**2.UDP传输-接收端思路**


* 1:建立udp的socket服务.
* 2:通过receive方法接收数据
* 3:将收到的数据存储到数据包对象中
* 4:通过数据包对象的功能来完成对接收到数据进行解析.
* 5:可以对资源进行关闭


![这里写图片描述](https://img-blog.csdn.net/20160229213314741)

package cn.itcast_03;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class SendDemo {
public static void main(String[] args) throws IOException {
// 创建发送端的Socket对象
DatagramSocket ds = new DatagramSocket();

    // 创建数据并打包
    byte[] bys = "helloworld".getBytes();
    DatagramPacket dp = new DatagramPacket(bys, bys.length,
            InetAddress.getByName("192.168.12.92"), 12345);

    // 发送数据
    ds.send(dp);

    // 释放资源
    ds.close();
}

}

package cn.itcast_03;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/*
* 多次启动接收端：
* java.net.BindException: Address already in use: Cannot bind
* 端口被占用。
*/
public class ReceiveDemo {
public static void main(String[] args) throws IOException {
// 创建接收端的Socket对象
DatagramSocket ds = new DatagramSocket(12345);

    // 创建一个包裹
    byte[] bys = new byte[1024];
    DatagramPacket dp = new DatagramPacket(bys, bys.length);

    // 接收数据
    ds.receive(dp);

    // 解析数据
    String ip = dp.getAddress().getHostAddress();
    String s = new String(dp.getData(), 0, dp.getLength());
    System.out.println("from " + ip + " data is : " + s);

    // 释放资源
    ds.close();
}

}

B:先开启那个方法?   
 谁先开都行.因为udp的特点是面向无连接.   
 如果你先开启了发送,那么,它收不到数据而已.


**实例1：从键盘录入数据进行发送，如果输入的是886那么客户端就结束输入数据。**

package cn.itcast_04;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/*
* 数据来自于键盘录入
* 键盘录入数据要自己控制录入结束。
*/
public class SendDemo {
public static void main(String[] args) throws IOException {
// 创建发送端的Socket对象
DatagramSocket ds = new DatagramSocket();

    // 封装键盘录入数据
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String line = null;
    while ((line = br.readLine()) != null) {
        if ("886".equals(line)) {
            break;
        }

        // 创建数据并打包
        byte[] bys = line.getBytes();
        // DatagramPacket dp = new DatagramPacket(bys, bys.length,
        // InetAddress.getByName("192.168.12.92"), 12345);
        DatagramPacket dp = new DatagramPacket(bys, bys.length,
                InetAddress.getByName("192.168.12.255"), 12345);

        // 发送数据
        ds.send(dp);
    }

    // 释放资源
    ds.close();
}

}

package cn.itcast_04;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

/*
* 多次启动接收端：
* java.net.BindException: Address already in use: Cannot bind
* 端口被占用。
*/
public class ReceiveDemo {
public static void main(String[] args) throws IOException {
// 创建接收端的Socket对象
DatagramSocket ds = new DatagramSocket(12345);

    while (true) {
        // 创建一个包裹
        byte[] bys = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bys, bys.length);

        // 接收数据
        ds.receive(dp);

        // 解析数据
        String ip = dp.getAddress().getHostAddress();
        String s = new String(dp.getData(), 0, dp.getLength());
        System.out.println("from " + ip + " data is : " + s);
    }

    // 释放资源
    // 接收端应该一直开着等待接收数据，是不需要关闭
    // ds.close();
}

}

实例2：多线程的聊天室   
 如何改进呢，使用广播地址即可。

package cn.itcast_05;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class SendThread implements Runnable {

private DatagramSocket ds;

public SendThread(DatagramSocket ds) {
    this.ds = ds;
}

@Override
public void run() {
    try {
        // 封装键盘录入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(
                System.in));
        String line = null;
        while ((line = br.readLine()) != null) {
            if ("886".equals(line)) {
                break;
            }

            // 创建数据并打包
            byte[] bys = line.getBytes();
            // DatagramPacket dp = new DatagramPacket(bys, bys.length,
            // InetAddress.getByName("192.168.12.92"), 12345);
            DatagramPacket dp = new DatagramPacket(bys, bys.length,
                    InetAddress.getByName("192.168.12.255"), 12306);

            // 发送数据
            ds.send(dp);
        }

        // 释放资源
        ds.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}

package cn.itcast_05;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class ReceiveThread implements Runnable {
private DatagramSocket ds;

public ReceiveThread(DatagramSocket ds) {
    this.ds = ds;
}

@Override
public void run() {
    try {
        while (true) {
            // 创建一个包裹
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);

            // 接收数据
            ds.receive(dp);

            // 解析数据
            String ip = dp.getAddress().getHostAddress();
            String s = new String(dp.getData(), 0, dp.getLength());
            System.out.println("from " + ip + " data is : " + s);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

}

package cn.itcast_05;

import java.io.IOException;
import java.net.DatagramSocket;

/*
* 通过多线程改进刚才的聊天程序，这样我就可以实现在一个窗口发送和接收数据了
*/
public class ChatRoom {
public static void main(String[] args) throws IOException {
DatagramSocket dsSend = new DatagramSocket();
DatagramSocket dsReceive = new DatagramSocket(12306);

    SendThread st = new SendThread(dsSend);
    ReceiveThread rt = new ReceiveThread(dsReceive);

    Thread t1 = new Thread(st);
    Thread t2 = new Thread(rt);

    t1.start();
    t2.start();
}

}

### 四、TCP编程


##### **4.1 TCP传输**


Socket和ServerSocket   
 建立客户端和服务器端   
 建立连接后，通过Socket中的IO流进行数据的传输   
 关闭socket   
 同样，客户端与服务器端是两个独立的应用程序。


**1.TCP传输-客户端思路**


* 1:建立客户端的Socket服务,并明确要连接的服务器。
* 2:如果连接建立成功,就表明,已经建立了数据传输的通道.就可以在该通道通过IO进行数据的读取和写入.该通道称为Socket流,Socket流中既有读取流,也有写入流.
* 3:通过Socket对象的方法,可以获取这两个流
* 4:通过流的对象可以对数据进行传输
* 5:如果传输数据完毕,关闭资源


##### **2.TCP传输-服务器端思路**


* 1:建立服务器端的socket服务，需要一个端口
* 2:服务端没有直接流的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信
* 3:通过客户端的获取流对象的方法,读取数据或者写入数据
* 4:如果服务完成,需要关闭客户端,然后关闭服务器，但是,一般会关闭客户端,不会关闭服务器,因为服务端是一直提供服务的


A:客户端和服务器都写好后，先开启谁呢？   
 开启服务器端。因为服务器如果不开启，客户端就不知道和谁进行连接啊。


![这里写图片描述](https://img-blog.csdn.net/20160229213342725)

package cn.itcast_06;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

/*
* TCP协议发送数据：
* A:创建发送端的Socket对象
* 这一步如果成功，就说明连接已经建立成功了。
* B:获取输出流，写数据
* C:释放资源
*
* 连接被拒绝。TCP协议一定要先看服务器。
* java.net.ConnectException: Connection refused: connect
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建发送端的Socket对象
// Socket(InetAddress address, int port)
// Socket(String host, int port)
// Socket s = new Socket(InetAddress.getByName(“192.168.12.92”), 8888);
Socket s = new Socket(“192.168.12.92”, 8888);

    // 获取输出流，写数据
    // public OutputStream getOutputStream()
    OutputStream os = s.getOutputStream();
    os.write("hello,tcp,我来了".getBytes());

    // 释放资源
    s.close();
}

}

package cn.itcast_06;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/*
* TCP协议接收数据：
* A:创建接收端的Socket对象
* B:监听客户端连接。返回一个对应的Socket对象
* C:获取输入流，读取数据显示在控制台
* D:释放资源
*/
public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建接收端的Socket对象
// ServerSocket(int port)
ServerSocket ss = new ServerSocket(8888);

    // 监听客户端连接。返回一个对应的Socket对象
    // public Socket accept()
    Socket s = ss.accept(); // 侦听并接受到此套接字的连接。此方法在连接传入之前一直阻塞。

    // 获取输入流，读取数据显示在控制台
    InputStream is = s.getInputStream();

    byte[] bys = new byte[1024];
    int len = is.read(bys); // 阻塞式方法
    String str = new String(bys, 0, len);

    String ip = s.getInetAddress().getHostAddress();

    System.out.println(ip + "---" + str);

    // 释放资源
    s.close();
    // ss.close(); //这个不应该关闭
}

}

**1. 实例1 ：有反馈的TCP通信——-服务器给客户端反馈**

package cn.itcast_07;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket s = new Socket(“192.168.12.92”, 9999);

    // 获取输出流
    OutputStream os = s.getOutputStream();
    os.write("今天天气很好,适合睡觉".getBytes());

    // 获取输入流
    InputStream is = s.getInputStream();
    byte[] bys = new byte[1024];
    int len = is.read(bys);// 阻塞
    String client = new String(bys, 0, len);
    System.out.println("client:" + client);

    // 释放资源
    s.close();
}

}

package cn.itcast_07;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务器Socket对象
ServerSocket ss = new ServerSocket(9999);

    // 监听客户端的连接
    Socket s = ss.accept(); // 阻塞

    // 获取输入流
    InputStream is = s.getInputStream();
    byte[] bys = new byte[1024];
    int len = is.read(bys); // 阻塞
    String server = new String(bys, 0, len);
    System.out.println("server:" + server);

    // 获取输出流
    OutputStream os = s.getOutputStream();
    os.write("数据已经收到".getBytes());

    // 释放资源
    s.close();
    // ss.close();
}

}

**2.示例2：客户端键盘录入，服务器输出到控制台**

package cn.itcast_08;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

/*
* 客户端键盘录入，服务器输出到控制台
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket s = new Socket(“192.168.12.92”, 22222);

    // 键盘录入数据
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    // 把通道内的流给包装一下
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
            s.getOutputStream()));

    String line = null;
    while ((line = br.readLine()) != null) {
        // 键盘录入数据要自定义结束标记
        if ("886".equals(line)) {
            break;
        }
        bw.write(line);
        bw.newLine();
        bw.flush();
    }

    // 释放资源
    // bw.close();
    // br.close();
    s.close();
}

}

package cn.itcast_08;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务器Socket对象
ServerSocket ss = new ServerSocket(22222);

    // 监听客户端连接
    Socket s = ss.accept();

    // 包装通道内容的流
    BufferedReader br = new BufferedReader(new InputStreamReader(
            s.getInputStream()));
    String line = null;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }

    // br.close();
    s.close();
    // ss.close();
}

}

**3. 实例3：客户端键盘录入，服务器输出文本文件**

package cn.itcast_09;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

/*
* 客户端键盘录入，服务器输出文本文件
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket s = new Socket(“192.168.12.92”, 23456);

    // 封装键盘录入
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    // 封装通道内的数据
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
            s.getOutputStream()));

    String line = null;
    while ((line = br.readLine()) != null) {
        if ("over".equals(line)) {
            break;
        }

        bw.write(line);
        bw.newLine();
        bw.flush();
    }

    // bw.close();
    // br.close();
    s.close();
}

}

package cn.itcast_09;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务器Socket对象
ServerSocket ss = new ServerSocket(23456);

    // 监听客户端连接
    Socket s = ss.accept();

    // 封装通道内的数据
    BufferedReader br = new BufferedReader(new InputStreamReader(
            s.getInputStream()));
    // 封装文本文件
    BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));

    String line = null;
    while ((line = br.readLine()) != null) {
        bw.write(line);
        bw.newLine();
        bw.flush();
    }

    bw.close();
    // br.close();
    s.close();
    // ss.close();
}

}

**4.客户端文本文件，服务器输出到控制台**

package cn.itcast_10;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;

/*
* 客户端文本文件，服务器输出到控制台
*/
public class ClientDemo {
public static void main(String[] args) throws IOException {
// 创建Socket对象
Socket s = new Socket(“192.168.12.92”, 34567);

    // 封装文本文件
    BufferedReader br = new BufferedReader(new FileReader(
            "InetAddressDemo.java"));
    // 封装通道内的流
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
            s.getOutputStream()));

    String line = null;
    while ((line = br.readLine()) != null) {
        bw.write(line);
        bw.newLine();
        bw.flush();
    }

    br.close();
    s.close();
}

}

package cn.itcast_10;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo {
public static void main(String[] args) throws IOException {
// 创建服务器Socket对象
ServerSocket ss = new ServerSocket(34567);

    // 监听客户端连接
    Socket s = ss.accept();

    // 封装通道内的流
    BufferedReader br = new BufferedReader(new InputStreamReader(
            s.getInputStream()));

    String line = null;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }


    s.close();
}

}

**5.客户端文本文件，服务器输出文本文件**

package cn.itcast_11;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class UploadClient {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket s = new Socket(“192.168.12.92”, 11111);

    // 封装文本文件
    BufferedReader br = new BufferedReader(new FileReader(
            "InetAddressDemo.java"));
    // 封装通道内流
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
            s.getOutputStream()));

    String line = null;
    while ((line = br.readLine()) != null) {
        bw.write(line);
        bw.newLine();
        bw.flush();
    }

    // 释放资源
    br.close();
    s.close();
}

}

package cn.itcast_11;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class UploadServer {
public static void main(String[] args) throws IOException {
// 创建服务器端的Socket对象
ServerSocket ss = new ServerSocket(11111);

    // 监听客户端连接
    Socket s = ss.accept();

    // 封装通道内的流
    BufferedReader br = new BufferedReader(new InputStreamReader(
            s.getInputStream()));
    // 封装文本文件
    BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));

    String line = null;
    while ((line = br.readLine()) != null) {
        bw.write(line);
        bw.newLine();
        bw.flush();
    }

    bw.close();
    s.close();
}

}

TCP传输容易出现的问题


* 客户端连接上服务端，两端都在等待，没有任何数据传输。
* 通过例程分析：   
 因为read方法或者readLine方法是阻塞式。
* 解决办法：   
 自定义结束标记   
 使用shutdownInput，shutdownOutput方法。

package cn.itcast_12;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

/*
* 按照我们正常的思路加入反馈信息，结果却没反应。为什么呢?
* 读取文本文件是可以以null作为结束信息的，但是呢，通道内是不能这样结束信息的。
* 所以，服务器根本就不知道你结束了。而你还想服务器给你反馈。所以，就相互等待了。
*
* 如何解决呢?
* A:在多写一条数据，告诉服务器，读取到这条数据说明我就结束，你也结束吧。
* 这样做可以解决问题，但是不好。
* B:Socket对象提供了一种解决方案
* public void shutdownOutput()
*/

public class UploadClient {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket s = new Socket(“192.168.12.92”, 11111);

    // 封装文本文件
    BufferedReader br = new BufferedReader(new FileReader(
            "InetAddressDemo.java"));
    // 封装通道内流
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
            s.getOutputStream()));

    String line = null;
    while ((line = br.readLine()) != null) { // 阻塞
        bw.write(line);
        bw.newLine();
        bw.flush();
    }

    //自定义一个结束标记

// bw.write(“over”);
// bw.newLine();
// bw.flush();

    //Socket提供了一个终止，它会通知服务器你别等了，我没有数据过来了
    s.shutdownOutput();

    // 接收反馈
    BufferedReader brClient = new BufferedReader(new InputStreamReader(
            s.getInputStream()));
    String client = brClient.readLine(); // 阻塞
    System.out.println(client);

    // 释放资源
    br.close();
    s.close();
}

}

package cn.itcast_12;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class UploadServer {
public static void main(String[] args) throws IOException {
// 创建服务器端的Socket对象
ServerSocket ss = new ServerSocket(11111);

    // 监听客户端连接
    Socket s = ss.accept();// 阻塞

    // 封装通道内的流
    BufferedReader br = new BufferedReader(new InputStreamReader(
            s.getInputStream()));
    // 封装文本文件
    BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));

    String line = null;
    while ((line = br.readLine()) != null) { // 阻塞
    // if("over".equals(line)){
    // break;
    // }
        bw.write(line);
        bw.newLine();
        bw.flush();
    }

    // 给出反馈
    BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(
            s.getOutputStream()));
    bwServer.write("文件上传成功");
    bwServer.newLine();
    bwServer.flush();

    // 释放资源
    bw.close();
    s.close();
}

}

**6.上传图片案例**

package cn.itcast_13;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

public class UploadClient {
public static void main(String[] args) throws IOException {
// 创建客户端Socket对象
Socket s = new Socket(“192.168.12.92”, 19191);

    // 封装图片文件
    BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
            "林青霞.jpg"));
    // 封装通道内的流
    BufferedOutputStream bos = new BufferedOutputStream(s.getOutputStream());

    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = bis.read(bys)) != -1) {
        bos.write(bys, 0, len);
        bos.flush();
    }

    s.shutdownOutput();

    // 读取反馈
    InputStream is = s.getInputStream();
    byte[] bys2 = new byte[1024];
    int len2 = is.read(bys2);
    String client = new String(bys2, 0, len2);
    System.out.println(client);

    // 释放资源
    bis.close();
    s.close();
}

}

package cn.itcast_13;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class UploadServer {
public static void main(String[] args) throws IOException {
// 创建服务器Socket对象
ServerSocket ss = new ServerSocket(19191);

    // 监听客户端连接
    Socket s = ss.accept();

    // 封装通道内流
    BufferedInputStream bis = new BufferedInputStream(s.getInputStream());
    // 封装图片文件
    BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream("mn.jpg"));

    byte[] bys = new byte[1024];
    int len = 0;
    while ((len = bis.read(bys)) != -1) {
        bos.write(bys, 0, len);
        bos.flush();
    }

    // 给一个反馈
    OutputStream os = s.getOutputStream();
    os.write("图片上传成功".getBytes());

    bos.close();
    s.close();
}

总结

面试前要精心做好准备，简历上写的知识点和原理都需要准备好，项目上多想想难点和亮点，这是面试时能和别人不一样的地方。

还有就是表现出自己的谦虚好学，以及对于未来持续进阶的规划，企业招人更偏爱稳定的人。

万事开头难，但是程序员这一条路坚持几年后发展空间还是非常大的，一切重在坚持。

前端面试题汇总

JavaScript

前端资料汇总