Netty(6)-客户端登陆并与服务端收发信息

一.实现流程图

二.代码实现

• 整体结构图
  

• utils/Attributes

/**
 * @Auther: ARong
 * @Date: 2020/2/7 9:47 下午
 * @Description: channel的参数
 */
public interface Attributes {
    AttributeKey<Boolean> LOGIN = AttributeKey.newInstance("login");
}

• utils/Command

/*
 * @Author ARong
 * @Description 定义指令集
 * @Date 2020/2/4 8:58 下午
 **/
public interface Command {
    byte LOGIN_REQUEST = 1; // 登陆请求指令
    byte LOGIN_RESPONSE = 2; // 登陆响应指令
    byte MESSAGE_REQUEST = 3; // 普通消息请求指令
    byte MESSAGE_RESPONSE = 4; // 普通消息响应指令
}

• utils/MyJsonSerializer

/**
 * @Auther: ARong
 * @Date: 2020/2/4 9:09 下午
 * @Description:
 */
public class MyJsonSerializer implements MySerializer {
    /*
     * @Author ARong
     * @Description 自定义JSON序列化器 将Java对象转化为二进制字节流
     * @Date 2020/2/4 9:07 下午
     * @Param object
     * @return byte[]
     **/
    @Override
    public byte[] serialize(Object object) {
        return JSON.toJSONBytes(object);
    }

    /*
     * @Author ARong
     * @Description 二进制转换成 java 对象
     * @Date 2020/2/4 9:08 下午
     * @Param [clazz, bytes]
     * @return T
     **/
    @Override
    public <T> T deserialize(Class<T> clazz, byte[] bytes) {
        return JSON.parseObject(bytes, clazz);
    }
}

• utils/MySerializer

/*
 * @Author ARong
 * @Description 定义序列化器
 * @Date 2020/2/4 9:06 下午
 **/
public interface MySerializer {

    /*
     * @Author ARong
     * @Description 将Java对象转化为二进制字节流
     * @Date 2020/2/4 9:07 下午
     * @Param object
     * @return byte[]
     **/
    byte[] serialize(Object object);


    /*
     * @Author ARong
     * @Description 二进制转换成 java 对象
     * @Date 2020/2/4 9:08 下午
     * @Param [clazz, bytes]
     * @return T
     **/
    <T> T deserialize(Class<T> clazz, byte[] bytes);
}

• utils/PacketUtil

/**
 * @Auther: ARong
 * @Date: 2020/2/4 9:14 下午
 * @Description: 用于包编码和解码
 */
public class PacketUtil {
    /*
     * @Author ARong
     * @Description 将Packet按照约定序列化方式编码成ByteBuf
     * @Date 2020/2/4 9:15 下午
     * @Param [packet]
     * @return io.netty.buffer.ByteBuf
     **/
    public static ByteBuf encode(Packet packet) {
        // 创建ByteBuf对象
        ByteBuf byteBuf = ByteBufAllocator.DEFAULT.ioBuffer();
        // 获取序列化器序列化对象
        MySerializer serializer = SerializerFactory.getSerializer(packet.getSerMethod());
        byte[] data = serializer.serialize(packet);
        // 按照通信协议填充ByteBUf
        byteBuf.writeInt(packet.getMagic());// 魔数
        byteBuf.writeByte(packet.getVersion()); // 版本号
        byteBuf.writeByte(packet.getSerMethod()); // 序列化方式
        byteBuf.writeByte(packet.getCommand()); // 指令
        byteBuf.writeInt(data.length);// 数据长度
        byteBuf.writeBytes(data); // 数据
        return byteBuf;
    }

    /*
     * @Author ARong
     * @Description 将ByteBuf按照约定序列化方式解码成Packet
     * @Date 2020/2/4 9:21 下午
     * @Param [byteBuf]
     * @return io_learn.netty.part4_protocol.packet.Packet
     **/
    public static Packet decode(ByteBuf byteBuf) {
        // 暂不判断魔数，跳过
        byteBuf.skipBytes(4);
        // 暂不判断魔数版本号，跳过
        byteBuf.skipBytes(1);
        // 获取序列化方式
        byte serMethod = byteBuf.readByte();
        // 获取指令
        byte command = byteBuf.readByte();
        // 获取数据包长度
        int length = byteBuf.readInt();
        // 获取存储数据的字节数组
        byte[] data = new byte[length];
        byteBuf.readBytes(data);
        // 反序列化数据，获取Packet
        Class<? extends Packet> packetType = getPacketType(command);
        Packet res = SerializerFactory.getSerializer(serMethod).deserialize(packetType, data);
        return res;
    }


    /*
     * @Author ARong
     * @Description 通过指令获取相应的Packet
     * @Date 2020/2/4 9:31 下午
     * @Param [commond]
     * @return io_learn.netty.part4_protocol.packet.Packet
     **/
    public static Class<? extends Packet> getPacketType(byte commond) {
        if (commond == Command.LOGIN_REQUEST) {
            return LoginRequestPacket.class;
        }
        if (commond == Command.LOGIN_RESPONSE) {
            return LoginResponsePacket.class;
        }
        if (commond == Command.MESSAGE_REQUEST) {
            return MessageRequestPacket.class;
        }
        if (commond == Command.MESSAGE_RESPONSE) {
            return MessageResponsePacket.class;
        }
        return null;
    }
}

• utils/Serialize

/*
 * @Author ARong
 * @Description 定义序列化方式
 * @Date 2020/2/4 9:05 下午
 **/
public interface Serialize {
    byte JSON = 1;
}

• utils/SerializerFactory

/*
 * @Author ARong
 * @Description 序列化器工厂
 * @Date 2020/2/4 8:56 下午
 **/
public class SerializerFactory {
    /*
     * @Author ARong
     * @Description 通过序列化名称获取相应的序列化器
     * @Date 2020/2/4 9:17 下午
     * @Param [serName]
     * @return io_learn.netty.part4_protocol.utils.MySerializer
     **/
    public static MySerializer getSerializer(byte serName) {
        if (serName == Serialize.JSON) {
            return new MyJsonSerializer();
        }
        return null;
    }
}

• packet/Packet

/**
 * @Auther: ARong
 * @Date: 2020/2/4 8:44 下午
 * @Description: 自定义通信协议的抽象包
 */
@Data
public abstract class Packet {
    private int magic; // 魔数
    private byte version; // 版本号
    private byte serMethod; // 的序列化/反序列化方式
    private byte command; // 指令
}

• packet/MessageResponsePacket

/**
 * @Auther: ARong
 * @Date: 2020/2/4 8:52 下午
 * @Description: 用以数据请求响应的协议包
 */
@Data
public class MessageResponsePacket extends Packet {
    private int magic = 20202020; // 魔数
    private byte version = 1; // 版本号
    private byte serMethod = Serialize.JSON; // 序列化反序列化方式为Json
    private byte command = Command.MESSAGE_RESPONSE; // 登陆响应指令
    // ---------以下为返回的响应数据----------
    private String message;

    @Override
    public String toString() {
        return "MessageRequestPacket{" +
                "magic=" + magic +
                ", version=" + version +
                ", serMethod=" + serMethod +
                ", command=" + command +
                ", message='" + message + '\'' +
                '}';
    }
}

• packet/MessageRequestPacket

/**
 * @Auther: ARong
 * @Date: 2020/2/4 8:52 下午
 * @Description: 用以数据请求的协议包
 */
@Data
public class MessageRequestPacket extends Packet {
    private int magic = 20202020; // 魔数
    private byte version = 1; // 版本号
    private byte serMethod = Serialize.JSON; // 序列化反序列化方式为Json
    private byte command = Command.MESSAGE_REQUEST; // 登陆响应指令
    // ---------以下为请求数据----------
    private String message;

    @Override
    public String toString() {
        return "MessageRequestPacket{" +
                "magic=" + magic +
                ", version=" + version +
                ", serMethod=" + serMethod +
                ", command=" + command +
                ", message='" + message + '\'' +
                '}';
    }
}

• packet/LoginResponsePacket

/**
 * @Auther: ARong
 * @Date: 2020/2/4 8:52 下午
 * @Description: 用以登陆响应协议包
 */
@Data
public class LoginResponsePacket extends Packet {
    private int magic = 20202020; // 魔数
    private byte version = 1; // 版本号
    private byte serMethod = Serialize.JSON; // 序列化反序列化方式为Json
    private byte command = Command.LOGIN_RESPONSE; // 登陆响应指令
    // ---------以下为登陆响应数据----------
    private boolean status;
    private String message;

    @Override
    public String toString() {
        return "LoginResponsePacket{" +
                "magic=" + magic +
                ", version=" + version +
                ", serMethod=" + serMethod +
                ", command=" + command +
                ", loginStatus=" + status +
                ", message='" + message + '\'' +
                '}';
    }
}

• packet/LoginRequestPacket

/**
 * @Auther: ARong
 * @Date: 2020/2/4 8:52 下午
 * @Description: 用以登陆的登陆协议包
 */
@Data
public class LoginRequestPacket extends Packet {
    private int magic = 20202020; // 魔数
    private byte version = 1; // 版本号
    private byte serMethod = Serialize.JSON; // 序列化反序列化方式为Json
    private byte command = Command.LOGIN_REQUEST; // 登陆指令
    // ---------以下为登陆数据----------
    private long userId;
    private String name;
    private String password;


    @Override
    public String toString() {
        return "LoginPacket{" +
                "magic=" + magic +
                ", version=" + version +
                ", serMethod=" + serMethod +
                ", command=" + command +
                ", userId=" + userId +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

• handler/MyServerHandler

public class MyServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 解码
        ByteBuf response = ByteBufAllocator.DEFAULT.ioBuffer();
        Packet packet = PacketUtil.decode((ByteBuf) msg);
        if (packet instanceof LoginRequestPacket) {
            System.out.println("=====服务端接收到客户端登陆请求，正在校验=====");
            LoginRequestPacket request = (LoginRequestPacket) packet;
            LoginResponsePacket responsePacket = new LoginResponsePacket();
            if (check(request)) {
                System.out.println("登陆成功:"+request);
                // 为channel设置登陆成功属性，下次请求时进行校验
                ctx.channel().attr(Attributes.LOGIN).set(true);
                responsePacket.setStatus(true);
            } else {
                System.out.println("登陆失败:"+request);
                responsePacket.setStatus(false);
            }
            // 编码登陆响应返回
            response = PacketUtil.encode(responsePacket);
        }

        if (packet instanceof MessageRequestPacket) {
            // 首先获取登陆状态
            if (ctx.channel().attr(Attributes.LOGIN).get() == null) {
                System.out.println("=====客户端尚未登陆，无法进行数据通信=====");
            } else {
                System.out.println("=====客户端登陆成功,进行数据通信=====");
                MessageRequestPacket request = (MessageRequestPacket) packet;
                System.out.println("收到:"+request.toString());
                // 编码
                MessageResponsePacket responsePacket = new MessageResponsePacket();
                responsePacket.setMessage("数据通信响应测试Reponse Test1");
                response = PacketUtil.encode(responsePacket);
            }
        }
        ctx.writeAndFlush(response);
    }

    private boolean check(LoginRequestPacket request) {
        // 硬编码校验条件
        if ("ARong".equals(request.getName()) && "2020".equals(request.getPassword())) {
            return true;
        }
        return false;
    }
}

• hanlder/MyClientHandler

/**
 * @Auther: ARong
 * @Date: 2020/2/5 1:17 下午
 * @Description: 客户端的Handler
 */
public class MyClientHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // 第一次连接，首先尝试登陆
        System.out.println("=====客户端连接成功，尝试登陆=====");
        // 收集需要编码的登陆消息
        Scanner input = new Scanner(System.in);
        LoginRequestPacket packet = new LoginRequestPacket();
        System.out.println("请输入登陆的用户ID");
        packet.setUserId(Long.parseLong(input.nextLine()));
        System.out.println("请输入登陆的用户账户");
        packet.setName(input.nextLine());
        System.out.println("请输入登陆的用户密码");
        packet.setPassword(input.nextLine());
        System.out.println("=====客户端开始发送登陆数据包=====");
        // 编码数据包进行发送
        ByteBuf request = PacketUtil.encode(packet);
        ctx.writeAndFlush(request);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 解码
        Packet packet = PacketUtil.decode((ByteBuf) msg);
        if (packet instanceof LoginResponsePacket) {
            LoginResponsePacket response = (LoginResponsePacket) packet;
            if (response.isStatus()) {
                System.out.println("=====客户端登陆成功=====");
            } else {
                System.out.println("=====客户端登陆失败=====");
            }
            // 编码
            MessageRequestPacket request = new MessageRequestPacket();
            request.setMessage("数据通信请求测试Request Test1");
            ByteBuf byteBuf = PacketUtil.encode(request);
            ctx.writeAndFlush(byteBuf);
        }

        if (packet instanceof MessageResponsePacket) {
            MessageResponsePacket request = (MessageResponsePacket) packet;
            System.out.println("收到:"+request.toString());
        }
    }
}

• server/NettyServer

/**
 * @Auther: ARong
 * @Date: 2020/2/4 9:13 下午
 * @Description: Netty Server
 */
public class NettyServer {
    public static void main(String[] args) {
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        serverBootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(
                        new ChannelInitializer<SocketChannel>() {
                            @Override
                            // 初始化channel
                            protected void initChannel(SocketChannel ch) throws Exception {
                                ch.pipeline().addLast(new MyServerHandler());
                            }
                        }
                ).bind(8000);
    }
}

• server/NettyClient

/**
 * @Auther: ARong
 * @Date: 2020/2/5 1:28 下午
 * @Description:
 */
public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        Bootstrap bootstrap = new Bootstrap();
        NioEventLoopGroup group = new NioEventLoopGroup();

        bootstrap.group(group).channel(NioSocketChannel.class).handler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel ch) throws Exception {
                ch.pipeline().addLast(new MyClientHandler());
            }
        });
        // 连接服务端
        bootstrap.connect("127.0.0.1", 8000);
    }
}