Java基础<十四>_网络编程-CSDN博客

本文链接：https://blog.csdn.net/liyuanq/article/details/12138279

网络编程

一、网络编程概述

网络编程：可以在不同网络终端上通信的编程。

网络通讯三要素：IP地址、端口号、传输协议。

IP地址：标识通信双方计算机，简单说：标识对方，找到对方；在java中，IP封装成为InetAddress类；本地回环地址：127.0.0.1，主机名为localhost。

端口号：用于标识进程的逻辑地址，即不同进程的标识；有效端口号：0—65535，其中0—1024系统使用或者为保留端口，Tomcat服务器默认端口为8080，Web服务为80。

传输协议：通信双方的数据遵循规则必须一致，否则无法通信；网络上用TCP/IP协议。

网络之间的通信是一个很复杂的过程，为了把复杂事物简单化，网络可以理论分为七个参考模型(OSI)：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层；也可以按TCP/IP(实际应用的模型)分为四层：网络接口层、网络层、传输层、应用层。

常见的协议：网络层：IP；传输层：TCP、UDP；应用层：HTTP、FTP等。

总之：发送方：是一个数据封包的过程；接收方：是一个数据解包的过程。

UDP和TCP是运输层的两个不同协议，UDP面向无连接，TCP面向连接；区别如下：

UDP：1、将数据及源和目的封装成数据包，不需要建立连接；2、每个数据包的大小限制在64K内；3、因为无连接，数据通信不可靠；4.因为不需要建立连接，所以速度快。

TCP：1、需要建立连接，形成传输数据的通道；2、在通道中进行大数据的传输；3、通过三次握手完成连接，数据通信可靠；4、因为需要建立连接，所以效率稍低。

Socket：socket是为网络服务提供的一种机制。好比水运的码头，想要运输货物，必须先建立好码头，同理,想要进行网络传输，必须先建立Socket接口；码头有专门为客船服务的，也有专门为军事服用的，同理，Socket有专门为UDP类型传输的，也有专门为TCP类型传输的；所以，根据不同的需要建立不同的Socket接口。

二、UDP传输

UDP传输：面向无连接的传输，传输数据的两端分为发送端和接收端，“码头”为DatagramSocket，在“码头”上运送的数据封装对象Datagrampacket，想获取具体的数据，可以通过DatagramPacket类中的相应方法获取。

注意：要发送的数据包必须带上地址，即：明确目的地IP、端口；接收端必须指明端口，发送端可以不指定端口，系统会分配默认的端口。

思路：网路编程重要的就是思路，具体对象可以查阅API

UDP发送端：

1、建立udpsocket服务；

2、提供数据，并将数据封装到数据包中；

3、通过socket服务的发送功能，将数据包发出去；

4、关闭资源。

UDP接收端：

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

2、定义一个数据包，存储接收到的字节数据；

3、通过socket服务的receive方法接收到的数据存入指定的数据包中；

4、通过数据包对象的特有功能，将这些不同的数据取出，打印到控制台上；

5、关闭资源。

下面代码演示：

1、发送端发送数据到接收端

发送端：

package itheima.day23;

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

public class udpSend2 {

	public static void main(String[] args) throws IOException {
		
		DatagramSocket ds = new DatagramSocket();
		BufferedReader bufr =
				new BufferedReader(new InputStreamReader(System.in));
		
		String line = null;
		while((line = bufr.readLine())!=null){
			if("886".equals(line))
				break;
			byte[] buf = line.getBytes();
			
			DatagramPacket dp = 
					new DatagramPacket(buf,buf.length,InetAddress.getByName("100.64.37.118"),10017);
			ds.send(dp);
		}
		ds.close();
	}
}

接收端：

package itheima.day23;

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

public class UdpRece2 {

	public static void main(String[] args) throws IOException {
		
		DatagramSocket ds = new DatagramSocket(10017);
		
		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());
			int port = dp.getPort();
			System.out.println(ip+":::"+data+":::"+port);
		}
	}
}

2、简单聊天程序：

package itheima.day23;

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

//需求：编写一个聊天程序。
public class ChatDemo {

	public static void main(String[] args) throws SocketException {
		
		DatagramSocket sendSocket = new DatagramSocket();
		DatagramSocket receSocket = new DatagramSocket(10005);
		
		new Thread(new Send(sendSocket)).start();
		new Thread(new Recv(receSocket)).start();
	}
}

class Send implements Runnable{
	
	private DatagramSocket ds;
	Send(DatagramSocket ds){
		this.ds = ds;
	}
	
	@Override
	public void run() {
		try {	
			BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
			String line = null;
			while((line = bufr.readLine())!=null){
				if("886".equals(line))
					break;
				byte[] buf = line.getBytes();
				DatagramPacket dp = 
						new DatagramPacket(buf,buf.length,InetAddress.getByName("100.64.37.118"),10005);
				ds.send(dp);
			}
		} catch (IOException e) {
			throw new RuntimeException("发送端失败");
		}
	}
}

//接收端
class Recv implements Runnable{

	private DatagramSocket ds;
	Recv(DatagramSocket ds){
		this.ds = ds;
	}
	
	@Override
	public void run() {
		while(true){
			byte[] buf = new byte[1024];
			DatagramPacket dp = new DatagramPacket(buf,buf.length);//接收数据的包
			try {
				ds.receive(dp);
				String ip = dp.getAddress().getHostAddress();
				String data = new String(dp.getData(),0,dp.getLength());
				
				System.out.println(ip+"::"+data);
				
			} catch (IOException e) {
				throw new RuntimeException("接收端失败");
			}
		}
	}	
}

三、TCP传输

TCP传输：TCP是面向连接的传输，分为客户端和服务端，客户端对应的对象是Socket，服务端对应的对象是ServerSocket。

客户端：socket对象在建立时，就可以去连接指定的主机，因为tcp是面向连接的，所以建立socket服务时，就要有服务端存在，并连接成功，形成通路后，在通道上进行数据的传输。

服务端：专门给客户端提供服务，采用多线程技术同时给多个客户请求提供服务，大型的服务器一般不关闭，例如：新浪。

思路：

TCP客户端：

1、创建socket服务，并指定要链接的主机和端口；

2、获取socket流中的输出流，将数据写到该流中，通过网络发送给服务端；

3、获取socket流中的输入流，将服务端返回的数据获取到，并打印；

4、关闭客户端。

TCP服务端：

1、建立服务端的socket服务，ServerSocket()，并监听一个端口；

2、获取链接过来的客户端的对象，通过ServerSocket的accept方法，阻塞式方法；

3、客户端如果发过来数据，那么服务端要使用对应的客户端对象，获取数据；

4、关闭服务端（可选）。

注意：客户端和服务端都莫名的等待，那是因为客户端和服务端都有阻塞式方法，这些方法没有读到结束标记，一直等待的缘故。

域名解析原理：当在浏览器中输入一个域名时，浏览器会先去C:\Windows\System32\drivers\etc hosts 文件查找是否有对应的ip地址；若没有，再去公网的DNS服务器去查询，当获得了域名对应的ip地址后，再根据ip地址去访问具体的网页，最终还是用ip是访问网页。其中DNS服务器我们可以自行设置，默认时，走的是最近的DNS服务器。

下面代码体现：

3、演示客户端与服务端

客户端：

package itheima.day23;

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

//演示tcp传输的客户端和服务端的互访
// 需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。
public class TCPClient2 {

	public static void main(String[] args) throws UnknownHostException, IOException {
		
		Socket s = new Socket("100.64.86.48",10012);
		OutputStream out = s.getOutputStream();
		out.write("服务端，服务端，我是客户端".getBytes());
		InputStream in = s.getInputStream();
		
		byte[] buf = new byte[1024];
		int len = in.read(buf);//阻塞式方法
		System.out.println(new String(buf,0,len));
		s.close();
	}
}

服务端：

package itheima.day23;

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

public class TCPServer2 {

	public static void main(String[] args) throws IOException {
		
		ServerSocket ss = new ServerSocket(10012);
		Socket s = ss.accept();
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+".....connected");
		InputStream in = s.getInputStream();
		
		byte[] buf = new byte[1024];
		int len = in.read(buf);
		System.out.println(new String(buf,0,len));
		
		OutputStream out = s.getOutputStream();
		out.write("客户端，客户端，服务端收到".getBytes());
		s.close();
		ss.close();
	}

}

4、建立一个文本转换服务器，服务端将客户端发送来的文本转成大写回给客户端

客户端：

package itheima.day23;

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

//需求：建立一个文本转换服务器，服务端将客户端发送来的文本转成大写回给客户端。
// 	    客户端可以不断的进行文本转换，当客户端输入over时，转换结束
//步骤：1、建立服务，2、获取键盘录入，3、将数据发给服务端，
// 4、获取服务端回给的大写数据，5.结束，关闭资源。
 
public  class TransClient {

	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket s = new Socket("100.64.86.48",10021);
		BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
//		打印流，打印的目的：Socket对象的输出流，自动刷新
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);
//		BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
		String line = null;
		while((line = bufr.readLine())!=null){
			if("over".equals(line))
				break;	
			out.println(line);
			
//			bufOut.write(line);//写到输出流中
//			bufOut.newLine();//结束标记
//			bufOut.flush();
			String str = bufIn.readLine();
			System.out.println("Server:"+str);
		}
	}
}

服务端：

package itheima.day23;

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

//服务端：源：socket读取流；目的：socket输出流
public class TransServer {

	public static void main(String[] args) throws IOException  {
		
	ServerSocket ss = new ServerSocket(10021);
	Socket s = ss.accept();
	String ip = s.getInetAddress().getHostAddress();
	System.out.println(ip+"....connected");
	BufferedReader bufIn = 
			new BufferedReader(new InputStreamReader(s.getInputStream()));
	PrintWriter out = new PrintWriter(s.getOutputStream(),true);
//	BufferedWriter bufOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
	
	String line = null;
	while((line = bufIn.readLine())!=null){
		System.out.println("client:"+line);
		
		out.println(line.toUpperCase());
		
//		bufOut.write(line.toUpperCase());
//		bufOut.newLine();
//		bufOut.flush();		
	}
	s.close();
	ss.close();
	
	}
}

5、将一个文本上传给服务器：

客户端：

package itheima.day23;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class TextClient {

	public static void main(String[] args) throws UnknownHostException, IOException {
		
<span style="white-space:pre">	</span>	Socket s = new Socket("100.64.86.48",10007);
		BufferedReader bufr = 
				new BufferedReader(new FileReader("4.txt"));
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);
		
		String line = null;
		while((line = bufr.readLine())!=null){
			out.println(line);
		}
		s.shutdownOutput();
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
		String str = bufIn.readLine();
		System.out.println("server:"+str);
		bufr.close();
		bufIn.close();
		out.close();
		s.close();	
	}
}

服务端：

package itheima.day23;

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

public class TextServer {

	public static void main(String[] args) throws IOException {
		
		ServerSocket ss = new ServerSocket(10007);
		Socket s = ss.accept();
		
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+".....connected");
		BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
		PrintWriter out = new PrintWriter(new FileWriter("Server.txt"),true);
	
		String line = null;
		while((line = bufIn.readLine())!=null){	
			out.println(line);
		}
		
		PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
		pw.println("恭喜。上传成功！");
		s.close();
		ss.close();
	}
}

6、给服务器上传图片

客户端：

package itheima.day24;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
/*客户端：
 * 1、服务端点
 * 2、读取客户端已有的图片数据
 * 3、通过socket 输出流将数据发送给服务端
 * 4、读取服务端反馈信息
 * 5、关闭资源
 * */
public class PictureClient {

	public static void main(String[] args) throws UnknownHostException, IOException {
		/*
		if(args.length != 1){
			System.out.println("请选择一个jpg格式的图片");
			return ;
		}
		
		File file = new File(args[0]);
		
		if(!(file.exists() && file.isFile())){
			System.out.println("该文件有问题");
			return ;
		}
		
		if(!file.getName().endsWith(".jpg")){
			System.out.println("图片格式有误，请重新选择");
			return ;
		}
		
		if(file.length() > 5*1024*1024){
			System.out.println("文件过大，不安好心");
		}
		*/
		
		Socket s = new Socket("100.64.15.72",10007);
		File file = new File("1.jpg");
		
		FileInputStream fis = new FileInputStream(file);
		OutputStream out = s.getOutputStream();
		
		byte[] buf = new byte[1024];
		int len = 0;
		while((len = fis.read(buf))!=-1){
			out.write(buf,0,len);
		}
//		关闭Socket服务的输出流，结束标记
		s.shutdownOutput();
		
		InputStream in = s.getInputStream();
		byte[] bufIn = new byte[1024];
		
		int num = in.read(bufIn);
		System.out.println(new String(bufIn,0,num));
		
		fis.close();
		s.close();
	}
}

服务端：

package itheima.day24;

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

//所有的服务器都是这个原理
public class PicServer {

	public static void main(String[] args) {
		ServerSocket ss = null;
		try {
			ss = new ServerSocket(10007);
		} catch (IOException e) {
			e.printStackTrace();
		}
		while(true){
			Socket s = null;
			try {
				if(ss!=null)
					s = ss.accept();//阻塞式方法
			} catch (IOException e) {
				e.printStackTrace();
			}
			new Thread(new PicThread(s)).start();
		}
	}
}

//其实实现Runnable接口的子类，就是线程要执行的目标
//只是作为构造参数传给Thread类罢了
//每一个任务里面都有一个Socket服务为连接进来的客户服务
class PicThread implements Runnable{
	
	private Socket s;
	PicThread(Socket s){
		this.s = s;
	}
	
	@Override
	public void run() {
		
		int count = 1;
		String ip = s.getInetAddress().getHostAddress();
		try{
			System.out.println(ip+"....connected");
			
			InputStream in = s.getInputStream();
			
			File file = new File(ip+"("+count+")"+".jpg");
			
			while(file.exists()){
				file = new  File(ip+"("+(count++)+")"+".jpg");
			}
			
			FileOutputStream fos = new FileOutputStream(file);
			
			byte[] buf = new byte[1024];
			int len = 0;
			while((len = in.read(buf))!=-1){
				fos.write(buf, 0, len);
			}
			OutputStream out = s.getOutputStream();
			
			out.write("恭喜，上传成功".getBytes());
			
			fos.close();
			s.close();
		}catch(Exception e){
			throw new RuntimeException(ip+"上传失败");
		}
	}
}

7、模拟用户的登陆

客户端：

package itheima.day24;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

//客户端通过键盘录入用户名，服务端对这个用户进行校验
// 如果该用户存在，在服务端显示xxx，已登录；并在客户端显示xxx，欢迎光临
// 如果该用户存在，在服务端显示xxx，尝试登陆；并在客户端显示xxx，用户不存在。
// 最多三次
public class LoginClient {

	public static void main(String[] args) throws UnknownHostException, IOException {
		
		Socket s = new Socket("100.64.15.72",10008);
		BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);
		BufferedReader bufIn = 
				new BufferedReader(new InputStreamReader(s.getInputStream()));
		
		for(int x = 0;x<3;x++){
			String line = bufr.readLine();
			if(line == null)
				break;
			out.println(line);
		
			String info = bufIn.readLine();
			System.out.println("info::"+info);
			
			if(info.contains("欢迎"))
				break;
		}
		bufr.close();
		s.close();
	}
}

服务端：

package itheima.day24;

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

public class LoginServer {

	public static void main(String[] args) throws IOException {
		
		ServerSocket ss = new ServerSocket(10008);
		while(true){
			Socket s = ss.accept();	
			new Thread(new UserThread(s)).start();
		}
	}
}

class UserThread implements Runnable
{
	private Socket s;
	UserThread(Socket s){
		this.s = s;
	}
	
	@Override
	public void run() {
		
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip+"....connected");
		
		try {
			for(int x = 0;x<3;x++){
				
				BufferedReader bufIn = 
						new BufferedReader(new InputStreamReader(s.getInputStream()));
				String name = bufIn.readLine();
				if(name == null)
					break;
				BufferedReader bufr = 
						new BufferedReader(new FileReader("user.txt"));
				PrintWriter out = new PrintWriter(s.getOutputStream(),true);
				
				String line = null;
				boolean flag = false;
				while((line = bufr.readLine())!=null){
				if(line.equals(name)){
					flag = true;
					break;
				}	
			}
			if(flag){
				System.out.println(name+",已登录");
				out.println(name+",欢迎光临");
				break;
			}else{
				System.out.println(name+"尝试登陆");
				out.println(name+"用户名不存在");
				}
			} 
			s.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}	
}

8、定义一个服务器给浏览器提供服务：

package itheima.day24;

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

/*
 演示客户端和服务端
 1、
  客户端：浏览器
  服务端：自定义
 2、
  客户端：浏览器
  服务端：Tomcat服务器
 */
public class ServerDemo {

	public static void main(String[] args) throws IOException {
		
		ServerSocket ss = new ServerSocket(11000);
		
		Socket s = ss.accept();
		
		System.out.println(s.getInetAddress().getHostAddress());
		
		InputStream in = s.getInputStream();
		
		byte[] buf = new byte[1024*1024];
		int len = in.read(buf);
		
		System.out.println(new String(buf,0,len));
		PrintWriter out = new PrintWriter(s.getOutputStream(),true);
		out.println("客户端你好");
		
		s.close();
		ss.close();
		
	}

}
/*
  HTTP的请求消息头
GET / HTTP/1.1    请求方式； 1.1版本
Accept: text/html, application/xhtml+xml,等等； 接收的类型
Accept-Language: zh-CN 支持的语言
User-Agent: Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; Trident/6.0)
Accept-Encoding: gzip, deflate 可接受的编码
Host: 100.64.130.205:11000
DNT: 1
Connection: Keep-Alive
 */

9、socket走的都是传输层，URLConnection中封装了socket流，走的是应用层：

package itheima.day24;

import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class URLConnectionDemo {

	public static void main(String[] args) throws IOException {
		
		URL url = new URL("http://www.baidu.com/s?wd=java%E5%9F%B9%E8%AE%AD&ie=utf-8");
//		走的是应用层，传输层把消息头拆包了，应用层收到的只是数据体
		URLConnection conn =url.openConnection();
		System.out.println(conn);

		InputStream in = conn.getInputStream();
		byte[]   buf = new  byte[1024*1024];
		int len = in.read(buf);
//		接收到的数据没有消息头
		System.out.println(new String(buf,0,len));
	}
}