RPC模式
一、概念：
rpc模式：即客户端、服务端之间的信息交流模式，
客户端通过发送请求数据包给服务端，
服务端接收到数据包（拆解数据包），进行业务处理后，返回一个处理过的数据包给客户端，
然后客户端再进行操作。
二、流程图
三、举例：
❀ 客户端界面（登录界面）
import Client.net.Client;
import Common.entity.BizType;
import Common.entity.User;
import Common.util.SysDto;
/**
* 登录界面类
* @author Huangyujun
*/
public class LoginFrame extends JFrame{//登录客户端
Client client = null;
//.....界面的东西省略....../**
* 为登录按纽添加事件(~核心功能~~~)
*/
private void loginEvent() {
//btnLogin: 登录按钮
btnLogin.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
//构建客户端
client = new Client("localhost", 8888);
//构建登录业务的DTO（DTO 是数据包对象）
SysDto sysDto = new SysDto(BizType.登录);
//account和 password 是登录界面的账号和密码输入框
String account = txtLoginName.getText();
String password = txtLoginPwd.getText();
sysDto.setUser(new User(account, password));
//发送
SysDto dto = null;
try {
dto = client.sendAndReadDto(sysDto);
} catch (ClassNotFoundException | IOException e1) {
e1.printStackTrace();
}
//若登录成功后，进入聊天界面
if(dto.getBizType().equals(BizType.登录成功)) {
//打印从服务端处理后的登录用户信息
System.out.println("从服务端处理后的登录用户信息: ");
System.out.println("从服务端返回用户账号：" + dto.getUser().getAccount());
System.out.println("从服务端返回用户密码：" + dto.getUser().getPassword());
}
}
});
}
}
❀ 客户端
package Client.net;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.concurrent.TimeUnit;
import Common.entity.BizType;
import Common.util.SysDto;
/**
* 客户端
* @author Huangyujun
*
*/
public class Client {
private String host;
private int port;
private Socket client;
private ObjectOutputStream objOutStream;
private ObjectInputStream objInStream;
private boolean isRunning;
//构造方法
public Client(String host, int port) {
this.host = host;
this.port = port;
isRunning = true;
try {
client = new Socket(host, port);
objOutStream = new ObjectOutputStream(client.getOutputStream());
objInStream = new ObjectInputStream(client.getInputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 发送DTO
* @param sysDto
* @throws IOException
*/
public void sendDto(SysDto sysDto) throws IOException {
objOutStream.writeObject(sysDto);
//推流
objOutStream.flush();
}
/**
* 接收DTO
* @return
* @throws ClassNotFoundException
* @throws IOException
*/
public SysDto readDto() throws ClassNotFoundException, IOException {
Object data = objInStream.readObject();
return (SysDto) data;
}
/**
* 发送并接收DTO
* @param sysDto
* @return
* @throws IOException
* @throws ClassNotFoundException
*/
public SysDto sendAndReadDto(SysDto sysDto) throws IOException, ClassNotFoundException {
sendDto(sysDto);
return readDto();
}
/**
* 关闭操作方法
*/
public void close(SysDto sysDto) {
if(sysDto.getBizType().equals(BizType.退出)) {
//发送退出数据包给服务器，让服务器断开处理客户端的客户端任务
try {
sendDto(sysDto);
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
//退出：关闭各种流和Socket
try {
//休息一下,避免与更新界面冲突
TimeUnit.MILLISECONDS.sleep(5000);
objInStream.close();
objOutStream.close();
client.close();
} catch (IOException | InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public Socket getClient() {
return client;
}
public void setClient(Socket client) {
this.client = client;
}
public boolean isRunning() {
return isRunning;
}
public void setRunning(boolean isRunning) {
this.isRunning = isRunning;
}
}
❀ 数据包
package Common.util;
import java.io.Serializable;
import Common.entity.BizType;
import Common.entity.User;
/**
* 数据传输对象,也需要在网络上传输，实现序列化
* @author Huangyujun
*
*/
public class SysDto implements Serializable {
private static final long serialVersonUID = 2;
private BizType bizType; //数据传输对象类型
//先考虑登录业务所需传输的数据对象
private User user;
//构造方法
public SysDto(BizType bizType) {
this.bizType = bizType;
}
public BizType getBizType() {
return bizType;
}
public void setBizType(BizType bizType) {
this.bizType = bizType;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
}
❀ 服务端
package ServerNet;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import Common.entity.User;
import Common.util.SysDto;
/**
* 服务端
* @author Huangyujun
*
*/
public class Server {
private int port; //端口
private boolean isRunning; //运行状态
private ServerSocket serverSocket; //服务器
/** 客户端任务集合 */
private static List<SocketHandler> listHandler = null;
//构造方法
public Server(int port) {
this.port = port;
isRunning = true;
listHandler = new ArrayList<SocketHandler>();
}
/**
* 启动方法
*/
public void start() {
//构建服务端，并连接
serverSocket = null;
try {
serverSocket = new ServerSocket(port);
System.out.println("服务端已经连接，正在监听端口：" + port);
//循环不断地监听客户端
while(isRunning) {
Socket client = serverSocket.accept();
//创建客户端任务处理客户端业务请求，将当前活跃的客户端传入
SocketHandler socketHandler = new SocketHandler(client);
//listHandler 添加socketHandler 客户端任务
listHandler.add(socketHandler);
//启动客户端任务线程
new Thread(socketHandler).start();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public ServerSocket getServerSocket() {
return serverSocket;
}
public void setServerSocket(ServerSocket serverSocket) {
this.serverSocket = serverSocket;
}
public List<SocketHandler> getListHandler() {
return listHandler;
}
}
❀ 客户端处理器
package ServerNet;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import Common.entity.BizType;
import Common.entity.User;
import Common.util.SysDto;
import ServerBiz.ServerBiz;
/**
* 客户端任务类
* @author Huangyujun
*
*/
public class SocketHandler implements Runnable{
private Socket client;
private boolean isRunning;
private ObjectInputStream objInStream;
private ObjectOutputStream objOutStream;
/** 服务端业务处理对象 */
private ServerBiz serverBiz;
//当前用户~登录完成就有啦
private User loginUsers;
//构造方法
public SocketHandler(Socket client) {
//当前客户端
this.client = client;
serverBiz = new ServerBiz();
isRunning = true;
//获得输入对象流、输出对象流
objInStream = null;
try {
objInStream = new ObjectInputStream(client.getInputStream());
objOutStream = new ObjectOutputStream(client.getOutputStream());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void run() {
//先不断地接收客户端传递的业务数据
Object data = null;
try {
while((data = objInStream.readObject()) != null){
//1，先判断数据属于什么业务
if(!(data instanceof SysDto)) {
System.out.println("未知业务类型，无法处理！");
}else {
//2，进行类型转换
SysDto sysDto = (SysDto) data;
//3，调用业务类的方法，处理返回处理后的数据包
SysDto dto = serverBiz.dealWithType(sysDto);
if(dto.getBizType().equals(BizType.登录成功)) {
this.loginUsers = dto.getUser();
}
//4，将处理后得到的数据包写回给客户端
objOutStream.writeObject(dto);
//5，推流
objOutStream.flush();
if(dto.getBizType().equals(BizType.退出成功)) {
//休息10秒钟
Thread.sleep(10000);
//设置客户端任务状态为false,
isRunning = false;
//关闭各种流和Socket
objOutStream.close();
objInStream.close();
client.close();
break;
}
}
}
} catch (ClassNotFoundException | IOException | InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public boolean isRunning() {
return isRunning;
}
public User getLoginUsers() {
return loginUsers;
}
}
❀ 服务业务类
package ServerBiz;
import java.io.IOException;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import Common.entity.BizType;
import Common.entity.Message;
import Common.entity.User;
import Common.util.SysDto;
import ServerNet.Server;
import ServerNet.SocketHandler;
/**
* 服务端业务处理类，把传进来的Dto进行处理后返回
* @author Huangyujun
*
*/
public class ServerBiz {
//工厂方法
public SysDto dealWithType(SysDto sysDto) throws IOException {
switch(sysDto.getBizType()) {
case 登录:
return doLogin(sysDto);
case 退出:
return doExit(sysDto);
}
return null;
}
/**
* 登录业务
* @param sysDto
* @return
*/
private SysDto doLogin(SysDto sysDto) {
//1,验证密码、账号是否正确（没有数据库省略）
//2，从数据库获取该用户信息
//3，设置sysDto类型为登录成功
//4,返回设置了用户信息的sysDto
String account = sysDto.getUser().getAccount();
String password = sysDto.getUser().getPassword();
User user = new User(account, password);
System.out.println("当前从客户端传递来的用户账号是：" + account + " 密码是:" + password);
//设置业务类型为登录成功
sysDto.setBizType(BizType.登录成功);
System.out.println("当前在线人数：" +Server.getOnlineHandler().size());
//设置DTO的用户信息
sysDto.setUser(user);
return sysDto;
}
}