网络编程（二）

最新推荐文章于 2020-11-09 18:02:04 发布
最新推荐文章于 2020-11-09 18:02:04 发布
阅读量200 收藏 1
点赞数
分类专栏： Java 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nieo_Waiting/article/details/104206518
版权

服务端和客户端无限通信（需要线程）（基于TPC协议的网络编程）

Cilent

public class Client {
      public static void main(String[] args) {
  		try {
  			Socket socket = new Socket("127.0.0.1", 9000);
  			System.out.println("客户端连接");
  			//接收服务器的信息
  			InputStream inputStream = socket.getInputStream();
  			BufferedInputStream bis = new BufferedInputStream(inputStream);
  			//给服务器发送数据
  			OutputStream outputStream = socket.getOutputStream();
  		    //控制台输入信息
  			Scanner input= new Scanner(System.in);
  			
  			BufferedOutputStream bos = new BufferedOutputStream(outputStream);
  		    
  			new ReadThread(bis).start();
  		    while(true) {
  		    	String next = input.next();
  		    	bos.write(next.getBytes());
  		    	bos.flush();
  		    }
  		
  		
  		} catch (IOException e) {
  			// TODO Auto-generated catch block
  			e.printStackTrace();
  		}
  		
	}
}

Server

public class Server {

	public static void main(String[] args)  {
		
	 try {
		 ServerSocket server = new ServerSocket(9000);
		 System.out.println("等待连接");
		 //连接客户端
		 Socket socket = server.accept();
		 System.out.println("连接成功");
		 //获取输出流对象
		 OutputStream outputStream = socket.getOutputStream();
		 BufferedOutputStream bos = new BufferedOutputStream(outputStream);
		 //获取客户端的信息
		 BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
		  //控制台输入信息
		 Scanner input = new Scanner(System.in);
		 new ReadThread(bis).start();
		 
		 while(true) {
			String next = input.next();
			bos.write(next.getBytes());			 
			bos.flush();
		 }
		 
		 
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	}
}

ReadThread线程

public class ReadThread extends Thread {

	BufferedInputStream bis;

	public ReadThread(BufferedInputStream bis) {
		super();
		this.bis = bis;
	}
	
	@Override
	public void run() {
		
		while(true) {
			int i=0;
			byte[] b =new byte[1024];
			try {
				while((i=bis.read(b))!=-1) {
					String str = new String(b,0,i);
					System.out.println(str);
				}
				
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}			
		}	
	}
	
}

效果图
Server
在这里插入图片描述Client
在这里插入图片描述

服务端向客户端群发（基于TPC协议的网络编程）

Client（开启三个，代码都一样）

public class Client1 {

	public static void main(String[] args) throws Exception {
		   Socket socket =  new Socket("127.0.0.1",9000);
		   System.out.println("客户端连接......");
		   BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));			
			new ReadThread(in).start();			
	}
}

Server

public class Server {
	//创建集合存储客户端的socket
    static List<Socket> collections = new ArrayList<>();
	public static void main(String[] args) throws Exception {
		ServerSocket server = new ServerSocket(9000);		
		System.out.println("等待连接");
	    Scanner input =new Scanner(System.in);
	//  加线程  为了遍历取出connections中的socket 
	    new QunFaThread(input).start();
	    while(true){
	    	//开始连接客户端
			Socket socket = server.accept();
			System.out.println("连接的客户端："+socket);
			//存储客户端的socket
			collections.add(socket);
			System.out.println("集合中的元素------"+collections);
		    //获取客户端发来的信息
		   // BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));	    
	    }
	}	
	public static void sendAll(String s) throws Exception{
		 if(null != collections){
			 for (int i = 0; i < collections.size(); i++) {
				 Socket socket = collections.get(i);
				 PrintWriter pw = new PrintWriter(socket.getOutputStream());
				 pw.println(s);
				 pw.flush();
			}
		 }
	}
}

ReadThread

public class ReadThread extends Thread{
	BufferedReader br;	
public ReadThread(BufferedReader br) {
		super();
		this.br = br;
	}
public void run() {
	while(true){
	  try {
		String readLine = br.readLine();
		System.out.println(readLine);
	} catch (IOException e) {
		e.printStackTrace();
		}
	}
}
}

QunFaThread

public class QunFaThread extends Thread{
    Scanner input;	
	public QunFaThread(Scanner input) {
		super();
		this.input = input;
	}
	public void run() {
		while(true){
			String s = input.nextLine();
		 try {
			Server.sendAll(s);
		} catch (Exception e) {
			
			e.printStackTrace();
		}
		}	 
	}
}

效果图：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

客户端向客户端群发（基于TPC协议的网络编程）

客户端–服务端–客户端
Client(开启三个客户端)

public class Client1 {

	public static void main(String[] args) throws Exception {
		   Socket socket =  new Socket("127.0.0.1",9000);
		   System.out.println("客户端连接......");
		   BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		   PrintWriter pw = new PrintWriter(socket.getOutputStream());
		   Scanner input = new Scanner(System.in);
		  new ReadThread(in).start();
		  while(true){
				pw.println(input.nextLine());
				pw.flush();
			}
	}
}

Server

public class Server {

	//创建集合存储客户端的socket
    static List<Socket> collections = new ArrayList<>();
	public static void main(String[] args) throws Exception {
		
		ServerSocket server = new ServerSocket(9000);
		
		System.out.println("等待连接");
	    Scanner input =new Scanner(System.in);
	
	  
	    while(true){
	    	//开始连接客户端
			Socket socket = server.accept();
			System.out.println("连接的客户端："+socket);
			//存储客户端的socket
			collections.add(socket);
			System.out.println("集合中的元素------"+collections);
		    
		    new QunFaThread(socket).start();
	    }
	}
	
	public static void sendAll(String s) throws Exception{
		 if(null != collections){
			 for (int i = 0; i < collections.size(); i++) {
				 Socket socket = collections.get(i);
				 PrintWriter pw = new PrintWriter(socket.getOutputStream());
				 pw.println(s);
				 pw.flush();
			}
		 }
	}
}

ReadThread

public class ReadThread extends Thread{
	BufferedReader br;
	
public ReadThread(BufferedReader br) {
		super();
		this.br = br;
	}

public void run() {
	while(true){
	  try {
		String readLine = br.readLine();
		System.out.println(readLine);
	} catch (IOException e) {
		e.printStackTrace();
		}
	}
}
}

QunFaThread

public class QunFaThread extends Thread{
	Socket socket;	
	public QunFaThread( Socket socket) {
		super();
		this.socket = socket;
	}
	public void run() {
		   while(true){
			//得到输入流
				try {
					BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
					String s = br.readLine();
						Server.sendAll(s);
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}			
	}
}
}

效果图：在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

客户端和客户端的私聊（基于TPC协议的网络编程）

Client

public class Client1 {

	public static void main(String[] args) throws UnknownHostException, IOException {
		//输入自己的名称
		Scanner input = new Scanner(System.in);
		System.out.println("请输入您的姓名：");
		String name = input.next();
		Socket socket = new Socket("127.0.0.1",9001);
		//接收服务端发来的消息
		BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		//将自己的姓名传过去
		PrintWriter pw = new PrintWriter(socket.getOutputStream());
		pw.println(name);
	    pw.flush();
	    
	    new ReadThread(br).start();
	     
	    while(true) {
	     //给服务端发送消息		
	     PrintWriter pw2 = new PrintWriter(socket.getOutputStream());
	     pw2.println(input.next());
	     pw2.flush();
	     }

	}
}

Server

public class Server {

	static ArrayList<Socket> socketList = new ArrayList<>(); 
	static ArrayList<QunFaThread> threadList = new ArrayList<>(); 
	
	public static void main(String[] args) throws Exception {
		
		@SuppressWarnings("resource")
		ServerSocket serverSocket = new ServerSocket(9001);
		System.out.println("等待连接");
		while(true) {
			//连接客户端
			Socket socket = serverSocket.accept();
			socketList.add(socket);
			System.out.println("连接成功-----------------------"+socket);
			BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			//获取客户端的名字
			String name = br.readLine();
			QunFaThread qf = new QunFaThread(name,socket);		
			threadList.add(qf);
			//开启线程
			qf.start();
		}
		
	}
	//群发
	public static void sendAll(String str) throws IOException {
		if(null!=socketList) {
			for (int i = 0; i < socketList.size(); i++) {
				Socket socket = socketList.get(i);
                //向所有的客户端发送消息
				PrintWriter pw = new PrintWriter(socket.getOutputStream());				
				pw.println(str);
				pw.flush();
			}
			
		}
		else {
			System.out.println("没有客户端连接服务器");
		}
	}
	
	//私聊
	public static  void sendOne(String fromName,String toName,String line) throws IOException {
		
		if(null!=socketList) {
			
			for (int i = 0; i < socketList.size(); i++) {
				
				QunFaThread qf = threadList.get(i);
				PrintWriter pw = new PrintWriter(new OutputStreamWriter(qf.getSocket().getOutputStream()));				
				if(qf.getFromName().equals(toName)){
					pw.println(line);
				    pw.flush();
				}
				else {
					System.out.println("查无此人");
				}				
			}			
		}	
	}
}

ReadThread

public class ReadThread extends Thread {
	BufferedReader br;

	public ReadThread(BufferedReader br) {
		super();
		this.br = br;
	}

	public void run() {
		while (true) {
			try {
				String readLine = br.readLine();
				System.out.println(readLine);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

QunFaThread

public class QunFaThread extends Thread{

	String fromName;
	Socket socket;
	public QunFaThread(String fromName, Socket socket) {
		super();
		this.fromName = fromName;
		this.socket = socket;
	}	
	public String getFromName() {
		return fromName;
	}
	public void setFromName(String fromName) {
		this.fromName = fromName;
	}
	public Socket getSocket() {
		return socket;
	}
	public void setSocket(Socket socket) {
		this.socket = socket;
	}



	@Override
	public void run() {	
	   while(true) {		 		   
		   try {
			BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		     
		    //获取客户端发来的信息
			String readLine = br.readLine();
		   //@one@xiaoming@nihao
			if(readLine.startsWith("@one")) {
				//私聊
				String[] s = readLine.split("@");
				Server.sendOne(fromName, s[2], s[3]);
			}
			else {
				//群发
				Server.sendAll(readLine);
			}
		   } catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		   
	   }
	}	
}

效果图
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

关闭Socket

Socket的close()方法，关闭socket的同时也会关闭由socket创建的流
调用流的close方法关闭socket获取的输入或输出流的同时，也会关闭对应的socket。
在这里插入图片描述

UPD协议

定义： UDP协议是提供非连接的、面向事务的、简单不可靠的通信服务的传输层协议

基于UDP协议的网络编程：

DatagramSocket
定义：用于发送和接收数据报包的套接字
构造方法：

DatagramSocket ds=new DatagramSocket(); 
DatagramSocket ds=new DatagramSocket(int prot);//端口号
DatagramSocket ds=new DatagramSocket(int port, InetAddress laddr);//端口号 ip地址

方法：
在这里插入图片描述
DatagramPacket
包含要发送或接收的数据
包含数据报发送或接收的地址信息
构造方法

DatagramPacket  dp = DatagramPacket(byte[ ] data, int length) //数据   数据长度
DatagramPacket  dp = DatagramPacket(byte[ ] data, int offset, int length)//数据  数据偏移量 数据长度
DatagramPacket  dp = DatagramPacket(byte[ ] data, int length, InetAddress remoteAddr, int remotePort)//数据  数据长度 目的ip地址 目的端口号

方法
在这里插入图片描述

服务端给客户端发送消息（基于UDP协议的网络通信）

Server

public class Server {

	@SuppressWarnings("resource")
	public static void main(String[] args) throws SocketException, Exception {
		//创建套接字
		DatagramSocket ds = new DatagramSocket();
		//要发送的数据
		String str="你好，我是服务端";
		//创建要发送的数据报包，传入要发送的数据，数据长度，目的ip地址及端口号
		DatagramPacket datagramPacket = new DatagramPacket(str.getBytes(), str.length(),InetAddress.getByName("127.0.0.1"),7788);
		//发送数据
		ds.send(datagramPacket);
		//释放资源
		ds.close();
	}
}

Client

public class Client {

    @SuppressWarnings("resource")
	public static void main(String[] args) throws Exception {
		
    	//创建套接字，端口号7788
    	DatagramSocket ds = new DatagramSocket(7788);
        //创建DatagramPacket对象，用于接收数据
    	DatagramPacket dp = new DatagramPacket(new byte[1024], 1024);
    	//等待接收数据，没有数据则阻塞
    	ds.receive(dp);
    	
    	String str = new String(dp.getData(),0,dp.getLength());
	   //打印接收到的信息
        System.out.println(str+"来自"+dp.getAddress()+"-----"+dp.getPort());
       ds.close();
    }
}

效果图
在这里插入图片描述

服务端和客户端即时通信（UDP协议网络通信）

Server

public class Server {

	public static void main(String[] args) throws Exception {
		//创建发送套接字               
		DatagramSocket sendsocket = new DatagramSocket(10000);
		//创建接收套接字
		DatagramSocket recesocket = new DatagramSocket(9000);
		//准备目的主机的IP地址
		InetAddress address = InetAddress.getByName("localhost");
		//发送线程建立         发送套接字，目的主机IP地址和目的主机用于接收的端口号
		Send_Thread send_thread = new Send_Thread(sendsocket, address,8888);
		//接收线程的建立
		Receive_Thread rece_thread = new Receive_Thread(recesocket);
		//启动线程
		send_thread.start();
		rece_thread.start();

	}
}

Client

public class Client {

	public static void main(String[] args) throws Exception {
		
		//创建发送套接字
		DatagramSocket sendsocket = new DatagramSocket(10001);
		//创建接收套接字
		DatagramSocket recesocket = new DatagramSocket(8888);
		//准备目的主机的IP地址
		InetAddress address = InetAddress.getByName("localhost");
		//发送线程建立            //发送套接字，目的主机IP地址和目的主机用于接收的端口号
		Send_Thread send_thread = new Send_Thread(sendsocket, address,9000);
		//接收线程的建立
		Receive_Thread rece_thread = new Receive_Thread(recesocket);
		//启动线程
		send_thread.start();
		rece_thread.start();
	}

}

Send_Thread

public class Send_Thread extends Thread {
	//发送的socket端
    private DatagramSocket sender = null;
    //待发送的目标地址
    private InetAddress address = null;
    private int port;   //监听端口
    //从键盘输入
    Scanner scan = new Scanner(System.in);
    public Send_Thread(DatagramSocket sender,InetAddress address,int port)
    {
        this.sender = sender;
        this.address = address;
        this.port = port;
    }
    public void run(){
    	  try{
              while(true){
                  //输入待发送的内容
                  String input = scan.nextLine();
                  if(input.equals("exit"))
                      break;
                  byte[] data = null;
                  data = input.getBytes("UTF-8");
                  //构造数据报包对象
                  DatagramPacket pack = new DatagramPacket(data, data.length,address,port);
                  sender.send(pack);    
              }
              System.out.println("Exit!");  
          }catch(IOException e){
        	  
          }

    }

}

Receive_Thread

public class Receive_Thread extends Thread {
	private static final int MAX_RECEIVE_BUFFER = 1024;
    private DatagramSocket server;
    private DatagramPacket packet;
    byte[] buffer = new byte[MAX_RECEIVE_BUFFER];
    public Receive_Thread(DatagramSocket server){
        this.server = server;
        packet = new DatagramPacket(buffer, buffer.length);
    }
   
    public void run(){
    	   while(true) {
    	      //接收套接字负责接收数据包
    	      try {
				server.receive(packet);
				//数据报包中获取数组格式的数据转为字符串格式
	    	    String s = new String(packet.getData(),packet.getOffset(),packet.getLength(),"UTF-8");
	    	    System.out.println(packet.getAddress()+"：端口号"+packet.getPort()+"说 :"+s);
	    	  
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
    	       }
    	}
}

效果图
在这里插入图片描述
在这里插入图片描述

UDP与TCP协议比较

优缺点比较
在这里插入图片描述
适用场景对比
TCP协议适用于对网络质量有要求的场景。比如文件传输，发送或接收邮件。
UDP协议适用于对网络通讯质量要求不高，但速度要快的场景。比如语音广播或视频。

Nieo?
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络编程（五）
rongnianci的博客
02-12 477
Netty Netty是什么？优势是什么？ 为什么要使用Netty 1、虽然JAVA NIO框架提供了 多路复用IO的支持，但是并没有提供上层“信息格式”的良好封装。例如前两者并没有提供针对 Protocol Buffer、JSON这些信息格式的封装，但是Netty框架提供了这些数据格式封装（基于责任链模式的编码和解码功能）； 2、NIO的类库和API相当复杂，使用它来开发，需要非常熟练地掌握Se...
Java多线程，对锁机制的进一步分析
程序员小乐
07-24 219
点击上方 "程序员小乐"关注,星标或置顶一起成长每天凌晨00点00分,第一时间与你相约每日英文A lot of people would rather stay si...
Java多线程与线程同步
qq_43886407的博客
06-12 122
继承Runnable接口实现 public class TicketSaling implements Runnable{ private int ticket=100; private Object obj= new Object(); public void run(){ while(ticket>0){ synchronized(obj){ System.out.println(Thread.currentThread().getName()+ ...
多线程之继承Thread类
weixin_34204722的博客
06-17 63
2019独角兽企业重金招聘Python工程师标准>>> ...
【java学习记录】11.用多线程实现阶乘的计算过程和结果的读取（thread类ReadThread ）
六盆的博客
11-23 6672
* 采用Thread类的子类实现线程  * 编写一多线程程序，实现如下功能：   * （1）一个线程进行阶乘和的运算（1！+2！+3！+… … +30!）， 每次阶乘计算时间随机间隔0.5-1秒；  * （2）另一个线程每隔1秒时间读取上个线程的运算结果和计算 进程，并在图形界面中实时显示结果。 ComputeThread  public class ComputeThread ex
cas CompareAndSwap
alenejinping的专栏
11-09 245
import org.apache.xmlbeans.impl.xb.xsdschema.Public; import java.util.concurrent.atomic.AtomicInteger; /** * 1 cas : CompareAndSet * 2 比较并交换 * 3 自旋锁 * 4 Unsafe类 */ public class CasDemo { public static void main(String[] ags){ Atomic...
Windows网络编程 杨秋黎 课后习题答案.pdf
07-04
在介绍知识点之前，需要明确一点：Windows网络编程是一个比较广泛的领域，涵盖了很多基础概念和高级技巧，而提供的文件内容仅涉及到IP地址和子网掩码相关的一些习题答案。因此，以下内容将主要围绕IP地址分类、子网...
UNIX网络编程随书源代码（包含卷一卷二）
02-29
Richard Stevens撰写，分为卷一和卷二，深入探讨了UNIX系统上的网络编程技术。这本书对于理解和掌握网络编程的基本概念、API以及实际应用有着极大的帮助。源代码是学习过程中的重要辅助资料，通过实践这些代码，...
c++网络编程 卷一卷二
11-09
"C++网络编程 卷一卷二"可能是一套深入探讨这个主题的书籍，分为两卷，旨在通过ACE（Adaptive Communication Environment）库和设计模式来降低网络编程的复杂性。 首先，让我们详细了解一下ACE库。ACE是一个开源的...
《Python网络编程基础》第二章，套接字网络编程基础PPT，网络小白必看
08-14
PPT内容是基于《Python网络编程基础》这本教材，但是去粗取精，可以作为期末考试复习的资料，而且第二章是网络编程最重要的一章——套接字通信，里面有学习视频的链接。
笔记_UNIX环境网络编程卷二进程间通信_中文第二版.pdf
06-16
笔记_UNIX环境网络编程卷二进程间通信_中文第二版
2018-06-15 第四十天
06-19 173
一、TCP使用 Socket 对象 进行 通信 ，使用底层的TCP 协议。 面向连接的协议。 1：先建立连接。  通信的两端 都会有进行通信的Socket 对象。2：使用Socket 对象 使用字节流进行消息的通信。 import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.DataInputStream;...
【网络安全】HTTPS以及socket实现代码（1）
11-10 910
服务端 [java] view plain copy   import java.io.BufferedInputStream;   import java.io.BufferedOutputStream;   import java.io.FileInputStream;   import java.io.InputStream;   import java.io.OutputStr...
Java Socket/HttpURLConnection读取HTTP网页
Zhang Phil
03-05 4149
以读取百度的http网页为例。如果知道了IP地址和端口，然后新建一个Socket，就直接去读百度的首页，根本没反应，原因是www.baidu.com是以http协议传输的，而现在要以Socket原始的套接字读写，远程服务器没有收到客户端的GET报文，故无法做出响应。正确的方式是在Socket输出流中写入HTTP的GET报文，输出流中的报文告诉远程服务器自己要GET网页内容，这样远程服务器才会响应我...
java Socket编程（二）
zbwork000的专栏
12-20 522
下面的程序实现通过客户端向服务器端发送输入的消息，服务器端接收消息进行打印。 服务器端程序 package com.robert.view; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.D
Android在使用socket时，调用BufferedInputStream.read方法时的阻塞问题
Dimanche的博客
06-20 2659
这两天在搞一个实时通讯的东西，自然就使用到了socket，关于socket的介绍以及原理可参考https://www.cnblogs.com/kakawater/p/7085122.html或自行百度。 在使用BufferedInputStream.read()方法读取socket传输过来的数据的时候，发现该方法会阻塞主线程，导致程序不能够往下继续运行，一直到下一次...
Java Socket框架Apache MINA实现Socket服务器-客户端双向即时消息通信
Zhang Phil
04-06 2091
Java Socket框架Apache MINA实现Socket服务器-客户端双向即时消息通信 基于Java Socket框架Apache MINA，实现一对简单的基于Socket的服务-客户端双向即时消息通信。服务器绑定本地80端口，客户端连接服务器，建立连接后，双方开始互发消息服务器端可客户端均能在控制台收发消息（控制台输入字符串然后按enter键发送）。当任意一方发送消息字符串“bye”时...
基于单片机的红外感应防盗报警器的硬件设计-本科毕业设计.doc
最新发布
08-27
基于单片机的红外感应防盗报警器的硬件设计-本科毕业设计.doc
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值