Netty实现Unity登录验证(四)

这里我们用Netty实现消息的接受及分发,服务器端的 handler 添加流程如图：

package com.netty.dispatch;

import com.netty.model.SocketModel;
import com.netty.protocol.LoginProtocol;
import io.netty.channel.ChannelHandlerContext;

public class BattleDispatch {
    private static BattleDispatch instance = new BattleDispatch();

    public static BattleDispatch getInstance() {
        return instance;
    }

    public void dispatch(ChannelHandlerContext ctx, SocketModel message) {
        switch (message.getArea()) {
        case LoginProtocol.Area_LoginRequest:
            // 处理登录的事务
            break;
        default:
            break;
        }
    }
}

package com.netty.dispatch;

/*
 * 处理登陆数据并把结果分发回客户端
 */

import java.util.List;
import com.netty.model.SocketModel;
import com.netty.protocol.LoginProtocol;
import com.netty.protocol.TypeProtocol;
import com.netty.util.VerifyOperate;

import io.netty.channel.ChannelHandlerContext;

public class LoginDispatch {

  private static LoginDispatch instance = new LoginDispatch();

  public static LoginDispatch getInstance() {
    return instance;
  }

  public void dispatch(ChannelHandlerContext ctx, SocketModel message) {
    switch (message.getArea()) {
    case LoginProtocol.Area_LoginRequest:
      LoginResponse(ctx, message);

      break;
    default:
      break;
    }
  }
  /*
  *检测用户登录是否密码错误，用户名不存在等，返回int对应的不同类型
  */
  public void LoginResponse(ChannelHandlerContext ctx, SocketModel request) {
    SocketModel response = new SocketModel();
    int command = LoginCheck(ctx, request);               //success 10
    response.setType(TypeProtocol.TYPE_LOGIN);            //0
    response.setArea(LoginProtocol.Area_LoginResponse);   //6
    response.setCommand(command);
    response.setMessage(request.getMessage());
    ctx.writeAndFlush(response);                          //

    if (command == LoginProtocol.Login_Succeed) {
      LoginUser(ctx, request);// 如果成功就登陆用户,开始新手向导
    }
  }

  public int LoginCheck(ChannelHandlerContext ctx, SocketModel request) {
    List<String> message = request.getMessage();
    String username = message.get(0);
    String password = message.get(1);

    System.out.println(username);
    System.out.println(password);

    if (message.isEmpty()) {
      return LoginProtocol.Login_InvalidMessage;
    } else {
      if (VerifyOperate.getInstance().checkPlayer("tb_verify", username,
          password) > 1000) {
        return LoginProtocol.Login_Succeed;
      } else {
        return LoginProtocol.Login_InvalidPassword;
      }
    }
  }

  public void LoginUser(ChannelHandlerContext ctx, SocketModel socketModel) {
    // user =
    // UserMySQL.getInstance().initUser(User.getUserByChannel(ctx.channel()));
    // user.setWizard(WizardMySQL.getInstance().initWizard(user.getUserID()));
    // SocketModel message = new SocketModel();
    // message.setType(TypeProtocol.TYPE_WIZARD);
    // message.setArea(WizardProtocol.Wizard_Create_Request);
    // message.setCommand(user.getWizard().getStepIndex());
    // message.setMessage(null);
    // ctx.writeAndFlush(message);
  }
}

package com.netty.server;

import com.netty.dispatch.BattleDispatch;
import com.netty.dispatch.LoginDispatch;
import com.netty.model.SocketModel;
import com.netty.protocol.TypeProtocol;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

public class ServerHandler extends ChannelHandlerAdapter {

    public void channelActive(ChannelHandlerContext ctx) throws Exception // 客户端连上服务器的时候会触发
    {
        System.out.println("client:" + ctx.channel().id() + " join server");
    }

    public void channelInactive(ChannelHandlerContext ctx) throws Exception // 当客户端断开连接的时候触发
    {
        System.out.println("client:" + ctx.channel().id() + " leave server");
    }

    public void channelRead(ChannelHandlerContext ctx, Object msg)
            throws Exception // 当客户端发送数据到服务器会触发
    {
        SocketModel message = (SocketModel) msg;

        switch (message.getType()) {
        case TypeProtocol.TYPE_LOGIN:
            LoginDispatch.getInstance().dispatch(ctx, message);
            break;
            
        case TypeProtocol.TYPE_USER:
            //UserDispatch.getInstance().dispatch(ctx, message);
            break;
            
        case TypeProtocol.TYPE_WIZARD:
            //WizardDispatch.getInstance().dispatch(ctx, message);
            break;
            
        case TypeProtocol.TYPE_BATTLE:
            BattleDispatch.getInstance().dispatch(ctx, message);
            break;
            
        default:
            break;
        }

    }

    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {

    }
}

package com.netty.server;

import com.netty.decoder.LengthDecoder;
import com.netty.decoder.MessageDecoder;
import com.netty.encoder.MessageEncoder;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class GameServer {
  
  public void bind(int port) throws Exception
  {
    //Netty内部都是通过线程在处理各种数据，EventLoopGroup就是用来管理调度他们的，
    //注册Channel，管理他们的生命周期 
    //服务器端需要指定两个 EventLoopGroup, 一个是 bossGroup, 用于处理客户端的连接请求; 
    //另一个是 workerGroup, 用于处理与各个客户端连接的 IO 操作.
    EventLoopGroup bossGroup = new NioEventLoopGroup();
    EventLoopGroup workGroup = new NioEventLoopGroup();
    try
    {
      ServerBootstrap b = new ServerBootstrap();   //server 引导程序
      
      b.group(bossGroup, workGroup)
      .channel(NioServerSocketChannel.class)    //指定 Channel类型. 因为是服务器端使用NioServerSocketChannel.
      .option(ChannelOption.SO_BACKLOG, 1024)   //客户端连接数为1024
      .childHandler(new ChannelInitializer<SocketChannel>()
          {
            protected void initChannel(SocketChannel ch) throws Exception
            {
              //注册业务handler
              ch.pipeline().addLast(new LengthDecoder(1024, 0, 4, 0, 4));
              ch.pipeline().addLast(new MessageDecoder());
              ch.pipeline().addLast(new MessageEncoder());
              ch.pipeline().addLast(new ServerHandler());
            }
          });
      
      ChannelFuture f = b.bind(port).sync();
      
      if(f.isSuccess())
      {
        System.out.println("Server starts success at port: " + port);
      }
      
      f.channel().closeFuture().sync();
    }
    catch(Exception e)
    {
      e.printStackTrace();
    }
    finally
    {
      bossGroup.shutdownGracefully();
      workGroup.shutdownGracefully();
    }
    
  }
  
  public static void main(String args[]) throws Exception 
  {
    int port = 8080;
    new GameServer().bind(port);
  }
}

我们添加客户端登陆逻辑

using UnityEngine;
using System.Collections.Generic;
using UnityEngine.UI;

public class LoginUI : MonoBehaviour {

    private InputField UserNameInput;
    private InputField PassWordInput;

    void Start()
    {
        UserNameInput = transform.Find("UserName").GetComponent<InputField>();
        PassWordInput = transform.Find("PassWord").GetComponent<InputField>();

        if (PlayerPrefs.GetString("Username") != null && PlayerPrefs.GetString("Username") != "")
        {
            UserNameInput.text = PlayerPrefs.GetString("Username");  //数据持久化
        }
    }

    public void ButtonClick(GameObject click)
    {
        if(click.name.Equals("BtnLogin"))
        {
            if (UserNameInput.text == "")
            {
                return;
            }
            else if (PassWordInput.text == "")
            {
                return;
            }
            else
            {
                SocketModel LoginRequest = new SocketModel();
                LoginRequest.SetType(TypeProtocol.TYPE_LOGIN);
                LoginRequest.SetArea(LoginProtocol.Area_LoginRequest);
                LoginRequest.SetCommand(0);
                List<string> message = new List<string>();
                message.Add(UserNameInput.text);
                message.Add(PassWordInput.text);
                LoginRequest.SetMessage(message);
                MainClient.instance.SendMsg(LoginRequest);
            }
        }
        if (click.name.Equals("BtnRegister"))
        {
            //用户注册
        }
    }    
}

最后新建一个gameobject，将MainClient赋给它，将之做成prefab

using UnityEngine;
using System.Net.Sockets;
using System;
using System.IO;
using ProtoBuf;

public class MainClient : MonoBehaviour {

    private const string HOST = "192.168.5.141";  //服务器IP
    private const int PORT = 8080;
    public static MainClient instance;
    public static TcpClient client;

    private byte[] receiveData;
    private int len;     //消息长度
    private bool isHead;
    private SocketModel message;

    void Awake()
    {
        if (instance == null)
        {
            instance = this;
            DontDestroyOnLoad(this.gameObject);
        }
    }

    // Use this for initialization
    void Start ()
    {
        if (client == null)
        {
            Connect();
        }

        isHead = true;
        receiveData = new byte[800];
        ///在start里面开始异步接收消息
        client.GetStream().BeginRead(receiveData, 0, 800, ReceiveMsg, client.GetStream());
    }

    public void SendMsg(SocketModel socketModel)
    {
        byte[] msg = Serial(socketModel);
        //消息体结构：消息体长度+消息体
        byte[] data = new byte[4 + msg.Length];
        IntToBytes(msg.Length).CopyTo(data, 0);
        msg.CopyTo(data, 4);
        client.GetStream().Write(data, 0, data.Length);
    }

    public void ReceiveMsg(IAsyncResult ar)   //异步接收消息
    {
        NetworkStream stream = (NetworkStream)ar.AsyncState;
        stream.EndRead(ar);
        
        if(isHead)     //读取消息体的长度
            {
            byte[] lenByte = new byte[4];
            System.Array.Copy(receiveData, lenByte, 4);
            len = ByteToInt(lenByte, 0);
            isHead = false;
        }
        if(!isHead)    //读取消息体内容
        {
            byte[] msgByte = new byte[len];
            //ConstrainedCopy： sourceArray,int sourceIndex,Array destinationArray,    
            //int destinationIndex,int length
            System.Array.ConstrainedCopy(receiveData, 4, msgByte, 0, len);  
            isHead = true;
            len = 0;
            message = DeSerial(msgByte);
        }

        stream.BeginRead(receiveData, 0, 800, ReceiveMsg, stream);

        switch (message.GetCommand())
        {
            case LoginProtocol.Login_Succeed:
                Debug.Log("Login_Succeed");
                break;
        
            case LoginProtocol.Login_InvalidPassword:
                Debug.Log("InvalidPassword");
                break;

            default:
                Debug.Log("TMT");
                break;
        }
    }

    private byte[] Serial(SocketModel socketModel)  //将SocketModel转化成字节数组
    {
        using (MemoryStream ms = new MemoryStream())
        {
            Serializer.Serialize<SocketModel>(ms, socketModel);
            byte[] data = new byte[ms.Length];
            ms.Position = 0;
            ms.Read(data, 0, data.Length);
            return data;
        }
    }

    private SocketModel DeSerial(byte[] msg)  //将字节数组转化成我们的消息类型SocketModel
    {
        using (MemoryStream ms = new MemoryStream())
        {
            ms.Write(msg, 0, msg.Length);
            ms.Position = 0;
            SocketModel socketModel = Serializer.Deserialize<SocketModel>(ms);
            return socketModel;
        }
    }

    public static int ByteToInt(byte[] data, int offset)
    {
        int num = 0;
        for(int i = offset; i < offset + 4; i++)
        {
            num <<= 8;
            num |= (data[i] & 0xff);
        }
        return num;
    }

    public static byte[] IntToBytes(int num)
    {
        byte[] bytes = new byte[4];
        for (int i = 0; i < 4; i++)
        {
            bytes[i] = (byte)(num >> (24 - i * 8));
        }
        return bytes;
    }

    void OnApplicatonQuit()
    {
        client.Close();
    }

    public void Connect()
    {
        client = new TcpClient();
        try
        {
            client.Connect(HOST, PORT);
        }
        catch(Exception e)
        {
            Debug.LogException(e);
            client.Close();
        }
    }

}