Java-网络编程

概述

• 下面给了两个链接，是关于OSI模型和TCPIP模型

网络七层模型及四层模型详解

网络编程完全总结

网络要素

IP地址

• 网络中设备的标识
• 不易记忆，可用主机名
• 本地回环地址：127.0.0.1 主机名：localhost

IP对象

public static void main(String[] args) throws UnknownHostException {
        InetAddress ip = InetAddress.getLocalHost();
        System.out.println(ip.getHostName()+":::"+ip.getHostAddress());
        ip = InetAddress.getByName("www.baidu.com");
    	System.out.println(ip.getHostName()+":::"+ip.getHostAddress());
    }

端口号

• 用于标识进程的逻辑地址，不同进程的标识
• 有效端口：0~65535，其中0~1024为系统保留端口

传输协议

• 通讯的规则
• 常见协议：TCP，UDP

UDP

• 将数据及源和目的封装在数据包内，不需要建立连接
• 将每个数据包大小限制在64K内
• 无连接，是不可靠协议
• 不需建立连接，所以速度快

TCP

• 建立连接，形成传输数据的通道
• 在连接中进行大数据量传输
• 通过三次握手完成连接，可靠协议
• 必须建立连接，效率会稍低

域名解析

• DNS( Domain Name System)是“域名系统”的英文缩写
• 它用于TCP/IP网络，提供的服务是用来将主机名和域名转换为IP地址的工作
• 当输入一个域名时，会先在本地的hosts下解析，如果没有就通过DNS解析为IP地址

屏蔽恶意网站原理

• 在本地 C:\Windows\System32\drivers\etc 目录下，有一个hosts文件
• 在最后面加上 127.0.0.1 www.xxxxx.com
• 那么这个网站就会被屏蔽掉了

socket编程

UDP协议

发送端

• 思路
  • 1，建立UDP的socket服务
  • 2、将要发送的数据封装到数据包中
  • 3、通过UDP的socket服务将数据包发送出去
  • 4、关闭socket服务

public static void main(String[] args) throws IOException {

	System.out.println("发送端启动......");
	
    //1、udpsocket服务。使用DatagramSocket对象。
    DatagramSocket ds = new DatagramSocket();

    //2、将要发送的数据封装到数据包中。
    String str = "嘎嘎嘎嘎";
    //使用DatagramPacket将数据封装到的该对象包中。
    byte[] buf = str.getBytes();
    
    DatagramPacket dp =
    new DatagramPacket(buf,buf.length, InetAddress.getByName("172.20.10.12"),10000);
    //3、通过udp的socket服务将数据包发送出去。使用send方法。
    ds.send(dp);
    //4、关闭资源。
    ds.close();
}

接收端

• 思路：
  • 1、建立UDP socket服务,因为是要接收数据，必须要明确一个端口号
  • 2、创建数据包，用于存储接收到的数据。方便用数据包对象的方法解析这些数据
  • 3、使用socket服务的receive方法将接收的数据存储到数据包中
  • 4、通过数据包的方法解析数据包中的数据
  • 5、关闭资源

public static void main(String[] args) throws  IOException {

    System.out.println("接收端启动......");
    //1,建立udp socket服务。
    DatagramSocket ds = new DatagramSocket(10000);


    //2,创建数据包。
    byte[] buf = new byte[1024];
    DatagramPacket dp = new DatagramPacket(buf,buf.length);

    //3,使用接收方法将数据存储到数据包中。
    ds.receive(dp);//阻塞式的。

    //4，通过数据包对象的方法，解析其中的数据,比如，地址，端口，数据内容。
    String ip = dp.getAddress().getHostAddress();
    int port = dp.getPort();
    String text = new String(dp.getData(),0,dp.getLength());

    System.out.println(ip+":"+port+":"+text);

    //5,关闭资源。
    ds.close();


}

• 先开启接收端，再开启发送端
• 注意：发送端的DatagramPacket和接收端的DatagramSocket 端口需要一致

TCP协议

客户端

• 客户端发数据到服务端
• TCP传输，客户端建立的过程：
  • 1、创建TCP客户端socket服务。使用的是Socket对象，建议该对象一创建就明确目的地，要连接的主机
  • 2、如果连接建立成功，说明数据传输通道已建立。该通道就是socket流 ,是底层建立好的。
  • ​ 既然是流，说明这里既有输入，又有输出。想要输入或者输出流对象，可以找Socket来获取。
  • ​ 可以通过getOutputStream()，和getInputStream()来获取两个字节流。
  • 3、使用输出流，将数据写出
  • 4、关闭资源

public static void main(String[] args) throws UnknownHostException, IOException {

    Socket socket = new Socket("172.20.10.12",10002);

    OutputStream out = socket.getOutputStream();	

    out.write("tcp演示：哥们又来了!".getBytes());

    //读取服务端返回的数据,使用socket读取流。 
    InputStream in = socket.getInputStream();

    byte[] buf = new byte[1024];
    int len = in.read(buf);
    String  text = new String(buf,0,len);

    System.out.println(text);

    //关闭资源。
    socket.close();
}

服务端

• 服务端接收客户端发送过来的数据，并打印在控制台上。
• 建立TCP服务端的思路：
  • 1、创建服务端socket服务。通过ServerSocket对象。
  • 2、服务端必须对外提供一个端口，否则客户端无法连接
  • 3、获取连接过来的客户端对象
  • 4、通过客户端对象获取socket流读取客户端发来的数据，并打印在控制台上
  • 5、关闭资源。关客户端，关服务端

public static void main(String[] args) throws IOException {

    //1创建服务端对象。
    ServerSocket ss = new ServerSocket(10002);

    //2,获取连接过来的客户端对象。
    Socket s = ss.accept();

    String ip = s.getInetAddress().getHostAddress();

    //3，通过socket对象获取输入流，要读取客户端发来的数据
    InputStream in = s.getInputStream();

    byte[] buf = new byte[1024];

    int len = in.read(buf);
    String text = new String(buf,0,len);
    System.out.println(ip+":"+text);

    //使用客户端socket对象的输出流给客户端返回数据
    OutputStream out = s.getOutputStream();
    out.write("收到".getBytes());

    s.close();
    ss.close();	
}

练习一

需求

• 客户端输入字母数据，发送给服务端，服务端收到后显示在控制台，
• 并将该数据转成大写返回给客户端，直到客户端输入over.转换结束.
• 创建一个英文大写转换服务器
• 分析：
  • 有客户端和服务端，使用TCP传输

客户端编写

• 客户端思路：
  • 1、需要先有socket端点
  • 2、客户端的数据源：键盘
  • 3、客户端的目的：socket
  • 4、接收服务端的数据，源：socket
  • 5、将数据显示在打印出来：目的：控制台
  • 6、在这些流中操作的数据，都是文本数据
• 转换客户端思路：
  • 1、创建socket客户端对象
  • 2、获取键盘录入
  • 3、将录入的信息发送给socket输出流

public static void main(String[] args) throws UnknownHostException, IOException {

    //1、创建socket客户端对象。
    Socket s = new Socket("192.168.1.100",10004);

    //2、获取键盘录入。
    BufferedReader bufr  =
        new BufferedReader(new InputStreamReader(System.in));

    //3、socket输出流。
    PrintWriter out = new PrintWriter(s.getOutputStream(),true);


    //4、socket输入流，读取服务端返回的大写数据
    BufferedReader bufIn  = new BufferedReader(new InputStreamReader(s.getInputStream()));

    String line = null;

    while((line=bufr.readLine())!=null){

        if("over".equals(line))
            break;

//		out.print(line+"\r\n");
//		out.flush();
        out.println(line);

        //读取服务端发回的一行大写数。
        String upperStr = bufIn.readLine();
        System.out.println(upperStr);
    }
    s.close();
}

服务端编写

• 转换服务端思路：
  • 1、ServerSocket服务
  • 2、获取socket对象
  • 3、源：socket，读取客户端发过来的需要转换的数据
  • 4、目的：显示在控制台上
  • 5、将数据转成大写发给客户端

public static void main(String[] args) throws IOException {

    //1、ServerSocket服务
    ServerSocket ss = new ServerSocket(10004);

    //2、获取socket对象。
    Socket s = ss.accept();

    //获取ip.
    String ip = s.getInetAddress().getHostAddress();
    System.out.println(ip+"......connected");

    //3、获取socket读取流，并装饰。 
    BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));

    //4、获取socket的输出流，并装饰。
    PrintWriter out = new PrintWriter(s.getOutputStream(),true);

    String line = null;
    while((line=bufIn.readLine())!=null){

        System.out.println(line);
        out.println(line.toUpperCase());
//		out.print(line.toUpperCase()+"\r\n");
//		out.flush();
    }

    s.close();
    ss.close();	
}

常见问题

• 如果将这两段代码中的PrintWriter 的true删掉，也就是不让他自动刷新
• 再将out.println(line) 及 out.println(line.toUpperCase())注释掉，
• 改写为out.print(xxx); 运行代码试试
• 是否发现客户端输入后，服务端没显示，客户端也不能继续输入了？
  • 这是因为堵塞了，没有刷新
• 加上out.flush()再试试？还是不行
  • 没有换行符没法终止，服务端认为客户端没有输入完整
• 一定注意，需要换行和刷新，PrintWriter 的true，System.out.println(xxx)

练习二

需求

• 客户端发送服务端文本文件，服务端接收到后，返回接收成功

客户端编写

• 思路：
  • 1、创建一个socket端点
  • 2、客户端的数据源：硬盘文件
  • 3、客户端的目的：socket
  • 4、接收服务端的数据，源：socket
  • 5、将数据显示在打印出来：目的：控制台

public static void main(String[] args) throws UnknownHostException, IOException {

    System.out.println("上传客户端。。。。。。");
    //1、创建socket客户端对象
    Socket s = new Socket("192.168.1.100",10005);

    //2、读取将要传输的文件
    BufferedReader bufr =
        new BufferedReader(new FileReader(file));

    //3、socket输出流
    PrintWriter out = new PrintWriter(s.getOutputStream(),true);
    String line = null;
    while((line=bufr.readLine())!=null){
        out.println(line);
    }
    //告诉服务端，客户端写完了。
    s.shutdownOutput();

    //4、socket输入流，读取服务端返回的数据
    BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
    String str = bufIn.readLine();
    System.out.println(str);

    bufr.close();
    s.close();
}

服务端编写

• 服务端思路：
  • 1、ServerSocket服务
  • 2、获取socket对象
  • 3、源：socket，读取客户端发过来的文件数据
  • 4、目的：硬盘，存放在指定目录下
  • 5、返回客户端：上传成功

public static void main(String[] args) throws IOException {
    System.out.println("上传服务端。。。。。。。。。");

    //1、ServerSocket服务
    ServerSocket ss = new ServerSocket(10005);

    //2、获取socket对象
    Socket s = ss.accept();

    System.out.println(s.getInetAddress().getHostAddress()+".....connected");

    //3、读取客户端发送过来的文件字节，存到缓冲区
    BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));

    //4、将读取到的文件字节，存放到指定目录下
    BufferedWriter bufw = new BufferedWriter(new FileWriter("c:\\server.txt"));

    String line = null;

    while((line=bufIn.readLine())!=null){
        bufw.write(line);
        bufw.newLine();
        bufw.flush();
    }

    PrintWriter out = new PrintWriter(s.getOutputStream(),true);
    out.println("上传成功");

    bufw.close();

    s.close();
    ss.close();	
}

练习三

需求

• 多客户端进行上传图片操作，服务端接收后并回复

客户端

public class UploadPicClient {
	public static void main(String[] args) throws UnknownHostException, IOException {
		//1,创建客户端socket。
		Socket s = new Socket("192.168.1.100",10006);
		
		//2,读取客户端要上传的图片文件。
		FileInputStream fis = new FileInputStream("c:\\0.bmp");
		
		//3,获取socket输出流，将读到图片数据发送给服务端。
		OutputStream out = s.getOutputStream();
		
		byte[] buf = new byte[1024];
		int len = 0;
		while((len=fis.read(buf))!=-1){
			out.write(buf,0,len);
		}
		
		//告诉服务端说：这边的数据发送完毕。让服务端停止读取。
		s.shutdownOutput();
		
		//读取服务端发回的内容。 		
		InputStream in  = s.getInputStream();
		byte[] bufIn = new byte[1024];
		
		int lenIn = in.read(buf);
		String text = new String(buf,0,lenIn);
		System.out.println(text);
		
		fis.close();
		s.close();	
	}
}

服务端

• 因为是多客户端，所以需要用多线程
• 否则，一个客户端传文件时，别的客户端只能等待

public class UploadTask implements Runnable {

	private static final int SIZE = 1024*1024*2;
	private Socket s;

	public  UploadTask(Socket s) {
		this.s = s;
	}

	@Override
	public void run() {

		int count = 0;
		String ip = s.getInetAddress().getHostAddress();
		System.out.println(ip + ".....connected");
		
		try{

		// 读取客户端发来的数据。
		InputStream in = s.getInputStream();

		// 将读取到数据存储到一个文件中。
		File dir = new File("c:\\pic");
		if (!dir.exists()) {
			dir.mkdirs();
		}
		File file = new File(dir, ip + ".jpg");
		//如果文件已经存在于服务端 
		while(file.exists()){
			file = new File(dir,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);
			if(file.length()>SIZE){
				System.out.println(ip+"文件体积过大");
				fos.close();
				s.close();
				System.out.println(ip+"...."+file.delete());
				return ;
			}
		}

		// 获取socket输出流，将上传成功字样发给客户端。
		OutputStream out = s.getOutputStream();
		out.write("上传成功".getBytes());

		fos.close();
		s.close();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

public class UploadPicServer {

	public static void main(String[] args) throws IOException {
			
		//创建tcp的socket服务端。
		ServerSocket ss = new ServerSocket(10006);
		while(true){
     		//持续获取socket对象
			Socket s = ss.accept();			
			new Thread(new UploadTask(s)).start();			
		}		
	}
}

客户端服务端原理

模拟服务器

• 为了了解原理，自定义一个服务器

public class MyTomcat {
    public static void main(String[] args) throws IOException {

        ServerSocket ss = new ServerSocket(9090);

        Socket s = ss.accept();
        System.out.println(s.getInetAddress().getHostAddress()+".....connected");

        InputStream in = s.getInputStream();

        byte[] buf = new byte[1024];

        int len = in.read(buf);
        String text = new String(buf,0,len);
        System.out.println(text);


        //给客户端一个反馈信息。
        PrintWriter out = new PrintWriter(s.getOutputStream(),true);

        out.println("嘎嘎嘎嘎");

        s.close();
        ss.close();
    }
}

• 打开浏览器，输入localhost:9090，页面显示嘎嘎嘎嘎
• 控制台显示：

0:0:0:0:0:0:0:1.....connected
GET / HTTP/1.1 
Accept: text/html, application/xhtml+xml, image/jxr, */*
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36 Edge/16.16299
Accept-Encoding: gzip, deflate
Host: localhost:9090
Connection: Keep-Alive

• 解释：

GET / HTTP/1.1  请求行  请求方式  http协议版本。

请求消息头 . 属性名：属性值
Accept: text/html, application/xhtml+xml, image/jxr, */*
.....
Connection: Keep-Alive

模拟浏览器

public class MyBrowser {

    public static void main(String[] args) throws UnknownHostException, IOException {

        Socket s = new Socket("127.0.0.1",9090);

        //模拟浏览器，给tomcat服务端发送符合http协议的请求消息。
        PrintWriter out = new PrintWriter(s.getOutputStream(),true);
        out.println("GET / HTTP/1.1");
        out.println("Accept: */*");
        out.println("Host: 192.168.1.100:8080");
        out.println("Connection: close");
        out.println();
        out.println();
        
        InputStream in = s.getInputStream();
        byte[] buf = new byte[1024];
        int len = in.read(buf);
        String str =new String(buf,0,len);
        System.out.println(str);

        s.close();
    }
}

• 开启模拟服务器后，再开启模拟浏览器
• 模拟浏览器可以看到嘎嘎嘎嘎，模拟服务器也收到了浏览器传来的数据

URL

• 获取URL对象的URL连接器对象。将连接封装成了对象：
  • Java中内置的可以解析的具体协议的对象+socket

URLConnection conn = url.openConnection();
System.out.println(conn);
String value = conn.getHeaderField("Content-Type");
System.out.println(value);

常用网络结构

C/S

• client/server（客户端、服务端）

• 特点：
  • 该结构的软件，客户端和服务端都需要编写
  • 可发成本较高，维护较为麻烦
• 好处：
  • 客户端在本地可以分担一部分运算

B/S

• browser/server（浏览器、 服务端）

• 特点：
  • 该结构的软件，只开发服务器端，不开发客户端，因为客户端直接由浏览器取代。
  • 开发成本相对低，维护更为简单
• 缺点：
  • 所有运算都要在服务端完成