1.涉及到的知识
1.项目框架的设计
2.java面向对象编程
3.网络编程
4.多线程编程
5.IO流的操作
6.Mysql/先使用集合来充当内存数据库
核心功能的实现，界面的优化还是自己把握
项目吃透的意义:
1.网络编程
2.IO编程
3.面向对象的编程
4.多线程的管理
是对于这些的综合运用
用户分析：
界面带上
1.用户登录
2.拉取在线用户列表
3.无异常退出（客户端，服务端) 因为是通过网络进行控制的
4.私聊的实现
5.群聊的实现 （公网的实现）
6.发文件的实现：关键是给谁发送过去信息是关键
7.文件服务器推送新闻
1.客户端和服务端共同的代码
Message：是消息的种类的类型，里面包含着消息的种类，以及其各种特征
MessageType:消息的类型（消息头），对于不同的消息头，区别不同的消息，客户端服务端进行不同方式的处理
User的作用：一个User就是一个登录用户的各种信息的集合
FileClientService的作用：从指定路径获取发送文件的数据，将其存储在message当中，然后发送给服务端
ManageCilentConnectServerThread 的作用：管理客户端连接服务端线程的集合以及管理，以及相关的操作
Message代码如下
package com.lk0826.qqcommon;
//表示客户端和服务端通信时候的消息对象
import java.io.Serializable;
public class Message implements Serializable {
private static final long serivalVersionUID = 1L;
private String sender; // 发送者
private String getter;// 接收者
private String content;// 消息内容
private String sendTime;// 发送时间
private String mesType;// 消息类型【可以在接口当中定义已经知道的消息类型】
private byte[] fileBytes;
private int filelen = 0;
private String dest;// 文件传输的文职
private String src;// 文件的原始位置
public byte[] getFileBytes() {
return fileBytes;
}
public void setFileBytes(byte[] fileBytes) {
this.fileBytes = fileBytes;
}
public int getFilelen() {
return filelen;
}
public void setFilelen(int filelen) {
this.filelen = filelen;
}
public String getDest() {
return dest;
}
public void setDest(String dest) {
this.dest = dest;
}
public String getSrc() {
return src;
}
public void setSrc(String src) {
this.src = src;
}
public String getMesType() {
return mesType;
}
public void setMesType(String mesType) {
this.mesType = mesType;
}
public String getSender() {
return sender;
}
public void setSender(String sender) {
this.sender = sender;
}
public String getGetter() {
return getter;
}
public void setGetter(String getter) {
this.getter = getter;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getSendTime() {
return sendTime;
}
public void setSendTime(String sendTime) {
this.sendTime = sendTime;
}
}
MessageType的代码如下：
package com.lk0826.qqcommon;
//定义了不同的常量，这些不同的常量的值代表不同的消息类型
//IO/线程/网络的运用
public interface MessageType {
String MESSAGE_LOGIN_SUCCEED = "1";//代表登录成功
String MESSAGE_LONGIN_FAIL = "2";//代表登录失败
String MESSAGE_COMM_MES = "3";//普通的信息包
String MESSAGE_GET_ONLINE_FRIEND = "4";//要求返回在线的用户列表
String MESSAGE_RET_ONLINE_FRIEND = "5";//返回用户在线列表
String MESSAGE_CLIENT_EXIT = "6";//客户端请求退出的命令
String MESSAGE_TOALL_MES = "7";//群发的消息包
String MESSAGE_FILE_MES = "8";//发送文件的消息头
}
2.客户端代码
QQview的作用：QQ通信的界面设计
Utility的作用：作为工具类，从键盘读取数据的操作和方法等等
ClientConnectServerThread的作用：作为客户端和服务器进行交流的线程
FileClientService的作用：客户端发送文件的操作
UserClientService的作用：用户向服务端请求的操作的方法
QQview的代码如下:
package com.lk0826.qqview;
import com.lk0826.MessageChat.MessageClientService;
import com.lk0831.QQclientservice.FileClientService;
import com.lk0831.QQclientservice.UserClientService;
public class QQview {
private boolean loop = true;//控制是否显示菜单
private String key = "";//控制键盘的输入
private UserClientService userClientService = new UserClientService();//用于登录和注册用户的类的方法
private MessageClientService messageclientservice = new MessageClientService();//对象用户的私聊，群聊
private FileClientService fileclientservice = new FileClientService();
public static void main(String[] args) {
new QQview().mainMenu();
System.out.println("客户端退出系统....");
}
private void mainMenu() {
while(loop) {
System.out.println("\n=========欢迎登录网络通信系统==========");
System.out.println("\t\t 1 登录系统");
System.out.println("\t\t 9 退出登录");
System.out.print("请输入你的选择 :");
key = Utility.readString(1);
//根据用户的输入，来处理不同的逻辑
switch(key) {
case "1":
System.out.println("请输入用户号 ：");
String UserId = Utility.readString(50);//用户号限制在五十个的范围
System.out.println("请输入密 码 ：");
String pwd = Utility.readString(50);
//这里就比较麻烦了，需要构建一个USer对象在服务端去看这个用户是否合法
//大量的代码
if(userClientService.checkUser(UserId,pwd)) {
System.out.println("======欢迎（用户"+UserId+"登录成功)======");
//进入了二级菜单
while(loop) {
System.out.println("\n=========网络通信系统二级菜单=========（用户"+UserId+")");
System.out.println("\t\t 1. 显示在线用户列表");
System.out.println("\t\t 2.群发消息");
System.out.println("\t\t 3.私聊消息");
System.out.println("\t\t 4.发送文件");
System.out.println("\t\t 9.退出系统");
System.out.print("请输入你的选择 ：");
key = Utility.readString(1);
switch (key) {
case "1":
//这里用一个方法来获取在线用户列表
userClientService.onlineFriendList();
break;
case "2":
System.out.println("群发消息");
System.out.println("请输入相对大家说的话： ");
String s = Utility.readString(100);
//调用一个方法，将消息封装成一个对象
messageclientservice.sendMessageAll(s,UserId);
break;
case "3"://当我私聊给一个用户发送消息的时候
System.out.print("请输入想聊天的用户名（在线）：");
String getterid = Utility.readString(50);
System.out.print("请输入想输入的话 ：");
String content = Utility.readString(100);
//编写一个方法，将消息发送给服务器端口
//局部变量在方法当中可以使用
messageclientservice.sendMessageToOne(content, UserId, getterid);
System.out.println("私聊消息");
break;
case "4":
System.out.print("请输入你想把文件发送给的用户");
String getterId = Utility.readString(50);
System.out.print("请输入发送文件的路径（形式 d：\\xx.jpg）");
String src = Utility.readString(100);
System.out.print("请输入把文件发送到对方的路径（形式 d:\\yy.jpg）");
String dest = Utility.readString(100);
fileclientservice.sendFiletoOne(src, dest, UserId, getterId);
break;
case "9":
loop = false;
System.out.print("退出登录");
//调用一个方法，给服务器发送关闭的message
userClientService.logout();
break;
default:
break;
}
}
}else {
//登录服务器失败了
System.out.println("====登录失败====");
}
break;
case "9":
loop = false;
System.out.println("退出登录");
break;
}
}
}
}
Utility的代码如下：
package com.lk0826.qqview;
/**
工具类的作用:
处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
*/
import java.util.*;
/**
*/
public class Utility {
//静态属性。。。
private static Scanner scanner = new Scanner(System.in);
/**
* 功能：读取键盘输入的一个菜单选项，值：1——5的范围
* @return 1——5
*/
public static char readMenuSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1, false);//包含一个字符的字符串
c = str.charAt(0);//将字符串转换成字符char类型
if (c != '1' && c != '2' &&
c != '3' && c != '4' && c != '5') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
/**
* 功能：读取键盘输入的一个字符
* @return 一个字符
*/
public static char readChar() {
String str = readKeyBoard(1, false);//就是一个字符
return str.charAt(0);
}
/**
* 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
* @param defaultValue 指定的默认值
* @return 默认值或输入的字符
*/
public static char readChar(char defaultValue) {
String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
return (str.length() == 0) ? defaultValue : str.charAt(0);
}
/**
* 功能：读取键盘输入的整型，长度小于2位
* @return 整数
*/
public static int readInt() {
int n;
for (; ; ) {
String str = readKeyBoard(10, false);//一个整数，长度<=10位
try {
n = Integer.parseInt(str);//将字符串转换成整数
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
/**
* 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
* @param defaultValue 指定的默认值
* @return 整数或默认值
*/
public static int readInt(int defaultValue) {
int n;
for (; ; ) {
String str = readKeyBoard(10, true);
if (str.equals("")) {
return defaultValue;
}
//异常处理...
try {
n = Integer.parseInt(str);
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
/**
* 功能：读取键盘输入的指定长度的字符串
* @param limit 限制的长度
* @return 指定长度的字符串
*/
public static String readString(int limit) {
return readKeyBoard(limit, false);
}
/**
* 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
* @param limit 限制的长度
* @param defaultValue 指定的默认值
* @return 指定长度的字符串
*/
public static String readString(int limit, String defaultValue) {
String str = readKeyBoard(limit, true);
return str.equals("")? defaultValue : str;
}
/**
* 功能：读取键盘输入的确认选项，Y或N
* 将小的功能，封装到一个方法中.
* @return Y或N
*/
public static char readConfirmSelection() {
System.out.println("请输入你的选择(Y/N): 请小心选择");
char c;
for (; ; ) {//无限循环
//在这里，将接受到字符，转成了大写字母
//y => Y n=>N
String str = readKeyBoard(1, false).toUpperCase();
c = str.charAt(0);
if (c == 'Y' || c == 'N') {
break;
} else {
System.out.print("选择错误，请重新输入：");
}
}
return c;
}
/**
* 功能： 读取一个字符串
* @param limit 读取的长度
* @param blankReturn 如果为true ,表示 可以读空字符串。
* 如果为false表示 不能读空字符串。
*
* 如果输入为空，或者输入大于limit的长度，就会提示重新输入。
* @return
*/
private static String readKeyBoard(int limit, boolean blankReturn) {
//定义了字符串
String line = "";
//scanner.hasNextLine() 判断有没有下一行
while (scanner.hasNextLine()) {
line = scanner.nextLine();//读取这一行
//如果line.length=0, 即用户没有输入任何内容，直接回车
if (line.length() == 0) {
if (blankReturn) return line;//如果blankReturn=true,可以返回空串
else continue; //如果blankReturn=false,不接受空串，必须输入内容
}
//如果用户输入的内容大于了 limit，就提示重写输入
//如果用户如的内容 >0 <= limit ,我就接受
if (line.length() < 1 || line.length() > limit) {
System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
continue;
}
break;
}
return line;
}
}
User的代码如下：
package com.lk0826.qqcommon;
import java.io.Serializable;
//客户的信息
//User对象要在网络上面传输，因此要用对象流，对象对应的类需要序列化
public class User implements Serializable{
private static final long serivalVersionUID = 1L;
private String userid;//用户名
private String passwd;//用户密码
public User() {
}
/**
* @param userid
* @param passwd
*/
public User(String userid, String passwd) {
super();
this.userid = userid;
this.passwd = passwd;
}
public String getUserid() {
return userid;
}
public void setUserid(String userid) {
this.userid = userid;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
}
ClientConnectServerThread代码如下：
package com.lk0831.QQclientservice;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;
import com.lk0826.qqcommon.Message;
import com.lk0826.qqcommon.MessageType;
public class ClientConnectServerThread extends Thread {
// 该线程需要持有socket
private Socket socket;
// 这个构造器在构建的时候，可以构建一个socket对象
public ClientConnectServerThread(Socket socket) {
this.socket = socket;
}
// 以后可能还需要获取这个方法
public Socket getSocket() {
return socket;
}
// 这个包含socket的线程，需要在后台和服务器通讯，因此需要一直存在，因此我们将其做成一个while循环
public void run() {
while (true) {
// 读取
System.out.println("客户端线程，等待读取从服务器端口发送的消息");
try {
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
// 如果服务器没有发送Message对象，线程会阻塞在这里
Message ms = (Message) ois.readObject();
// 拿到消息以后就可以做其它的处理
if (ms.getMesType().equals(MessageType.MESSAGE_RET_ONLINE_FRIEND)) {
// 取出在线列表的信息，并且显示
String[] onlineUsers = ms.getContent().split(" ");
System.out.println("\n=====当前用户列表如下===========");
for (int i = 0; i < onlineUsers.length; i++) {
System.out.println("用户 ：" + onlineUsers[i]);
}
} else if (ms.getMesType().equals(MessageType.MESSAGE_COMM_MES)) {
System.out.println(ms.getSendTime());// 时间
System.out.println("\n" + ms.getSender() + " 对 " + ms.getGetter() + " 说 ：" + ms.getContent());// 谁对谁说怎样的话语
} else if (ms.getMesType().equals(MessageType.MESSAGE_TOALL_MES)) {
// 显示在客户端的控制台即可
System.out.println("\n" + ms.getSender() + "对大家说：" + ms.getContent());
} else if (ms.getMesType().equals(MessageType.MESSAGE_FILE_MES)) {
System.out.println("\n"+ms.getSender()+
"给"+ms.getGetter()+"发送文件从"+ms.getSrc()+"到我的电脑目录"+ms.getDest());
//取出message的文件字节数组，通过文件输出流写出到磁盘
FileOutputStream fos = new FileOutputStream(ms.getDest());
fos.write(ms.getFileBytes());//这种文件输出流，发送了以后记得关闭即可
fos.close();
System.out.println("\n 保存文件成功---");
} else {
System.out.println("是其它类型的message，暂时不处理");
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
FileClientService代码如下：
package com.lk0831.QQclientservice;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Date;
import com.lk0826.qqcommon.Message;
import com.lk0826.qqcommon.MessageType;
//完成文件传输服务
public class FileClientService {
//原文件位置，目标文件位置，发送用户的id，接收用户的id
public void sendFiletoOne(String src,String dest,String senderId,String getterId) {
//读取src文件，将其封装到
Message message = new Message();
message.setMesType(MessageType.MESSAGE_FILE_MES);
message.setSender(senderId);
message.setGetter(getterId);
message.setSrc(src);
message.setSendTime(new Date().toString());
message.setDest(dest);
//需要将文件进行读取
FileInputStream fis = null ;
File file = new File(src);
if(file.exists()) {
byte[] filebytes = new byte[(int)new File(src).length()];
try {
//检查这个文件是否存在不存在就提示文件不存在
//存在的话在进行传输的操作
fis = new FileInputStream(src);
fis.read(filebytes);//将文件读入到字节数组当中来
//将文件字节数组，设置到我们的message对象当中去
message.setFileBytes(filebytes);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
if(fis!=null) {
try {
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
//提示信息
System.out.println("\n"+senderId+"给"+
getterId+"发送文件 ："+src+"到对方的电脑的目录"+"dest");
//发送
try {
ObjectOutputStream oos =
new ObjectOutputStream(ManageCilentConnectServerThread.getClientConnectServerThread(senderId).getSocket().getOutputStream());
oos.writeObject(message);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}else {
System.out.println("文件不存在："+src);
}
}
}
ManageCilentConnectServerThread 的代码如下：
package com.lk0831.QQclientservice;
import java.util.HashMap;
//管理客户端连接到服务端的线程的一个类
public class ManageCilentConnectServerThread {
private static HashMap<String,ClientConnectServerThread> hm = new HashMap<>();
//将某个线程加入到这个集合当中
public static void addClientConnectServerThread(String userid,ClientConnectServerThread clientConnectServerThread) {
hm.put(userid, clientConnectServerThread);
}
//通过一个方法 通过userid可以得到对应的线程
public static ClientConnectServerThread getClientConnectServerThread(String userid) {
return hm.get(userid);
}
}
UserClientService 的代码如下
package com.lk0831.QQclientservice;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Iterator;
import com.lk0826.qqcommon.Message;
import com.lk0826.qqcommon.MessageType;
import com.lk0826.qqcommon.User;
//退出的时候有大量的异常报出，是因为当我的一个服务器或者客户端关闭了以后，另外一端还在不断的寻求读取
//看是否登录成功
public class UserClientService {
//User作为一个属性的原因，可能在其它地方使用User信息
private User u = new User();
private Socket socket;
//方法作用：判断登录是否成功
public boolean checkUser(String userid,String pwd) {
boolean b = false;
u.setUserid(userid);
u.setPasswd(pwd);
//连接到服务端，并且发送u对象
//因为socket在其它地方也可能使用，所以也要将其存为属性
try {
socket = new Socket(InetAddress.getLocalHost(),9999);
//得到objetcOutputStream的一个对象
//socket只能得到节点流
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(u);//发送User对象
//读取服务端回复的Message对象
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message ms = (Message)ois.readObject();//如果有一个要抛出异常的话，那就将其抛出异常的范围变得更大
ArrayList<Message> al =(ArrayList<Message>)ois.readObject();
ArrayList<Message> al2 =(ArrayList<Message>)ois.readObject();
if(ms.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)) {
//成功登录的话，启动一个线程，让这个线程持有这个socket，能让服务器端一直和其保持通讯
//所以要创建一个线程类ClientConnectServerThread
//在将线程放在集合里面去管理
//创建和服务器保持通信的线程，如果不做成一个线程的话，主线程只能做一件事情，不能额外的做事情
Iterator<Message> iterator = al.iterator();
while(iterator.hasNext()) {
Message message = iterator.next();
System.out.println(message.getSender()+"对"+message.getGetter()+"说"+message.getContent());
}
Iterator<Message> iterator2 = al2.iterator();
while(iterator2.hasNext()) {
Message message2 = iterator2.next();
FileOutputStream fos = new FileOutputStream(message2.getDest());
fos.write(message2.getFileBytes());//这种文件输出流，发送了以后记得关闭即可
fos.close();
System.out.println("\n 离线保存文件成功---");
}
ClientConnectServerThread ccst = new ClientConnectServerThread(socket);
ccst.start();
//一个客户端可能有几个线程和服务端进行通信，所以线程可以放入到一个集合当中去管理
ManageCilentConnectServerThread.addClientConnectServerThread(userid, ccst);
b = true;
}else {//登录失败了，我们就不能启动和服务器通讯的线程
b = false;
socket.close();
oos.close();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return b;
}
//向服务器端请求在线用户列表
public void onlineFriendList() {
//发送一个Message
Message message = new Message();
message.setSender(u.getUserid());
message.setMesType(MessageType.MESSAGE_GET_ONLINE_FRIEND);
//发送给服务器，首先等到当前线程的Socket 对应的objectOutputStream
//从管理线程的集合里面，得到userid对应的线程，再从线程里面得到对应的socket，再从socket里面得到对象输出流
Socket so = ManageCilentConnectServerThread.getClientConnectServerThread(u.getUserid()).getSocket();
try {
ObjectOutputStream oos = new ObjectOutputStream(so.getOutputStream());
oos.writeObject(message);//发送一个message，向服务端要求在线用户列表
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//编写方法，退出客户端，并给服务端发送一个退出系统的message对象
public void logout() {
Message message = new Message();
message.setMesType(MessageType.MESSAGE_CLIENT_EXIT);
message.setSender(u.getUserid());//一定指定userid，这样才不是乱关闭的
try {
//ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
//如果一个客户端有多个线程，最好通过id的形式获取到我们需要的socket，来进行数据操作
ObjectOutputStream oos = new ObjectOutputStream(ManageCilentConnectServerThread.getClientConnectServerThread(u.getUserid()).getSocket().getOutputStream());
oos.writeObject(message);
System.out.println(u.getUserid()+"退出系统");
System.exit(0);//结束进程
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//
}
3.服务端代码
QQFrame的作用：内含main主方法，可以启动服务端
QQServer的主要作用：启动服务端，等待客户端的连接，其中还包含着离线消息和离线文件的存储，判断用户登录时候的账号密码是否输入成功
SendNewstoAll的主要作用：这个类包含着服务器将消息发送给所有人（新闻推送的功能）
ServerConnectClientThread的主要作用：当客户端和服务端建立起来连接以后，服务端因为接收连接的socket，保存在线程当中，而这个线程独立的保持运行，和客户端一直保持着通信
package com.lk0826.qqframe;
import com.lk0826.qqService.QQServer;
//扩展功能：独立解决问题的能力（有意识的去培养），独立完成的功能
//离线留言的功能，如果某个用户不在线，登录以后可以接收离线的消息
//如果某个用户不在线，登录以后可以接收离线的文件
//服务器端 做一个集合 这个集合存放离线的message和发送者的id ConcurrentHashMap存放离线的message
//key：getterid ArrayList<Message>
//当客户端一个用户登录成功以后，去集合当中看看有没有getterid对应的，然后将ArrayList发送给
public class QQFrame {
public static void main(String[] args) {
QQServer qs = new QQServer();
}
}
QQServer的代码如下：
package com.lk0826.qqService;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
import com.lk0826.qqcommon.Message;
import com.lk0826.qqcommon.MessageType;
import com.lk0826.qqcommon.User;
//无异常退出等等的优化操作
//客户端正在读取的时候，突然把服务器关闭了，就会出现一系列的问题
//这是服务器，在监听9999，等待客户端 的连接，并且保持通信
//******离线文件，离线消息的扩展功能
public class QQServer {
private ServerSocket ss = null;
//创建一个集合，存放多个用户，如果是这些用户登录，就认为是合法的
private static HashMap<String,User> validUsers = new HashMap<>();
private static ConcurrentHashMap<String, ArrayList<Message>> offOnlineDb = new ConcurrentHashMap<>();
//这个集合来收集离线的文件的集合
private static ConcurrentHashMap<String, ArrayList<Message>> offOnlineFileDb = new ConcurrentHashMap<>();
//处理并发的集合 ConcurrentHashMap 可以处理并发的集合，没有线程安全问题
//HashMap是没有处理线程安全的，因此在多线程的情况下是不安全的 ConcurrentHashMap是线程同步的，在多线程情况下是安全的
static {//在静态代码块，初始化validUsers
validUsers.put("100", new User("100","123456"));
ArrayList<Message> al1 = new ArrayList<>();
offOnlineDb.put("100", al1);
offOnlineFileDb.put("100", al1);
validUsers.put("200", new User("100","123456"));
ArrayList<Message> al2 = new ArrayList<>();
offOnlineDb.put("200", al2);
offOnlineFileDb.put("200", al2);
validUsers.put("300", new User("100","123456"));
ArrayList<Message> al3 = new ArrayList<>();
offOnlineDb.put("300", al3);
offOnlineFileDb.put("300", al3);
validUsers.put("至尊宝", new User("至尊宝","123456"));
ArrayList<Message> al4 = new ArrayList<>();
offOnlineDb.put("至尊宝", al4);
offOnlineFileDb.put("至尊宝", al4);
validUsers.put("紫霞仙子", new User("紫霞仙子","123456"));
ArrayList<Message> al5 = new ArrayList<>();
offOnlineDb.put("紫霞仙子", al5);
offOnlineFileDb.put("紫霞仙子", al5);
validUsers.put("菩提老祖", new User("菩提老祖","123456"));
ArrayList<Message> al6 = new ArrayList<>();
offOnlineDb.put("菩提老祖", al6);
offOnlineFileDb.put("菩提老祖", al6);
}
//验证用户是否有效的方法
//当用户登录成功以后，先遍历一遍自己的离线列表，看有没有message，有message就打印出来，然后再删除这个key
//
public static void addoffFile(String getterId,ArrayList<Message> al)
{
offOnlineFileDb.put(getterId, al);
}
//给离线的消息库添加消息
public static void addOffpnlineDb(String getterId,ArrayList<Message> al) {
offOnlineDb.put(getterId, al);
}
private boolean checkUser(String userid,String passwd) {
User user = validUsers.get(userid);
//if if 过关斩将的判断方式
if(user == null) {//说明userId没有存在valid
return false;
}
if(!user.getPasswd().equals(passwd)) {//userId正确，但是密码错误
return false;
}
return true;
}
//服务器端要实现的功能的方法
//当登录成功以后，遍历offOnlienDb
public void offOlinechat(String usreid) {
Iterator<String> iterator = offOnlineDb.keySet().iterator();
while(iterator.hasNext()) {
String s = iterator.next();
if(s.equals(usreid)) {
ArrayList<Message> al = offOnlineDb.get(s);
ServerConnectClientThread scct = ManageClientThreads.getClientThread(s);
try {
ObjectOutputStream oos = new ObjectOutputStream(scct.getSocket().getOutputStream());
oos.writeObject(al);//将离线的消息列表发送给对应的客户端
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public QQServer() {
//服务器给各个客户端推送消息
//服务器端专门启动一个线程，专门负责推送新闻
try {
System.out.println("服务端在9999端口监听。。。");
ss = new ServerSocket(9999);
new Thread(new SendNewstoAll()).start();
//并不是监听到一个监听的工作就不监听了
//监听9999的这个工作，这是一个while循环
while(true) {//当和某个客户端建立连接以后会继续一直的监听的，因此我们这里while循环
Socket socket = ss.accept();//没有客户端连接的话，就会阻塞在这里
//得到这个socket关联的对象输入流
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
User u = (User)ois.readObject();//向下转型需要强制转型，理论上面后台是有一个数据库来验证用户名字和id是否正确的才对
//验证用户
Message message = new Message();//设置在外面的原因是因为，无论登录成功还是登录失败我们都需要回复一个消息才行
if(checkUser(u.getUserid(), u.getPasswd())) {
//创建一个Message对象，准备回复客户端
message.setMesType(MessageType.MESSAGE_LOGIN_SUCCEED);
//将message对象发送回复
oos.writeObject(message);
//登录成功以后，取出离线的数据包
ArrayList<Message> al = offOnlineDb.get(u.getUserid());
oos.writeObject(al);
offOnlineDb.remove(u.getUserid());
ArrayList<Message> al2 = offOnlineFileDb.get(u.getUserid());
oos.writeObject(al2);
offOnlineFileDb.remove(u.getUserid());
//创建一个线程，和客户端保持通讯的状态，该线程需要持有这个socket对象，并且要将线程放在管理线程的集合当中去
ServerConnectClientThread scct =
new ServerConnectClientThread(socket, u.getUserid());
//启动线程，线程不会影响到主线程的工作
scct.start();
//把对象放到集合当中进行管理
//这个ManageClientThreads可以看成一个仓库
ManageClientThreads.addClientThread(u.getUserid(), scct);
}
else {//登录失败
System.out.println("用户 id = "+u.getUserid()+"pwd = "+u.getPasswd()+"验证失败");
message.setMesType(MessageType.MESSAGE_LONGIN_FAIL);
oos.writeObject(message);
//关闭socket
socket.close();
}
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
//如果服务器端退出了while，服务端不在监听，因此关闭ServerSocket
try {
ss.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
SendNewstoAll的代码如下：
package com.lk0826.qqService;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;
import com.lk0826.Utils.Utility;
import com.lk0826.qqcommon.Message;
import com.lk0826.qqcommon.MessageType;
public class SendNewstoAll implements Runnable{
private Scanner scanner = new Scanner(System.in);
public void run() {
//为了可以推送多次新闻，我使用while循环
while(true) {
System.out.println("请输入服务器要推送的消息/新闻【输入exit表示退出推送服务】");
String news = Utility.readString(1000);
if("exit".equals(news)) {
break;
}
Message message = new Message();
message.setSender("服务器");
message.setContent(news);
message.setMesType(MessageType.MESSAGE_TOALL_MES);
message.setSendTime(new Date().toString());
System.out.println("服务器推送消息给所有人说 "+news);
//下一步，遍历当前所有的通讯线程，并得到其socket，然后发送即可
HashMap<String,ServerConnectClientThread> hm = ManageClientThreads.getHashMap();
Iterator iterator = hm.keySet().iterator();
while(iterator.hasNext()) {
String s = iterator.next().toString();
ServerConnectClientThread scct = hm.get(s);
try {
ObjectOutputStream oos =new ObjectOutputStream(scct.getSocket().getOutputStream());
oos.writeObject(message);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
ServerConnectClientThread的代码如下：
package com.lk0826.qqService;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import com.lk0826.qqcommon.Message;
import com.lk0826.qqcommon.MessageType;
//该类对应的一个对象，和某个客户端保持通讯
//它必须有一个socket属性
public class ServerConnectClientThread extends Thread{
private Socket socket;
private String userid;//为了区分socket和哪一个用户之间进行的连接
/**
* @param socket
* @param userid
*/
public ServerConnectClientThread(Socket socket, String userid) {
super();
this.socket = socket;
this.userid = userid;
}
public Socket getSocket() {
return socket;
}
//线程处于一个运行的状态
//可以发送或者是接收消息
public void run() {
while(true) {
try {
System.out.println("服务端和客户端"+userid+"保持通信，读取信息");
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message message = (Message)ois.readObject();
//Message是一种通讯的协议，是一种通讯的规则
//根据message类型做出相应的业务的处理,先处理拉取在线
if(message.getMesType().equals(MessageType.MESSAGE_GET_ONLINE_FRIEND)) {
System.out.println(message.getSender()+" 要在线用户列表");
String onlineUser = ManageClientThreads.getOnlineUser();
//构建一个Message对象，返回给客户端
Message message2 = new Message();
message2.setMesType(MessageType.MESSAGE_RET_ONLINE_FRIEND);
message2.setContent(onlineUser);//将用户在线列表打过去
message2.setGetter(message.getSender());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());//线程里面本身就持有这个socket
//返回给客户端
oos.writeObject(message2);
}
else if(message.getMesType().equals(MessageType.MESSAGE_CLIENT_EXIT)) {//客户端退出的消息
System.out.println(message.getSender() + "退出");
//将和客户端保持通信的线程从服务器集合当中移除
//ManageClientThreads
ManageClientThreads.removeThread(message.getSender());
socket.close();//关闭数据通道
//退出线程
break;
}else if(message.getMesType().equals(MessageType.MESSAGE_COMM_MES)) {
//根据message获取 getterid ,在获取对应的线程
//当获取消息的时候，发现服务器的管理线程里面没有这个线程那样的话，就采用离线处理的方式
ServerConnectClientThread scct = ManageClientThreads.getClientThread(message.getGetter());
if(scct==null) {
//如果线程是空的代表还没有登录才去离线的处理方式
ArrayList<Message> al = new ArrayList<>();
al.add(message);
QQServer.addOffpnlineDb(message.getGetter(),al);
}else {
ObjectOutputStream oos2 = new ObjectOutputStream(scct.getSocket().getOutputStream());
oos2.writeObject(message);
}//转发，提示如果客户不在线，可以保存到数据库当中，这样可以实现离线留言
}else if(message.getMesType().equals(MessageType.MESSAGE_TOALL_MES)) {
//需要编列管理线程的集合，把所有线程的socket得到，然后将message转发即可
HashMap<String,ServerConnectClientThread> hm = ManageClientThreads.getHashMap();
Iterator<String> iterator = hm.keySet().iterator();//这个语句是什么意思
while(iterator.hasNext()) {//集合的操作而已
//取出在线用户的id
String s = iterator.next().toString();
if(!s.equals(message.getSender())){
ObjectOutputStream oos3 =new ObjectOutputStream( hm.get(s).getSocket().getOutputStream());
oos3.writeObject(message);
}
}
}else if(message.getMesType().equals(MessageType.MESSAGE_FILE_MES)) {
//根据getterid获取到对应的线程，然后将message转发
//当发送的文件的目标对象的离线的时候
ServerConnectClientThread scct2 = ManageClientThreads.getClientThread(message.getGetter());
if(scct2==null) {
//如果还未登录
ArrayList<Message> al2 = new ArrayList<>();
al2.add(message);
QQServer.addoffFile(message.getGetter(), al2);
}else {
ObjectOutputStream oos2 = new ObjectOutputStream(scct2.getSocket().getOutputStream());
oos2.writeObject(message);
}
}
else {
System.out.println("其它类型的message暂时不处理");
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
整体思路的设计和框架的搭建
1.首先我们设计服务端和客户端都要有的共同的代码，因为用户和消息，消息类型种类，都是要进入数据通道，也就是客户端和服务端这两种数据必须相同，所以两端这几种消息类型必须相同并且在同一个包当中
2.对于要用对象流的操作，我们必须进行序列化和反序列化的操作才行
3.注意在写一个程序的时候首先是要将其主要功能跑通，然后每个类各司其职，最好每个线程都由一个线程的管理类的管理，先画出大致的思路的图形，这样慢慢来结构清晰
4.不熟悉代码知识点的总结
- Message ms = (Message)ois.readObject(); 因为对象输出流，当我们读入的时候得到的是对象，需要用强制转型将其转换为Message
-
ArrayList<Message> al =(ArrayList<Message>)ois.readObject(); ArrayList<Message> al2 =(ArrayList<Message>)ois.readObject(); if(ms.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)) { //成功登录的话，启动一个线程，让这个线程持有这个socket，能让服务器端一直和其保持通讯 //所以要创建一个线程类ClientConnectServerThread //在将线程放在集合里面去管理 //创建和服务器保持通信的线程，如果不做成一个线程的话，主线程只能做一件事情，不能额外的做事情 Iterator<Message> iterator = al.iterator(); while(iterator.hasNext()) { Message message = iterator.next(); System.out.println(message.getSender()+"对"+message.getGetter()+"说"+message.getContent());
数组可以转换成为同样的迭代器
iterator.hasNext()判断迭代器的下一个是否还有数据，当我们到达迭代器末尾的时候，返回false
iterator取的是下一位迭代器当中的数据，刚开始的时候指针指在迭代器的前面
举例来说:开始是头部之前是空，下一个有数据，所以取到下一个message，然后继续循环，判断第一个数据后面有没有，然后再next，取出数据，将指针移动到下一位的位置
public static String getOnlineUser() {
//集合的遍历，遍历HashMap的key
Iterator<String> iterator = hm.keySet().iterator();
String olineUserList = "";
while(iterator.hasNext()) {
olineUserList += iterator.next().toString()+" ";
}
return olineUserList;
}
hm.keyset()将哈希表的key变成一个集合，最后在将这个集合变为一个迭代器，迭代器的内容的类型
根据哈希表key值的类型决定，将在线的用户取出用间隔隔开转换为String的类型，将其赋值在message的content当中，然后将message发送过去
176
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
