IT十八掌作业_java基础第十七天_QQ案例

IT十八掌大数据实践

最新推荐文章于 2025-09-09 08:37:13 发布

weixin_34206899

最新推荐文章于 2025-09-09 08:37:13 发布

阅读量102

点赞数

CC 4.0 BY-SA版权

文章标签： java 大数据操作系统

原文链接：http://blog.51cto.com/it18zhang/1754006

本文介绍了一个基于IT十八掌的大数据实践项目，包括客户端和服务端的通信机制、UI设计及消息处理流程等内容。

感谢大家对IT十八掌大数据的支持，今天的作业如下：

按照老师讲的，自己练习项目

--------------------------------------------------------------------------------------------------------

项目源码：

package com.it18zhang.client;

import java.net.Socket;

/**

* 通信类,单例类

public class Comm {

private String ip = "192.168.12.2";

private int port = 1234 ;

private static Comm instance ;

private Socket sock ;

private ReceiverThread receiver ;

private SenderThread sender ;

public Socket getSock() {

return sock;

}

public void setSock(Socket sock) {

this.sock = sock;

}

/**

* 返回单例对象

public static Comm getInstance(MyWindow window){

if(instance == null){

instance = new Comm(window);

}

return instance ;

}

private Comm(MyWindow window) {

try {

sock = new Socket(ip, port);

//启动后台接收线程

receiver = new ReceiverThread(sock, window);

receiver.start();

//启动后台发送线程

sender = new SenderThread(sock);

sender.start();

}

catch (Exception e) {

}

public String getIp() {

return ip;

}

public void setIp(String ip) {

this.ip = ip;

}

public int getPort() {

return port;

}

public void setPort(int port) {

this.port = port;

}

/**

* 发送消息

public void sendText(String txt) {

sender.setTxt(txt);

}

package com.it18zhang.client;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JList;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.JTextArea;

import javax.swing.table.AbstractTableModel;

import javax.swing.table.TableModel;

/**

* 窗体

public class MyWindow extends JFrame {

private static final long serialVersionUID = -6944831795769317874L;

// 历史记录

private JTextArea taHistory;

//滚动面板

private JScrollPane spHistory ;

// 内容

private JTextArea taContent;

// 发送按钮

private JButton btnSend;

// 联系人列表

private JList listContacts;

private JTable table;

public MyWindow() {

ini();

}

// 初始化

private void ini() {

this.setSize(600, 400);

this.setLocation(200, 200);

// 绝对布局

this.setLayout(null);

//联系人表格

table = new JTable();

table.setBounds(500, 0, 100, 400);

this.add(table);

//聊天记录区

taHistory = new JTextArea();

taHistory.setEditable(false);

taHistory.setBounds(0, 0, 480, 300);

spHistory = new JScrollPane(taHistory);

spHistory.setBounds(0, 0, 480, 300);

this.add(spHistory);

//输入区

taContent = new JTextArea();

taContent.setBounds(0, 310,450, 90);

this.add(taContent);

//发送按钮

btnSend = new JButton("发送");

btnSend.setBounds(460,350 , 50, 50);

btnSend.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

//发送消息

String txt = taContent.getText();

Comm comm = Comm.getInstance(MyWindow.this);

comm.sendText(txt);

//清空输入区

taContent.setText("");

}

});

this.add(btnSend);

this.setVisible(true);

// 事件

this.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {

System.exit(-1);

}

});

}

/**

* 刷新联系人

public void refreshFriendsUI(final List<String> friends) {

//去重

Set<String> set = new HashSet<String>(friends);

final List<String> newclients = new ArrayList<String>(set);

TableModel dataModel = new AbstractTableModel() {

public int getColumnCount() {

return 1;

}

public int getRowCount() {

return newclients.size();

}

public Object getValueAt(int row, int col) {

return newclients.get(row);

}

};

table.setModel(dataModel);

}

/**

* 更新聊天记录

public void updateHistory(String addr, String line) {

//原文

String old = taHistory.getText();

StringBuilder builder = new StringBuilder();

builder.append(old);

builder.append("\r\n");

builder.append(addr);

builder.append("\r\n");

builder.append(line);

builder.append("\r\n");

//更新聊天区域

taHistory.setText(builder.toString());

}

/**

* 追加内容到聊天区域

public void appendCont2History(String cont) {

String old = taHistory.getText() ;

StringBuilder builder = new StringBuilder();

builder.append(old);

builder.append("\r\n");

builder.append(cont);

String newCont = builder.toString();

taHistory.setText(newCont);

}

package com.it18zhang.client;

public class QQ {

public static void main(String[] args) {

MyWindow window = new MyWindow();

Comm comm = Comm.getInstance(window);

}

package com.it18zhang.client;

import java.io.InputStream;

import java.net.Socket;

import java.util.List;

import com.it18zhang.common.Message;

import com.it18zhang.common.MessageFactory;

import com.it18zhang.server.LatestFriendsServerMessage;

import com.it18zhang.server.TalkServerMessage;

import com.it18zhang.util.SocketUtil;

/**

* 接收者线程

public class ReceiverThread extends Thread {

//客户端UI

private MyWindow window ;

//sock

private Socket sock ;

//输入流,读取服务器回传的信息

private InputStream is ;

public ReceiverThread(Socket sock,MyWindow window){

try {

this.sock = sock ;

this.window = window ;

is = sock.getInputStream() ;

}

catch (Exception e) {

e.printStackTrace();

}

public void run() {

try {

//读取消息类型

//读取文件长度

//读取消息内容

while(true){

processMessage();

}

catch (Exception e) {

}

/**

* 处理消息

private void processMessage() {

Message msg = MessageFactory.parsePack(is);

int type = msg.getType();

switch(type){

//刷新列表

case Message.MESSAGE_TYPE_SERVER_REFRESHFRIENDS:

List<String> list = (List<String>)((LatestFriendsServerMessage)msg).getData();

window.refreshFriendsUI(list);

break ;

//服务器对话

case Message.MESSAGE_TYPE_SERVER_TALK:

String str = (String) ((TalkServerMessage)msg).getData();

window.appendCont2History(str);

break ;

}

package com.it18zhang.client;

import com.it18zhang.common.Message;

/**

* 客户端请求刷新好友列表消息

public class RequestFriendsClientMessage extends Message {

public RequestFriendsClientMessage() {

this.setType(Message.MESSAGE_TYPE_CLIENT_REQUESTFRIENDS);

}

/**

* 重写该方法，该消息没有消息长度和消息内容。

public byte[] genMessagePack() {

byte[] bytes = new byte[1];

bytes[0] = (byte)this.getType();

return bytes ;

}

/**

* 无需实现

public Object getData() {

return null;

}

package com.it18zhang.client;

import java.io.IOException;

import java.io.OutputStream;

import java.net.Socket;

import com.it18zhang.util.SocketUtil;

/**

* 发送者线程

public class SenderThread extends Thread {

private String txt ;

private OutputStream os ;

public SenderThread(Socket sock){

try {

this.os = sock.getOutputStream() ;

}

catch (IOException e) {

e.printStackTrace();

}

public String getTxt() {

return txt;

}

public void setTxt(String txt) {

this.txt = txt;

}

public void run() {

while(true){

if(txt != null){

//发送

SocketUtil.writeMessage(os, txt);

txt = null ;

}

package com.it18zhang.client;

import com.it18zhang.common.Message;

/**

* 客户端输入的话语消息

public class TalkClientMessage extends Message {

public TalkClientMessage(String text) {

//处理消息

this.setType(Message.MESSAGE_TYPE_CLIENT_TALK) ;

byte[] bytes = text.getBytes() ;

this.setContent(bytes);

}

/**

* 无需实现

public Object getData() {

return null;

}

package com.it18zhang.common;

import com.it18zhang.util.SocketUtil;

/**

* 消息

public abstract class Message {

//客户端发送talk

public static final int MESSAGE_TYPE_CLIENT_TALK = 0 ;

//客户端请求好友列表(手动刷新)

public static final int MESSAGE_TYPE_CLIENT_REQUESTFRIENDS = 1 ;

//服务端推送刷新好友列表

public static final int MESSAGE_TYPE_SERVER_REFRESHFRIENDS = 2 ;

//推送某个客户端的说的话

public static final int MESSAGE_TYPE_SERVER_TALK = 3 ;

//消息类型

private int type ;

//消息长度

private int length ;

//消息内容

private byte[] content ;

//原生报文

private byte[] pack ;

public Message(){

}

public int getType() {

return type;

}

public void setType(int type) {

this.type = type;

}

public int getLength() {

return length;

}

public void setLength(int length) {

this.length = length;

}

public byte[] getContent() {

return content;

}

public void setContent(byte[] content) {

this.content = content;

this.length = content.length ;

}

public byte[] getPack() {

return pack;

}

public void setPack(byte[] pack) {

this.pack = pack;

}

/**

* 生成整个报文，含有头信息 + 消息本身

public byte[] genMessagePack(){

pack = new byte[1 + 4 + length];

//类型

pack[0] = (byte)type ;

//数组复制

byte[] lenArr = SocketUtil.int2ByteArr(length);

System.arraycopy(lenArr, 0, pack, 1, 4);

//内容复制

System.arraycopy(content, 0, pack, 5, length);

return pack ;

}

public abstract Object getData() ;

}

package com.it18zhang.common;

import java.io.InputStream;

import com.it18zhang.server.LatestFriendsServerMessage;

import com.it18zhang.server.MessageServer;

import com.it18zhang.server.TalkServerMessage;

import com.it18zhang.util.SocketUtil;

/**

* 消息工厂

public class MessageFactory {

/**

* 转换报文，返回服务器端的消息对象,该方法只给服务器使用

public static Message tranformPack(InputStream is){

Message msg = null ;

try {

//消息类型

int type = is.read();

int length = 0 ;

byte[] cont = null ;

switch(type){

//客户端talk消息

case Message.MESSAGE_TYPE_CLIENT_TALK:

//消息长度

length = SocketUtil.readMsglength(is);

cont = SocketUtil.readMessage(is, length);

//转换成服务器talk

msg = new TalkServerMessage(length,cont);

break ;

//客户端刷新好友

case Message.MESSAGE_TYPE_CLIENT_REQUESTFRIENDS:

msg = new LatestFriendsServerMessage(MessageServer.friends);

break ;

}

//返回消息

return msg ;

}

catch (Exception e) {

}

return null ;

}

/**

* 解析报文，提取消息内容，只给客户端使用

public static Message parsePack(InputStream is){

Message msg = null;

try {

//消息类型

int type = is.read();

int length = 0 ;

byte[] cont = null ;

//消息长度

length = SocketUtil.readMsglength(is);

cont = SocketUtil.readMessage(is, length);

switch(type){

//客户端talk消息

case Message.MESSAGE_TYPE_SERVER_TALK:

msg = new TalkServerMessage(length, cont);

break ;

//客户端刷新好友

case Message.MESSAGE_TYPE_SERVER_REFRESHFRIENDS:

msg = new LatestFriendsServerMessage(cont);

break ;

}

//返回消息

return msg ;

}

catch (Exception e) {

}

return null ;

}

package com.it18zhang.server;

import java.io.ByteArrayOutputStream;

import java.io.ObjectOutputStream;

import java.util.List;

import com.it18zhang.common.Message;

import com.it18zhang.util.SocketUtil;

/**

* 服务器端消息，最新的好友列表

public class LatestFriendsServerMessage extends Message {

public LatestFriendsServerMessage(List<String> list){

this.setType(MESSAGE_TYPE_SERVER_REFRESHFRIENDS);

this.setContent(serialFriends(list));

}

public LatestFriendsServerMessage(byte[] content){

this.setType(MESSAGE_TYPE_SERVER_REFRESHFRIENDS);

this.setContent(content);

}

/**

* 串行好友列表

private byte[] serialFriends(List<String> list){

try {

ByteArrayOutputStream baos = new ByteArrayOutputStream();

ObjectOutputStream oos = new ObjectOutputStream(baos);

oos.writeObject(list);

oos.close();

baos.close();

return baos.toByteArray();

}

catch (Exception e) {

e.printStackTrace();

}

return null ;

}

/**

* 取得消息中的数据部分，反串行化。

public Object getData() {

return SocketUtil.deserializeFriends(getContent());

}

package com.it18zhang.server;

import java.io.IOException;

import java.net.Socket;

import com.it18zhang.common.Message;

import com.it18zhang.util.SocketUtil;

/**

* 服务器消息推送器

public class MessagePusher {

/**

* 推送消息

public static void push(final Message msg){

//遍历所有socket

for(final Socket s : MessageServer.allSockets){

new Thread(){

public void run() {

try {

SocketUtil.writeMessage(s.getOutputStream(), msg);

}

catch (IOException e) {

e.printStackTrace();

}

}.start();

}

package com.it18zhang.server;

import java.net.InetAddress;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.ArrayList;

import java.util.List;

import com.it18zhang.util.SocketUtil;

/**

public class MessageServer {

//客户端集合

public static List<String> friends = new ArrayList<String>();

//存放所有socket

public static List<Socket> allSockets = new ArrayList<Socket>();

//启动

public void start(int port){

try {

ServerSocket ss = new ServerSocket(port);

System.out.println("服务器启动了!!");

while(true){

Socket sock = ss.accept();

//添加好友

friends.add(SocketUtil.getAddr(sock));

//维护socket集合

allSockets.add(sock);

MessagePusher.push(new LatestFriendsServerMessage(friends));

//分配线程,单独处理

new ServerReceiverThread(sock).start();

}

catch (Exception e) {

}

package com.it18zhang.server;

import java.io.IOException;

import java.io.InputStream;

import java.net.Socket;

import com.it18zhang.common.Message;

import com.it18zhang.common.MessageFactory;

import com.it18zhang.util.SocketUtil;

import sun.awt.windows.ThemeReader;

/**

* 服务器接收线程.

public class ServerReceiverThread extends Thread {

private Socket sock ;

private InputStream is ;

public ServerReceiverThread(Socket sock) {

try {

this.sock = sock ;

this.is = sock.getInputStream() ;

}

catch (Exception e) {

e.printStackTrace();

}

public void run() {

while(true){

try {

//转成服务器消息

Message msg = MessageFactory.tranformPack(is);

int type = msg.getType();

switch(type){

case Message.MESSAGE_TYPE_SERVER_TALK :

MessagePusher.push(msg);

break ;

case Message.MESSAGE_TYPE_SERVER_REFRESHFRIENDS:

MessagePusher.push(msg);

break ;

}

catch (Exception e) {

e.printStackTrace();

}

package com.it18zhang.server;

public class StartServer {

public static void main(String[] args) {

//消息服务器

MessageServer server = new MessageServer();

//启动消息服务器

server.start(1234);

}

package com.it18zhang.server;

import com.it18zhang.common.Message;

/**

* 服务器端推送给客户端的talk消息

public class TalkServerMessage extends Message {

public TalkServerMessage(String text){

//处理消息

this.setType(Message.MESSAGE_TYPE_SERVER_TALK) ;

byte[] bytes = text.getBytes() ;

this.setContent(bytes);

}

/**

* 直接通过原生报文构造消息对象

public TalkServerMessage(byte[] pack){

this.setPack(pack);

pack[0] = Message.MESSAGE_TYPE_SERVER_TALK ;

}

/**

* 直接通过原生报文构造消息对象

public TalkServerMessage(int length,byte[] content){

this.setType(Message.MESSAGE_TYPE_SERVER_TALK) ;

this.setContent(content);

}

public byte[] genMessagePack() {

if(getPack() != null){

return getPack();

}

else{

return super.genMessagePack();

}

public Object getData() {

return new String(getContent());

}

package com.it18zhang.util;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.ObjectInputStream;

import java.io.OutputStream;

import java.io.UnsupportedEncodingException;

import java.net.Socket;

import java.util.List;

import com.it18zhang.common.Message;

/**

* 工具类

public class SocketUtil {

/**

* 返回地址串

public static String getAddr(Socket sock){

String ip = sock.getInetAddress().getHostName() ;

String ip0 = ip.substring(ip.lastIndexOf(".") + 1);

return ip0 + ":" + sock.getPort() ;

}

/**

* 从输入流is的当前读取byte，处理成消息类型.

* 0-好友列表 1-文本内容

public static int readMsgType(InputStream is){

try {

return is.read() ;

}

catch (IOException e) {

e.printStackTrace();

}

return -1 ;

}

/**

* 读取消息的长度

public static int readMsglength(InputStream is){

try {

byte[] buf = new byte[4];

is.read(buf);

//最高位

int s3 = buf[0] << 24 ;

//次高位

int s2 = (buf[1] & 0xFF) << 16 ;

//次低位

int s1 = (buf[2] & 0xFF) << 8 ;

//最低位

int s0 = buf[3] & 0xFF ;

return s3 | s2 | s1 | s0 ;

}

catch (Exception e) {

e.printStackTrace();

}

return -1 ;

}

/**

* 读取指定消息长度的内容

public static byte[] readMessage(InputStream is,int len){

try {

byte[] bytes = new byte[len];

is.read(bytes);

return bytes ;

}

catch (IOException e) {

e.printStackTrace();

}

return null ;

}

/**

* 反序列化字节数组成好友列表

public static List<String> deserializeFriends(byte[] bytes){

try {

ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));

List<String> list= (List<String>)ois.readObject();

ois.close();

return list ;

}

catch (Exception e) {

e.printStackTrace();

}

return null ;

}

/**

* 读取字符串

public static String readString(byte[] bytes){

return new String(bytes);

}

/**

* 使用指定的字符集读取字符串

public static String readString(byte[] bytes,String charset){

try {

return new String(bytes,charset);

}

catch (UnsupportedEncodingException e) {

e.printStackTrace();

}

return null ;

}

/**

* 发送消息到os中

public static void writeMessage(OutputStream os , String txt){

try {

byte[] bytes = txt.getBytes();

//先写入字节数组的长度

os.write(int2ByteArr(bytes.length));

//再写入字节

os.write(bytes);

}

catch (Exception e) {

e.printStackTrace();

}

/**

* 发送Message的原始报文到os中

public static void writeMessage(OutputStream os , Message msg){

try {

os.write(msg.genMessagePack());

os.flush();

}

catch (Exception e) {

e.printStackTrace();

}

/**

* 整型转换成字节数组

public static byte[] int2ByteArr(int i){

byte[] bytes = new byte[4] ;

bytes[0] = (byte)(i >> 24) ;

bytes[1] = (byte)(i >> 16) ;

bytes[2] = (byte)(i >> 8) ;

bytes[3] = (byte)(i >> 0) ;

return bytes ;

}

转载于:https://blog.51cto.com/it18zhang/1754006