UDP_and_TCP、 Socket、ServerSocket客户端不断键盘录入数据/文件,服务器端将数据输出在某个文件中/输出在控制台上 反馈操作

网络编程

java.net.InetAddress类:互联网ip地址统称
	这个类没有构造方法,不能直接创建对象!,提供一些成员方法使用:静态的

Runtime类: 单例模式
提供静态方法,返回该类本身

    public static InetAddress getByName(String host):
参数为:主机名称:

成员方法
    public String getHostAddress()返回 IP 地址字符串（以文本表现形式）。 
    public String getHostName():获取主机名

网络编程的三要素

协议   
	网络协议
		UDP和TCP
	应用协议
		http协议 smtp ftp
ip地址   
端口号  有效端口号:0-65535		
		0-1024:保留端口号
		常见端口号
		tomcat: 8080
            redis:6575.. (数据库---非关系型数据库  key-value )
		mysql软件:3306

Socket编程:特点:

1)两端都需要有Socket对象
2)发送端/客户端:有对应ip地址和端口号
3)接收端/服务端:绑定对应的端口号

UDP协议发送端的步骤

package com.other_stream_udp;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/*
 	UDP协议发送端的步骤
 	1) 创建发送端的Socket对象
 	2)数据报包对象 DatagramSocket
 	3)发送数据
 	4)关闭资源
 */
public class SendUDP {
	public static void main(String[] args) throws IOException {
//	 	1) 创建发送端的Socket对象
		DatagramSocket ds = new DatagramSocket();
//	 	2)数据报包对象 DatagramSocket
		String s = "hello ....弟弟";
		byte[] bytes = s.getBytes();
		int length = bytes.length;
		DatagramPacket dp = new DatagramPacket(bytes, length,
				InetAddress.getByName("10.12.156.194"),10086);
//	 	3)发送数据
		ds.send(dp);
//	 	4)关闭资源
		ds.close();
	}
}

UDP协议接收端的实现步骤

package com.other_stream_udp;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/*
 	UDP协议接收端的实现步骤
 	1)创建接收端的Socket对象,绑定端口号
 	2)创建一个数据报包--DatagramPacket:当前接收容器
 	3)接收数据
 	4)从接收容器中解析实际数据
 	5)展示数据
 */
public class ReceiveUDP {
	public static void main(String[] args) throws IOException {
//	 	1)创建接收端的Socket对象,绑定端口号
		DatagramSocket ds = new DatagramSocket(10086);
//	 	2)创建一个数据报包--DatagramPacket:当前接收容器
		byte[] bytes = new byte[1024];
		int length = bytes.length;
		DatagramPacket dp = new DatagramPacket(bytes, length);
//	 	3)接收数据
		ds.receive(dp);
//	 	4)从接收容器中解析实际数据
		//public byte[] getData()获取缓冲区数据中实际字节数组
		//public int getLength() 获取缓冲区的实际长度
		byte[] buf = dp.getData();
		int length2 = dp.getLength();
		//获取接收端发送的数据  IP地址
		InetAddress address = dp.getAddress();
		String ip = address.getHostAddress();		
//	 	5)展示数据
		String s = new String(buf,0,length2);
		System.out.println("data is:   "+s+",from "+ip);		
		//6)关闭资源
		//ds.close();
	}
}

udp发送端键盘录入数据,接收端不断接受数据(不关闭)

package com.udp.udp_01;
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 {
		//1)创建发送端的Socket对象
		DatagramSocket ds = new DatagramSocket();
		//2)键盘录入数据
		BufferedReader br = new BufferedReader(
				new InputStreamReader(System.in));
		//一次读取一行内容
		String line = null;
		while ((line = br.readLine()) != null) {
            //结束条件
			if(line.equals("88")) {
				break;
			}
			byte[] bytes = line.getBytes();
			int length = bytes.length;
			//创建数据报包对象
			/*
			public DatagramPacket(byte[] buf,
                      int length,
                      InetAddress address,
                      int port)
                 buf - 包数据。
                length - 包长度。
                address - 目的地址。
                port - 目的端口号。
			*/
			DatagramPacket dp = new DatagramPacket(bytes, length,
						InetAddress.getByName("10.12.156.190"),10000);
			//发送数据
			ds.send(dp);
		}
		ds.close();
	}
}
package com.udp.udp_01;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class ReceiveDemo {
	public static void main(String[] args) throws IOException {
//	 	1)创建接收端的Socket对象,绑定端口号
		DatagramSocket ds = new DatagramSocket(10000);
//	 	2)创建一个数据报包--DatagramPacket:当前接收容器
		while (true) {
			byte[] bytes = new byte[1024];
			int length = bytes.length;
			DatagramPacket dp = new DatagramPacket(bytes, length);
	//	 	3)接收数据
			ds.receive(dp);
	//	 	4)从接收容器中解析实际数据
			//public byte[] getData()获取缓冲区数据中实际字节数组
			//public int getLength() 获取缓冲区的实际长度
			byte[] buf = dp.getData();
			int length2 = dp.getLength();
			//获取接收端发送的数据  IP地址
			InetAddress address = dp.getAddress();
			String ip = address.getHostAddress();
			
	//	 	5)展示数据
			String s = new String(buf,0,length2);
			System.out.println("data is"+s+",from "+ip);
		}
		//6)关闭资源
		//ds.close();
	}
}

在一个窗口下聊天: 多线程,发送端开启发送端线程 接收端开启接收端线程

package com.udp.udp_02;
import java.net.DatagramSocket;
import java.net.SocketException;
/*
 	需要在一个窗口下进行聊天,发送和接收数据
 	分析
 	1)发送端和接收端都需要有Socket都需要在当前用户线程中创建出来
 	2)多线程实现方式2
 	sendThread /ReceiveThread  实现Runnable接口重写run方法
 	这两个资源类对象需要将上面的Socket对象传递进来
 	3)创建Thread类对象,将上面的SendThread和ReceiveThread作为参数传递
 	4)启动线程
 */
public class ChatRoom {
	public static void main(String[] args){
		try {
            //创建发送端的socket
			DatagramSocket ds1 = new DatagramSocket();
            //创建接收端的socket
			DatagramSocket ds2 = new DatagramSocket(10000);
			//创建资源类对象
			SendThread st = new SendThread(ds1);
			ReceiveThread rt = new ReceiveThread(ds2);
			//创建Thread类对象
			Thread t1 = new Thread(st);
			Thread t2 = new Thread(rt);
			//开启线程
			t1.start();
			t2.start();
		} catch (SocketException e) {
			e.printStackTrace();
		}
	}
}
package com.udp.udp_02;
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) {
		super();
		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 (line.equals("88")) {
					break;
				}
				byte[] bytes = line.getBytes();
				int length = bytes.length;
                //创建数据报包对象
				DatagramPacket dp = new DatagramPacket(bytes, length, InetAddress.getByName("10.12.156.190"), 10000);
                //发送数据
				ds.send(dp);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(ds != null) {
				ds.close();
			}
		}
	}
}
package com.udp.udp_02;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class ReceiveThread implements Runnable {
	private DatagramSocket ds;	
	public ReceiveThread(DatagramSocket ds) {
		super();
		this.ds = ds;
	}
	@Override
	public void run() {
		try {
			while (true) {
                //创建接收容器
				byte[] bytes = new byte[1024];
				int length = bytes.length;
				DatagramPacket dp = new DatagramPacket(bytes, length);
				// 3)接收数据
				ds.receive(dp);
				// 4)从接收容器中解析实际数据
				// public byte[] getData()获取缓冲区数据中实际字节数组
				// public int getLength() 获取缓冲区的实际长度
				byte[] buf = dp.getData();
				int length2 = dp.getLength();
				// 获取接收端发送的数据 IP地址
				InetAddress address = dp.getAddress();
				String ip = address.getHostAddress();
				// 5)展示数据
				String s = new String(buf, 0, length2);
				System.out.println("data is: " + s + ",from " + ip);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

TCP的基本使用

客户端 Scoket
服务器端: ServerScoket
需要有一种通道内流: 客户端写数据到服务器端,服务器端解析数据(读取数据)
OutputStream						InputStream

客户端不断发送数据,服务器端不断接收 展示数据
客户端的某个文件文本,服务器端复制文本文件

TCP客户端的实现步骤

package com.qianfeng.tcp_03;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
/*
  客户端的实现步骤
  	1)创建客户端的Socket对象
  		public Socket(String host,int port)
  	2)获取客户端通道内输出流,写入内容
  	3)关闭资源
  
 */
public class ClientDemo {	
	public static void main(String[] args) throws  IOException {		
		//创建客户端的Socket对象
		//public Socket(String host,int port)
		Socket s = new Socket("10.12.156.36", 8888) ;		
		//获取客户端通道内输出流,写入内容
		//public OutputStream getOutputStream()
		OutputStream out = s.getOutputStream() ;
		out.write("你好...弟弟".getBytes());		
		//释放资源
		s.close();
	}
}

TCP服务器端的实现步骤

package com.tcp.tcp_01;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
/*
 	步骤
 	1)创建服务器端的Socket对象,绑定端口
 	2)进入阻塞状态,监听客户端连接
 	3)获取动态内输入流,读数据
 	4)展示数据
 	5)释放资源
 */
public class ServerDemo {
	public static void main(String[] args) throws IOException {
        //1)创建服务器端的Socket对象,绑定端口
		ServerSocket ss = new ServerSocket(10000);
        //2)进入阻塞状态,监听客户端连接!
		Socket s = ss.accept();
        //3)获取动态内输入流,读数据
		InputStream in = s.getInputStream();
        //读数据
		byte[] bytes = new byte[1024];
		int len = in.read(bytes);
        //展示数据
		String clientStr = new String(bytes,0,len);
		String ip = s.getInetAddress().getHostAddress();
        //输出
		System.out.println("数据是: "+clientStr+"来源于"+ip);
        //释放资源
		ss.close();
	}
}

客户端发送数据,服务器将数据读取出来—服务器端反馈操作 ,客户端读取反馈信息

package com.tcp.tcp_02;
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 socket = new Socket("10.12.156.190", 8888);
		// 获取通道内的输出流
		OutputStream out = socket.getOutputStream();
		out.write("你好,我是....".getBytes());

		// 读取服务器端的反馈数据
		// 获取通道内的输入流对象
		InputStream in = socket.getInputStream();
		// 一次读取一个字节数组
		byte[] bytes = new byte[1024];
		int len = in.read(bytes);
		// 展示数据
		String serverStr = new String(bytes, 0, len);
		System.out.println(serverStr);
		// 释放资源
		socket.close();
	}
}
package com.tcp.tcp_02;
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 {
		// 创建ServerSocket对象
		ServerSocket ss = new ServerSocket(8888);
		// 监听客户端的链接
		Socket socket = ss.accept();
		// 获取通道输入流,读取数据
		InputStream in = socket.getInputStream();
		// 一次读取一个字节数组
		byte[] bytes = new byte[1024];
		int len = in.read(bytes);
		// 展示数据:客户端发来的数据
		String clientStr = new String(bytes, 0, len);
		System.out.println(clientStr);
		// 服务器端反馈给客户端
		// 获取通道内的输出流对象
		OutputStream out = socket.getOutputStream();
		out.write("数据已经收到了".getBytes());
		// 释放资源
		ss.close();
	}
}

客户端键盘录入数据,服务器端不断将数据展示在控制台上

package com.tcp.tcp_03;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
/*
 * 需求
 * 	键盘录入:BufferedReader
 * 1)客户端不断键盘录入数据,服务器端不断将数据展示在控制台上
 */
public class ClientTest {
	public static void main(String[] args) throws IOException {		
			// 创建客户端的socket
			Socket socket = new Socket("10.12.156.190", 8888);
			// 创建字符输入流 BufferedReader
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			// 获取通道内的输出流
			// OutputStream out = socket.getOutputStream();
			// 输出流要和输入流BufferedReader对应: BufferedWriter字符输出流
			// 封装getOutputStream():使用桥梁OutputStreamWriter
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
			String line = null;
			while ((line = br.readLine()) != null) {
				if(line.equals("88")) {
					break;
				}
				bw.write(line);
				bw.newLine();
				bw.flush();
			}
			socket.close();
	}
}
package com.tcp.tcp_03;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerTest {
	public static void main(String[] args) throws IOException {
			// 创建ServerSocket对象
			ServerSocket ss = new ServerSocket(8888);
			// 监听客户端的链接
			Socket socket = ss.accept();
			// 获取通道输入流,读取数据
			BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			String line = null ;
			while((line=br.readLine())!=null) {
				//输出数据
				System.out.println(line);
			}
			// 释放资源
		//	ss.close();

	}
}

客户端不断键盘录入数据,服务器端将数据输出在某个文件中

package com.tcp.tcp_04;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
// 2)客户端不断键盘录入数据,服务器端将数据输出在某个文件中
public class ClientTest {
	public static void main(String[] args) throws IOException {
		
		// 创建客户端的socket
		Socket socket = new Socket("10.12.156.190", 8888);
		// 创建字符输入流 BufferedReader
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// 获取通道内的输出流
		// OutputStream out = socket.getOutputStream();
		// 输出流要和输入流BufferedReader对应: BufferedWriter字符输出流
		// 封装getOutputStream():使用桥梁OutputStreamWriter
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
		String line = null;
		while ((line = br.readLine()) != null) {
			if(line.equals("88")) {
				break;
			}
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		socket.close();
	}
}
package com.tcp.tcp_04;
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 ServerTest {
	public static void main(String[] args) throws IOException {
		// 创建ServerSocket对象
		ServerSocket ss = new ServerSocket(8888);
		// 监听客户端的链接
		Socket socket = ss.accept();
		// 获取通道输入流,读取数据
		BufferedReader br = new BufferedReader(new InputStreamReader(socket.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();
		ss.close();
	}
}

客户端将文件写入到通道内的流中,服务器端将客户端的文件复制到另一个文件中

package com.tcp.tcp_05;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.Socket;
//  2)客户端将当前项目下ServerDemo.java文件写入到通道内的流中
//服务器端将客户端的文件进行复制到a.java文件中
public class ClientTest {
	public static void main(String[] args) throws IOException {		
		// 创建客户端的socket
		Socket socket = new Socket("10.12.156.190", 8888);
		// 创建字符输入流 BufferedReader
		BufferedReader br = new BufferedReader(new FileReader("ServerDemo.java"));
		// 获取通道内的输出流
		// OutputStream out = socket.getOutputStream();
		// 输出流要和输入流BufferedReader对应: BufferedWriter字符输出流
		// 封装getOutputStream():使用桥梁OutputStreamWriter
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
		String line = null;
		while ((line = br.readLine()) != null) {
			if(line.equals("88")) {
				break;
			}
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
		br.close();
		socket.close();
	}
}
package com.tcp.tcp_05;
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 ServerTest {
	public static void main(String[] args) throws IOException {
		// 创建ServerSocket对象
		ServerSocket ss = new ServerSocket(8888);
		// 监听客户端的链接
		Socket socket = ss.accept();
		// 封装通道内的字节输入流,读取数据 用桥梁InputStreamReader
		BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		//创建BufferedWriter 将通道流中给的数据进行复制
		BufferedWriter bw = new BufferedWriter(new FileWriter("a.java"));
		String line =null;
		while ((line = br.readLine()) != null) {

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

客户端将文件写入到通道内的流中,服务器端将客户端的文件复制到另一个文件中–加入反馈

package com.tcp.tcp_06;

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;
// * 客户端将当前项目下ServerDemo.java文件写入到通道内的流中
//服务器端将客户端的文件进行复制到a.java文件中
//加入服务器的反馈
/*
 	问题: 服务器端和客户端程序没有结束.但是文件已经复制完毕
 	String readLine() : 返回为null,仅仅表示文件已经读完了	
 	解决方案
 		1)在客户端自定义一个结束标记
 			通道输出流写入"over" 服务器端读取到over 结束
 		2)在客户端Socket中,结束的方法
 			public void shundownOutput()
 			禁用此套接字的输出流:告诉服务器端,没有传输的内容了
 */
public class ClientTest {
	public static void main(String[] args) throws IOException {		
		// 创建客户端的socket
		Socket socket = new Socket("10.12.156.190", 8888);
		// 创建字符输入流 BufferedReader
		BufferedReader br = new BufferedReader(new FileReader("ServerDemo.java"));
		// 获取通道内的输出流
		// OutputStream out = socket.getOutputStream();
		// 输出流要和输入流BufferedReader对应: BufferedWriter字符输出流
		// 封装getOutputStream():使用桥梁OutputStreamWriter
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
		String line = null;
		while ((line = br.readLine()) != null) {
			if(line.equals("88")) {
				break;
			}
			bw.write(line);
			bw.newLine();
			bw.flush();
		}
	/*	//自定义结束标记
		bw.write("over");
		bw.newLine();
		bw.flush();
	*/
		//使用Socket中结束的方法
		socket.shutdownOutput();
		//获取服务器端的反馈
		//将字节流--封装BufferedReader
		BufferedReader br2 = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		String s = br2.readLine();
		System.out.println(s);		
		br.close();
		socket.close();
	}
}
package com.tcp.tcp_06;
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 ServerTest {
	public static void main(String[] args) throws IOException {
		// 创建ServerSocket对象
		ServerSocket ss = new ServerSocket(8888);
		// 监听客户端的链接
		Socket socket = ss.accept();
		// 封装通道内的字节输入流,读取数据 用桥梁InputStreamReader
		BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		//创建BufferedWriter 将通道流中给的数据进行复制
		BufferedWriter bw = new BufferedWriter(new FileWriter("a.java"));
		String line =null;
		while ((line = br.readLine()) != null) {
		/*	//读取自定义标记
			if ("over".equals(line)) {
				break;
			}
		*/
			bw.write(line);
			bw.newLine();
			bw.flush();
	
		}
		//加入服务器的反馈
		BufferedWriter bw2 = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
		bw2.write("文件复制完毕");
		bw2.newLine();
		bw2.flush();
		bw2.close();
		
		
		bw.close();
		ss.close();
	}
}

客户端将图片写入到通道内的流中,服务器端将图片复制到另一个图片文件中–加入反馈

package com.qianfeng.tcp_09;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;
/*
  图片的复制:BufferedInputStream/BufferedOutputStream  
 
	客户端的一个图片文件 当前项目下 123.png
 	
 	服务器端将图片文件进行复制  mv.png
 	加入服务器的反馈
  
  发现问题:
  		图片文件:没有复制完整,图片文件缺失(少字节数)
  图片文件本身在内存中:缓存数据!
  
  字节缓冲输出流中:public void flush():强制将缓冲的字节数输出到流中!
 */
public class UploadImageClient {
	public static void main(String[] args) throws IOException {		
		//创建Scoket
		Socket s = new Socket("10.12.156.190",6666) ;		
		//创建字节输入流:封装图片文件
		BufferedInputStream bis = 
				new BufferedInputStream(new FileInputStream("123.png")) ;
		//封装通过的字节输出流
		BufferedOutputStream bos = new BufferedOutputStream(
									s.getOutputStream()) ;		
		//一次读取一个字节数组
		byte[] bytes = new byte[1024] ;
		int len = 0 ;
		while((len=bis.read(bytes))!=-1) {
			bos.write(bytes, 0, len);
			
			//刷新
			bos.flush();
		}
		
		//告诉服务器端,图片文件已经全部写入到输出流中,不要等待了
		s.shutdownOutput();

		//读取服务端反馈数据
		//获取通道内的字节输入流
		InputStream in = s.getInputStream() ;
		//一次读取一个字节数组
		byte[] bytes2 = new byte[1024] ;
		int len2 = in.read(bytes2) ;
		String str = new String(bytes2, 0, len2) ;
		System.out.println(str);
		
		//释放资源
		bis.close();
		s.close();
	}
}


package com.qianfeng.tcp_09;

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 UploadImageServer {
	
	public static void main(String[] args) throws IOException {
		
		ServerSocket ss = new ServerSocket(6666) ;
		
		Socket socket = ss.accept() ;
		
		//封装通道内在字节输入流
		BufferedInputStream bis = new BufferedInputStream(
							socket.getInputStream()) ;
		//输出到指定文件
		BufferedOutputStream bos = new BufferedOutputStream(
						new FileOutputStream("mv.png")) ;		
		//一次读取一个字节数组
		byte[] bytes = new byte[1024] ;
		int len = 0  ;
		while((len = bis.read(bytes))!=-1) {
			//写入
			bos.write(bytes, 0, len);
			
			//强制刷新
			bos.flush();
		}
		
		//加入反馈
		//获取通道内的输出流
		OutputStream out = socket.getOutputStream() ;
		out.write("图片已经复制完毕".getBytes());
		//刷新
		out.flush();
		
		
		//释放资源
		bos.close();
		socket.close();
	}
}