精华内容
下载资源
问答
  • Java 网络编程

    万次阅读 多人点赞 2019-05-30 23:07:18
    网络编程 一、网络编程基础概念 首先理清一个概念:网络编程不等于网站编程,网络编程即使用套接字来达到进程间通信,现在一般称为TCP/IP编程。 计算机网络: 把分布在不同地理区域的计算机与专门的外部设备用通信...

    首先理清一个概念:网络编程不等于网站编程,网络编程即使用套接字来达到进程间通信,现在一般称为TCP/IP编程。

    一、计算机网络

    (一)概念

    计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备,通过通信线路连接起来,在网络操作系统,网络管理软件及网络通信协议的管理和协调下,实现资源共享和信息传递的计算机系统。

    (二)计算机网络的主要功能

    1. 资源共享
      资源共享包括计算机硬件资源、软件资源和数据资源的共享。硬件资源的共享提高了计算机硬件资源的利用率,由于受经济和其他因素的制约,这些硬件资派不可能所有用户都有,所以使用计算机网络不仅可以使用自身的硬件资源,也可共享网络上的资源。软件资源和数据资源的共享可以充分利用已有的信息资派.减少软件开发过程中的劳动,避免大型数据库的重复建设。
    2. 信息交换
      这是计算机网络最基本的功能.计算机网络中的计算机之间或计算机与终端之间,可以快速可靠地相互传递数据、程序或文件。例如,用户可以在网上传送电子邮件、交换数据,可以实现在商业部门或公司之间进行订单、发票等商业文件安全准确地交换。
    3. 均衡负荷与分布处理
      对于大型的任务或课题.如果都集中在一台计算机上.负荷太重,这时可以将任务分散到不同的计算机分别完成,或由网络中比较空闲的计算机分担负荷,各个计算机连成网络有利于共同协作进行重大科研课题的开发和研究。利用网络技术还可以将许多小型机或傲型机连成具有高性能的分布式计算机系统,使它具有解决复杂问题的能力,从而大大降低费用。
    4. 综合信息服务
      计算机网络可以向全社会提供各处经济信息、科研情报、商业信息和咨询服务,如Internet中的www就是如此。

    (三)计算机网络分类

    计算机网络按其覆盖的地理范围可分为如下3类:

    • 局域网(LAN)。局域网是一种在小区域内使用的,由多台计算机组成的网络,覆盖范围通常局限在10 千米范围之内,属于一个单位或部门组建的小范围网。
    • 城域网(MAN)。城域网是作用范围在广域网与局域网之间的网络,其网络覆盖范围通常可以延伸到整个城市,借助通信光纤将多个局域网联通公用城市网络形成大型网络,使得不仅局域网内的资源可以共享,局域网之间的资源也可以共享。
    • 广域网(WAN) 广城网是一种远程网,涉及长距离的通信,覆盖范围可以是个国家或多个国家,甚至整个世界。由于广域网地理上的距离可以超过几千千米,所以信息衰减非常严重,这种网络一般要租用专线,通过接口信息处理协议和线路连接起来,构成网状结构,解决寻径问题。

    二、网络通信协议及接口

    (一)网络通信协议

    计算机网络中实现通信必须有一些约定,即通信协议;包括对速率,传输代码,代码结构,传输控制步骤,出错控制等制定的标准。常见的网络通信协议有:TCP/IP协议、IPX/SPX协议、NetBEUI协议等。

    TCP/IP协议:传输控制协议/因特网互联协议(Transmission Control Protocol/Internet Protocal),是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网,以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议,并采用了4层的分层模型,每一层都呼叫它的下一层所提供的协议来完成自己的需求。

    (二)网络通信接口

    为了使两个节点之间能进行对话,必须在他们之间建立通信工具(即接口),使彼此之间,能进行信息交换。接口包括两部分:

    • 硬件装置:实现结点之间的信息传送
    • 软件装置:规定双方进行通信的约定协议

    (三)通信协议分层思想

    1.为什么要分层

    由于结点之间联系很复杂,在制定协议时,把复杂成份分解成一些简单的成份,再将它们复合起来。最常用的复合方式就是层次方式,及同层间可以通信,上一层可以调用下一层,而与再下一层不发生关系。各层互不影响,利于系统的开发和扩展。

    2.通信协议的分层规定

    把用户应用程序作为最高层,把物理通信线路作为最底层,将其间的协议处理分为若干层,规定每层处理的任务,也规定每层的接口标准。

    3.参考模型

    在这里插入图片描述
    上图中,TCP/IP协议中的四层分别是应用层、传输层、网络层和链路层,每层分别负责不同的通信功能。

    • 应用层:主要负责应用程序的协议,例如HTTP协议、FTP协议等。
    • 传输层:主要使网络程序进行通信,在进行网络通信时,可以采用TCP协议,也可以采用UDP协议。
    • 网络层:网络层是整个TCP/IP协议的核心,它主要用于将传输的数据进行分组,将分组数据发送到目标计算机或者网络。
    • 数据链路层:链路层是用于定义物理传输通道,通常是对某些网络连接设备的驱动协议,例如针对光纤、网线提供的驱动。

    我们编写的程序位于应用层,因此我们的程序是和TCP/UDP打交道的。

    (四)协议分类

    通信的协议还是比较复杂的,java.net包中包含的类和接口,它们提供低层次的通信细节,我们可以直接使用这些类和接口,来专注于网络程序开发,而不用考虑通信的细节。

    java.net包中提供了两种常见的网络协议的支持:TCP和UDP

    • TCP是可靠的连接,TCP就像打电话,需要先打通对方电话,等待对方有回应后才会跟对方继续说话,也就是一定要确认可以发信息以后才会把信息发出去。TCP上传任何东西都是可靠的,只要两台机器上建立起了连接,在本机上发送的数据就一定能传到对方的机器上。
    • UDP就好比发电报,发出去就完事了,对方有没有接收到它都不管,所以UDP是不可靠的。
    • TCP传送数据虽然可靠,但传送得比较慢;UDP传送数据不可靠,但是传送得快。

    1.UDP

    • 用户数据报协议(User Datagram Protocol)。
    • 数据报(Datagram):网络传输的基本单位
    • UDP是无连接通信协议,即在数据传输时,数据的发送端和接收端不建立逻辑连接。简单来说,当一台计算机向另外一台计算机发送数据时,发送端不会确认接收端是否存在,就会发出数据,同样接收端在收到数据时,也不会向发送端反馈是否收到数据。
    • 由于使用UDP协议消耗资源小,通信效率高,所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议,因为这种情况即使偶尔丢失一两个数据包,也不会对接收结果产生太大影响。
    • 但是在使用UDP协议传送数据时,由于UDP的面向无连接性,不能保证数据的完整性,因此在传输重要数据时,不建议使用UDP协议。
    • 特点:数据被限制在64kb以内,超出这个范围就不能发送了。

    2.TCP

    • 传输控制协议(Transmission Control Protocol)。
    • TCP协议是面向连接的通信协议,即传输数据之前,在发送端和接收端建立逻辑连接,然后再传输数据,它提供了两台计算机之间可靠无差错的数据传输。
    • 在TCP连接中必须要明确客户端与服务器端,由客户端向服务端发出连接请求,每次连接的创建都需要经过“三次握手”。

    (1)三次握手

    TCP协议中,在发送数据的准备阶段,客户端与服务器之间的三次交互,以保证连接的可靠。

    在这里插入图片描述

    • 第一次握手,客户端发送SYN(SEQ=x)报文给服务器端,进入SYN_SEND状态。
      (客户端向服务器端发出连接请求,等待服务器确认。)
    • 第二次握手,服务器端收到SYN报文,回应一个SYN (SEQ=y)ACK(ACK=x+1)报文,进入SYN_RECV状态。(服务器端向客户端回送一个响应,通知客户端收到了连接请求。)
    • 第三次握手,客户端收到服务器端的SYN报文,回应一个ACK(ACK=y+1)报文,进入Established状态。(客户端再次向服务器端发送确认信息,确认连接。)

    三次握手完成,TCP客户端和服务器端成功地建立连接,可以开始传输数据了。

    (2)四次挥手

    其次,TCP的客户端和服务端断开连接,需要四次挥手
    在这里插入图片描述

    • 客户端打算关闭连接,此时会发送一个 TCP 首部 FIN 标志位被置为 1 的报文,也即 FIN 报文,之后客户端进入 FIN_WAIT_1 状态。
    • 服务端收到该报文后,就向客户端发送 ACK 应答报文,接着服务端进入 CLOSED_WAIT 状态。
    • 客户端收到服务端的 ACK 应答报文后,之后进入 FIN_WAIT_2 状态。
    • 等待服务端处理完数据后,也向客户端发送 FIN 报文,之后服务端进入 LAST_ACK 状态。
    • 客户端收到服务端的 FIN 报文后,回一个 ACK 应答报文,之后进入 TIME_WAIT 状态
    • 服务器收到了 ACK 应答报文后,就进入了 CLOSE 状态,至此服务端已经完成连接的关闭。
    • 客户端在经过 2MSL 一段时间后,自动进入 CLOSE 状态,至此客户端也完成连接的关闭。

    你可以看到,每个方向都需要一个 FIN 和一个 ACK,因此通常被称为四次挥手。这里一点需要注意是:主动关闭连接的,才有 TIME_WAIT 状态。

    为什么挥手需要四次?
    关闭连接时,客户端向服务端发送 FIN 时,仅仅表示客户端不再发送数据了但是还能接收数据。服务器收到客户端的 FIN 报文时,先回一个 ACK 应答报文,而服务端可能还有数据需要处理和发送,等服务端不再发送数据时,才发送 FIN 报文给客户端来表示同意现在关闭连接。从上面过程可知,服务端通常需要等待完成数据的发送和处理,所以服务端的 ACK 和 FIN 一般都会分开发送,从而比三次握手导致多了一次。参考

    通俗理解:

    • 三次握手
      A:我要过来了!B:我知道你要过来了!A:我现在过来!
    • 四次挥手
      A:我们分手吧!B:真的分手吗?B:真的真的要分手吗?A:是的!

    由此,可以可靠地进行连接和断开。

    三、IP协议

    (一)概念

    IP协议:网络互连协议

    在这里插入图片描述
    每个人的电脑都有一个独一无二的IP地址,这样互相通信时就不会传错信息了。

    (二)分类

    IP地址根据版本可以分类为:IPv4和IPv6

    IPv4IPv6
    地址长度IPv4协议具有32位(4字节)地址长度IPv6协议具有128位(16字节)地址长度
    格式IPv4 地址的文本格式为 nnn.nnn.nnn.nnn,其中 0<=nnn<=255,而每个 n 都是十进制数。可省略前导零。IPv6 地址的文本格式为 xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx,其中每个 x 都是十六进制数可省略前导零。
    数量共有43亿,30亿在北美,4亿在亚洲,2011年就已经用尽多到每一粒沙子都可以分配一个IPv6地址

    在这里插入图片描述
    IPv4又可以分为五类:

    • A类:在IP地址的四段号码中,第一段号码为网络号码,剩下的三段号码为本地计算机的号码;A类IP地址中网络的标识长度为8位,主机标识的长度为24位,A类网络地址数量较少,有126个网络,每个网络可以容纳主机数达1600多万(256的三次方-2)台。

    • B类:在IP地址的四段号码中,前两段号码为网络号码。B类IP地址中网络的标识长度为16位,主机标识的长度为16位,B类网络地址适用于中等规模的网络,有16384个网络,每个网络所能容纳的计算机数为6万多(256的二次方-2)台

    • C类:在IP地址的四段号码中,前三段号码为网络号码,剩下的一段号码为本地计算机的号码;此类地址中网络的标识长度为24位,主机标识的长度为8位,C类网络地址数量较多,有209万余个网络。适用于小规模的局域网络,每个网络最多只能包含254(256-2)台计算机

    • D类:此类IP地址在历史上被叫做多播地址(multicast address),即组播地址;在以太网中,多播地址命名了一组应该在这个网络中应用接收到一个分组的站点;多播地址的最高位必须是“1110”,范围从224.0.0.0到239.255.255.255

    • E类: 此类地址也不分网络地址和主机地址,它的第1个字节的前五位固定为“11110”,为将来使用保留,地址范围从240.0.0.1到255.255.255.254

    (三)InetAddress类

    说到IP地址,就要引入一个类:InetAddress
    此类表示互联网协议 (IP) 地址
    在这里插入图片描述

    InetAddress类无构造方法

    1.常用方法摘要

    byte[] getAddress()
    返回此 InetAddress 对象的原始 IP 地址。
    static InetAddress getByName(String host)
    在给定主机名的情况下确定主机的 IP 地址。
    String getHostAddress()
    返回 IP 地址字符串(以文本表现形式)。
    String getHostName()
    获取此 IP 地址的主机名。
    static InetAddress getLocalHost()
    返回本地主机。
    127.0.0.1:本机地址,主要用于测试。别名:Localhost

    案例演示1

    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    public class TestIP {
        public static void main(String[] args) throws UnknownHostException {
            //InetAdress类表示IP地址
    
            //获取本机IP
            InetAddress ip = InetAddress.getLocalHost();// ADMINISTRATOR/192.xxx.xxx.xxx
            System.out.println(ip);
            //获得主机名
            System.out.println(ip.getHostName());// ADMINISTRATOR
            //获得IP地址
            System.out.println(ip.getHostAddress());// 192.xxx.xxx.xxx
            //getLocalHost=getHostName+getHostAddress
            System.out.println(InetAddress.getByName("localhost"));
        }
    }
    

    案例演示2

    import java.net.InetAddress;
    import java.net.UnknownHostException;
    
    public class TestIP2 {
        public static void main(String[] args) throws UnknownHostException {
            InetAddress inetAddress = InetAddress.getByName("www.baidu.com");
            // 获取此 IP 地址的主机名。
            System.out.println(inetAddress.getHostName());
            //返回 IP 地址字符串(以文本表现形式)。
            System.out.println(inetAddress.getHostAddress());
        }
    }
    

    在这里插入图片描述

    四、端口

    • IP地址用来标识一台计算机,但是一台计算机上可能提供多种网络应用程序,如何来区分这些不同的程序呢?这就要用到端口。端口号是用来区分一台机器上不同的应用程序的。
    • 我们使用IP地址加端口号,就可以保证数据准确无误地发送到对方计算机的指定软件上了。
    • 端口是虚拟的概念,是一个逻辑端口。
    • 当我们使用网络软件一打开,那么操作系统就会为网络软件分配一个随机的端口号,或者打开的时候向系统要指定的端口号。
    • 通过端口,可以在一个主机上运行多个网络应用程序。端口的表示是一个16位的二进制整数,2个字节,对应十进制的0~65535
    • 端口号在计算机内部是占2个字节。一台机器上最多有65536个端口号。一个应用程序可以占用多个端口号。端口号如果被一个应用程序占用了,那么其他的应用程序就无法再使用这个端口号了。
    • 记住一点,我们编写的程序要占用端口号的话占用1024以上的端口号,1024以下的端口号不要去占用,因为系统有可能会随时征用。端口号本身又分为TCP端口和UDP端口,TCP的8888端口和UDP的8888端口是完全不同的两个端口。TCP端口和UDP端口都有65536个

    (一)分类

    1. 公有端口:0~1023
      • HTTP:80
      • HTTPS:443
      • FTP:21
      • Telnet:23
    2. 程序注册端口(分配给用户或者程序):1024~49151
      • Tomcat:8080
      • MySQL:3306
      • Oracle:1521
    3. 动态、私有端口:49152~65535

    (二)DOS命令查看端口

    • 查看所有端口:netstat -ano
    • 查看指定端口:netstat -ano|findstr "端口号"
    • 查看指定端口的进程:tasklist|findstr "端口号"

    (三)InetSocketAddress类

    说到端口,则要引入一个类:InetSocketAddress

    此类实现 IP 套接字地址(IP 地址 + 端口号)。

    1.构造方法摘要

    InetSocketAddress(InetAddress addr, int port)
    根据 IP 地址和端口号创建套接字地址。
    InetSocketAddress(int port)
    创建套接字地址,其中 IP 地址为通配符地址,端口号为指定值。
    InetSocketAddress(String hostname, int port)
    根据主机名和端口号创建套接字地址。

    2.常用方法摘要

    InetAddress getAddress()
    获取 InetAddress。
    String getHostName()
    获取 hostname。
    int getPort()
    获取端口号。

    案例演示

    import java.net.InetAddress;
    import java.net.InetSocketAddress;
    
    public class TestPort {
        public static void main(String[] args) {
            InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1",8082);
            System.out.println(inetSocketAddress);
            //返回主机名
            System.out.println(inetSocketAddress.getHostName());
            //获得InetSocketAddress的端口
            System.out.println(inetSocketAddress.getPort());
            //返回一个InetAddress对象(IP对象)
            InetAddress address = inetSocketAddress.getAddress();
            System.out.println(address);
        }
    }
    

    在这里插入图片描述

    五、TCP网络编程和UDP网络编程

    网络编程也叫做Socket编程,即套接字编程。套接字指的是两台设备之间通讯的端点。

    在这里插入图片描述

    (一)TCP网络编程

    1.概述

    TCP通信能实现两台计算机之间的数据交互,通信的两端,要严格区分为客户端(Client)与服务端(Server)。

    (1)两端通信时步骤:

    1. 服务端程序,需要事先启动,等待客户端的连接。
    2. 客户端主动连接服务器端,连接成功才能通信。服务端不可以主动连接客户端。

    (2)在Java中,提供了两个类用于实现TCP通信程序:

    1. 客户端:java.net.Socket 类表示。创建Socket对象,向服务端发出连接请求,服务端响应请求,两者建立连接开始通信。
    2. 服务端:java.net.ServerSocket 类表示。创建ServerSocket对象,相当于开启一个服务,并等待客户端的连接。

    2.Socket类

    Socket 类:该类实现客户端套接字,套接字指的是两台设备之间通讯的端点。

    (1)构造方法摘要

    • public Socket(String host, int port) :创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ,则相当于指定地址为回送地址
      回送地址(127.x.x.x) 是本机回送地址(Loopback Address),主要用于网络软件测试以及本地机进程间通信,无论什么程序,一旦使用回送地址发送数据,立即返回,不进行任何网络传输。

    案例演示

    Socket client = new Socket("127.0.0.1", 6666);
    

    (2)常用方法摘要

    • public InputStream getInputStream() : 返回此套接字的输入流。

      • 如果此Scoket具有相关联的通道,则生成的InputStream 的所有操作也关联该通道。
      • 关闭生成的InputStream也将关闭相关的Socket。
    • public OutputStream getOutputStream() : 返回此套接字的输出流。

      • 如果此Socket具有相关联的通道,则生成的OutputStream 的所有操作也关联该通道。
      • 关闭生成的OutputStream也将关闭相关的Socket。
    • public void close() :关闭此套接字。

      • 一旦一个socket被关闭,它不可再使用。
      • 关闭此socket也将关闭相关的InputStream和OutputStream 。
    • public void shutdownOutput() : 禁用此套接字的输出流。

      • 任何先前写出的数据将被发送,随后终止输出流。

    3.ServerSocket类

    ServerSocket类:这个类实现了服务器套接字,该对象等待通过网络的请求。

    (1)构造方法摘要

    • public ServerSocket(int port) :使用该构造方法在创建ServerSocket对象时,就可以将其绑定到一个指定的端口号上,参数port就是端口号。

    案例演示

    ServerSocket server = new ServerSocket(6666);
    

    (2)常用方法摘要

    • public Socket accept() :侦听并接受连接,返回一个新的Socket对象,用于和客户端实现通信。该方法会一直阻塞直到建立连接。

    4.代码实现

    案例演示1

    客户端:

    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    public class TCPClient {
        public static void main(String[] args){
            Socket socket = null;
            OutputStream os = null;
            try {
                //1、创建Socket对象,它的第一个参数需要的是服务端的IP,第二个参数是服务端的端口
                InetAddress inet = InetAddress.getByName("127.0.0.1");
                socket = new Socket(inet,8090);
                //2、获取一个输出流,用于写出要发送的数据
                os = socket.getOutputStream();
                //3、写出数据
                os.write("你好,我是客户端!".getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {//4、释放资源
                if(socket!=null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(os!=null){
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    服务端:

    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class TCPServer {
        public static void main(String[] args) {
            ServerSocket serverSocket = null;
            Socket socket = null;
            InputStream is = null;
            ByteArrayOutputStream baos = null;
            try {
                //1、创建服务端的ServerSocket,指明自己的端口号
                serverSocket = new ServerSocket(8090);
                //2、调用accept接收到来自于客户端的socket
                socket = serverSocket.accept();//阻塞式监听,会一直等待客户端的接入
                //3、获取socket的输入流
                is = socket.getInputStream();
    
    //        不建议这样写:因为如果我们发送的数据有汉字,用String的方式输出可能会截取汉字,产生乱码
    //        int len=0;
    //        byte[] buffer = new byte[1024];
    //        while ((len=is.read(buffer))!=-1){
    //            String str = new String(buffer, 0, len);
    //            System.out.println(str);
    //        }
                
                //4、读取输入流中的数据
                //ByteArrayOutputStream的好处是它可以根据数据的大小自动扩充
                baos = new ByteArrayOutputStream();
                int len=0;
                byte[] buffer = new byte[1024];
                while ((len=is.read(buffer))!=-1){
                    baos.write(buffer,0,len);
                }
                System.out.println("收到了来自于客户端"+socket.getInetAddress().getHostName()
                        +"的消息:"+baos.toString());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {//5、关闭资源
                if(serverSocket!=null){
                    try {
                        serverSocket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(socket!=null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(is!=null){
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(baos!=null){
                    try {
                        baos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    

    在这里插入图片描述
    服务器是没有IO流的,服务器可以获取到请求的客户端对象socket
    使用每个客户端socket中提供的IO流和客户端进行交互
    服务器使用客户端的字节输入流读取客户端发送的数据
    服务器使用客户端的字节输出流给客户端回写数据

    案例演示2
    服务端向客户端回写数据

    客户端:

    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    public class TCPClient {
        public static void main(String[] args){
            Socket socket = null;
            OutputStream os = null;
            ByteArrayOutputStream baos=null;
            InputStream is=null;
            try {
                //1、创建Socket对象,它的第一个参数需要的是服务端的IP,第二个参数是服务端的端口
                InetAddress inet = InetAddress.getByName("127.0.0.1");
                socket = new Socket(inet,8888);
                //2、获取一个输出流,用于写出要发送的数据
                os = socket.getOutputStream();
                //3、写出数据
                os.write("你好,我是客户端!".getBytes());
                //==========================解析回复==================================
                //4、首先必须通知服务器,我已经输出完毕了,不然服务端不知道什么时候输出完毕
                //服务端的while循环会一直执行,会阻塞
                socket.shutdownOutput();
                ///5、获取输入流,用于读取服务端回复的数据
                is = socket.getInputStream();
                baos = new ByteArrayOutputStream();
                int len=0;
                byte[] buffer = new byte[1024];
                while ((len=is.read(buffer))!=-1){
                    baos.write(buffer,0,len);
                }
                System.out.println("收到了来自服务端的消息:"+baos.toString());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {//6、释放资源
                if(socket!=null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(os!=null){
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(is!=null){
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (baos!=null){
                    try {
                        baos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    服务端:

    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class TCPServer {
        public static void main(String[] args) {
            ServerSocket serverSocket = null;
            Socket socket = null;
            InputStream is = null;
            ByteArrayOutputStream baos = null;
            OutputStream os=null;
            try {
                //1、创建服务端的ServerSocket,指明自己的端口号
                serverSocket = new ServerSocket(8888);
                //2、调用accept接收到来自于客户端的socket
                socket = serverSocket.accept();//阻塞式监听,会一直等待客户端接入
                //3、获取socket的输入流
                is = socket.getInputStream();
    
    //        不建议这样写:因为如果我们发送的数据有汉字,用String的方式输出可能会截取汉字,产生乱码
    //        int len=0;
    //        byte[] buffer = new byte[1024];
    //        while ((len=is.read(buffer))!=-1){
    //            String str = new String(buffer, 0, len);
    //            System.out.println(str);
    //        }
    
                //4、读取输入流中的数据
                //ByteArrayOutputStream的好处是它可以根据数据的大小自动扩充
                baos = new ByteArrayOutputStream();
                int len=0;
                byte[] buffer = new byte[1024];
                while ((len=is.read(buffer))!=-1){
                    baos.write(buffer,0,len);
                }
                System.out.println("收到了来自于客户端"+socket.getInetAddress().getHostName()
                        +"的消息:"+baos.toString());
                //===========================回复==========================================
                //5、获取一个输出流,写出回复给客户端
                os = socket.getOutputStream();
                //6、写出数据
                os.write("你好,我是服务端".getBytes());
            } catch (IOException e) {
                e.printStackTrace();
            } finally {//7、关闭资源
                if(serverSocket!=null){
                    try {
                        serverSocket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(socket!=null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(is!=null){
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(baos!=null){
                    try {
                        baos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(os!=null){
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    在这里插入图片描述
    在这里插入图片描述
    案例演示3
    上传文件:客户端发送文件给服务端,服务端将文件保存在本地
    在这里插入图片描述

    客户端:

    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.InetAddress;
    import java.net.Socket;
    
    public class TCPClient {
        public static void main(String[] args) {
            Socket socket = null;
            FileInputStream fis = null;
            OutputStream os = null;
            try {
                //1、创建Socket对象,它的第一个参数需要的是服务端的IP,第二个参数是服务端的端口
                InetAddress inet = InetAddress.getByName("127.0.0.1");
                socket = new Socket(inet, 8888);
                //2、创建一个文件输入流,读取要上传的文件
                fis = new FileInputStream("D:/test/touxiang.jpg");
                //3、获取一个输出流,用于写出要发送的数据
                os = socket.getOutputStream();
                byte[] buffer = new byte[1024];
                int len=0;
                while((len=fis.read(buffer))!=-1){
                    //4、写出数据
                    os.write(buffer,0,len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {//5、释放资源
                if(socket!=null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(fis!=null){
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(os!=null){
                    try {
                        os.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    服务端:

    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class TCPServer {
        public static void main(String[] args) {
            ServerSocket serverSocket = null;
            Socket socket = null;
            FileOutputStream fos = null;
            InputStream is = null;
            try {
                //1、创建服务端的ServerSocket,指明自己的端口号
                serverSocket = new ServerSocket(8888);
                //2、调用accept接收到来自于客户端的socket
                socket = serverSocket.accept();//阻塞式监听,会一直等待客户端的接入
                //3、创建一个文件输出流,用于将读取到的客户端上传的文件输出
                fos = new FileOutputStream("touxiang.jpg");
                //4、获取socket的输入流
                is = socket.getInputStream();
                byte[] buffer = new byte[1024];
                int len=0;
                while((len=is.read(buffer))!=-1){
                    fos.write(buffer,0,len);//5、写出文件
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {//6、释放资源
                if(serverSocket!=null){
                    try {
                        serverSocket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(socket!=null){
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(fos!=null){
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if(is!=null){
                    try {
                        is.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    

    假设大海里有许多岛屿,客户端和服务端相当于其中的两座岛屿,“客户端”岛屿生产了一种农作物要运到“服务端”岛屿,所以“客户端”要知道“服务端”确切的地址(IP),不然就运错地方了,socket就相当于运输的船只,port就相当于“服务端”岛屿的某个港口。

    (二)UDP网络编程

    从技术意义上来讲,只有TCP才会分Server和Client。对于UDP来说,严格意义上,并没有所谓的Server和Client。
    java.net包给我们提供了两个类DatagramSocket(此类表示用于发送和接收数据报的套接字)和DatagramPacket(该类表示数据报的数据包。 )

    1.DatagramSocket

    (1)构造方法摘要

    protected DatagramSocket()构造数据报套接字并将其绑定到本地主机上的任何可用端口。
    protected DatagramSocket(int port)构造数据报套接字并将其绑定到本地主机上的指定端口。
    protected DatagramSocket(int port, InetAddress laddr)创建一个数据报套接字,绑定到指定的本地地址。

    2.DatagramPacket

    (1)构造方法摘要

    DatagramPacket(byte[] buf, int offset, int length)构造一个 DatagramPacket用于接收指定长度的数据报包到缓冲区中。
    DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)构造用于发送指定长度的数据报包到指定主机的指定端口号上。

    (2)常用方法摘要

    byte[] getData() 返回数据报包中的数据。
    InetAddress getAddress() 返回该数据报发送或接收数据报的计算机的IP地址。
    int getLength() 返回要发送的数据的长度或接收到的数据的长度。

    3.代码实现

    案例演示1
    发送方:

    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.InetAddress;
    
    public class UDPSender {
        public static void main(String[] args) throws IOException {
            //1、创建一个socket
            DatagramSocket socket = new DatagramSocket();
            InetAddress inet = InetAddress.getLocalHost();
            String msg="你好,很高兴认识你!";
            byte[] buffer = msg.getBytes();
            //2、创建一个包(要发送给谁)
            DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length,inet,9090);
            //3、发送包
            socket.send(packet);
            //4、释放资源
            socket.close();
        }
    }
    

    接收方:

    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    
    public class UDPReceiver {
        public static void main(String[] args) throws IOException {
            //1、创建一个socket,开放端口
            DatagramSocket socket = new DatagramSocket(9090);
            byte[] buffer = new byte[1024];
            //2、创建一个包接收数据
            DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
            //3、接收数据
            socket.receive(packet);//阻塞式接收
            //将数据包转换为字符串输出
            String msg = new String(packet.getData(), 0, packet.getLength());
            System.out.println(msg);
            //4、释放资源
            socket.close();
        }
    }
    

    在这里插入图片描述
    注意
    如果是TCP中先启动客户端会报错:
    在这里插入图片描述
    而如果是UDP中先启动发送方不会报错,但会正常退出。

    案例演示2
    完成在线咨询功能,学生和老师在线一对一交流(多线程

    发送方:

    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 UDPSender implements Runnable{
        //创建一个socket
        DatagramSocket socket=null;
        //创建一个流 用于录入键盘的数据
        BufferedReader bfr=null;
        //发送数据目的地的IP
        private String toIP;
        //发送数据目的地的端口
        private int toPort;
    
        public UDPSender(String toIP, int toPort) {
            this.toIP = toIP;
            this.toPort = toPort;
            try {
                socket=new DatagramSocket();//创建一个socket
            } catch (SocketException e) {
                e.printStackTrace();
            }
            bfr=new BufferedReader(new InputStreamReader(System.in));//从键盘录入数据到流中
        }
    
        @Override
        public void run() {
            while (true){//循环发送数据
                try {
                    String msg = bfr.readLine();//从流中读取数据
                    byte[] buffer = msg.getBytes();
                    InetAddress inet = InetAddress.getByName(toIP);
                    DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length, inet, toPort);
                    socket.send(packet);
                    //如果发送了拜拜,则退出发送
                    if(msg.equals("拜拜")){
                        break;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //释放资源
            if(socket!=null){
                socket.close();
            }
            if (bfr!=null){
                try {
                    bfr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    接收方:

    import java.io.IOException;
    import java.net.DatagramPacket;
    import java.net.DatagramSocket;
    import java.net.SocketException;
    
    public class UDPReceiver implements Runnable{
        //创建一个socket
        DatagramSocket socket=null;
        //接收方自己所在的端口
        private int fromPort;
        //数据发送者的姓名
        private String msgFrom;
    
        public UDPReceiver(int fromPort,String msgFrom) {
            this.fromPort = fromPort;
            this.msgFrom=msgFrom;
            try {
                socket=new DatagramSocket(fromPort);//创建一个socket
            } catch (SocketException e) {
                e.printStackTrace();
            }
        }
    
        @Override
        public void run() {
            while(true){//循环接收
                try {
                    byte[] buffer = new byte[1024 * 8];
                    DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
                    socket.receive(packet);
                    String msg = new String(packet.getData(), 0, packet.getLength());
                    System.out.println(msgFrom+":"+msg);
                    if (msg.equals("拜拜")){//如果接收到的数据为拜拜,则退出接收
                        break;
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            //释放资源
            socket.close();
        }
    }
    

    学生线程:

    public class Student {
        public static void main(String[] args) {
            new Thread(new UDPSender("127.0.0.1",8888)).start();
            new Thread(new UDPReceiver(7777,"老师")).start();
        }
    }
    

    老师线程:

    public class Teacher {
        public static void main(String[] args) {
            new Thread(new UDPSender("127.0.0.1",7777)).start();
            new Thread(new UDPReceiver(8888,"学生")).start();
        }
    }
    

    学生的窗口:
    在这里插入图片描述
    老师的窗口:
    在这里插入图片描述

    六、URL

    (一)概念

    URL(Uniform Resource Locator)统一资源定位符,它表示Internet上某一资源的地址。
    通过URL我们可以访问Internet上的各种网络资源,比如最常见的www,ftp站点。浏览器通过解析给定的URL可以在网络上查找相应的文件或其他资源。

    URI=URL+URN

    • URI:Uniform Resource Identifier ,统一资源标志符。
    • URL:Uniform Resource Locator,统一资源定位符。
    • URN:Uniform Resource Name,统一资源命名。

    网络三大基石:HTML,HTTP,URL

    (二)格式

    URL的基本结构由5部分组成:
    <传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表

    • 片段名:即锚点,例如看小说,直接定位到章节
    • 参数列表格式:参数名=参数值&参数名=参数值......

    例如:
    http://localhost:8080/index.jsp#a?username=Tom&password=123456

    (三)URL类

    java.net包下

    1.构造方法摘要

    URL(String spec)根据 String 表示形式创建 URL 对象。
    URL(String protocol, String host, int port, String file) 根据指定协议名、主机名、端口号和文件名创建 URL 对象。
    URL(String protocol, String host, String file) 根据指定的协议名、主机名和文件名创建 URL。

    2.常用方法摘要

    String getProtocol()获取此 URL的协议名称。
    String getHost() 获取此 URL 的主机名。
    int getPort() 获取此 URL 的端口号。
    String getPath() 获取此 URL 的文件路径。
    String getFile()获取此 URL 的文件名。
    String getQuery()获取此 URL的查询部分。
    URLConnection openConnection() 返回一个URLConnection实例,表示与URL引用的远程对象的URL 。

    • URLConnection类中又有一个方法:
      InputStream getInputStream() 返回从此打开的连接读取的输入流。

    案例演示1

    import java.net.MalformedURLException;
    import java.net.URL;
    
    public class Test {
        public static void main(String[] args) throws MalformedURLException {
            URL url = new URL("http://localhost:8080/index.jsp?username=Tom&password=123456");
            System.out.println(url.getProtocol());//获取协议名
            System.out.println(url.getHost());//获取主机名
            System.out.println(url.getPort());//获取端口号
            System.out.println(url.getPath());//获取文件路径
            System.out.println(url.getFile());//获取文件名
            System.out.println(url.getQuery());//获取查询名
        }
    }
    

    在这里插入图片描述
    案例演示2
    URL下载网络资源

    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.HttpURLConnection;
    import java.net.URL;
    
    public class Test {
        public static void main(String[] args) throws IOException {
            //下载地址
            URL url = new URL("https://img.t.sinajs.cn/t6/style/images/global_nav/WB_logo.png?id=1404211047727");
            //连接到这个资源 HTTP
            HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
            InputStream is = urlConnection.getInputStream();
            FileOutputStream fos = new FileOutputStream("weibo.jpg");
            byte[] buffer = new byte[1024];
            int len=0;
            while ((len=is.read(buffer))!=-1){
                fos.write(buffer,0,len);
            }
            //释放资源
            urlConnection.disconnect();//断开连接
            is.close();
            fos.close();
        }
    }
    

    小结

    在这里插入图片描述

    展开全文
  • Java网络编程实现

    万次阅读 多人点赞 2018-10-14 12:17:06
    网络应用程序就是在已连接的不同终端设备上运行的程序,这些网络程序相互之间可以进行数据交互。网络程序的数据交互则依赖于TCP/IP协议,在实际应用中TCP网络程序提供可靠的数据通信,而UDP网络程序则不保证数据的...

    前言

    计算机网路实现了多个网络终端的互联,彼此之间能够进行数据交流。而网络应用程序就是在已连接的不同终端设备上运行的程序,这些网络程序相互之间可以进行数据交互。网络程序的数据交互则依赖于TCP/IP协议,在实际应用中TCP网络程序提供可靠的数据通信,而UDP网络程序则不保证数据的可靠性,但是协议简单、传输速度快(比如用在音视频数据传输,它们不需要很高的可靠性,偶尔丢帧是可以忍受的)。

    ServerSocket类

    Java.net包中的ServerSocket类用于表示服务器套接字,其主要功能是监听客户端的请求,然后将客户端的请求连接存入队列中,默认请求队列大小是50。构造方法主要有以下几种形式:

    ServerSocket():创建非绑定服务器套接字。

    ServerSocket(int port):创建绑定到特定端口的服务器套接字。

    ServerSocket(int port,int backlog):利用指定的backlog创建服务器套接字并将其绑定到指定的本地端口号。

    ServerSocket(int port,int backlog,InetAdress bindAddress):使用指定的端口、监听backlog和要绑定到本地IP地址创建服务器,适用于计算机有多个网卡、多个IP的情景。

    TCP网络程序实例

    服务端程序代码

    //服务端程序
    import java.io.*;
    import java.net.*;
    public class MyTcpServer {
    	private BufferedReader reader;
    	private PrintWriter writer;
    	private ServerSocket server;
    	private Socket socket;
    	void getserver(){
    		try{
    			server = new ServerSocket(8866);
    			System.out.println("服务器套接字已经创建成功");
    			while(true){
    				System.out.println("等待客户机的连接");
    				socket = server.accept();	//阻塞的
    				reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    				writer = new PrintWriter(socket.getOutputStream(),true);
    				getClientMessage();			}
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    	}
    	private void getClientMessage(){
    		try{
    			while(true){
    				System.out.println("客户端信息接收:"+ reader.readLine());
    				writer.println("欢迎您连接服务端");
    			}
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		try{
    			if(reader != null){
    				reader.close();
    			}
    			if(writer != null){
    				writer.close();
    			}
    			if(socket != null){
    				socket.close();
    			}
    		}catch(IOException e){
    			e.printStackTrace();
    		}
    	}
    }
    public class Main {
    	public static void main(String[] args) {
    		MyTcpServer tcpserv = new MyTcpServer();
    		tcpserv.getserver();
    	}
    
    }

    客户端程序代码

    //客户端程序
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.Socket;
    
    
    public class MyTcpClient {
    	private PrintWriter writer;
    	private BufferedReader reader;
    	Socket socket;
    	public void connect(){
    		System.out.println("尝试连接");
    		try{
    			socket = new Socket("127.0.0.1",8866);
    			writer = new PrintWriter(socket.getOutputStream(),true);
    			reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    			System.out.println("连接成功");
    			writer.println("你好,来自客户端的连接");
    			getserverMessage();
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    	}
    	private void getserverMessage(){
    		try{
    			while(true){
    				System.out.println(":"+ reader.readLine());				
    			}
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		try{
    			if(reader != null){
    				reader.close();
    			}
    			if(writer != null){
    				writer.close();
    			}
    			if(socket != null){
    				socket.close();
    			}
    		}catch(IOException e){
    			e.printStackTrace();
    		}
    	}
    	
    }
    
    public class Main {
    	public static void main(String[] args) {
    		MyTcpClient tcpclient;
    		tcpclient = new MyTcpClient();
    		tcpclient.connect();
    	}
    
    }

    服务端运行效果图

    客户端运行效果图

    UDP网络程序

    使用UDP协议的程序流程简单很多,它收发包流程如下:

    UDP网络通信的发包过程:

    1. 使用DatagramSocket()创建一个数据包套接字。
    2. 使用DatagramPacket(byte[]buf,int offset,int length,InetAddress address,int port)创建要发送的数据包。
    3. 使用DatagramSocket类的send()方法数据包。

     

    UDP网络通信的收包过程:

    1. 使用DatagramSocket()创建一个数据包套接字,绑定到指定的端口。
    2. 使用DatagramPacket(byte[]buf,int length)创建字节数组来接收数据包.
    3. 使用DatagramPacket类的receive()方法接收UDP。

     

    总结

    网络编程是程序实现网络通信的基石,在互联网高度繁荣的当下,几乎没有什么应用不需要网络支持。网络通信基于TCP/IP,基于此,网络编程可以选择使用TCP传输或UDP传输,它们两个是比较底层的通信协议,TCP提供可靠的连接,UDP则不提供可靠的连接,在实际应用中大多数选用TCP,而UDP主要用于音视频、NTP对时这种对数据可靠性要求不是那么高的场合。

    展开全文
  • 使用多线程实现多客户端连接服务器, 客户端代码如下: /** * Socket客户端 * 功能为:发送字符串nihao到服务器端,并打印出服务器端的返回信息 */ import java.io.InputStream; import java.io.OutputStream...

    使用多线程实现多客户端连接服务器,

    客户端代码如下:

    /**
     * Socket客户端
     * 功能为:发送字符串nihao到服务器端,并打印出服务器端的返回信息
     */
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    
    public class SocketClient {
    
    	public static void main(String[] args) {
    		Socket socket = null;
    		InputStream is = null;
    		OutputStream os = null;
    		// 服务器IP
    		String serverIP = "127.0.0.1";
    		// 服务器端口
    		int port = 8080;
    		try {
    			// 建立连接
    			socket = new Socket(serverIP, port);
    			is = socket.getInputStream();
    			os = socket.getOutputStream();
    			//发送信息
    			os.write("nihao".getBytes());
    			//接收信息
    			byte[] buffer = new byte[1024]; 
    			int n = is.read(buffer);
    			// 输出返回信息
    			System.out.println("接收服务器信息:" + new String(buffer, 0, n));
    		} catch (Exception e) {
    			e.printStackTrace(); 
    		} finally {
    			try {
    				//关闭流和连接
    				is.close();
    				os.close();
    				socket.close();
    			} catch (Exception e2) {
    			}
    		}
    	}
    }

    服务器端代码如下:

    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
     
    public class SocketServer {
    
    	public class ClientHandler implements Runnable {
     
    		Socket socket = null;
    		InputStream inputStream = null;
    		OutputStream outputStream = null;
    
    		public ClientHandler(Socket socket) {
    			this.socket = socket; 
    		}
    
    		public void run() {
    			byte[] buffer = new byte[1024];
    			//读取数据
                int length;
    			try {
    				inputStream = socket.getInputStream();
    				outputStream = socket.getOutputStream();
    				length = inputStream.read(buffer); 
    	            System.out.println(new String(buffer,0,length)); 
    	            outputStream.write("niyehao".getBytes());
    			} catch (IOException e) {
     				e.printStackTrace(); 
    			}finally{
    				try {
    					inputStream.close();
    					outputStream.close();
    					socket.close();
    				} catch (IOException e) { 
     					e.printStackTrace();
    				}
    			}
    		} 
    	}
    	
    	public static void main(String[] args){
    		new SocketServer().StartServer();  
     
    	}
    	
    	public void StartServer(){
    		ServerSocket serverSocket  = null;
    		Socket socket = null;
    		int port=5555;
    		try{
    			serverSocket = new ServerSocket(port);
    			System.out.println("server start");
    			while(true){
    				socket = serverSocket.accept(); 
    				System.out.println("client connectioned,IP:"+socket.getInetAddress()); 
    				Thread t = new Thread(new ClientHandler(socket));
                    t.start();
    			}
    		}catch(IOException e){
    			e.printStackTrace();
    		} finally{
    			 
    		}
    	}
    }


    展开全文
  • java网络编程实现聊天小程序

    千次阅读 2019-04-08 19:50:45
    这里运用到的是Java基于TCP的socket编程,详细讲解,请自行百度。 我这里分三步,贴出代码! 1.客户端 ClientTest01.java import java.io.BufferedReader; import java.io.IOException; import java.io....

    这里运用到的是Java基于TCP的socket编程,详细讲解,请自行百度。
    我这里分三步,贴出代码!

    1.客户端

    ClientTest01.java

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.Socket;
    import java.net.UnknownHostException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class ClientTest01 {
    	
    	public static void main(String[] args) {
    		BufferedReader br = null;
    		 String clientStr="";
    		try {
    			//建立通信端口,并向服务器端发送通信请求
    			Socket s = new Socket("10.25.200.153",3838);
    		    System.out.println("与服务器端建立连接");
    		    BusinessHanderTest01 send = new BusinessHanderTest01(s);
    			Thread t1 = new Thread(send);
    			t1.start();
    			   while(true){
    				    
    					//获取客户端通信的信息
    				   SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    			
    				   br = new BufferedReader(new InputStreamReader(s.getInputStream()));
    				   clientStr = br.readLine();
    				   System.out.println(df.format(new Date())+"  服务器端 :  "+clientStr);
    			   }
    		    
    		} catch (UnknownHostException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    
    	}
    
    }
    
    

    注:Socket s = new Socket(“10.25.200.153”,3838);中的第一个参数是服务器端的网络地址,第二个参数是服务器开放的端口号。

    2.服务器端

    ServerTest01.java

    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class ServerTest01 {
    	public static void main(String[] args) throws IOException {
    		 BufferedReader br = null;
    		 String clientStr="";
    		 ServerSocket ss  = null;
    		 
    		  try {
    			//创建一个监听的端口
    			ss = new ServerSocket(3838);
    			Socket s = null;
    		    System.out.println("服务器启动...");
    		    System.out.println("本机IP地址:"+InetAddress.getLocalHost());
    			//接受客户端通信请求,并建立专用通信端口
    		    s = ss.accept();
    			System.out.println("客户端已连接...");
    			BusinessHanderTest01 send = new BusinessHanderTest01(s);
    			Thread t1 = new Thread(send);
    			t1.start();
    		   while(true){
    			    
    			   //获取客户端通信的信息
    			   SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    			   br = new BufferedReader(new InputStreamReader(s.getInputStream()));
    			   clientStr = br.readLine();
    			   
    			   System.out.println(df.format(new Date())+"  客户端:  "+clientStr);
    		   }
    		  } catch (Exception e) {
    			e.printStackTrace();
    		  }finally {
    			  ss.close();
    		  }
    		}
    }
    
    

    注:ss = new ServerSocket(3838);中的参数是该服务器端开放的端口号,需要与客户端填写的端口号保持一致。

    3.多线程助手

    BusinessHanderTest01 .java

    import java.io.OutputStreamWriter;
    import java.io.PrintWriter;
    import java.net.Socket;
    import java.util.Scanner;
    
    public class BusinessHanderTest01 implements Runnable{
    	Socket s ;
    	Scanner in = new Scanner(System.in);
    
    	public BusinessHanderTest01(Socket s){
    		this.s = s;
    	}
    	public void run() {
    
    		PrintWriter out = null;
    		try {
    			while(true){
    				out = new PrintWriter(new OutputStreamWriter(s.getOutputStream()),true);
    				String str = in.nextLine();
    			    out.println(str);
    	
    			}
    			
    		} catch (Exception e) {
    			e.printStackTrace();
    		}finally{
    			out.close();
    		}
    		
    	}
    	
    }
    
    

    运行时,需要服务器端先开启,等待客户端连接,不然会报错!

    展开全文
  • Java Java网络编程

    千次阅读 2012-09-11 20:08:45
    Java网络编程 通信协议 计算机网络中实现通信必须有一些约定,即通信协议。对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准。 TCP协议:提供可靠的数据传输服务的规则。 IP协议进行IP数据包的...
  • Java 网络编程 之 socket 的用法与实现

    万次阅读 多人点赞 2018-05-15 09:44:00
    在简化的计算机网络OSI模型中,它完成第四层传输层所指定的功能,用户数据报协议(UDP,下一篇博客会实现)是同一层内 另一个重要的传输协议。在因特网协议族(Internet protocol suite)中,TCP层是...
  • java网络编程实现聊天室功能(多台电脑进行连接) 所谓的网络编程就是计算机之间的信息交互,对于程序员而言掌握一种编程方法相对就会简单的多。java SDK给我们提供了一些API来简化了程序的编写,网络编程的所有的类都...
  • 这是基于前面一篇文章的一个简单扩展,当然这不是最好的实现 服务端如果要想接收多个客户端连接,必须
  • Java网络编程

    千次阅读 2016-06-08 21:48:28
    网络编程是指编写运行在多个设备(计算机)的程序,这些设备都通过网络连接起来。 java.net包中J2SE的API包含有类和接口,它们提供低层次的通信细节。你可以直接使用这些类和接口,来专注于解决 问题,而不用关注...
  • 思维导图参考:【十五】Java网络编程思维导图 一、什么是网络 网络的概念 由点和线构成,表示诸多对象间的相互联系 比如: 蜘蛛网 人脉网 计算机网络 二、计算机网络 为实现资源共享和信息传递,用过...
  • Java网络编程实现QQ邮件发送客户端

    千次阅读 多人点赞 2020-12-09 11:35:01
    本篇详细记录了使用Java网络编程的技术思想,初步实现QQ邮件发送客户端。从零开始学习,认识计算机网络邮件传输协议(SMTP、POP3),并开通QQ邮箱的smtp/pop3服务,为之后程序设计做准备,自行实现简单的Java GUI,...
  • java多线程以及java网络编程实现简单的聊天系统

    千次阅读 热门讨论 2015-10-15 20:57:04
    该系统采用java多线程技术及java网络编程技术实现一个基于C/S的聊天系统,系统分为客户端及服务器端: 服务器端主要涉及到以下几个线程: 1.在服务器启动之后会启动一个名为ConnectThread的线程,该线程用来处理...
  • import java.io.IOException; import java.net.URI; import java.net.URISyntaxException; import java.util.List; import org.apache.http.HeaderElement; import org.apache.http.HeaderElementIterator; impo...
  • 老曹眼中的网络编程基础 转自:https://mp.weixin.qq.com/s/XXMz5uAFSsPdg38bth2jAA 我们是幸运的,因为我们拥有网络。网络是一个神奇的东西,它改变了你和我的生活方式,改变了整个世界。 然而,网络的无标度...
  • 【带你入门】java网络编程

    万次阅读 多人点赞 2018-02-18 12:10:41
    网络编程网络编程对于很多的初学者来说,都是很向往的一种编程技能,但是很多的初学者却因为很一段时间无法进入网络编程的大门而放弃了对于该部分技术的学习。在 学习网络编程以前,很多初学者可能觉得网络编程是...
  • Java使用socket网络编程实现多人聊天室

    万次阅读 多人点赞 2016-01-21 19:52:54
    前言:套接字(socket)编程能够实现服务器和客户端的通信,以下通过Socket编程实现多人聊天室。 程序展示: 界面类1.客户端界面 ClientView.javapublic class ClientView extends JFrame implements ...
  • java实现的基于TCP网络编程步骤

    千次阅读 2014-03-30 23:29:45
    参考 java 程序设计教程(第二版)雍俊海老师编著的书12章 服务器端程序设计模型的建立通常由如下五个步骤组成: (1)在服务器端,首先要创建ServerSocket的实例对象,注册在服务器端进行连接的端口号以及允许...
  • Java 网络编程详解(二)

    万次阅读 2012-08-14 17:59:05
    在上一篇关于 Java 网络编程的文章中【Java网络编程详解(一)】,我们介绍网络通信的一些基础概念,如:OSI网络模型、TCP/IP 网络模型、UDP 协议、TCP 协议以及 Java 中如何实现网络编程Java 网络编程实现图片...
  • Java网络编程笔记启用UDP广播发送下通信编程//发送端代码 import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net....
  • post、get请求一般出现在前端调用后端接口的时候,现在如果希望java代码去调用controller接口,比如在job定时器中,达到某一条件需要返回给前端一条提示消息(如订单30分钟内未付款,已被自动取消),而前端只能调...
  • Java Language——网络编程

    千次阅读 多人点赞 2016-05-21 15:26:00
    计算机网络主要功能包括资源共享、信息传输和集中处理、负载均衡和...实际上 Java网络编程就是服务器通过 ServerSocket 建立监听,客户端通过 Socket 连接到指定服务器后,通信双方就可以通过 IO 流进行通信了。
  • 基于UDP协议网络Socket编程(java实现C/S通信案例)

    千次阅读 多人点赞 2020-10-11 21:33:41
    本篇详细记录运用java进行网络编程,基于UDP套接字(Socket)实现服务器与客户端间的通信,在实战案例中更深刻理解UDP的实现原理,掌握UDP实践应用步骤。
  • 昨天晚上学了网络线程,并写了一个,客户端连接服务器的简单例子,有点QQ的感觉,但是实际上还差远,差不多就是很久之前那种“长江长江我是黄河”的通话形式。 代码如下: 服务器端代码:import java.io....
  • Java实现基于Socket的网络编程

    千次阅读 2019-11-23 00:59:14
    使用Java语言,采用TCP协议,实现一对一、一对多的通信(无用户界面)
  • Java网络编程基础

    千次阅读 2016-05-08 16:19:43
    一、Java网络编程 网络编程在如今这样的网络时代是十分重要的,Java语言提供了丰富的类库来支持网络编程。这里将重点介绍Java.net中的类,充分了解认识Java网络编程的原理并深入学习各模块。在学习Java网络编程之前...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 176,341
精华内容 70,536
关键字:

java实现网络编程实现长连接

java 订阅