Este artigo compartilha um exemplo para atender às necessidades da comunicação da Web on -line. Devido à versão web da função de bate -papo online implementada pelo soquete Java, para sua referência, o conteúdo específico é o seguinte
Etapas de implementação:
1. Use o componente AWT e o soquete para implementar um cliente único simples para enviar continuamente mensagens para o servidor;
2. Combinado com threads, realize a conexão com vários clientes com o servidor para enviar mensagens;
3. Implemente as mensagens do cliente de encaminhamento de servidor para todos os clientes e exibi -las no cliente ao mesmo tempo;
4. Altere a interface da janela gerada pelo componente AWT para a interface exibida pelo JSP ou HTML frontal e altere o cliente implementado pelo soquete Java para a implementação da tecnologia front-end.
Aqui, primeiro implementamos a função simples da primeira etapa, a dificuldade é:
1. Nunca usei o componente AWT e nunca usei eventos de escuta relacionados a Java;
2. Não usei soquetes por longos períodos de tempo para interagir entre o cliente e o servidor, e não desenvolvi realmente a estrutura CSS.
Código para implementar a função :
Cliente de bate -papo online:
1. Gere contorno da interface gráfica da janela
2. Adicione um evento próximo ao esboço
3. Adicione a área de entrada e a área de exibição de conteúdo ao esboço
4. Adicione um evento de retorno de transporte à área de entrada
5. Estabeleça uma conexão de servidor e envie dados
pacote chat.chat; importar java.awt.borderlayout; importar java.awt.frame; importar java.awt.textarea; importar java.awt.textfield; importar java.awt.event.actionEvent; importar java.awt.event.actionListener; importar java.awt.event.windowadapter; importar java.awt.event.windowEvent; importar java.io.dataOutputStream; importar java.io.ioException; importar java.net.socket; importar java.net.unknownhostException; / ** * Cliente de bate -papo on -line 1. Gere o esboço da interface gráfica 2. Adicione um evento de fechamento ao esboço 3. Adicione uma área de entrada e uma área de exibição de conteúdo ao esboço 4. Adicione um evento de retorno de carro para a área de entrada * 5.Felt Felt uma conexão de servidor e envie dados de dados * * @Author TUZONNUN123 */ Public Class Class CHATCIENTE FROÇÃO { // Área de exibição de conteúdo TEXTAREA PRIVADO DE TEXTAREA = NOVA TEXTAREA (); soquete privado soquete = nulo; // fluxo de saída de dados DataSOUTPTUTTREAM DataOutputStream = null; public static void main (string [] args) {new ChatClient (). Launcframe (); } / ** * Crie uma janela gráfica simples * * @Author: TUzongxun * @title: Launcframe * @param * @return void * @date 18 de maio de 2016 9:57:00 * @throws * / public void launcframe () {setLocation (300, 200); this.SetSize (200, 400); add (tftxt, borderlayout.south); add (tarea, borderlayout.north); pacote(); // Ouça o evento de encerramento da janela da interface gráfica this.addwindowlistener (new windowAdapter () {@Override public void WindowClosing (WindowEvent e) {System.exit (0); desconect ();}}); tftxt.addactionListener (new tflister ()); setvisible (true); conectar(); } / ** * Conecte -se ao servidor * * @Author: TUZONGXUN * @TITLE: Connect * @param * @return void * @date 18 de maio de 2016 9:56:49 * @throws * / public void Connect () {Try {// Crie um novo soquete de conexão =; // Obtenha o fluxo de saída do cliente dataOutputStream = new DataOutputStream (Socket.getOutputStream ()); System.out.println ("Conecte -se ao servidor"); } catch (desconhecidohostException e) {e.printStackTrace (); } catch (ioexception e) {e.printStackTrace (); }} / ** * Feche os recursos do cliente * * @Author: TUzongxun * @Title: Desconect * @param * @return void * @date 18 de maio de 2016 9:57:46 AM * @THOWS * / public void desconect () {Try {DataOutstream.Close (); Socket.Close (); } catch (ioexception e) {e.printStackTrace (); }} / ** * Envie uma mensagem para o servidor * * @Author: TUzongxun * @title: sendMessage * @param @param texto * @return void * @date 18 de maio de 2016 9:57:56 AM * @THOWS * / private void sendMessage (text) dataOutputStream.flush (); } catch (ioexception e1) {e1.printStackTrace (); }} / ** * Área de entrada da janela gráfica para ouvir para o evento de retorno de carruagem * * @Author TUzongxun123 * * / classe privada tflister implementa ActionListener {@Override public void ActionPerformed (ActionEvent e) {String text = tftxt.getText (). Trim (); taxa.settext (texto); tftxt.settext (""); // Envie dados para o servidor sendMessage (texto); }}} Servidor:
pacote chat.chat; importar java.io.datainputStream; importar java.io.eofexception; importar java.io.ioException; importar java.net.bindexception; importar java.net.serversocket; importar java.net.socket; /*** Java usa componentes de soquete e AWT para simplesmente implementar a função de bate -papo online. O servidor pode realizar a conexão do servidor para enviar mensagens continuamente para o servidor depois que um cliente estiver conectado*, mas não suporta vários clientes para se conectar ao mesmo tempo. O motivo é que, depois de obter a conexão do cliente no código, ele continuará ouvindo as entradas do cliente em loop, causando bloqueio* para que o servidor não possa ouvir outro cliente duas vezes. Se você deseja implementá -lo, precisará usar as síncronas ou multithread * * @author tuzongxun123 * */ public class ChatServer {public static void main (string [] args) {// se o servidor é iniciado com sucesso boolean isStart = false; // servidor soket serversocket ss = null; // soquete de soquete do cliente soquete = nulo; // servidor Leia o fluxo de dados do cliente DatainputStream DatainputStream = null; tente {// iniciar servidor ss = new ServerSocket (8888); } catch (bindException e) {System.out.println ("Porta já está em uso"); // fechar o programa System.exit (0); } catch (Exceção e) {e.printStackTrace (); } tente {isStart = true; while (isStart) {boolean isConnect = false; // Inicie o soquete de escuta = ss.accept (); System.out.println ("One Client Connect"); isConnect = true; while (isConnect) {// Obtenha o fluxo de entrada do cliente DataAinputStream = new DatainputStream (Socket.getInputStream ()); // Leia os dados passados pela mensagem da String Client = DatainputStream.readUtf (); System.out.println ("Cliente diz:" + mensagem); }}} catch (eofexception e) {System.out.println ("Cliente fechado!"); } catch (Exceção e) {e.printStackTrace (); } finalmente {// feche o recurso relacionado tente {datainputStream.close (); Socket.Close (); } catch (ioexception e) {e.printStackTrace (); }}}}Continue, com base em uma única conexão do cliente, a segunda etapa aqui requer a implementação de várias conexões do cliente, o que requer o uso de threads. Sempre que um novo cliente se conecta, o servidor precisa iniciar um novo thread para processamento, resolvendo o problema de bloquear nas leituras anteriores do loop.
Geralmente, existem dois métodos para escrever threads: integrando threads ou implementando a interface executável. Em princípio, se puder implementar o Runnable, não será herdado porque a maneira de implementar a interface é mais flexível.
O código do cliente não mudou em comparação com antes e se tornou um servidor; portanto, apenas o código do servidor foi publicado aqui:
O Java usa componentes de soquete e AWT e multi-threading para simplesmente implementar o servidor de funções de bate-papo online:
Depois que vários clientes estão conectados, as mensagens são enviadas continuamente ao servidor. Comparado com a primeira versão, o foco está em usar o multi-threading. O servidor ainda não implementou a função de encaminhamento. O cliente pode ver apenas as informações inseridas por si só na janela gráfica e não pode ver as mensagens enviadas por outros clientes.
pacote chat.chat; importar java.io.datainputStream; importar java.io.eofexception; importar java.io.ioException; importar java.net.bindexception; importar java.net.serversocket; importar java.net.socket; importar java.net.socketexception; / ** * * * @Author tUzongxun123 * */ public class ChatServer {public static void main (string [] args) {new ChatServer (). start (); } // se o servidor é iniciado com sucesso privado boolean isStart = false; // servidor de servidor Servidor privado ss = null; // soquete de soquete do cliente soquete privado = nulo; public void start () {try {// Iniciar servidor ss = new ServerSocket (8888); } catch (bindException e) {system.out.println ("porta está em uso"); // fechar o programa System.exit (0); } catch (Exceção e) {e.printStackTrace (); } tente {isStart = true; while (isStart) {// comece a ouvir soquete = ss.accept (); System.out.println ("One Client Connect"); // Iniciar o cliente do cliente Cliente = novo cliente (soquete); novo thread (cliente) .start (); }} catch (Exceção e) {e.printStackTrace (); } finalmente {// feche o serviço tente {ss.close (); } catch (ioexception e) {e.printStackTrace (); }}} / ** * Tópico do cliente * * @Author TUZONGXUN123 * * / Classe cliente implementa Runnable {// Socket Socket Socket Socket Socket = NULL; // Fluxo de entrada do cliente DatainputStream DataAinputStream = null; private boolean isConnect = false; public client (soquete de soquete) {this.socket = soket; tente {isConnect = true; // Obter fluxo de entrada do cliente DataAinputStream = new DatainputStream (Socket.getInputStream ()); } catch (ioexception e) {e.printStackTrace (); }} @Override public void run () {isConnect = true; tente {while (isConnect) {// Leia os dados passados pelo cliente String message = DatainputStream.readUtf (); System.out.println ("Cliente diz:" + mensagem); }} catch (eofexception e) {System.out.println ("Cliente fechado!"); } catch (Socketexception e) {System.out.println ("Cliente está fechado !!!"); } catch (Exceção e) {e.printStackTrace (); } finalmente {// feche o recurso relevante tente {datainputStream.close (); Socket.Close (); } catch (ioexception e) {e.printStackTrace (); }}}}}O acima apresenta principalmente a função do uso de threads para permitir que o servidor receba solicitações de vários clientes. Aqui, o cliente precisa receber mensagens com vários clientes ao encaminhar mensagens para cada cliente conectado, e o cliente deve poder exibi-las na área de exibição de conteúdo, realizando assim um bate-papo simples em grupo on-line.
Ao implementar o encaminhamento do cliente, nada mais é do que aumentar o fluxo de saída; Antes, o cliente apenas enviou, mas não o recebeu, por isso também precisa alterar o cliente para receber mensagens do servidor de maneira circular, por isso também precisa implementar o multi-threading.
Ao implementar essa função, lembrei -me acidentalmente da função de gerar aleatoriamente códigos de verificação, por isso tive uma inspiração repentina para gerar aleatoriamente um nome para cada cliente, para que, ao produzir, pareça mais um bate -papo em grupo, não apenas tenha saída de mensagem, mas também pode ver quem é.
Depois de implementar essas funções, você pode basicamente ter um bate -papo em grupo on -line ao mesmo tempo para várias pessoas. Como existe um método principal no código, você pode transformar o servidor e o cliente em pacotes JAR executáveis. Você pode consultar outra postagem do meu blog: use Eclipse para criar um pacote JAR JAR JAVA Executável.
Em seguida, clique duas vezes no arquivo JAR correspondente na área de trabalho para iniciar o servidor e o cliente, e você não precisa mais confiar no Eclipse para ser executado.
O código do cliente modificado é o seguinte:
pacote chat.chat; importar java.awt.borderlayout; importar java.awt.frame; importar java.awt.textarea; importar java.awt.textfield; importar java.awt.event.actionEvent; importar java.awt.event.actionListener; importar java.awt.event.windowadapter; importar java.awt.event.windowEvent; importar java.io.datainputStream; importar java.io.dataOutputStream; importar java.io.ioException; importar java.net.socket; importar java.net.unknownhostException; importar java.util.random; /** * Etapas do cliente de bate -papo online: * 1. Gere a interface gráfica da janela contorna*2. Adicione um evento próximo para o esboço*3. Adicione uma área de entrada e uma área de exibição de conteúdo no contorno*4. Adicione um evento de retorno de carruagem para a área de entrada*5. Estabeleça uma conexão do servidor e envie dados * * @Author TUZONGXUN123 * */ Public Class ChatClient estende o quadro {/ ** * */ private estático final serialversionuid = 1L; // Área de entrada do usuário Private TextField tftxt = new textfield (); // Área de exibição de conteúdo TEXTAREA PRIVADO DE TEXTAREA = NOVA TEXTAREA (); soquete privado soquete = nulo; // fluxo de saída de dados DataSOUTPTUTTREAM DataOutputStream = null; // fluxo de entrada de dados DataAinputStream DataAinputStream = null; private boolean isConnect = false; Thread Treceive = novo Thread (new Receivethread ()); String name = ""; public static void main (string [] args) {chatclient chatclient = new chatclient (); chatclient.createname (); chatclient.launcframe (); } / ** * Crie uma janela gráfica simples * * @Author: TUzongxun * @title: Launcframe * @param * @return void * @date 18 de maio de 2016 9:57:00 * @throws * / public void launcframe () {setLocation (300, 200); this.SetSize (200, 400); add (tftxt, borderlayout.south); add (tarea, borderlayout.north); // determinar o tamanho ideal do quadro de acordo com o layout na janela e o tamanho preferido do pacote de componentes (); // Ouça o evento de encerramento da janela da interface gráfica this.addwindowlistener (new windowAdapter () {@Override public void WindowClosing (WindowEvent e) {System.exit (0); desconect ();}}); tftxt.addactionListener (new tflister ()); // defina a janela para ver o setVisible (true); conectar(); // Inicie o thread que aceita a mensagem Treceive.start (); } / ** * Conecte -se ao servidor * * @Author: TUZONGXUN * @TITLE: Connect * @param * @return void * @date 18 de maio de 2016 9:56:49 * @throws * / public void Connect () {Try {// Crie um novo soquete de conexão =; // Obtenha o fluxo de saída do cliente dataOutputStream = new DataOutputStream (Socket.getOutputStream ()); DataAinputStream = new DatainputStream (Socket.getInputStream ()); System.out.println ("Conecte -se ao servidor"); isConnect = true; } catch (desconhecidohostException e) {e.printStackTrace (); } catch (ioexception e) {e.printStackTrace (); } } // Generate random client name public void createName() { String[] str1 = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"}; RAN RAND = novo aleatório (); for (int i = 0; i <6; i ++) {// long num = math.round (math.random () * (str1.length - 0)+0); // int n = (int) num; int n = ran.nextInt (str1.length); if (n <str1.length) {string str = str1 [n]; nome = nome + str; System.out.println (nome); } else {i--; continuar; }} this.setTitle (nome); } / ** * Feche os recursos do cliente * * @Author: TUzongxun * @Title: Desconect * @param * @return void * @date 18 de maio de 2016 9:57:46 * @throws * / public void desconect () {try {isConnect = false; // pare thread Treceive.join (); } catch (interruptedException e) {e.printStackTrace (); } finalmente {tente {if (dataOutputStream! = null) {dataOutputStream.close (); } if (soquete! = null) {socket.close (); soquete = nulo; }} catch (ioexception e) {e.printStackTrace (); }}} / ** * Envie uma mensagem para o servidor * * @author: tuzongxun * @title: sendMessage * @param @param texto * @return void * @date 18 de maio de 2016 9:57:56 AM * @THOWS * / private void sendMessage (text) {Try {DatatUSTRUTTER.; dataOutputStream.flush (); } catch (ioexception e1) {e1.printStackTrace (); }} / ** * Evento de retorno de entrada de carro de entrada da janela gráfica * * @Author TUZONGXUN123 * * / classe privada tflister implementa ActionListener {@Override public void ActionPerformed (ActionEvent e) {string text = tftxt.getText (). Trim (); // limpe as informações da área de entrada tftxt.settext (""); // Envie os dados para o servidor depois de pressionar o carruagem para sendMessage (texto); }} classe privada ReceivethRead implementa runnable {@Override public void run () {try {while (isConnect) {string message = datainputStream.readUtf (); System.out.println (mensagem); String txt = keyword.getText (); if (txt! = null &&! "". Equals (txt.trim ())) {message = taxa.getText () + "/n" + message; } taxa.settext (mensagem); }} catch (ioexception e) {e.printStackTrace (); }}}} O código do servidor modificado é o seguinte:
pacote chat.chat; importar java.io.datainputStream; importar java.io.dataOutputStream; importar java.io.eofexception; importar java.io.ioException; importar java.net.bindexception; importar java.net.serversocket; importar java.net.socket; importar java.net.socketexception; importar java.util.arraylist; importar java.util.list; /** * O Java usa componentes de soquete e AWT e multi-threading para simplesmente implementar o servidor de função de bate-papo on-line: * O servidor implementa que as informações recebidas do cliente são encaminhadas a todos os clientes conectados e permite que o cliente leia essas informações e as exiba na área de exibição de conteúdo. * * @Author TUZONGXUN123 * */ Public Class ChatServer {public static void main (string [] args) {new ChatServer (). start (); } // se o servidor é iniciado com sucesso privado boolean isStart = false; // servidor de servidor Servidor privado ss = null; // soquete de soquete do cliente soquete privado = nulo; // Salvar lista de coleta de clientes <Client> clientes = new ArrayList <SterMem> (); public void start () {try {// Inicie o servidor ss = new ServerSocket (8888); } catch (bindException e) {system.out.println ("porta está em uso"); // fechar o programa System.exit (0); } catch (Exceção e) {e.printStackTrace (); } tente {isStart = true; while (isStart) {// inicie o soquete de audição = ss.accept (); System.out.println ("One Client Connect"); // Inicie o cliente do Thread Client Client = novo cliente (soquete); novo thread (cliente) .start (); clientes.add (cliente); }} catch (Exceção e) {e.printStackTrace (); } finalmente {// feche o serviço tente {ss.close (); } catch (ioexception e) {e.printStackTrace (); }}} / ** * Tópico do cliente * * @Author TUZONGXUN123 * * / CLASS DE PRIVADO IMPLEMMENTO RUNNABLE {// SOQUETO DO SOQUETO DE CLIENTE SOCKET SOBRECKET = NULL; // Fluxo de entrada do cliente DatainputStream DataAinputStream = null; // Fluxo de saída do cliente DataSOUTTUPTTREAM DataOutputStream = null; private boolean isConnect = false; public client (soquete de soquete) {this.socket = soket; tente {isConnect = true; // Obter fluxo de entrada do cliente DataAinputStream = new DatainputStream (Socket.getInputStream ()); // Obtenha o fluxo de saída do cliente dataOutputStream = new DataOutputStream (Socket.getOutputStream ()); } catch (ioexception e) {e.printStackTrace (); } } /** * Bulk send (forward) data to the client* * @author: tuzongxun * @Title: sendMessageToClients * @param @param message * @return void * @date May 18, 2016 11:28:10 AM * @throws */ public void sendMessageToClients(String message) { try { dataOutputStream.writeUTF(message); } catch (Socketexception e) {} catch (ioexception e) {e.printStackTrace (); }} @Override public void run () {isConnect = true; Cliente c = nulo; tente {while (isConnect) {// Leia os dados passados pelo cliente String message = DatainputStream.readUtf (); System.out.println ("O cliente diz:" + mensagem); for (int i = 0; i <clients.size (); i ++) {c = clients.get (i); C.SendMessageToclients (Mensagem); }}} catch (eofexception e) {System.out.println ("Cliente fechado!"); } Catch (SockeTexception e) {if (c! = null) {clients.remove (c); } System.out.println ("Cliente está fechado !!!"); } catch (Exceção e) {e.printStackTrace (); } finalmente {// feche o recurso relevante tente {if (datainputStream! = null) {datainputStream.close (); } if (soquete! = null) {socket.close (); soquete = nulo; }} catch (ioexception e) {e.printStackTrace (); }}}}}}}}}}}}}}}}}}}}Vamos apresentá -lo primeiro e depois atualizá -lo para você se houver algum conteúdo novo.
Em relação à realização da função de bate -papo on -line da web, você também pode consultar os seguintes artigos para aprender:
Java implementa um simples compartilhamento de funções da sala de bate -papo tcpsocket
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que você possa continuar prestando atenção a um conteúdo mais emocionante do Wulin.com.