java笔记-网络编程-网络基础

最新推荐文章于 2021-08-04 18:39:54 发布

Cs1275

最新推荐文章于 2021-08-04 18:39:54 发布

阅读量782

点赞数

分类专栏：走走

本文链接：https://blog.csdn.net/cs_ing/article/details/38610341

版权

走走专栏收录该内容

28 篇文章 0 订阅

订阅专栏

网络编程

网络通信的基础：

1.找到对方IP

2.将数据发送到对方指定的应用程序上，该应用程序需要有一个端口被发送的数据识别。

3.定义通信规则，该规则称为协议。

网络参考模型

网络传输协议(UDP,TCP/IP)

UDP

1.将数据，源和目的封装成到数据包中，不需要连接；

2.每个数据包的大小限制在64k内；

3.因无连接，是不可靠协议；

4.不需要建立建立，传输速度快。

TCP/IP

1.需要建立连接，形成数据传输的通道；

2.在连接中可进行大量的数据传输；

3.通过三次握手连接，是可靠的通信协议；

4.必须建立连接，效率会慢。

网络通信机制Socket

Socket就是为网络服务提供的一种机制，通信的两端都有Socket，网络通信其实就是Socket间的通信，数据在两个Socket间通过IO传输。

Socket发送端

思路：

1.建立UDPSocket服务；

2.将发送的数据存储在数据包中；

3.通过Socket服务的发送功能将数据发送出去；

4.关闭资源。

import java.net.*;
class SocketSendDemo 
{
	public static void main(String[] args) throws Exception
	{
		//构建数据包;
		DatagramSocket ds=new DatagramSocket();
		//定义要发送的数据并存储在字节数组中。
		byte[] buf="Socket send data.".getBytes();;
		//打包要发送的数据；
		DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("localhost"),1004);
		//发送打包的数据。
		ds.send(dp);
		//关闭资源。
		ds.close();
	}
}

Socket接收端

思路：

1.定义UDPSocket服务，通常会监听一个端口，其实就是给这个接收网络应用程序定义数字标识，方便识别哪些应用程序可以通过该端口处理数据；

2.定义数据包，存储接收到的数据，通过数据包对象可以更方便的提取包中的不同数据信息；

3.通过Socket服务的receive方法接收发送的数据并存储在定义好的数据包中；

4.通过数据包对像的特有功能，将不同的数据取出并打印在控制台上；

5.关闭资源。

import java.net.*;
class UdpReceive 
{
	public static void main(String[] args) throws Exception
	{
		//构建数据包;并定义该接收端的端口为1004
		DatagramSocket ds=new DatagramSocket(1004);
		//构建字节数组存储要发送的数据
		byte[] buf=new byte[1024];
		//打包要接收长度为buf.length的数据
		DatagramPacket dp=new DatagramPacket(buf,buf.length);
		//接收发送的数据的数据。该语句会一直等待接收发送端发送过来的数据
		ds.receive(dp);
		//根据接收到的包的对象获取相关信息。
		//getAddress返回InetAddress对象，该对象的getHostAddress方法返回主机ip地址的字符串。
		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();
	}
}

发送键盘录入的数据

思路：

1.构建socket发送端

2.接收键盘录入的信息，以行为单位，按照字节存储

3.将存储后的字节数据打包发送给接收端

4.构建socket接收端

5.循环接收发送端发送的数据

6.根据发送的数据包对象分拆数据信息并打印。

/*
** 发送键盘录入的数据。
*/
import java.io.*;
import java.net.*;
class KeySend 
{
	public static void main(String[] args) throws Exception
	{
		//构建socket服务
		DatagramSocket ds=new DatagramSocket();
		//接收键盘数据
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		String line;
		//循环读取键盘输入。
		while((line=bufr.readLine())!=null){
			//设置中止输入符
			if("886".equals(line)){
				break;
			}
			//将行数据转化为字节数据
			byte[] buf=line.getBytes();
			//构建socket包，打包要发送的数据
			//localhost若更改为192.168.1.255,为广播。
			DatagramPacket dp=new DatagramPacket(buf,0,buf.length,InetAddress.getByName("localhost"),10004);
			ds.send(dp);
		}
		ds.close();
	}
}
class KeyReceive 
{
	public static void main(String[] args) throws Exception
	{
		//构建socket服务，接收发送给10004端口的数据。
		DatagramSocket ds=new DatagramSocket(10004);
		//循环接收数据。
		while(true){
			//存储接受到的数据。
			byte[] bufr=new byte[1024];
			//将接收到的数据打包。
			DatagramPacket dp=new DatagramPacket(bufr,bufr.length);
			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+"::"+port+"::"+data);
		}
		//ds.close();
	}
}

聊天程序

聊天分为发送和接收两部分，建立两个线程分别启动发送和接收线程即可。

1.构建发送线程

2.不断读取键盘输入信息，按行打包数据

3.将打包的数据发送到接收端

4.异常捕捉

5.构建接收线程

6.建立字节数组，接收发送过来的数据并存储在字节数组中

7.打包接收到的字节数组，建立包对象

8.根据包对象分拆包数据信息并打印

9.异常捕捉

10.启动发送和接收线程。

import java.io.*;
import java.net.*;
/*
** 发送
*/
class Send implements Runnable
{
	private DatagramSocket ds;
	Send(DatagramSocket ds){
		this.ds=ds;
	}
	public void run(){
		try{
			//读取键盘输入
			BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
			String line=null;
			//循环读取行信息。
			while((line=bufr.readLine())!=null){
				//输入886停止程序
				if("886".equals(line)){
					break;
				}
				byte[] buf=new byte[1024];
				buf=line.getBytes();
				//将要发送的数据打包并发送，指定要发送的ip地址和端口
				DatagramPacket dp=new DatagramPacket(buf,0,buf.length,InetAddress.getByName("localhost"),10009);
				ds.send(dp);
			}
			//关闭资源。
			ds.close();
		}
		catch(Exception e){
			throw new RuntimeException("send error.");
		}
	}
}
/*
** 接收
*/
class Receive implements Runnable
{
	private DatagramSocket ds;
	Receive(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("receive error.");
		}	
	}
}
class ChatDemo 
{
	public static void main(String[] args) throws Exception
	{
		//建立发送socket服务。
		DatagramSocket sendInfo=new DatagramSocket();
		//建立接收socket服务，并初始化接收端口
		DatagramSocket receiveInfo=new DatagramSocket(10009);
		//开启发送和接收线程。
		new Thread(new Receive(receiveInfo)).start();
		new Thread(new Send(sendInfo)).start();
	}
}

TCP协议数据传输

客户端：

1.建立socket服务，指定要连接的主机和端口

2.获取socket的输出流，将数据写入到输出流，通过网络发送给服务器

3.获取socket的输入流，获取服务器端的反馈信息并打印

4.关闭客户端资源

服务端：

1.建立SeverSocket服务，监听连接到服务器的端口

2.获取连接到服务器的客户端对象

3.根据客户端对象获取输入流，读取客户端发送数据并打印

4.接收到数据后，再获取输出流，向输出流发送反馈信息

/*
** 需求：客户端向服务器端发送数据，服务器端接收数据后打印到控制台
*/
import java.io.*;
import java.net.*;
class TcpClient 
{
	public static void main(String[] args) throws Exception
	{
		/*
		** 客户端发送数据
		*/
		//建立socket对象，该对象一旦建立，即和服务端建立了连接。
		Socket s=new Socket("localhost",10000);
		//通过socket对像方法获取输出流。
		OutputStream os=s.getOutputStream();
		//将数据写入到输出流
		os.write("client send:hello cs.".getBytes());
		/*
		** 接收服务端发送的数据
		*/
		InputStream in=s.getInputStream();
		byte[] buf=new byte[1024];
		int len=0;
		//读取客户端输入流中的数据
		len=in.read(buf);
		System.out.println(new String(buf,0,len));
		s.close();
	}
}
class TcpServer
{
	public static void main(String[] args)throws Exception{
		/*
		** 服务器接收客户端发送的数据
		*/
		//建立serverSocket服务端并监听10000端口
		ServerSocket ss=new ServerSocket(10000);
		//通过serverSocket对象方法获取连接到该服务器的客户端。
		Socket s=ss.accept();
		//通过连接的客户端获取输入流。
		InputStream is=s.getInputStream();
		byte[] buf=new byte[1024];
		int len=0;
		//读取输入流中的数据。
		len=is.read(buf);
		//根据客户端对象获取连接的客户端的ip地址。
		String ip=s.getInetAddress().getHostAddress();
		//打印输出。
		System.out.println(ip+":"+new String(buf,0,len));
		/*
		** 服务器端接收到数据后发送反馈信息。
		*/
		OutputStream os=s.getOutputStream();
		os.write("sever send:I have receive data.".getBytes());
	}
}

客户端服务端交互（使用缓存技术）

/*
** 需求：建立文本转换服务器
** 客户端给服务端发送文本，服务端将文本转换为大写再发送给客户端
** 客户端可不断输入进行文本转换，但输入over时退出。
*/
import java.io.*;
import java.net.*;
class TransClient 
{
	public static void main(String[] args) throws Exception
	{
		//建立socket服务，初始化主机连接和端口
		Socket s=new Socket("localhost",10001);
		/*
		** 向服务端发送键盘录入数据
		*/
		//建立缓存，由于客户端和服务端传送的是字节数据，缓存使用的是字符数据，需要进行字节到字符的转换。
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
		String len=null;
		while((len=bufr.readLine())!=null){
			if("over".equals(len)){
				break;
			}
			bufw.write(len);
			//bufr.readLine()在读取数据时没有读取换行。需要在行数据后面添加换行。
			bufw.newLine();
			bufw.flush();
			
			/*
			** 接收服务器端返回的大写数据，并打印。
			*/
			String receUper=bufIn.readLine();
			System.out.println(receUper);
		}
		bufr.close();
		s.close();
	}
}
class TransServer
{
	public static void main(String[] args)throws Exception{
		/*
		** 建立服务器端和客户端的连接
		*/
		//建立服务器，监听端口10001
		ServerSocket ss=new ServerSocket(10001);
		//获取连接到服务器的客户端。
		Socket s=ss.accept();
		//获取客户端ip
		String ip=s.getInetAddress().getHostAddress();
		//一旦连接到客户端即输出连接成功信息。
		System.out.println(ip+"...connected.");
		/*
		** 接收客户端的数据并转化为大写
		*/
		//建立缓存，由于客户端和服务端传送的是字节数据，缓存使用的是字符数据，需要进行字节到字符的转换。
		BufferedReader bufr=new BufferedReader(new InputStreamReader(s.getInputStream()));
		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		String len=null;
		//readLine以换行为结束标识。
		while((len=bufr.readLine())!=null){
			System.out.println("client:"+len);
			String uper=len.toUpperCase();
			/*
			** 向服务端发送键盘录入数据
			*/
			bufw.write(uper);
			bufw.newLine();
			bufw.flush();
		}
		s.close();
		//由于客户端的连接是建立在服务端的基础上，服务端一旦断开，客户端也将断开连接。
		ss.close();
	}
}

保存客户端发送服务器的文本文件（上传文件）

import java.io.*;
import java.net.*;
class TextClient
{
	public static void main(String[] args) throws Exception
	{
		/*
		** 建立客户端，并初始化连接主机和端口
		*/
		Socket s=new Socket("localhost",10011);
		/*
		** 建立缓存，读取文本
		*/
		//将文本信息放入缓存。
		BufferedReader bufr=new BufferedReader(new FileReader("KeyDemo.java"));
		//将数据打印到输出流，并自动刷新(true)缓存
		PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
		String line=null;
		while((line=bufr.readLine())!=null){
			//该打印附带换行。
			pw.println(line);
		}
		//此套接字的输入流至于流的末尾（文本结束标识）
		s.shutdownOutput();
		//读取输入流信息并打印
		BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
		String uploadOk=bufIn.readLine();
		System.out.println(uploadOk);
		//关闭资源。
		bufr.close();
		s.close();
	}
}
class TextServer
{
	public static void main(String[] args)throws Exception{
		/*
		** 建立服务器端，并监听端口10011
		*/
		ServerSocket ss=new ServerSocket(10011);
		//获取连接到服务器的客户端。
		Socket s=ss.accept();
		//倘或连接成功则获取ip地址并打印。
		String ip=s.getInetAddress().getHostAddress();
		System.out.println(ip);
		//构建输入流缓存。
		BufferedReader bufr=new BufferedReader(new InputStreamReader(s.getInputStream()));
		//将文本数据写入server.txt并自动刷新。
		PrintWriter printw=new PrintWriter(new FileWriter("server.txt"),true);
		String line=null;
		while((line=bufr.readLine())!=null){
			//附带换行信息。
			printw.println(line);
		}
		//将客户端发送的数据写入指定文件后反馈上传成功信息，该信息打印到socket的输出流。
		PrintWriter pw=new PrintWriter(s.getOutputStream(),true);
		pw.println("上传成功。");
		//关闭资源。
		bufr.close();
		s.close();
		ss.close();
	}
}