Java回顾之网络通信

　　在这篇文章里，我们主要讨论如何使用Java实现网络通信，包括TCP通信、UDP通信、多播以及NIO。

　　TCP连接

　　TCP的基础是Socket，在TCP连接中，我们会使用ServerSocket和Socket，当客户端和服务器建立连接以后，剩下的基本就是对I/O的控制了。

　　我们先来看一个简单的TCP通信，它分为客户端和服务器端。

　　客户端代码如下：

简单的TCP客户端
import java.net.*;
import java.io.*;
public class SimpleTcpClient {

    public static void main(String[] args) throws IOException
    {
        Socket socket = null;
        BufferedReader br = null;
        PrintWriter pw = null;
        BufferedReader brTemp = null;
        try
        {
            socket = new Socket(InetAddress.getLocalHost(), 5678);
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            pw = new PrintWriter(socket.getOutputStream());
            brTemp = new BufferedReader(new InputStreamReader(System.in));
            while(true)
            {
                String line = brTemp.readLine();
                pw.println(line);
                pw.flush();
                if (line.equals("end")) break;
                System.out.println(br.readLine());
            }
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
        finally
        {
            if (socket != null) socket.close();
            if (br != null) br.close();
            if (brTemp != null) brTemp.close();
            if (pw != null) pw.close();
        }
    }
}

　　

　　服务器端代码如下：

简单版本TCP服务器端
import java.net.*;
import java.io.*;
public class SimpleTcpServer {

    public static void main(String[] args) throws IOException
    {
        ServerSocket server = null;
        Socket client = null;
        BufferedReader br = null;
        PrintWriter pw = null;
        try
        {
            server = new ServerSocket(5678);
            client = server.accept();
            br = new BufferedReader(new InputStreamReader(client.getInputStream()));
            pw = new PrintWriter(client.getOutputStream());
            while(true)
            {
                String line = br.readLine();
                pw.println("Response:" + line);
                pw.flush();
                if (line.equals("end")) break;
            }
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
        finally
        {
            if (server != null) server.close();
            if (client != null) client.close();
            if (br != null) br.close();
            if (pw != null) pw.close();
        }
    }
}

　　

　　这里的服务器的功能非常简单，它接收客户端发来的消息，然后将消息“原封不动”的返回给客户端。当客户端发送“end”时，通信结束。

　　上面的代码基本上勾勒了TCP通信过程中，客户端和服务器端的主要框架，我们可以发现，上述的代码中，服务器端在任何时刻，都只能处理来自客户端的一个请求，它是串行处理的，不能并行，这和我们印象里的服务器处理方式不太相同，我们可以为服务器添加多线程，当一个客户端的请求进入后，我们就创建一个线程，来处理对应的请求。

　　改善后的服务器端代码如下：

 1 import java.net.*;
 2 import java.io.*;
 3 public class SmartTcpServer {
 4     public static void main(String[] args) throws IOException
 5     {
 6         ServerSocket server = new ServerSocket(5678);
 7         while(true)
 8         {
 9             Socket client = server.accept();
10             Thread thread = new ServerThread(client);
11             thread.start();
12         }
13     }
14 }
15
16 class ServerThread extends Thread
17 {
18     private Socket socket = null;
19
20     public ServerThread(Socket socket)
21     {
22         this.socket = socket;
23     }
24
25     public void run() {
26         BufferedReader br = null;
27         PrintWriter pw = null;
28         try
29         {
30             br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
31             pw = new PrintWriter(socket.getOutputStream());
32             while(true)
33             {
34                 String line = br.readLine();
35                 pw.println("Response:" + line);
36                 pw.flush();
37                 if (line.equals("end")) break;
38             }
39         }
40         catch(Exception ex)
41         {
42             System.err.println(ex.getMessage());
43         }
44         finally
45         {
46             if (socket != null)
47                 try {
48                     socket.close();
49                 } catch (IOException e1) {
50                     e1.printStackTrace();
51                 }
52             if (br != null)
53                 try {
54                     br.close();
55                 } catch (IOException e) {
56                     e.printStackTrace();
57                 }
58             if (pw != null) pw.close();
59         }
60     }
61 }

　　修改后的服务器端，就可以同时处理来自客户端的多个请求了。

　　在编程的过程中，我们会有“资源”的概念，例如数据库连接就是一个典型的资源，为了提升性能，我们通常不会直接销毁数据库连接，而是使用数据库连接池的方式来对多个数据库连接进行管理，已实现重用的目的。对于Socket连接来说，它也是一种资源，当我们的程序需要大量的Socket连接时，如果每个连接都需要重新建立，那么将会是一件非常没有效率的做法。

　　和数据库连接池类似，我们也可以设计TCP连接池，这里的思路是我们用一个数组来维持多个Socket连接，另外一个状态数组来描述每个Socket连接是否正在使用，当程序需要Socket连接时，我们遍历状态数组，取出第一个没被使用的Socket连接，如果所有连接都在使用，抛出异常。这是一种很直观简单的“调度策略”，在很多开源或者商业的框架中（Apache/Tomcat），都会有类似的“资源池”。

　　TCP连接池的代码如下：

多线程版本的TCP服务器端
import java.net.*;
import java.io.*;
public class SmartTcpServer {
    public static void main(String[] args) throws IOException
    {
        ServerSocket server = new ServerSocket(5678);
        while(true)
        {
            Socket client = server.accept();
            Thread thread = new ServerThread(client);
            thread.start();
        }
    }
}

class ServerThread extends Thread
{
    private Socket socket = null;

    public ServerThread(Socket socket)
    {
        this.socket = socket;
    }

    public void run() {
        BufferedReader br = null;
        PrintWriter pw = null;
        try
        {
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            pw = new PrintWriter(socket.getOutputStream());
            while(true)
            {
                String line = br.readLine();
                pw.println("Response:" + line);
                pw.flush();
                if (line.equals("end")) break;
            }
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
        finally
        {
            if (socket != null)
                try {
                    socket.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            if (br != null)
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            if (pw != null) pw.close();
        }
    }
}

　　

　　UDP连接

　　UDP是一种和TCP不同的连接方式，它通常应用在对实时性要求很高，对准确定要求不高的场合，例如在线视频。UDP会有“丢包”的情况发生，在TCP中，如果Server没有启动，Client发消息时，会报出异常，但对UDP来说，不会产生任何异常。

　　UDP通信使用的两个类时DatagramSocket和DatagramPacket，后者存放了通信的内容。

　　下面是一个简单的UDP通信例子，同TCP一样，也分为Client和Server两部分，Client端代码如下：

一个简单的TCP连接池
import java.net.*;
import java.io.*;
public class TcpConnectionPool {

    private InetAddress address = null;
    private int port;
    private Socket[] arrSockets = null;
    private boolean[] arrStatus = null;
    private int count;

    public TcpConnectionPool(InetAddress address, int port, int count)
    {
        this.address = address;
        this.port = port;
        this .count = count;
        arrSockets = new Socket[count];
        arrStatus = new boolean[count];

        init();
    }

    private void init()
    {
        try
        {
            for (int i = 0; i < count; i++)
            {
                arrSockets[i] = new Socket(address.getHostAddress(), port);
                arrStatus[i] = false;
            }
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
    }

    public Socket getConnection()
    {
        if (arrSockets == null) init();
        int i = 0;
        for(i = 0; i < count; i++)
        {
            if (arrStatus[i] == false)
            {
                arrStatus[i] = true;
                break;
            }
        }
        if (i == count) throw new RuntimeException("have no connection availiable for now.");

        return arrSockets[i];
    }

    public void releaseConnection(Socket socket)
    {
        if (arrSockets == null) init();
        for (int i = 0; i < count; i++)
        {
            if (arrSockets[i] == socket)
            {
                arrStatus[i] = false;
                break;
            }
        }
    }

    public void reBuild()
    {
        init();
    }

    public void destory()
    {
        if (arrSockets == null) return;

        for(int i = 0; i < count; i++)
        {
            try
            {
                arrSockets[i].close();
            }
            catch(Exception ex)
            {
                System.err.println(ex.getMessage());
                continue;
            }
        }
    }
}

　　

　　Server端代码如下：

UDP通信客户端
import java.net.*;
import java.io.*;
public class UdpClient {

    public static void main(String[] args)
    {
        try
        {
            InetAddress host = InetAddress.getLocalHost();
            int port = 5678;
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            while(true)
            {
                String line = br.readLine();
                byte[] message = line.getBytes();
                DatagramPacket packet = new DatagramPacket(message, message.length, host, port);
                DatagramSocket socket = new DatagramSocket();
                socket.send(packet);
                socket.close();
                if (line.equals("end")) break;
            }
            br.close();
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
    }
}

　　

　　这里，我们也假设和TCP一样，当Client发出“end”消息时，认为通信结束，但其实这样的设计不是必要的，Client端可以随时断开，并不需要关心Server端状态。

　　多播（Multicast）

　　多播采用和UDP类似的方式，它会使用D类IP地址和标准的UDP端口号，D类IP地址是指224.0.0.0到239.255.255.255之间的地址，不包括224.0.0.0。

　　多播会使用到的类是MulticastSocket，它有两个方法需要关注：joinGroup和leaveGroup。

　　下面是一个多播的例子，Client端代码如下：

UDP通信服务器端
import java.net.*;
import java.io.*;
public class UdpServer {

    public static void main(String[] args)
    {
        try
        {
            int port = 5678;
            DatagramSocket dsSocket = new DatagramSocket(port);
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            while(true)
            {
                dsSocket.receive(packet);
                String message = new String(buffer, 0, packet.getLength());
                System.out.println(packet.getAddress().getHostName() + ":" + message);
                if (message.equals("end")) break;
                packet.setLength(buffer.length);
            }
            dsSocket.close();
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
    }
}

　　

　　服务器端代码如下：

多播通信客户端
import java.net.*;
import java.io.*;
public class MulticastClient {

    public static void main(String[] args)
    {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try
        {
            InetAddress address = InetAddress.getByName("230.0.0.1");
            int port = 5678;
            while(true)
            {
                String line = br.readLine();
                byte[] message = line.getBytes();
                DatagramPacket packet = new DatagramPacket(message, message.length, address, port);
                MulticastSocket multicastSocket = new MulticastSocket();
                multicastSocket.send(packet);
                if (line.equals("end")) break;
            }
            br.close();
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
    }
}

　　

　　NIO（New IO）

　　NIO是JDK1.4引入的一套新的IO API，它在缓冲区管理、网络通信、文件存取以及字符集操作方面有了新的设计。对于网络通信来说，NIO使用了缓冲区和通道的概念。

　　下面是一个NIO的例子，和我们上面提到的代码风格有很大的不同。

多播通信服务器端
import java.net.*;
import java.io.*;
public class MulticastServer {

    public static void main(String[] args)
    {
        int port = 5678;
        try
        {
            MulticastSocket multicastSocket = new MulticastSocket(port);
            InetAddress address = InetAddress.getByName("230.0.0.1");
            multicastSocket.joinGroup(address);
            byte[] buffer = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
            while(true)
            {
                multicastSocket.receive(packet);
                String message = new String(buffer, packet.getLength());
                System.out.println(packet.getAddress().getHostName() + ":" + message);
                if (message.equals("end")) break;
                packet.setLength(buffer.length);
            }
            multicastSocket.close();
        }
        catch(Exception ex)
        {
            System.err.println(ex.getMessage());
        }
    }
}

　　

　　上述代码会试图访问一个本地的网址，然后将其内容打印出来。

时间： 2024-10-13 00:31:25

Java回顾之网络通信的相关文章

Java回顾之Spring基础

第一篇:Java回顾之I/O 第二篇:Java回顾之网络通信 第三篇:Java回顾之多线程 第四篇:Java回顾之多线程同步 第五篇:Java回顾之集合 第六篇:Java回顾之序列化 第七篇:Java回顾之反射 第八篇:Java回顾之一些基础概念 第九篇:Java回顾之JDBC 第十篇:Java回顾之ORM框架 我计划分两到三篇文章来描述Spring,这一篇主要讲Spring一些基础的内容. 概述 我印象4.5年前,我还做java开发的时候,Spring是一个非常火的框架,尤其是在Web开发领域

用JAVA实现P2P网络通信

一. 前言     P2P(Peer-to-Peer 端到端)模型是与C/S(客户/服务器)模型相对应.基于C/S的用户间通信需要由服务器中转,在C/S中的服务器故障将导致整个网络通信的瘫痪..而基于P2P的用户间通信则是直接通信,去掉了服务器这一层,带来的显著优点是通信时没有单一的失败点,一个用户的故障不会影响整个P2P网络.本文提供了一种用JAVA实现P2P网络通信的方法. 二.P2P通信的关键技术分析 1．P2P通信模型 在P2P网络中,任意两个端点之间可实现直接通信.在基于C/S的网络中

Java回顾：用一个Demo来说明继承抽象类和实现接口的简单框架模型

大家都知道,在java应用开发中,要"面向接口编程". 那么什么是接口?接口有什么作用?接口如何使用?我们一起来回顾一下. [声明]欢迎转载,但请保留文章原始出处:http://blog.csdn.net/yelangjueqi/article/details/44701369 1,接口回顾: 1.1,Java中接口的概念 在Java中接口是一种特殊的抽象类,跟一般的抽象类相比,接口里面的所有方法都是抽象方法,接口里面的所有属性都是常量.也就是说,接口里面只有方法定义而没有任何方法实现

Java中Socket网络通信

目录 目录 网络协议信息 InetAddress类的应用 URL类的应用 基于TCP的Socket通信 基于UDP的socket通信 Socket通信总结 markdown编辑器快捷键 网络协议信息 TCP 传输控制协议(Transmission Control Protocol) IP 互联网协议(Internet Protocol) HTTP 超文本传输协议(默认端口号为80) FTP 文件传输协议(默认端口号为:21) Telnet (远程登录服务,默认端口号为:23) InetAddre

Java高级篇——网络通信

JAdam Java高级篇(二)--网络通信 网络编程是每个开发人员工具相中的核心部分,我们在学习了诸多Java的知识后,也将步入几个大的方向,Java网络编程就是其中之一. 如今强调网络的程序不比涉及网络的更多.除了经典的应用程序,如电子邮件.Web浏览器和远程登陆外,大多数主要的应用程序都有某种程度的内质网络功能.比如我们最常使用的IDE(Eclipse/IDEA)与源代码存储库(GitHub等等)进行通信:再比如Word,可以从URL打开文件:又或者是我们玩的众多联机游戏,玩家实时相互对战

java回顾之包装类

Java包装类由于基本类型比如int,char不具有支持面向对象的编程机制,比如所有引用类型的变量都继承与Object,都可以当成Object使用,如果有个方法需要Object类型的参数,但是实际需要的值却是2,3等数值,这就比较难处理所以Java提供了8种包装类byte->Byteint->Integer等等 同时Java提供了自动装箱(把基本类型直接赋值给对应的包装类),和自动拆箱(把包装类直接赋值给对应的基本类)功能. 例如 public class AutoBoxingUnBoxing

java回顾之初始化

初始化块 Java使用构造器来完成状态初始化,与构造器类似的是初始化块 创建Java对象时,总是先调用初始化块,如果有多个块,则按照顺序依次执行,初始化总是在创建Java对象时隐式的执行,并在构造器之前执行 public class Person { { int a=6; if(a>4) { System.out.println("person的初始化块:局部变量大于4");//注意此时为局部变量 } } { System.out.println("person的第二个

java回顾之多态

java引用变量有两个类型,一个是编译时类型,一个是运行时类型.编译时由申明该变量时候使用的类型决定,比如Fruit duotai;运行时由实际赋给该变量的对象决定,比如duotai=new Apple();这就呈现了多态. class Book { public String name="Book"; public void base() { System.out.println("书籍"); } public void open() { System.out.p

java回顾之类初级

类 [修饰符]class MyClass (首字母大写,其余全部小写 { 零到多个构造器 (一旦程序员为一个类提供了构造器,系统将会不在为该类提供默认构造器 零到多个成员变量 (首单词字母小写,其余单词首字大写 零到多个方法 } static修饰符的成员不能访问没有static修饰的成员,毕竟没有实例,用static表示这个成员属于类本身,不属于单个实例,没有static的成员属于该类的实例 对象的this引用this关键字总是指向调用该方法的对象, class Dog{ public void