¿Cómo utilizar el socket Java para enviar y recibir emoticonos similares al código detallado de QQ?
Ja, resulta que estoy trabajando en un sistema similar a QQ, pero aún no está terminado, pero se puede ejecutar. Ahora solo implementa el inicio de sesión, mostrar grupos, enumerar amigos y ver el folleto de información de amigos. , echemos un vistazo al código.
Oye, hay demasiadas categorías. No publicaré las clases vo y las clases de implementación. Además, estas clases tienen poco contenido técnico.
Si es necesario, deje su dirección de correo electrónico y se la enviaré. Se le enviarán dos proyectos y códigos de base de datos
Clase de servidor:
paquete de chat
importar impl.UserImpl;
importar java.io.IOException;
importar java.io.InputStream
importar java.io.ObjectInputStream;
importar java.io.ObjectOutputStream;
importar java.io.OutputStream
importar java.net.ServerSocket; importar java.net.Socket;
importar vo.Userinfo
importar dao.UserDao
/**
* Servidor; clase, utilizada para aceptar solicitudes del cliente. Este sistema estipula que cada solicitud del cliente. Se pasan al menos dos parámetros en la solicitud. El primero se utiliza para identificar qué operación realizará esta solicitud. >
* los parámetros son los parámetros necesarios que requiere el cliente para solicitar el servicio
*
* @author Cheng Sheng
* @version 0.1.
* @fecha 01-09-08
*
*/
clase pública ChatServer extiende el hilo {
// Definir el número máximo de conexiones
private static final int MAXLINK = 50
//Registrar el número actual de conexiones
public static int; linkNum = 0;
//Definir el objeto de conexión del servicio
private static ServerSocket ss;
public static void main(String[] args) throws Exception {
// Crear una instancia de la clase de servicio
ss = new ServerSocket(8001)
// Habilitar subprocesos múltiples: de hecho, es para llamar a la ejecución. Parece que no es necesario iniciar otro hilo. No se cambiará después de escribir
new ChatServer().start()
System.out. .println("El servidor se ha iniciado correctamente...");
}
/*
* Anular el método de ejecución
*/
public void run() {
Socket soc = null
prueba {
prueba {
<; p>Socket soc = null; p>// Bucle para escuchar las solicitudes de los clientes
while (true) {
while (true) {
//Si el número de conexiones está completo, espera
if (linkNum gt; = MAXLINK)
this.sleep(100 ) ;
else {
descanso
}
}
// Escuche las solicitudes
soc = ss.accept();
//Aumentar la conexión en uno
linkNum
//Llamar a la clase de procesamiento después obteniendo el objeto socket
new Operate(soc);
}
} catch (Exception e) {
System.out. println(e);
} finalmente {
if (soc != null) {
prueba {
soc.close(
ss.close();
} captura (IOException e) {
e.printStackTrace();
System.out.println("¡El servidor tiene una falla inexplicable y el servidor se cierra!"
}
}
}
/**
* Clase de operación, utilizada para manejar solicitudes de clientes
*
* @author Administrador
*
*/
clase Operar {
// La definición de conexión se utiliza para identificar qué la solicitud superior del cliente hará variables para cualquier operación
private String operación
/**
* Las siguientes líneas se utilizan para declarar lo necesario. variables para operaciones de red
*/
private Socket soc = null
private InputStream ips = null
private OutputStream ops =; null;
soops privados de ObjectOutputStream = null;
soops privados de ObjectInputStream = null
/**
* Constructor, en el cual; se asignan las variables definidas anteriormente
/** p>
*
* @param soc
*/
Operar (Socket soc) {
this.soc =
prueba {
ips = soc.getInputStream(); = soc.getOutputStream();
soips = new ObjectInputStream(ips);
// Recibe la solicitud número uno enviada por el cliente, que se utiliza para identificar el contenido de este. solicitud
operar = soips.readObject(). toString()
} captura (Excepción e)
{
System.out.println(e);
}
// Llama al método de operación real
WhichOpe();
}
/**
* Determinar qué operación es
*/
private void whatOpe () {
if ("iniciar sesión".equals(operar)) {
iniciar sesión()
} más {
if ( "".equals(operate)) {
}
}
}
/**
* Conéctese a la base de datos para verificar el inicio de sesión
*/
private void login() {
UserDao userdao = new UserImpl(); >
Userinfo user = null;
prueba {
//Leer los datos pasados desde el cliente
user = (Userinfo) soips.readObject( ) ;
usuario = userdao.login(usuario);
soops = new ObjectOutputStream(ops);
// Pasar el resultado al cliente
p >soops.writeObject(usuario);
soops.flush();
} captura (Excepción e) {
e.printStackTrace( ) ;
} finalmente {
prueba {
soops.close()
soips.close(); >
soc.close();
// Disminuir el número de conexiones en uno
ChatServer.linkNum--
} catch (IOException) e) {
System.out.println(e
}
}
}
}
p>
Dos clases de clientes:
paquete cliente
importar java.awt.Font
importar; java.awt.GridLayout;
importar java.awt.TextField;
importar java.awt.Window
importar java.awt.event.ActionEvent;
importar java.awt.event.ActionListener
importar java.io.IOException
importar java.io.InputStream; >importar java.io.ObjectInputStream
importar java.io.ObjectOutputStream
importar java.io.Outp;
utStream;
importar java.net.Socket;
importar javax.swing.JButton
importar javax.swing.JFrame; >importar javax.swing.JLabel;
importar javax.swing.JOptionPane;
importar javax.swing.JPanel
importar javax.swing.JTextField;
import vo.Userinfo;
/**
* Interfaz de inicio de sesión, heredada de la clase jframe
*
* @autor Cheng Sheng
* @versión 0.1
* @fecha 01-09-08
* @dirección Dormitorio escolar: Edificio Integral 424
*
*/
public class Login extends JFrame {
private final int TEXTSIZE = 10 // Definir el valor de longitud del texto
lname de JLabel privado = new JLabel("nombre de usuario");
contraseña de JLabel privado = new JLabel("contraseña"); = new JLabel("Inicio de sesión de usuario");
bok JButton privado = new JButton("Iniciar sesión");
JButton privado bcancel = new JButton("Salir"); p >
JPanel privado pcenter = nuevo JPanel();
JPanel privado pname = nuevo JPanel()
JPanel privado ppwd = nuevo JPanel();
JPanel privado psur = nuevo JPanel();
JPanel privado pnorth = nuevo JPanel();
TextField privado pwd = nuevo TextField(TEXTSIZE); p >nombre de JTextField privado = nuevo JTextField(TEXTSIZE);
Glayout de GridLayout privado = nuevo GridLayout();
Inicio de sesión público() {
// Configuración Tamaño y posición de la interfaz
this.setBounds(300, 200, 320, 250);
this.setTitle("Inicio de sesión de usuario"); setResizable (false);
//Establecer el método de cierre de la ventana
this.setDefaultCloseOperation(this.EXIT_ON_C
LOSE);
// Diseñar la ventana
this.frameLayout();
// Agregar eventos
this.addAction ()
// Ventana de visualización
this.show()
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Código auxiliar de método generado automáticamente
nuevo inicio de sesión();
}
/**
* Organizar el contenedor
*/
frameLayout final vacío privado() {
lhead.setFont(new Font("", Font.BOLD, 28));
glayout.setColumns(1);
p>
glayout.setRows(2);
pcenter.setLayout(glayout);
pname.add(lname); >
pname.add (nombre);
pwd.setEchoChar('*');
ppwd.add(lcontraseña
ppwd. agregar(pwd);
ppwd.add(pwd);
p>
pnorth.add(lhead);
psouth.add(bok);
psouth.add(bcancel);
pcenter.add (pname); >this.add(pnorth, "Norte");
this.add(pcenter, "Centro");
this.add(psouth, "Sur"); p>
}
/**
* Agregar evento
*/
privado final void addAction() {
bok.addActionListener(new AddAction());
bcancel.addActionListener (new AddAction());
nombre.addActionListener(new AddAction());
pwd.addActionListener(new AddAction());
}
/**
* Esta clase es incorporada clase utilizada para el procesamiento de eventos
*
* @author Administrador
*
*/
clase privada AddAction implementa ActionListener {
public void actionPerformed(ActionEvent e) {
if ( e.getSource() == bcanc
el) {
System.exit(0);
} else {
if ("".equals(nombre.getText()) || " ".equals(pwd.getText())) {
JOptionPane.showMessageDialog(Login.this, "El nombre de usuario y la contraseña no pueden estar vacíos");
} else {
try {
// Determinar si los datos de entrada son legales
Integer.parseInt(name.getText()
} catch ( Excepción por ejemplo) {
JOptionPane.showMessageDialog(Login.this, "Ingrese el número correctamente");
return
}
new TcpLogin(nombre.getText(), pwd.getText()).check()
}
}
}
;}
/**
* Clase de verificación de inicio de sesión, la clase integrada transmite el nombre de usuario y la contraseña al servidor para su verificación
*
* @autor Cheng Sheng
* @versión 0.1
* @fecha 09-01-08
*/
clase TcpLogin {
nombre int privado;
cadena privada pwd = ""
/**
*; Constructor, inicialice el nombre de usuario y la contraseña El valor de
*
* @param nombre
* @param pwd
*/
TcpLogin( nombre de cadena, contraseña de cadena) {
this.name = Integer.parseInt(nombre);
this.pwd = contraseña
;}
/**
* Método para conectarse al servidor y verificar la información del usuario
*/
anular verificación () {
Ventana waitWin=new Window(Login.this);
//Obtener interfaz
Iniciar sesión = Login.this
Userinfo usuario = nueva información de usuario();
user.setUserId(nombre);
user.setPassword(pwd);
Socket soc = null;
InputStream ips = nulo;
Opciones de OutputStream = nulo;
ObjectInputStream coips = nulo
ObjectOutputStream coops = nulo; /p>
intenta {
soc = new Socket("127.0.0.1", 8001
);
ips = soc.getInputStream();
ops = soc.getOutputStream();
coops = new ObjectOutputStream(ops);
coops.writeObject(" iniciar sesión");
coops.writeObject(usuario);
coops.flush();
ObjectInputStream oips = nuevo ObjectInputStream(ips);
usuario = nulo;
usuario = (Información de usuario) oips.readObject();
if (usuario!= nulo){
nuevo XiHa (usuario);
login.dispose();
}
else {
JOptionPane.showMessageDialog(iniciar sesión, "Nombre de usuario y Contraseña incorrecta");
}
} catch (Exception e) {
e.printStackTrace();
} finalmente {
prueba {
ips.close();
ops.close(); p>
p>
} catch (IOException e) {
e.printStackTrace()
}
}
}
}
}
cliente de paquete
importar java.awt.GridLayout
importar java.awt.event.ActionEvent;
importar java.awt.event.ActionListener
importar java. awt.event.MouseAdapter ;
importar java.awt.event.MouseEvent;
importar java.util.ArrayList
importar java.util.Iterator;
importar java.util.List
importar java.util.Set
importar javax.swing.JButton
importar; javax.swing.JFrame ;
importar javax.swing.JLabel
importar javax.swing.JPanel
importar javax.swing.JScrollPane
p>
importar javax.swing.JTextArea
importar javax.swing.JTextField
importar javax;
.swing.JTree;
importar javax.swing.Timer
importar javax.swing.tree.DefaultMutableTreeNode
importar vo.Groupinfo
import vo.Relationinfo;
import vo.Userinfo;
/**
* Este tipo es la interfaz principal del cliente de este Después de pensarlo un rato, decidí llamarlo "hip hop", que significa "hip hop"
*
* @autor Cheng Sheng
<. p>* @versión 0.1 p>* @fecha 01-09-08
* @address Dormitorio escolar: Edificio Integral 424
*/
clase pública XiHa extiende JFrame {
//Información de amigos
Listlt estático; amigos = new ArrayListlt (); >// Información del usuario
Información de usuario privada usuario = null;
JPanel privado ptree = nuevo JPanel()
JPanel privado psouth = nuevo JPanel();
JButton privado bfind = new JButton("Buscar");
JButton privado bsystem = new JButton("Configuración del sistema");
/**
* Constructor, Establecer parámetros básicos de la interfaz
*/
public XiHa(usuario Userinfo) {
this.user = usuario <; /p>
this.setTitle ("Riendo");
this.setDefaultCloseOperation(this.EXIT_ON_CLOSE);
this.setBounds(800, 100, 200, 500) ;
this .setResizable(false);
// Diseño de interfaz
initFrame()
// this.pack(
this.setVisible(true);
}
/**
* Se utiliza para el diseño de la interfaz
*/
private void initFrame() {
ptree.add(new JScrollPane(new CreateTree(user).createNode())); >psouth.add(bsystem);
psouth.add(bfind);
this.add(ptree, "Centro"); (psur, "Sur");
}
}
/**
* Esta clase se utiliza para crear un árbol con información del usuario como nodos
*
* @author Cheng Sheng
* @version 0.1
* @fecha 01-09-08
* @address Dormitorio escolar: Edificio Integral 424
*
*/
clase CreateTree {
JTree tree=null;
usuario privado de información de usuario = nulo
CreateTree(usuario de información de usuario) {
}
/**
* Crea un árbol usando los datos devueltos por el servidor
*
* @return
*/
JTree createNode() {
//Nodo raíz
DefaultMutableTreeNode all = new DefaultMutableTreeNode("Todos los amigos");
Setlt;Groupinfogt; groups = user.getGroupinfos()
Setlt;Relationinfogt;
Iteratorlt;Groupinfogt; ig = groups.iterator();
Iteratorlt;Relationinfogt; ir = null
Grupo de información = null;
Relationinfo relación = null;
DefaultMutableTreeNode friendNode = null;
Userinfo amigo = null
mientras (ig.hasNext()) {
p>
grupo = ig.next();
friendNode = new DefaultMutableTreeNode(group.getGroupName());
ir = relaciones.iterator(
mientras (ir.hasNext()) {
relación = ir.next()
if (relación.getResideGroupId() == grupo; .getGroupId()) {
amigo = relación.getFriend();
friendNode.add(new DefaultMutableTreeNode(amigo
.getPetname()
" (" relación.getFriendId() ")"));
XiHa.friends.add(amigo);
}
}
all.add(friendNode);
//
rootTree.add(friendNode);
}
árbol=new JTree(all);
tree.addMouseListener(new TreeListener()); >
return tree;
}
/**
* Esta clase es una clase incorporada para crear árboles y se utiliza para manejar eventos. en nodos
*
* @autor Cheng Sheng
* @versión 0.1
* @fecha 09-01-09 <. /p>
* @address Dormitorio de la escuela: Edificio Integral 424
*/
clase TreeListener extiende MouseAdapter{
private JFrame friendInfo=null <; /p>
private String nodeInfo="";
//Se utiliza para distinguir un solo clic y un doble clic
Timer mouseTimer =null
/ *
* Anula el método mouseClicked en mouseAdapter y activa cuando se hace clic con el mouse
*/
public void mouseClicked(MouseEvent e){
//Devolver el nodo seleccionado
DefaultMutableTreeNode treeNode =null;
treeNode =(DefaultMutableTreeNode)CreateTree.this.tree.getLastSelectedPathComponent()
if (treeNode= =null)return;
//Regresar si no es un nodo hoja
if(!treeNode.isLeaf())return; nodeInfo=treeNode .toString();
if(e.getClickCount()==1){
mouseTimer = nuevo javax.swing.Timer(350, nuevo ActionListener() {
public void actionPerformed(ActionEvent evt) {
//Interfaz de información de diseño
initFriendInfo()
mouseTimer.stop(); ;
p>
}
});
mouseTimer.restart()
}else{
if(e. getClickCount()==2amp;amp;mouseTimer.isRunning()){
mouseTimer.stop()
//Crear una instancia de la interfaz de chat.
nuevo WinChat();
}
}
}
/**
* Diseño de la interfaz de friendInfo
*/
private void initFriendInfo() {
p>
friendInfo=new JFrame();
friendInfo.setSize(300, 120);
friendInfo.setDefaultCloseOperation(friendInfo.DISPOSE_ON_CLOSE); >friendInfo.setLocationRelativeTo(null);
friendInfoContent(this.treat());
friendInfo.setVisible(true);
/**
* Establecer el contenido específico en la ventana
* @param friendId
* @return
* /
private void friendInfoContent(int friendId) {
friendInfo.dispose();
Información de usuario amigo=this.findFriend(friendId);
JPanel pmain=nuevo JPanel();
pmain.setLayout(nuevo GridLayout(3,1));
JPanel panel1=nuevo JPanel();
panel1.add(new JLabel("Número de hip-hop: " amigo.getUserId() " " "Apodo: " amigo.getPetname()));
JPanel panel2=new JPanel() ;
JPanel panel2=new JPanel();
p>
panel2.add(new JLabel("Nombre:" (friend.getName()==null?" ":friend.getName()) " " "Edad:" friend.getAge() " " "Género: " friend.getSex()));
JPanel panel3=new JPanel();
panel3.add(new JLabel("Firma personal: " (friend.getAutograph() ==null?"": friend.getAutograph())));
pmain.add( panel1); pmain.add(panel2); pmain.add(panel3);
friendInfo.add(pmain);
}
/**
* Este método se utiliza para obtener el número de identificación del amigo del texto en el nodo
* @return id de amigo
*/
<. p>private int treat(){int len=nodeInfo.getBytes() length;
int friendId=Integer.parseInt(new String(nodeInfo.getBytes(), len -5, 4));
return friendId;
}
/**
* Este método se utiliza para encontrar amigos. información por id
* @para
m amigoId
* @return información de amigo
*/
información de usuario privada findFriend(int friendId){
Información de usuario amigo=null;
Iterador amigos=XiHa.friends.iterator();
mientras(amigos.hasNext()){
Información de usuario ifriend=(Información de usuario)amigos.siguiente ();
if(ifriend.getUserId()==friendId){
amigo=ifriend
romper;
}
regresar amigo
}
}
}
/ **
* No sé cómo escribir este tipo de clase de ventana de chat. Ahora estoy un poco confundido. Acabo de comunicarme con los internautas.
* Siento que la comunicación. El código escrito antes es muy irregular, debería reescribirse. Primero escribamos la interfaz.
*
* Volveré pronto para el Año Nuevo chino, así que puedo. No tengo tiempo suficiente para escribir este sistema
* @author Cheng Sheng
* @version 0.1
* @date 09-01-11
* @address Dormitorio de la escuela: Edificio Integral 424
*
*/
class WinChat extiende JFrame{
privado JPanel pmain=nuevo JPanel();
JPanel privado pcether=nuevo JPanel();
JPanel privado psouth=nuevo JPanel(); JTextArea precod=new JTextArea(JTextArea.);
}