消息推送学习一、原生Socket的使用

　　消息推送也是客户端和服务器连接然后进行交互的一种形式,但是不同于HTTP的连接,这种连接需要长时间的进行,当有消息时可以及时推送到客户端。除此之外还有多个用户,可能需要针对其身份进行不同的推送等等要求。而这种连接的形式在Java中可以使用Socket进行实现。

一、第一版：

　　1、首先是服务器部分,重要的操作说明

　　　　①使用ServerSocket可以开启服务器上的一个端口进行连接监听,类似于服务器监听80端口。

　　　　②使用accept()，阻塞式的等待客户端的接入。接入成功时返回连接的Socket对象。通过该对象可以进行数据的交换。

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.ServerSocket;
 import java.net.Socket;

 public class Service {
     public static void main(String[] args) {
         Service service=new Service();
         service.start();
     }

     private void start() {
         ServerSocket socketService=null;
         Socket socket=null;
         BufferedReader reader=null;
         BufferedWriter writer=null;
         try {
             //开启一个Socket服务器,监听9898端口
             socketService=new ServerSocket(9898);
             System.out.println("service start...");
             //等待客户端连入,一直阻塞直到接入,返回连接Socket对象
             socket=socketService.accept();
             System.out.println("client connection...");
             //以下就是数据交换
             reader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
             writer=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
             String message=null;
             while(!(message=reader.readLine()).equals("bye")){
                 System.out.println(message);
                 writer.write(socket.getLocalAddress()+":"+message+"\n");
                 writer.flush();
             }
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             try {
                 reader.close();
                 writer.close();
                 socket.close();
                 socketService.close();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }
 }

　　2、对于客户端来说比较简单：

　　　　①指定服务器和端口来创建Socket连接,

　　　　②使用该Socket对象来进行数据传输即可，这里是将控制台上的输入内容传递至服务器。需要注意的是读取操作是以"\n“为结束标记的,所以需要传输时需要加上,否则不被认为是结束。

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.Socket;

 public class Client {
     public static void main(String[] args) {
         //这里创建一个Client对象而不是直接在main()操作,是可以是使用的变量等不必是static类型的
         Client client=new Client();
         client.start();
     }

     private void start() {
         BufferedReader readFromSys=null;
         BufferedReader readFromService=null;
         BufferedWriter writeToService=null;
         Socket socket=null;
         try {
             //传入地址和端口号,和服务器建立连接
             socket=new Socket("127.0.0.1",9898);
             //以下是数据传输部分
             readFromSys=new BufferedReader(new InputStreamReader(System.in));
             readFromService=new BufferedReader(new InputStreamReader(socket.getInputStream()));
             writeToService=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

             String message;
             String responce;
             while(!(message=readFromSys.readLine()).equals("bye")){
                 //传输数据需要以 \n 结尾,否则不被认为是结束。客户端和服务器端都一样
                 writeToService.write(message+"\n");
                 writeToService.flush();
                 responce=readFromService.readLine();
                 System.out.println(responce);
             }
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             try {
                 writeToService.close();
                 readFromService.close();
                 readFromSys.close();
                 socket.close();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }

     }
 }

　　这一版已经成功的进行和客户端和服务器端的连接,但是有一些问题,下面是对其的总结:

　　　　①服务器端不能主动的向客户端进行消息的传递。

　　　　②客户端中的只能在发送一条数据之后的服务器响应时才能获取数据,总结为不能及时获取服务器端消息。

　　以上两条说明这种操作是完全不能作为一种推送服务的。

　　　　③服务器端只能处理一个用户的请求,即只能和一个客户端进行连接。

二、第二版：这是对第一版中存在的问题进行解决

　　1、解决①问题,即服务器端不能主动发送消息的问题，思路是通过Socket连接的输出流进行数据的传递即可。

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.util.Timer;
 import java.util.TimerTask;

 public class Service {
     public static void main(String[] args) {
         Service service=new Service();
         service.start();
     }

     private void start() {
         ServerSocket socketService=null;
         Socket socket=null;
             BufferedReader reader=null;
         BufferedWriter writer=null;
         try {
             //开启一个Socket服务器,监听9898端口
             socketService=new ServerSocket(9898);
             System.out.println("service start...");

                 socket=socketService.accept();
             System.out.println("client connection..."+socket.hashCode());

             try {
                 reader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
                 writer=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

                 //！！！服务器向客户端发送消息
                 sendMessage(writer);

                 String message=null;
                 while(!(message=reader.readLine()).equals("bye")){
                     System.out.println(message);
                     writer.write(socket.getLocalAddress()+":"+message+"\n");
                     writer.flush();
                 }
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             try {
                 socket.close();
                 socketService.close();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }

     private void sendMessage(final BufferedWriter writer) {
         //这里简单开启一个定时任务,每个几秒向客户端发送一条消息,进行模拟操作。
         new Timer().schedule(new TimerTask() {
             @Override
             public void run() {
                 try {
                     writer.write("消息发送测试！\n");
                     writer.flush();
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
         }, 1000, 3000);
     }
 }

服务器端修改

　　2、解决②问题,即客户端不能及时读取服务器端消息的问题,思路是对连接Socket的输入流进行监听,一旦有输入立即进行处理。

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.Socket;

 public class Client {
     public static void main(String[] args) {
         //这里创建一个Client对象而不是直接在main()操作,是可以是使用的变量等不必是static类型的
         Client client=new Client();
         client.start();
     }

     private void start() {
         BufferedReader readFromSys=null;
         BufferedReader readFromService=null;
         BufferedWriter writeToService=null;
         Socket socket=null;
         try {
             //传入地址和端口号,和服务器建立连接
             socket=new Socket("127.0.0.1",9898);
             //以下是数据传输部分
             readFromSys=new BufferedReader(new InputStreamReader(System.in));
             readFromService=new BufferedReader(new InputStreamReader(socket.getInputStream()));
             writeToService=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

             String message;

             //用于对服务器端输入的数据流进行监听
             socketInputStreamListener(readFromService);

             while(!(message=readFromSys.readLine()).equals("bye")){
                 //传输数据需要以 \n 结尾,否则不被认为是结束。客户端和服务器端都一样
                 writeToService.write(message+"\n");
                 writeToService.flush();
             }
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             try {
                 writeToService.close();
                 readFromService.close();
                 readFromSys.close();
                 socket.close();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }

     }

     private void socketInputStreamListener(final BufferedReader readFromService) {
         //1、首先是需要监听,所以是长时间操作,但是不能阻塞主线程的操作,所以使用子线程来进行处理
         new Thread(new Runnable(){
             @Override
             public void run() {
                 try {
                     String responce;
                     while(!(responce=readFromService.readLine()).equals(null)){
                         System.out.println(responce);
                     }
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
         }).start();
     }
 }

客户端修改

　　3、解决③问题,即服务器只能与一个客户端进行连接的问题,思路是循环调用accept()，该方法用于阻塞式的等待客户端的连接,然后将已经建立的连接的任务放在子线程中进行处理即可。而这里的连接任务就是数据的传递部分。

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.util.Timer;
 import java.util.TimerTask;

 public class Service {
     public static void main(String[] args) {
         Service service=new Service();
         service.start();
     }

     private void start() {
         ServerSocket socketService=null;
         Socket socket=null;
         try {
             //开启一个Socket服务器,监听9898端口
             socketService=new ServerSocket(9898);
             System.out.println("service start...");

             //
             while(true){
                 socket=socketService.accept();
                 System.out.println("client connection..."+socket.hashCode());
                 exectureConnectRunnable(socket);
             }
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             try {
                 socket.close();
                 socketService.close();
             } catch (Exception e) {
                 e.printStackTrace();
             }
         }
     }

     //这里的工作必须在子线程中工作,因为下面有一段死循环操作,如果不在子线程中则会阻塞主线程,不能和其他客户端进行连接。
     private void exectureConnectRunnable(final Socket socket) {
         new Thread(new Runnable(){
             @Override
             public void run() {
                 BufferedReader reader=null;
                 BufferedWriter writer=null;
                 //以下就是数据交换
                 try {
                     reader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
                     writer=new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

                     //服务器向客户端发送消息
                     sendMessage(writer);

                     String message=null;
                     while(!(message=reader.readLine()).equals("bye")){
                         System.out.println(message);
                         writer.write(socket.getLocalAddress()+":"+message+"\n");
                         writer.flush();
                     }
                 } catch (Exception e) {
                     e.printStackTrace();
                 }finally{
                     try {
                         reader.close();
                         writer.close();
                     } catch (Exception e) {
                         e.printStackTrace();
                     }
                 }
             }
         }).start();
     }

     private void sendMessage(final BufferedWriter writer) {
         //这里简单开启一个定时任务,每个几秒向客户端发送一条消息,进行模拟操作。
         new Timer().schedule(new TimerTask() {
             @Override
             public void run() {
                 try {
                     writer.write("消息发送测试！\n");
                     writer.flush();
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
             }
         }, 1000, 3000);
     }
 }

服务器端再次修改

到此为止,使用原生的Socket进行消息推送的基本尝试已经完成,但是其还是有很多问题,例如:

　　1、网络操作都是阻塞式实现的，所以不得不采用子线程来进行处理,当连接的用户过多时,性能就称为一个极大的瓶颈。

　　2、对各种流的处理等等操作。

在Java1.4版本之后就引入了nio包,即new IO,用来进行改善,但是操作比较麻烦。而已经有了大神对底层操作的封装框架,如Mina和Netty等,下一部分就是对Mina的体验使用。