java的网络编程(概括比较全面)

对java网络编程Socket(套接字)接口的使用做详细的介绍和使用。

原文链接

一.网络编程中两个主要的问题

一个是如何准确的定位网络上一台或多台主机,另一个就是找到主机后如何可靠高效的进行数据传输。

在TCP/IP协议中IP层主要负责网络主机的定位,数据传输的路由,由IP地址可以唯一地确定Internet上的一台主机。

而TCP层则提供面向应用的可靠(tcp)的或非可靠(UDP)的数据传输机制,

这是网络编程的主要对象,一般不需要关心IP层是如何处理数据的。

目前较为流行的网络编程模型是客户机/服务器(C/S)结构。

即通信双方一方作为服务器等待客户提出请求并予以响应。

客户则在需要服务时向服务器提 出申请。

服务器一般作为守护进程始终运行,监听网络端口,一旦有客户请求,

就会启动一个服务进程来响应该客户,同时自己继续监听服务端口,使后来的客户也 能及时得到服务。

二.两类传输协议:TCP;UDP

TCP是Tranfer Control Protocol的 简称,是一种面向连接的保证可靠传输的协议。

通过TCP协议传输,得到的是一个顺序的无差错的数据流。

发送方和接收方的成对的两个socket之间必须建 立连接,

以便在TCP协议的基础上进行通信,当一个socket(通常都是server socket)等待建立连接时,

另一个socket可以要求进行连接,一旦这两个socket连接起来,

它们就可以进行双向数据传输,双方都可以进行发送 或接收操作。

UDP是User Datagram Protocol的简称,是一种无连接的协议,

每个数据报都是一个独立的信息,包括完整的源地址或目的地址,它在网络上以任何可能的路径传往目的地,

因此能否到达目的地,到达目的地的时间以及内容的正确性都是不能被保证的。

(一)比较:UDP和TCP

UDP:

1.每个数据报中都给出了完整的地址信息,因此无需要建立发送方和接收方的连接。

2.UDP传输数据时是有大小限制的,每个被传输的数据报必须限定在64KB之内。

3.UDP是一个不可靠的协议,发送方所发送的数据报并不一定以相同的次序到达接收方

TCP:

1.面向连接的协议,在socket之间进行数据传输之前必然要建立连接,所以在TCP中需要连接时间。

 2.TCP传输数据大小限制,一旦连接建立起来,双方的socket就可以按统一的格式传输大的数据。

 3.TCP是一个可靠的协议,它确保接收方完全正确地获取发送方所发送的全部数据。

(二)应用:

1.TCP在网络通信上有极强的生命力,

例如远程连接(Telnet)和文件传输(FTP)都需要不定长度的数据被可靠地传输。

但是可靠的传输是要付出代价的,对数据内容正确性的检验必然占用计算机的处理时间和网络的带宽,

因此TCP传输的效率不如UDP高。

2.UDP操作简单,而且仅需要较少的监护,

因此通常用于局域网高可靠性的分散系统中client/server应用程序。

例如视频会议系统,并不要求音频视频数据绝对的正确,只要保证连贯性就可以了,

这种情况下显然使用UDP会更合理一些。

三.基于Socket的java网络编程

(一)Socket的定义

网络上的两个程序通过一个双向的通讯连接实现数据的交换,这个双向链路的一端称为一个Socket。

Socket通常用来实现客户方和服务方的连接。Socket是TCP/IP协议的一个十分流行的编程界面,

一个Socket由一个IP地址和一个端口号唯一确定。

但是,Socket所支持的协议种类也不光TCP/IP一种,因此两者之间是没有必然联系的。

在Java环境下,Socket编程主要是指基于TCP/IP协议的网络编程。

(二)Socket通讯的过程

Server端Listen(监听)某个端口是否有连接请求,Client端向Server 端发出Connect(连接)请求,

Server端向Client端发回Accept(接受)消息。一个连接就建立起来了。

Server端和Client 端都可以通过Send,Write(socket.getOutputStream/socket.getInputStream)等方法与对方通信。

对于一个功能齐全的Socket,都要包含以下基本结构,其工作过程包含以下四个基本的步骤:

1. 创建Socket;

2. 打开连接到Socket的输入/出流;

3. 按照一定的协议对Socket进行读/写操作;

4.关闭Socket.(在实际应用中,并未使用到显示的close,虽然很多文章都推荐如此,不过在我的程序中,可能因为程序本身比较简单,要求不高,所以并未造成什么影响。)

(三)创建Socket

创建Socket在java包java.net中提供了两个类Socket和ServerSocket,

分别用来表示双向连接的客户端和服务端。这是两个封装得非常好的类,使用很方便。其构造方法如下:

客户端类的构造器: 

 Socket(InetAddress address, int port);

  Socket(InetAddress address, int port, boolean stream);

  Socket(String host, int prot); //主要使用

  Socket(String host, int prot, boolean stream);

  Socket(SocketImpl impl)

  Socket(String host, int port, InetAddress localAddr, int localPort)

  Socket(InetAddress address, int port, InetAddress localAddr, int localPort)

  

服务端类的构造器:

​
ServerSocket(int port);  //主要使用

  ServerSocket(int port, int backlog);

  ServerSocket(int port, int backlog, InetAddress bindAddr)

​

其中address、host和port分别是双向连接中另一方的IP地址、主机名和端 口号,stream指明socket是流socket还是数据报socket,localPort表示本地主机的端口号,localAddr和 bindAddr是本地机器的地址(ServerSocket的主机地址),impl是socket的父类,既可以用来创建serverSocket又可 以用来创建Socket。count则表示服务端所能支持的最大连接数。例如:

Socket client = new Socket("127.0.01", 5555);  //127.0.01任何时候都代表本机IP地址,5555是自定义的端口号

  ServerSocket server = new ServerSocket(5555);

  注意,在选择端口时,必须小心。每一个端口提供一种特定的服务,

只有给出正确的端口,才 能获得相应的服务。

0~1023的端口号为系统所保留,例如http服务的端口号为80,telnet服务的端口号为21,ftp服务的端口号为23, 

所以我们在选择端口号时,最好选择一个大于1023的数以防止发生冲突。

  在创建socket时如果发生错误,将产生IOException,在程序中必须对之作出处理。所以在创建Socket或ServerSocket是必须捕获或抛出例外。

(四)简单的Client/Server程序

程序实现的功能:

(1)服务器在每一台客户端登陆的时候:发送一条短信给客户端“服务器正在向你发送消息!”,然后在服务器端显示连接上的客户端主机地址。

(2)客户端连接上了,会接收到一条短信,并且可以对服务器一直进行发送短信。

(3)服务器可以一直接收客户端的短信。

(4)这里服务器只写一句话,但是想要像客户端那样一直写也是可以的,改一下就可以了。

1. 服务器端程序的编写

package com.xykj.server;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
    服务器端继承Thread
 * 可以实现简单的交互
 * */
public class Server extends Thread {

    // 定义服务器接口ServerSocket
    ServerSocket server = null;

    // 定义一个服务器,定义端口
    public Server(int port) {
        try {
            server = new ServerSocket(port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 发送消息的线程
    @Override
    public void run() {
        super.run();
        try {
            System.out.println("服务器在启动中...等待用户的连接");
            //一直接收用户的连接,连接之后发送一条短信给用户
            while(true){
                // 建立socket接口,accept方法是一个阻塞进程,等到有用户连接才往下走
                // 定义Socket类
                Socket  socket = server.accept();
                //通过socket对象可以获得输出流,用来写数据
                OutputStream os = socket.getOutputStream();
                // 向客户端发送消息
                os.write("服务器正在向你发送消息!".getBytes());
                //在服务器上显示连接的上的电脑、
                System.out.println(socket.getInetAddress().getHostAddress()+"连接上了!");
                //通过socket对象可以获得输入流,用来读取用户数据
                InputStream is=socket.getInputStream();
                //读取数据
                int len=0;
                byte[] buf=new byte[1024];
                while ((len=is.read(buf))!=-1) {
                    //直接把获得的数据打印出来
                    System.out.println("服务器接收到客户端的数据:"+new String(buf,0,len));
                }
                
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务器的启动:

 package com.xykj.server;


public class ServerTest {

    public static void main(String[] args) {
        
        //这里服务器只需要定义一个端口号就可以了,程序会自动获取IP地址
        //但是客户端需要连接这个服务器时,需要知道它的IP地址还有端口号
        //ip地址的查看方法:进入cmd窗口,输入ipconfig/all可以看到
         Server server=new Server(6768);
         server.start();
    }

}







2. 客户端程序的编写



package com.xykj.client;

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

public class Client extends Thread {
    
    //定义一个Socket对象
    Socket socket = null;

    public Client(String host, int port) {
        try {
            //需要服务器的IP地址和端口号,才能获得正确的Socket对象
            socket = new Socket(host, port);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }

    @Override
    public void run() {
        //客户端一连接就可以写数据个服务器了
        new sendMessThread().start();
        super.run();
        try {
            // 读Sock里面的数据
            InputStream s = socket.getInputStream();
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = s.read(buf)) != -1) {
                System.out.println(new String(buf, 0, len));
            }
        
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    //往Socket里面写数据,需要新开一个线程
    class sendMessThread extends Thread{
        @Override
        public void run() {
            super.run();
            //写操作
            Scanner scanner=null;
            OutputStream os= null;
            try {
                scanner=new Scanner(System.in);
                os= socket.getOutputStream();
                String in="";
                do {
                    in=scanner.next();
                    os.write(("客户端:"+in).getBytes());
                    os.flush();
                } while (!in.equals("bye"));
            } catch (IOException e) {
                e.printStackTrace();
            } 
            scanner.close();
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

启动客户端:


 

package com.xykj.client2;
public class ClientTest2 {
    public static void main(String[] args) {
        //需要服务器的正确的IP地址和端口号
         Client2 client2=new Client2("192.168.18.128", 6768);
         client2.start();
    }
}


 

程序中要先开启服务端,在开启客户端,否则会报错!

还有就是一般的电脑是动态的IP地址,每天都在变化。要注意修改!

  

(五)支持多客户的client/server程序

在实际应用 中,往往是在服务器上运行一个永久的程序,它可以接收来自其他多个客户端的请求,

提供相应的服务。服务器总是在指定的端口上监听是否有客户请求,一旦监听到客户请求,

服务器就会启动一个专门的服务线程来响 应该客户的请求,

而服务器本身在启动完线程之后马上又进入监听状态,等待下一个客户的到来。

并且每一个用户对应一个固定的线程来接收信息。

服务器还会把接收到的信息发送给所有连接上的客户端。

示例:多人聊天室的实现:

1.服务器端的设计

package com.xykj.server2;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 * 可以实现和客户端的相互发送消息的交互 可以是多台电脑
 * */

public class Server2 extends Thread {
    // 用来存放连接上的用户的socket对象的值
    List list = new ArrayList<>();

    // 定义服务器接口ServerSocket
    ServerSocket server = null;

    // 定义一个服务器,定义端口
    public Server2(int port) {
        try {
            server = new ServerSocket(port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 发送消息的线程
    @Override
    public void run() {
        super.run();
        try {

            while (true) {
                // 建立socket接口,accept方法是一个阻塞进程,等到有用户连接才往下走
                // 定义Socket类
                Socket socket = server.accept();
                // 在服务器显示连接的上的电脑、
                String message = socket.getInetAddress().getHostAddress().toString();
                System.out.println(message+"连接上了");
                // 向用户发送消息
                SendMessageToAllUser(message);
                // 把连接上的用户添加到集合;里面去
                list.add(socket);
                //开始新连接用户的线程,用于该可以一直读取数据
                new readerThread(socket).start();;
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 把消息发送给每一个用户,涉及到写的操作OutStream
    private void SendMessageToAllUser(String message) {
        // 拿到每一个用户的socket对象,对其进行写入数据
        for (Socket socket : list) {
            // 判读之前保存的连接是否还在
            if (socket != null && socket.isConnected()) {
                try {
                    OutputStream os = socket.getOutputStream();
                    os.write(message.getBytes());
                    os.flush();// 刷新一下写入的数据,很有必要
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 读取客户端的信息
    class readerThread extends Thread {
        InputStream is = null;

        // 这里传入一个socket对象,因为每一个用户都要用一个不同的线程存放的socket对象来进行一直读取数据
        public readerThread(Socket socket) {
            try {
                // 获取输入流
                is = socket.getInputStream();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            super.run();
            try {
                int len = 0;
                byte[] buf = new byte[1024];
                while ((len = is.read(buf)) != -1) {
                    // 把读取到的数据发送给其他用户
                    SendMessageToAllUser(new String(buf, 0, len));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

启动服务端:

package com.xykj.server;
public class ServerTest {
public static void main(String[] args) {
//这里服务器只需要定义一个端口号就可以了,IP地址程序会自动获取
//但是客户端需要连接这个服务器时,需要知道它的IP地址还有端口号
//ip地址的查看方法:进入cmd窗口,输入ipconfig/all可以看到
 Server2 server=new Server2(6768);
 server.start();
}
 
}



2.客户端的设计

这个和上个例子的客户端的设计基本一样,就不再重复粘贴了。

总结:上面主要是对java网络编程Socket接口类的使用,

还有TCP协议的应用(Socket的主要应用),

当然TCP还有一个比较主要的应用就是文件传输,

其中涉及到比较复杂的字符串处理(接收前和接收后都要),

有兴趣的可以自己设计一下。

 

猜你喜欢

转载自blog.csdn.net/weixin_41719737/article/details/85272714