Einführung in diesen Abschnitt:

Die Konzeptlektion im vorherigen Abschnitt war trocken und langweilig, oder? Aber du hast trotzdem etwas gelernt, oder? Ab diesem Abschnitt beschäftigen wir uns mit der Socket-Kommunikation basierend auf dem TCP-Protokoll. Zuerst wollen wir das Konzept von Socket verstehen, das Socket-Kommunikationsmodell, die Schritte zur Implementierung von Socket und was der Socket-Server und der Client jeweils tun müssen! Also, lass uns Schritt für Schritt vom Einfachen zum Schwierigen in dieses Socket-Thema eintauchen!


1. Was ist Socket?


2. Socket-Kommunikationsmodell:

Analyse der Implementierungsschritte der Socket-Kommunikation:

Schritt 1: ServerSocket und Socket erstellen

Schritt 2: Die Eingabe-/Ausgabeströme des verbundenen Socket öffnen

Schritt 3: Lese-/Schreiboperationen auf dem Socket gemäß dem Protokoll durchführen

Schritt 4: Die Eingabe-/Ausgabeströme und den Socket schließen

Gut, schreiben wir ein einfaches Beispiel. Nach dem Starten des Servers klickt der Client auf eine Schaltfläche, um sich mit dem Server zu verbinden, und sendet eine Zeichenkette an den Server, die anzeigt, dass er sich über Socket mit dem Server verbunden hat~


3. Den Socket-Server schreiben:

Der Server muss Folgendes tun:

Schritt 1: Ein ServerSocket-Objekt erstellen und den Listening-Port binden

Schritt 2: Die Methode accept() aufrufen, um auf Client-Anfragen zu warten

Schritt 3: Nachdem die Verbindung hergestellt wurde, die vom Client über den Eingabestrom gesendeten Anfrageinformationen lesen

Schritt 4: Antwortinformationen über den Ausgabestrom an den Client senden

Schritt 5: Zugehörige Ressourcen schließen

Code-Implementierung:

Erstelle einfach ein Java-Projekt in Eclipse und füge den Java-Code ein!

public class SocketServer {
    public static void main(String[] args) throws IOException {
        //1.创建一个服务器端Socket,即ServerSocket,指定绑定的端口,并监听此端口
        ServerSocket serverSocket = new ServerSocket(12345);
        InetAddress address = InetAddress.getLocalHost();
        String ip = address.getHostAddress();
        Socket socket = null;
        //2.调用accept()等待客户端连接
        System.out.println("~~~服务端已就绪,等待客户端接入~,服务端ip地址: " + ip);
        socket = serverSocket.accept();
        //3.连接后获取输入流,读取客户端信息
        InputStream is=null;
        InputStreamReader isr=null;
        BufferedReader br=null;
        OutputStream os=null;
        PrintWriter pw=null;
        is = socket.getInputStream();     //获取输入流
        isr = new InputStreamReader(is,"UTF-8");
        br = new BufferedReader(isr);
        String info = null;
        while((info=br.readLine())!=null){//循环读取客户端的信息
            System.out.println("客户端发送过来的信息" + info);
        }
        socket.shutdownInput();//关闭输入流
        socket.close();
    }
}

Dann führen wir den Code aus, und die Konsole gibt aus:

In Ordnung, als Nächstes kommt der Android-Client!


4. Den Socket-Client schreiben:

Die Aufgaben, die der Client erledigen muss, sind wie folgt:

Schritt 1: Erstelle ein Socket-Objekt und gib die Adresse und Portnummer des Servers an, mit dem eine Verbindung hergestellt werden soll

Schritt 2: Nachdem die Verbindung hergestellt wurde, sende die Anforderungsinformationen über den Ausgabestream an den Server

Schritt 3: Rufe die Antwortinformationen des Servers über den Eingabestream ab

Schritt 4: Schließe die zugehörigen Ressourcen

Code-Implementierung:

MainActivity.java:

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button btn_accept = (Button) findViewById(R.id.btn_accept);
        btn_accept.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        new Thread() {
            @Override
            public void run() {
                try {
                    acceptServer();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }

    private void acceptServer() throws IOException {
        //1.创建客户端Socket,指定服务器地址和端口
        Socket socket = new Socket("172.16.2.54", 12345);
        //2.获取输出流,向服务器端发送信息
        OutputStream os = socket.getOutputStream();//字节输出流
        PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流
        //获取客户端的IP地址
        InetAddress address = InetAddress.getLocalHost();
        String ip = address.getHostAddress();
        pw.write("客户端:~" + ip + "~ 接入服务器!!");
        pw.flush();
        socket.shutdownOutput();//关闭输出流
        socket.close();
    }
}

Da Android keine Netzwerkoperationen im Hauptthread (UI-Thread) erlaubt, müssen wir hier selbst einen weiteren Thread starten, um den Socket zu verbinden!

Ausführungsergebnis:

Nach dem Klicken auf die Schaltfläche gibt die Serverkonsole aus:


5. Erweitertes Beispiel: Piggy Simple Chat Room

Einfach nur auf einen Button zu klicken und dann liefert der Server eine Information zurück, ist definitiv langweilig, oder? Als Nächstes bauen wir einen sehr einfachen Chatraum. Wir müssen einen Thread-Pool verwenden, eine Sammlung zum Speichern von Socket-Verbindungen, und außerdem müssen wir selbst einen Thread schreiben. Die Details erleben wir im Code!

Implementierungseffekt-Diagramm:

Zuerst führen wir unseren Server aus:

Dann führen wir unser Programm jeweils auf zwei Emulatoren aus:

Als Nächstes schreiben wir den Code:

Zuerst der Server. Er legt die Socket-Lese-/Schreiboperationen in einen benutzerdefinierten Thread. Nach dem Erstellen von ServerSocket ruft er die accept-Methode in einer Schleife auf. Wenn sich ein neuer Client verbindet, fügt er den Socket zur Sammlung hinzu und erstellt einen neuen Thread im Thread-Pool!

Darüber hinaus wird in der Methode zum Lesen von Informationen die eingegebene Zeichenkette geprüft. Wenn es die Zeichenkette "bye" ist, wird der Socket aus der Sammlung entfernt und anschließend geschlossen!

Server.java:

public class Server {
    //定义相关的参数,端口,存储Socket连接的集合,ServerSocket对象
    //以及线程池
    private static final int PORT = 12345;
    private List<Socket> mList = new ArrayList<Socket>();
    private ServerSocket server = null;
    private ExecutorService myExecutorService = null;
    
    
    public static void main(String[] args) {
        new Server();
    }

    public Server()
    {
        try
        {
            server = new ServerSocket(PORT);
            //创建线程池
            myExecutorService = Executors.newCachedThreadPool();
            System.out.println("服务端运行中...\n");
            Socket client = null;
            while(true)
            {
                client = server.accept();
                mList.add(client);
                myExecutorService.execute(new Service(client));
            }
            
        }catch(Exception e){e.printStackTrace();}
    }
    
    class Service implements Runnable
    {
        private Socket socket;
        private BufferedReader in = null;
        private String msg = "";
        
        public Service(Socket socket) {
            this.socket = socket;
            try
            {
                in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                 msg = "用户:" +this.socket.getInetAddress() + "~加入了聊天室"  
                            +"当前在线人数:" +mList.size();  
                this.sendmsg();
            }catch(IOException e){e.printStackTrace();}
        }
        
        
        
        @Override
        public void run() {
            try{
                while(true)
                {
                    if((msg = in.readLine()) != null)
                    {
                        if(msg.equals("bye"))
                        {
                            System.out.println("~~~~~~~~~~~~~");
                            mList.remove(socket);
                            in.close();
                            msg = "用户:" + socket.getInetAddress()  
                                    + "退出:" +"当前在线人数:"+mList.size();  
                            socket.close();  
                            this.sendmsg();  
                            break;
                        }else{
                            msg = socket.getInetAddress() + "   说: " + msg;  
                            this.sendmsg(); 
                        }
                    }
                }
            }catch(Exception e){e.printStackTrace();}
        }
        
        //为连接上服务端的每个客户端发送信息
        public void sendmsg()
        {
            System.out.println(msg);
            int num = mList.size();
            for(int index = 0;index < num;index++)
            {
                Socket mSocket = mList.get(index);  
                PrintWriter pout = null;  
                try {  
                    pout = new PrintWriter(new BufferedWriter(  
                            new OutputStreamWriter(mSocket.getOutputStream(),"UTF-8")),true);  
                    pout.println(msg);  
                }catch (IOException e) {e.printStackTrace();}  
            }
        }
        
    }
}

Dann kommt der Client. Die Schwierigkeit des Clients liegt darin, dass ein weiterer Thread gestartet werden muss, weil Android Netzwerkoperationen nicht direkt im Hauptthread erlaubt und keine UI-Operationen in anderen Threads als dem Hauptthread zulässt. Der Ansatz hier ist, selbst einen neuen Thread zu erstellen und einen Handler zu verwenden, um die UI zu aktualisieren. In der tatsächlichen Entwicklung wird davon abgeraten, dies direkt so zu machen!!!

Layout-Datei:activity_main.xml:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="小猪简易聊天室" />
    <TextView
        android:id="@+id/txtshow"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        />
    <EditText
        android:id="@+id/editsend"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        />
    <Button
        android:id="@+id/btnsend"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="发送"
        />
</LinearLayout>

MainActivity.java:

public class MainActivity extends AppCompatActivity implements Runnable {

    //定义相关变量,完成初始化
    private TextView txtshow;
    private EditText editsend;
    private Button btnsend;
    private static final String HOST = "172.16.2.54";
    private static final int PORT = 12345;
    private Socket socket = null;
    private BufferedReader in = null;
    private PrintWriter out = null;
    private String content = "";
    private StringBuilder sb = null;

    //定义一个handler对象,用来刷新界面
    public Handler handler = new Handler() {
        public void handleMessage(Message msg) {
            if (msg.what == 0x123) {
                sb.append(content);
                txtshow.setText(sb.toString());
            }
        }

        ;
    };


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        sb = new StringBuilder();
        txtshow = (TextView) findViewById(R.id.txtshow);
        editsend = (EditText) findViewById(R.id.editsend);
        btnsend = (Button) findViewById(R.id.btnsend);

        //当程序一开始运行的时候就实例化Socket对象,与服务端进行连接,获取输入输出流
        //因为4.0以后不能再主线程中进行网络操作,所以需要另外开辟一个线程
        new Thread() {

            public void run() {
                try {
                    socket = new Socket(HOST, PORT);
                    in = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
                    out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
                            socket.getOutputStream())), true);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }.start();

        //为发送按钮设置点击事件
        btnsend.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                String msg = editsend.getText().toString();
                if (socket.isConnected()) {
                    if (!socket.isOutputShutdown()) {
                        out.println(msg);
                    }
                }
            }
        });
        new Thread(MainActivity.this).start();
    }

    //重写run方法,在该方法中输入流的读取
    @Override
    public void run() {
        try {
            while (true) {
                if (socket.isConnected()) {
                    if (!socket.isInputShutdown()) {
                        if ((content = in.readLine()) != null) {
                            content += "\n";
                            handler.sendEmptyMessage(0x123);
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Zusammenfassung dieses Abschnitts:

Okay, in diesem Abschnitt wurde die Socket-Kommunikation basierend auf TCP erklärt. Der Artikel hat das Socket-Kommunikationsmodell vorgestellt, ein einfaches Beispiel für Socket-Kommunikation implementiert und ein erweitertes Beispiel geschrieben: Piggy Chat Room. Ich glaube, es wird denen, die gerade erst in die Socket-Programmierung einsteigen, eine Erleichterung sein~ Danke~