java程序设计之网络编程_Java多线程和网络编程项目[通俗易懂]

java程序设计之网络编程_Java多线程和网络编程项目[通俗易懂]浏览器就是我们日常使用的浏览器去访问各种网站,只要有浏览器就可以访问,不依赖特定的PC端,在任意设备上都可以访问网站服务器

前言必读

读者手册(必读)_云边的快乐猫的博客-CSDN博客

一、1网络通信的基本模式分为两种

1.CS模式(Client—客户端,Server—服务端) 

客户端是需要程序员去开发的,例如日常使用的各种的APP,服务端就是服务器。

例子:端游,依赖特定的PC端才能玩。

2.BS模式(Browser—浏览器,Server—服务端)—重点学习

服务端是需要程序员去开发的。浏览器就是我们日常使用的浏览器去访问各种网站,只要有浏览器就可以访问,不依赖特定的PC端,在任意设备上都可以访问网站服务器 。

例子:网页小游戏,联网浏览器就可以玩。 

一、2 请分析C/S和B/S架构相比的各自的优缺点?

1.CS(客户端–服务器结构)

优点 技术成熟,交互性强,网络通信量低,响应数据快。将任务分到了两端,降低了系统的开销。客户端要处理大多数的业务逻辑和UI展示。他是胖客户端。

缺点:更新太快,要求用户有相同的操作系统,如果有不同的操作系统还要开发不同的版本,对于计算机电脑的配置要求也高

2。BS(浏览器-服务器结构)

优点:主要事务在服务端实现。分布性强、维护方便、开发简单

共享性强、总体成本低,对客户端的电脑配置要求较低

缺点:数据安全性问题,对服务器要求高。数据传输速度较慢,软件的个性化明显降低,难以实现传统模式下的特殊功能要求,他是瘦客户端,大量的数据的传输都要通过服务器与浏览器进行交互,通信开销大,难以实现复杂的应用构造

二、实现网络编程的三种要素

IP地址可以理解为具体哪个计算机,端口理解计算机上的程序(一个程序一个端口),协议理解为电脑通过什么方式和外界交互

要素一:IP地址:设备在网络中的地址,是唯一的标识

详解:

(1)常见的IP分类为:

IPv4(32比特4字节)和IPv6(128位16个字节)–称号–可以标记地球上的每一粒沙子。

(2)IP地址的取经之路:

计算机:我要去找百度获取数据。

DNS服务器:发过来我看看哪个网址域名啊,给你指路具体的ip地址

计算机:知道了这个ip地址,我就可以去找具体要访问的服务器了

服务器:计算机老弟你来找我了啊,那我把你要的数据发给你吧。 

(3)公网地址和私有地址(局域网使用)

192.168开头的就是常见的私有地址 

(4)获取IP地址的代码

 要去实现这个IP地址的获取就要用到 InetAddress方法

代码例子:

package bao;

import java.net.InetAddress;

public class Test {
    public static void main(String[] args) throws Exception {
        //1.获取本机地址ip对象
        InetAddress ip1 = InetAddress.getLocalHost();
        System.out.println(ip1.getHostName());//获取主机名字
        System.out.println(ip1.getHostAddress());//获取ip地址
        //2.获取域名ip对象
        InetAddress ip2 = InetAddress.getByName("www.baidu.com");
        System.out.println(ip2.getHostName());//获取域名
        System.out.println(ip2.getHostAddress());//获取域名的ip地址
        //3.获取公网对象
        InetAddress ip3 = InetAddress.getByName("112.80.248.76");
        System.out.println(ip3.getHostName());//获取公网名字
        System.out.println(ip3.getHostAddress());//获取公网ip地址
        //判断网络是否能连接通信 ping 5s之前测试是否能通过
        System.out.println(ip3.isReachable(5000));//通过会返回true
    }
}

运行结果:

涉及到个人隐私就不放到这里来了,可以自己运行试试看  

 =========================================================================

要素二:端口:应用程序在设备中的唯一标识

一个主机设备中,端口号是唯一的

(1)端口号:一个程序一个端口号,被规定为16位的二进制,范围是0~65535

(2)周知端口:0~1023,被预先定义的知名应用占用。(例如:HTTP占用80端口,FTP占用21端口)

(3)注册端口:1024~49151,分配给用户进程或某些程序(例如:Tomcat占用8080端口)

(4)动态端口:49152~65535,不固定分配到某种进程,动态分配

 =========================================================================

要素三:协议:数据在网络中的传输协议,最常见的有UDP和TCP(重点)

java程序设计之网络编程_Java多线程和网络编程项目[通俗易懂]

(1)TCP协议: (安全,有连接确认可靠)

使用TCP协议,双方必须先建立连接,它是一种面向连接可靠通信协议,传输前,要建立三次握手方式建立连接确认。连接和发送数据都需要确认。传输完成后,还需要释放已连接的通信,通信效率相对比较低。

使用场景:对安全需求较高的文件下载、金融数据通信等。

三次握手连接:

客户端:在吗?

服务端:在

客户端:上号

四次握手断开连接:

客户端:不玩了

服务端:好吧

服务端:下次什么时候玩?

客户端:有空再玩 

例子:

一收一发

发送端(客户端) 

package bao;

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;

//发送端
public class Test {
    public static void main(String[] args) throws IOException {
        System.out.println("==============客户端启动===============");
        //1.创建发送通信管道
        Socket socket = new Socket("127.0.0.1",7777);//参数一:服务端地址 参数二:服务端端口
        //2.从scoket管道中获得一个字节输出流,负责发送数据
        OutputStream os = socket.getOutputStream();
        //3.字节流升级成打印流
        PrintStream ps = new PrintStream(os);
        //4.发送消息
        ps.println("大哥,我来了");
        ps.flush();//刷新
    }
}

 接收端 (服务端)

package bao;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

//服务端
public class Test1 {
    public static void main(String[] args) throws IOException {
        System.out.println("========服务端启动============");
        //1.创建接收管道,注册端口
        ServerSocket serverSocket = new ServerSocket(7777);//参数一:定义服务端口
        //2.等待管道连接
        Socket accept = serverSocket.accept();
        //3.从管道中获取一个字节输入流
        InputStream is = accept.getInputStream();
        //4.字节流升级生缓冲输入流
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        //5.按照行读取消息会更好
        String a;
        if ((a = br.readLine())!=null){
            System.out.println(accept.getRemoteSocketAddress()+"说了:"+a);
        }
    }
}

 运行结果:

/127.0.0.1:60316说了:大哥,我来了

 ==============客户端启动===============

多收多发 

发送端(客户端) 

package bao;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;


public class kehu {
    public static void main(String[] args) throws Exception {
        System.out.println("客户端启动");
        //1.创建与服务端连接的管道
        Socket s = new Socket(InetAddress.getLocalHost(), 9966);
        //2.创建一个线程负责客户端的消息读取
        new ClientReaderThread(s).start();
        //3.创建一个字节输入流管道
        OutputStream o = s.getOutputStream();
        PrintStream p = new PrintStream(o);//升级流
        //4.客户端输入数据
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请输入:");
            String s1 = sc.nextLine();
            p.println(s1);//发送数据出去
            p.flush();//刷新流
        }
    }
}
class ClientReaderThread extends Thread{
    private Socket socket;
    public ClientReaderThread(Socket socket){
        this.socket = socket;
    }
        @Override
        public void run(){
            try {
                //把字节输入流包装成字符输入流
                InputStream i = socket.getInputStream();
                BufferedReader b = new BufferedReader(new InputStreamReader(i));
                String s1;
                while (true){
                    if ((s1=b.readLine())!=null){
                        System.out.println("收到了消息"+s1);
                    }
                }
            } catch (IOException e) {
                System.out.println("服务器把你提出群聊");
            }
        }
    }

  接收端 (服务端)

package bao;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

public class fuwu {
    //1.定义一个静态变量储存全部管道
    public static List<Socket> all_Sockets = new ArrayList<>();
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动成功");
        //2.服务端口注册
        ServerSocket ss = new ServerSocket(9966);
        //3.管道死循环设置
        while (true){
            Socket s = ss.accept();
            System.out.println(s.getRemoteSocketAddress()+"上线了");
            all_Sockets.add(s);
            new fuwuThread(s).start();
        }
    }
}
class fuwuThread extends Thread{
    private Socket socket;
    public fuwuThread(Socket socket){
        this.socket=socket;
    }
    @Override
    public void run(){
        try {
            InputStream i = socket.getInputStream();
            BufferedReader b = new BufferedReader(new InputStreamReader(i));
            String s1;
            while ((s1=b.readLine())!=null){
                System.out.println(socket.getRemoteSocketAddress()+"说"+s1);
                sendMessage(s1);
            }
        } catch (IOException e) {
            System.out.println(socket.getRemoteSocketAddress()+"离线了");
            fuwu.all_Sockets.remove(socket);
        }
    }
    private void sendMessage (String s1) throws IOException {
        for (Socket s:fuwu.all_Sockets){
            OutputStream o = s.getOutputStream();
            PrintStream p = new PrintStream(o);
            p.println(s1);
            p.flush();
        }
    }
}

运行结果:

服务端启动成功
/192.168.78.1:56384上线了
/192.168.78.1:56384说大哥
/192.168.78.1:56389上线了
/192.168.78.1:56389说小弟
/192.168.78.1:56384说
/192.168.78.1:56384说大哥11

客户端启动
请输入:
大哥
请输入:
收到了消息大哥
收到了消息小弟

大哥11
请输入:
请输入:
收到了消息
收到了消息大哥11

客户端启动
请输入:
小弟
请输入:
收到了消息小弟
收到了消息
收到了消息大哥11 

 =========================================================================

                                                            TCP和UDP的分界线

 =========================================================================

(2)UDP协议:(速度快,无连接,不可靠)

不需要建立连接(因为把数据源IP、目的地IP、端口封装成数据包),每个数据包在64KB内,只管发,不管对方有没有接到确认什么的。

优点:可以广播发送,发送数据结束时无需释放资源,开销小,速度快。

使用场景:语言通话、视频通话等。

ps:这个就是一股脑的什么都封装一起,直接往外抛就什么都不管了,当然快了。

例子:

一收一发

发送端(客户端)

package bao;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class Test {
    public static void main(String[] args) throws Exception {
        //一、发送端(测试时候先启动接收再发送端)
        //1.创建发送端对象,发送端自带默认端口号(人)
        System.out.println("========客户端启动============");
        DatagramSocket socket1 = new DatagramSocket();//不定义就默认端口

        //2.创建一个要发送的数据容器(容器里面有数据)
        byte[] a ="我是水".getBytes();
        //3.创建一个数据包对象把容器装起来
        DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getLocalHost(),8899);//数据,大小,服务端的IP,服务端的端口
        //4.发送出去
        socket1.send(packet1);
        //5.关闭资源,避免资源浪费
       socket1.close();
    }
}

接收端 (服务端)

package bao;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class Test1 {
    public static void main(String[] args) throws Exception {
        //二、接收端(测试时候先启动接收再发送端)
        //1.创建接收端对象,注册端口(人)
        System.out.println("=========接收端启动===============");
        DatagramSocket socket2 = new DatagramSocket(8899);

        //2.创建一个要接收的数据容器(等待接收数据)
        byte[]b =new byte[1024*64];
        //3.把容器数据打包
        DatagramPacket packet2 = new DatagramPacket(b,b.length);
        //4.等待接收数据
        socket2.receive(packet2);
        //5.读取多少倒出多少
        int len = packet2.getLength();
        String rs = new String(b,0,len);
        System.out.println("接收到了数据了"+rs);

        //6.关闭资源,避免资源浪费
        socket2.close();
    }
}
//额外知识点,获取对方端口和ip地址
//String ip = packet2.getAddress().toString();
//System.out.println("对方IP地址为"+ip);

//int port = packet2.getPort();
//System.out.println("对方端口位置"+port);

运行结果:

========客户端启动============ 

=========接收端启动===============
接收到了数据了我是水 

多收多发

思想:把一收一发代码拿来改进就好了

发送端:把主要发送的代码写入死循环并写一个键盘输入代码,只有用户输入exit才能退出循环。

接收端:把等待接收的封装包开始写入死循环里面,然后再把释放资源的代码注释掉才能一直接收

发送端(客户端)

package bao;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;
//发送端
public class Test {
    public static void main(String[] args) throws Exception {
        //一、1.创建发送端对象,发送端自带默认端口号(人)
        DatagramSocket socket1 = new DatagramSocket();//不定义就默认端口
        System.out.println("========客户端启动============");
        //二.6创建键盘录入
        Scanner sc = new Scanner(System.in);
        while (true) {//二、5.死循环把代码封起来(多收多发步骤)
            //二、6.接收键盘录入
            System.out.println("请输入:");
            String msg = sc.nextLine();

            //二、7.设置exit退出
            if ("exit".equals(msg)){
                System.out.println("离线成功");
                socket1.close();//释放资源
                break;
            }

            //2.创建一个要发送的数据容器(容器里面有数据)
            byte[] a =msg.getBytes();
            //3.创建一个数据包对象把容器装起来
            DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getLocalHost(),8899);//数据,大小,服务端的IP,服务端的端口
            //4.发送出去
            socket1.send(packet1);
        }
    }
}

接收端 (服务端)

package bao;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
//二、接收端
public class Test1 {
    public static void main(String[] args) throws Exception {
        //1.创建接收端对象,注册端口(人)
        System.out.println("=========接收端启动===============");
        DatagramSocket socket2 = new DatagramSocket(8899);

        //2.创建一个要接收的数据容器(等待接收数据)
        byte[]b =new byte[1024*64];
        //3.把容器数据打包
        DatagramPacket packet2 = new DatagramPacket(b,b.length);
        while (true) {//二、6.把封装代码写入死循环并删掉释放资源的代码(多收多发步骤)
            //4.等待接收数据
            socket2.receive(packet2);
            //5.读取多少倒出多少
            int len = packet2.getLength();
            String rs = new String(b,0,len);
            System.out.println("接收到了来自:"+packet2.getAddress()+"对方端口是:"+packet2.getPort()+rs);
        }
    }
}
//额外知识点,获取对方端口和ip地址
//String ip = packet2.getAddress().toString();
//System.out.println("对方IP地址为"+ip);

//int port = packet2.getPort();
//System.out.println("对方端口位置"+port);

运行结果: 

========客户端启动============
请输入:
你在吗
请输入:
在干嘛
请输入: 

=========接收端启动===============
接收到了来自:(隐私不展示)对方端口是:(隐私不展示)你在吗
接收到了来自:(隐私不展示)对方端口是:(隐私不展示)在干嘛

多开客户端 步骤

一台主机中可以创建很多个客户端给接收端发消息 

 1.在客户端的页面右上角点击

java程序设计之网络编程_Java多线程和网络编程项目[通俗易懂]

2.找到Allow multiple instances勾选完成

java程序设计之网络编程_Java多线程和网络编程项目[通俗易懂] 广播(当前主机和所在网络中的所有主机通信)

步骤:(前提在同一网段内)

发送端的参数地址指定为255.255.255.255,并且指定端口:例如6666

接收端的参数端口只要匹配成功就可以了,例如:6666

例子:

发送端

//修改前

 //3.创建一个数据包对象把容器装起来
DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getLocalHost(),8899);//数据,大小,服务端的IP,服务端的端口

//修改后

 //3.创建一个数据包对象把容器装起来
DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getByName("255.255.255.255"),6666);//数据,大小,服务端的IP,服务端的端口

 接收端

//修改前
        //1.创建接收端对象,注册端口(人)
System.out.println("=========接收端启动===============");
DatagramSocket socket2 = new DatagramSocket(8899);

//修改后
        //1.创建接收端对象,注册端口(人)
System.out.println("=========接收端启动===============");
DatagramSocket socket2 = new DatagramSocket(6666);

组播 (当前主机和所在网络中的一组主机通信)

发送端和接收端都要用MulticastSocket绑定同一个IP地址和绑定同一个端口

范围:224.0.0.0~~~~239.255.255.255

发送端

//修改前
            //3.创建一个数据包对象把容器装起来
DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getByName("255.255.255.255"),6666);//数据,大小,服务端的IP,服务端的端口

//修改后
            //3.创建一个数据包对象把容器装起来
DatagramPacket packet1 = new DatagramPacket(a,a.length, InetAddress.getByName("224.0.1.1"),6666);//数据,大小,服务端的IP,服务端的端口

接收端

//修改前

         //1.创建接收端对象,注册端口(人)
System.out.println("=========接收端启动===============");
DatagramSocket socket2 = new DatagramSocket(6666);

//修改后
        //1.创建接收端对象,注册端口(人)
System.out.println("=========接收端启动===============");
MulticastSocket socket2 = new MulticastSocket(6666);
//绑定组播IP(JDK开始过时的API)
socket2.joinGroup(InetAddress.getByName("224.0.1.1"));

今天的文章java程序设计之网络编程_Java多线程和网络编程项目[通俗易懂]分享到此就结束了,感谢您的阅读。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/71016.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注