java基础_Socket

 

Socket编程：

Tcp 和 UDP的优缺点：
UDP：
1.面向无连接
2.发送大小限制，每个包不超过64k
3.因无连接，不可靠
4.不需要建立连接，效率高

Tcp
1.建立连接，形成数据传输的通道
2.在连接中进行大数据传输。
3.通过三次握手，完成连接，是可靠协议
4.必须建立连接，效率稍低

Socket:
所谓socket通常也称作"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。其实说白了就是服务端和客户端。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。

一个聊天小程序

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

/*
编写一个聊天程序
包括：收数据部分  发数据部分，这两部分同时运行，需要用到多线程技术。
一个控制send一个控制receive

因为接收数据和发送数据是两个不一致的，所以要定义两个run方法
而且这两个方法要封装到不同的类中。

 */

public class CharDemo04 {
	public static void main(String[] args) throws Exception {
		DatagramSocket send = new DatagramSocket();
		DatagramSocket rece = new DatagramSocket(10002);
	
		new Thread(new SendDemo(send)).start();
		new Thread(new ReceDemo(rece)).start();
	}
}

//发送端 实现类
class SendDemo implements Runnable {
	//成员变量
	private DatagramSocket ds;
	//构造方法
	public SendDemo(DatagramSocket ds){
		this.ds = ds;
	}
	
	public void run(){
		try {
			//缓冲区存储键盘录入
			BufferedReader bfw = new BufferedReader(new InputStreamReader(System.in));
			
			String line = null;
			while((line=bfw.readLine())!=null){
				if("886".equals(line))
					break;
				byte [] buf = new byte[1024];
				//创建DatagramPacket包，进行数据的封装
				DatagramPacket dp = new DatagramPacket(buf, buf.length,InetAddress.getByName

("127.0.0.1"),10001);
				//将数据发送
				ds.send(dp);
			}
		} catch (Exception e) {
			throw new RuntimeException("发送失败");
		}
	}
}

//接收端 实现类
class ReceDemo implements Runnable {
	
	//成员变量
	private DatagramSocket ds;
	//构造方法
	public ReceDemo(DatagramSocket ds){
		this.ds = ds;
	}
	
	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+": "+data);
			}
		} catch(Exception e){
			throw new RuntimeException("接收数据失败");
		}
	}
}

Socket编程，按照TCP传输

 

/*
	ServerSocket
	实现步骤：
	1.建立ServerSocket服务，绑定端口。
	2.获取连接的socket对象，通过accept方法接收数据，这个方法是阻塞式的，如果没有操作就会等。
	3.如果客户端发送数据过来，那么服务端要使用客户端对象获取相应流对象，对数据进行操作。
 */

public class TcpServer05 {
	public static void main(String[] args) throws Exception {
		//创建ServerSocket服务
		ServerSocket ss = new ServerSocket(10003);
		
		//获得客户端对象
		Socket s = ss.accept();
		
		//通过客户端对象获取ip
		String ip = s.getInetAddress().getHostAddress();
		
		InputStream ins = s.getInputStream();
		byte[] buf = new byte[1024];
		int len = ins.read(buf);
		System.out.println(ip+" : "+new String(buf,0,len));
		
		//客户端发送完数据被服务端关闭
		s.close();
	}
}

/*
 1.tcp分客户端和服务端，客户端对应Socket，服务端对应ServerSocket
 
 客户端
 客户端建立对象时，就可以去连接指定主机
 因为tcp是面向对连接的，所以建立socket服务时，就要有服务存在，并连接成功。形成通路后，在该通道进行数据的传输。
 
 步骤：
 1.创建socket服务，并制定要连接的主机和端口。
 2.使用socket封装的流对象进行数据的操作
 3，关闭资源
 */

public class TcpClient05 {
	public static void main(String[] args) throws Exception {
		//创建socket服务,指定目的主机和端口
		Socket s = new Socket("127.0.0.1",10003);
		
		//为了发送数据，获取socket中的输出流
		//socket中已封装了流对象，直接调用
		OutputStream out = s.getOutputStream();
		out.write("i'm comming".getBytes());
		
		//关闭socket，同时也会关闭掉内部的流对象
		s.close();
	}
}

Socket编程，按照UDP传输

public class SocketDemo {

	/**
	 * UPD工作步骤
	 * 1.创建socket服务
	 * 2.将数据封装成数据包
	 * 3.通过datagrampackage将封装的数据发送出去
	 * 4.关闭资源
	 */
	public static void main(String[] args) throws Exception {
		//1.创建socket服务
		DatagramSocket ds = new DatagramSocket(10000);
		//2.封装数据
		byte[] buf = "abcdefg".getBytes();
		DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.1"),1000);
		
		//3.将封装的数据发送
		ds.send(dp);
		
		//4.关闭数据流
		ds.close();
	}

}

class SocketDemo3 {
	public static void main(String[] args) throws Exception {
		//1.创建DatagramSocket服务
		DatagramSocket ds = new DatagramSocket(10000);
		//创建数据存储
		byte[]buf = new byte[1024];
		DatagramPacket dp = new DatagramPacket(buf, buf.length);
		//通过服务的receive方法
		ds.receive(dp);
		//通过数据包中的方法获取其中的数据
		String ip = dp.getAddress().getHostAddress();
		String data = new String(dp.getData(),0,dp.getLength());
		int port = dp.getPort();
		System.out.println(ip+"::"+data+"::"+port);
		
		//关闭资源
		ds.close();
	}
}

注意：应根据两种方式的区别更深刻的去了解他们本质的不同。

Socket转换数据
Client：

/*
 客户端分析
 步骤
 1.创建socket服务
 2.获取键盘录入的信息
 3.将信息发送到服务端
 4.接收服务端反馈的信息
 5.关闭资源
 */

public class TransClient07 {
	public static void main(String[] args) throws Exception {
		//socket
		Socket s = new Socket("127.0.0.1",10005);
		
		//获取键盘录入数据
		BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
		
		//数据写入流
		//BufferedWriter bfout = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		PrintStream bfout = new PrintStream(s.getOutputStream(),true);
		
		//接收服务端反馈的数据
		BufferedReader bfin = new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		String line = null;
		//操作  读取键盘信息||将数据写入到服务器端||读取服务器端的反馈
		while((line=bfr.readLine())!=null){
			//将数据写入到服务器端
			bfout.println(line);
//			bfout.write(line);
//			bfout.newLine();
//			bfout.flush();
			if("over".equals(line))
				break;
			//读取服务器端的反馈
			String len = bfin.readLine();
			System.out.println("server:"+len);
		}
		//关闭资源
		bfr.close();
		s.close();		
	}
}

Server：

/*
服务器端
步骤：
1.创建ServerSocket服务，绑定端口
2.接收客户端信息，处理后返回给客户端
3.关闭资源
 */
public class TransServer07 {
	public static void main(String[] args) throws Exception {
		//创建服务
		ServerSocket ss = new ServerSocket(10005);
		
		//连接客户端
		Socket s = ss.accept();
		System.out.println(s.getInetAddress().getHostAddress()+" is connected!");
		
		//接收数据
		BufferedReader bfin = new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		//数据处理流,进行反悔
		//BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		PrintStream bfw = new PrintStream(s.getOutputStream(),true);
		
		//数据处理
		String line = null;
		while((line=bfin.readLine())!=null){
//			System.out.println("server: "+line);
			bfw.println(line.toUpperCase());
//			bfw.write(line.toUpperCase());
//			bfw.newLine();
//			bfw.flush();
		}
		//关闭资源
		s.close();
		ss.close();
	}
}