AgileEAS.NET SOA 中间件平台.Net Socket通信框架-完整应用例子-在线聊天室系统-代码解析-低调大师

AgileEAS.NET SOA 中间件平台.Net Socket通信框架-完整应用例子-在线聊天室系统-代码解析

2017-11-05 461

一、AgileEAS.NET SOA中间件Socket/Tcp框架介绍

在文章AgileEAS.NET SOA 中间件平台.Net Socket通信框架-介绍一文之中我们对AgileEAS.NET SOA中间Socket/Tcp框架进行了总体的介绍，我们知道

AgileEAS.NET SOA中间件Socket/Tcp框架是一套Socket通信的消息中间件：

二、多人在线聊天室系统

在文章AgileEAS.NET SOA 中间件平台.Net Socket通信框架-简单例子-实现简单的服务端客户端消息应答给大家实例介绍了有关于AgileEAS.NET SOA 中间件Socket通信框架的简单应用之后，我们通过文章AgileEAS.NET SOA 中间件平台.Net Socket通信框架-完整应用例子-在线聊天室系统-下载配置向大家展示了一个完整成熟的.NET Socket 通信框架的应用案例，一个从在线聊天室系统，通过文章向大家讲解了如何下载和编译安案例源代码、以及如何配置服务端和客户段。

相对于简单的客户端==》服务端消息请求与应答的例子而言，在线多人聊天室系统的复杂度都要超过客户端==》服务端消息请求例子N多倍，但是限于文章篇幅的原因，我们没有在文章AgileEAS.NET SOA 中间件平台.Net Socket通信框架-完整应用例子-在线聊天室系统-下载配置这中为大家介绍这个案例的具体代码。

下面我将为大家介绍这个案例的关键代码及阅读、理解、修改完善所需要注意的地方。

三、关于代码编译环境及其他的地些设置

本案例的源代码在下载压缩包的Code目录之中，所有的引用AgileEAS.NET SOA 中间件平台的程序集及客户端、服务端运行所必须的文件都在下载压缩包的Publish目录之中，所有项目的编译输出路径也都是在Publish目录，也就是所有项目不管是在Debug编译环境还是在Release编译环境都是输出在Publish目录之中，有关具体的设置请看下图：

四、解决方案之中的项目说明

ChatRoom解决方案之是共有ChatRoom.Entities、ChatRoom.BLL.Contracts、ChatRoom.BLL.Host、ChatRoom.Messages、ChatRoom.Socket、ChatingRoom.MainClient、ChatingRoom.UserManage共七个项目，其中：

ChatRoom.Entities：是聊天室注册用启的数据存储实体，其中只包括一个实体User，即注册用户信息。

ChatRoom.BLL.Contracts：为用户管理、登录验证、密码找回修改等功能的分布式服务定义契约，其中仅包括一个服务契约定义IUserService（用户服务）。

ChatRoom.BLL.Host：为ChatRoom.BLL.Contracts所定义的服务契约的功能实现。

ChatRoom.Messages：服务端与客户端通信消息的定义，包括聊天消息、用户登录请求、登录结果、在线用户清单消息、用户上下线状态通知消息。

ChatRoom.Socket：为服务端的业务代码、包括AgileEAS.NET SOA服务进程的SocketService插件以及服务端收到客户端各种消息的消息处理器代码。

ChatingRoom.MainClient：为客户端代码、包括客户段界面以及客户端收到通信消息的消息处理器代码。

五、关于SOA服务SocketService插件

如果对比AgileEAS.NET SOA 中间件平台.Net Socket通信框架-简单例子-实现简单的服务端客户端消息应答，细心的朋友一定会发现本案例中没有了类似Socket.Demo.Server功能的项目，而是多了ChatRoom.Socket项目。

关于这个问题就涉及到了AgileEAS.NET SOA 中间件平台的SOA服务实例及Socket框架的设计，在SOA服务实例本身被设计成为了一个可以运行WCF、WS、Socket等各吃点通信及其他应用服务的运行容器，那么我们的Socket服务端也可以在此服务实例之中运行，同时在我们的AgileEAS.NET SOA中间件平台的微内核程序集EAS.MicroKernel.dll之中定义了SocketService插件的实现标准：

 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using EAS.Distributed; 
   
namespace EAS.Sockets 
{ 
    /// <summary> 
    /// SocketService服务接口定义。 
    /// </summary> 
    /// <remarks> 
    /// 一个Socket服务器可以承载多种/个Socket服务，一个Socket服务处理一种业务。 
    /// 如IM SocketService 处理IM相关的即时通讯业务，而WF SocketService 处理工作流相关的服务，这两种Socket服务可以同时运行在一个Socket服务器之中。 
    /// </remarks> 
    public interface ISocketService:IAppService 
    { 
        /// <summary> 
        /// 使用ServerEngine初始化SocketService。 
        /// </summary> 
        /// <param name="socketServer">Socket服务器对象。</param> 
        void Initialize(ISocketServerBase socketServer); 
    } 
} 
 

ISocketService接口中定义了一个初始化方法：void Initialize(ISocketServerBase socketServer)，用于SOA服务实例完成对ISocketService实例的初始化，其中传入参数为一个ISocketServerBase对象，其本质的含义为SOA服务实例调用ISocketService实例对象把SOA服务实例之中的SocketServer对象做为参数传入，那么我们就可以在ISocketService对象之中针对SocketServer做一些初始化工作，其中最重要的工作是，挂载与之相关的消息对象器IMessageHandler。

ChatRoom.Socket项目之中包括了一个ISocketService的实现ChatRoom.Socket.MessageService

 
using EAS.Loggers; 
using EAS.Sockets; 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
   
namespace ChatRoom.Socket 
{ 
    /// <summary> 
    /// 聊天室消息服务，由EAS.SOA.Server.Exe引擎的Socket初始化程序。 
    /// </summary> 
    public class MessageService : ISocketService 
    { 
        #region ISocketService 成员 
   
        public void Initialize(EAS.Sockets.ISocketServerBase socketServer) 
        { 
            try 
            { 
                socketServer.AddHander(new ChatMessageHandler()); 
                socketServer.AddHander(new LoginMessageHandler()); 
                ChatRoomContext.Instance.SocketServer = socketServer; 
            } 
            catch (System.Exception exc) 
            { 
                Logger.Error(exc); 
            } 
   
            socketServer.SessionStarted += socketServer_SessionStarted; 
            socketServer.SessionAbandoned += socketServer_SessionAbandoned; 
        } 
   
        void socketServer_SessionStarted(object sender, NetSessionEventArgs e) 
        { 
            Logger.Info(string.Format("Session:{0}  Started", e.Session.SessionID)); 
        } 
   
        void socketServer_SessionAbandoned(object sender, NetSessionEventArgs e) 
        { 
            Logger.Info(string.Format("Session:{0}  Abandoned", e.Session.SessionID)); 
        } 
   
        //void socketServer_MessagerReceived(object sender, EAS.Sockets.MessageEventArgs e) 
        //{ 
        //    Logger.Info(string.Format("MessagerReceived:{0}", e.Message.ToString())); 
        //} 
   
   
        //void socketServer_MessageSend(object sender, EAS.Sockets.MessageEventArgs e) 
        //{ 
        //    Logger.Info(string.Format("MessageSend:{0}", e.Message.ToString())); 
        //} 
   
        public void Start() 
        { 
   
        } 
   
        public void Stop() 
        { 
   
        } 
   
        #endregion 
    } 
} 
 

其中最重要的代码是Initialize函数之中挂载ChatMessage、LoginMessage两个消息的消息处理器代码:

 
socketServer.AddHander(new ChatMessageHandler()); 
socketServer.AddHander(new LoginMessageHandler());

Socket插件服务的定义除了代码定义之外，还需要在AgileEAS.NET SOA 中间件有SOA服务实例配置文件之中进行定义，因为SOA服务实例程序有32位和64位版本，分别为EAS.SOA.Server.exe和EAS.SOA.Server.x64.exe，所以要根据自身的机器条件和自己喜欢的运行环境修改EAS.SOA.Server.exe.config或EAS.SOA.Server.x64.exe.config：

 
<?xml version="1.0"?> 
<configuration> 
  <configSections> 
    <section name="eas" type="EAS.ConfigHandler,EAS.MicroKernel"/> 
  </configSections> 
  <!--支持混合程序集--> 
  <startup useLegacyV2RuntimeActivationPolicy="true"> 
    <supportedRuntime version="v4.0"/> 
  </startup> 
  <eas> 
    <configurations> 
      <item name="Key"  value="Value"/> 
    </configurations> 
    <appserver> 
      <channel> 
        <wcf enable="true"> 
          <config tcpPort="6907" httpPort="6908"/> 
          <serviceThrottling maxConcurrentCalls="128" maxConcurrentInstances="128" maxConcurrentSessions="256"/> 
          <wcfServices> 
            <wcfService key="Key" type="Value"/> 
          </wcfServices> 
        </wcf> 
        <socket enable ="true"> 
          <config tcpPort="6906"/> 
          <serviceThrottling maxConcurrence="8196"/> 
          <socketServices> 
            <socketService key="MessageService" type="ChatRoom.Socket.MessageService,ChatRoom.Socket"/> 
          </socketServices> 
        </socket> 
      </channel> 
      <appServices> 
        <service key="Key" type="Value"/> 
      </appServices> 
    </appserver> 
    <objects> 
      <!--数据访问提供者对象--> 
      <object name="DbProvider" assembly="EAS.Data.Provider" type="EAS.Data.Access.SqliteProvider" LifestyleType="Thread"> 
        <property name="ConnectionString" type="string" value="Data Source=..\db\Chat.db;" /> 
      </object> 
      <!--数据访问器--> 
      <object name="DataAccessor" assembly="EAS.Data" type="EAS.Data.Access.DataAccessor" LifestyleType="Thread"> 
        <property name="DbProvider" type="object" value="DbProvider"/> 
        <property name="Language" type="object" value="SqliteLanguage"/> 
      </object> 
      <!--ORM访问器--> 
      <object name="OrmAccessor" assembly="EAS.Data" type="EAS.Data.ORM.OrmAccessor" LifestyleType="Thread"> 
        <property name="DataAccessor" type="object" value="DataAccessor"/> 
      </object> 
      <!--本地服务桥--> 
      <object name="ServiceBridger" assembly="EAS.MicroKernel" type="EAS.Services.DirectServiceBridger" LifestyleType="Singleton" /> 
      <!--Linq查询语言--> 
      <object name="SqliteLanguage" assembly="EAS.Data.Provider" type="EAS.Data.Linq.SqliteLanguage" LifestyleType="Thread"/> 
      <!--日志记录--> 
      <object name="Logger" assembly="EAS.MicroKernel" type="EAS.Loggers.TextLogger" LifestyleType="Singleton"> 
        <property name="Path" type="string" value="..\logs" /> 
      </object> 
      <!--分布式服务上下文参数定义。--> 
      <object name="EAS.Distributed.ServiceContext" type="EAS.Distributed.ServiceContext,EAS.SOA.Server" LifestyleType="Singleton"> 
        <property name="EnableLogging" type="bool" value="false" /> 
      </object> 
    </objects> 
  </eas> 
  <startup> 
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/> 
  </startup> 
</configuration> 
 

需要在 <eas/appserver/channel/socket/socketServices>配置节中之中增加了一端：

     1: <socketService key="MessageService" type="ChatRoom.Socket.MessageService,ChatRoom.Socket"/>
 

用于告诉SOA服务实例在启动的时候加载并初始化类型为“ChatRoom.Socket.MessageService,ChatRoom.Socket”的SocketService。

六、注册用户数据库及Sqlite介绍

在线多人聊到室系统之中有登录、用户，那么也就必须有数据库，要存储这些注册用户的信息，为了方便这案例的使用和部署，我们选择了轻量级的Sqlite文件数据库，其特别是简单方便，对于小数据量存储非常好用，有关于Sqlite的知识请自己从网上学习，本人使用的sqlite管理工具为SQLite Expert。

注册用户表结构如下：

Ø CHAT_USER（聊天室用户表）

表名	CHAT_USER
所有者	dbo
列名	数据类型	空	说明
LOGINID	NVARCHAR(64)	N	登录ID
Name	NVARCHAR(64)	Y	用户名
PASSWORD	NVARCHAR(64)	Y	密码
MAIL	VARCHAR(128)	Y	邮件
SafeKey	NVARCHAR(64)	Y	密码找回问题
SafeResult	NVARCHAR(64)	Y	密码找回答案
STATE	BIT	Y	状态
REGTIME	DATETIME	Y	注册时间

有关针对CHAT_USER表的数据访问使用了AgileEAS.NET SOA中间件平台的ORM及与之配套的Linq进行访问，其对应的ORM实体对象为ChatRoom.Entities.User：

 
using System; 
using System.Linq; 
using System.ComponentModel; 
using System.Data; 
using EAS.Data; 
using EAS.Data.Access; 
using EAS.Data.ORM; 
using EAS.Data.Linq; 
using System.Runtime.Serialization; 
   
namespace ChatRoom.Entities 
{ 
   /// <summary> 
   /// 实体对象 User(聊天室用户表)。 
   /// </summary> 
   [Serializable()] 
   [Table("CHAT_USER","聊天室用户表")] 
   partial class User: DataEntity<User>, IDataEntity<User> 
   { 
       public User() 
       { 
           this.RegTime = DateTime.Now; 
       } 
        
       protected User(SerializationInfo info, StreamingContext context) 
           : base(info, context) 
       { 
       } 
        
       #region O/R映射成员 
   
       /// <summary> 
       /// 登录ID 。 
       /// </summary> 
       [Column("LOGINID","登录ID"),DataSize(64),PrimaryKey] 
       [DisplayName("登录ID")] 
       public string LoginID 
       { 
           get; 
           set; 
       } 
   
       /// <summary> 
       /// 用户名 。 
       /// </summary> 
       [Column("Name","用户名"),DataSize(64)] 
       [DisplayName("用户名")] 
       public string Name 
       { 
           get; 
           set; 
       } 
   
       /// <summary> 
       /// 密码 。 
       /// </summary> 
       [Column("PASSWORD","密码"),DataSize(64)] 
       [DisplayName("密码")] 
       public string Password 
       { 
           get; 
           set; 
       } 
   
       /// <summary> 
       /// 邮件 。 
       /// </summary> 
       [Column("MAIL","邮件"),DataSize(128)] 
       [DisplayName("邮件")] 
       public string Mail 
       { 
           get; 
           set; 
       } 
   
       /// <summary> 
       /// 密码找回问题 。 
       /// </summary> 
       [Column("SafeKey","密码找回问题"),DataSize(64)] 
       [DisplayName("密码找回问题")] 
       public string SafeKey 
       { 
           get; 
           set; 
       } 
   
       /// <summary> 
       /// 密码找回答案 。 
       /// </summary> 
       [Column("SafeResult","密码找回答案"),DataSize(64)] 
       [DisplayName("密码找回答案")] 
       public string SafeResult 
       { 
           get; 
           set; 
       } 
   
       /// <summary> 
       /// 状态 。 
       /// </summary> 
       [Column("STATE","状态")] 
       [DisplayName("状态")] 
       public int State 
       { 
           get; 
           set; 
       } 
   
       /// <summary> 
       /// 注册时间 。 
       /// </summary> 
       [Column("REGTIME","注册时间")] 
       [DisplayName("注册时间")] 
       public DateTime RegTime 
       { 
           get; 
           set; 
       } 
        
       #endregion 
   } 
} 
 

针对CHAT_USER表的用户登录、注册验证、找回密码等代码的实现在ChatRoom.BLL.Host.UserService之中：

 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using EAS.Services; 
using ChatRoom.Entities; 
using EAS.Data.ORM; 
using EAS.Data.Linq; 
   
namespace ChatRoom.BLL 
{ 
    /// <summary> 
    /// 账号服务。 
    /// </summary> 
    [ServiceBind(typeof(IUserService))] 
    public class UserService : IUserService 
    { 
        public void AddUser(User user) 
        { 
            using (DbEntities db = new DbEntities()) 
            { 
                user.RegTime = DateTime.Now; 
                int count  = db.Users.Where(p => p.LoginID == user.LoginID).Count(); 
                if (count>0) 
                { 
                    throw new System.Exception(string.Format("已经存在账号为{0}的用户", user.LoginID)); 
                } 
   
                db.Users.Insert(user); 
            } 
        } 
   
        public User UserLogin(string loginID, string password) 
        { 
            using (DbEntities db = new DbEntities()) 
            { 
                var v = db.Users.Where(p => p.LoginID == loginID).FirstOrDefault(); 
                if (v == null) 
                { 
                    throw new System.Exception(string.Format("不存在登账号称为{0}的用户", loginID)); 
                } 
   
                if (v.Password != password) 
                { 
                    throw new System.Exception("密码不正确定"); 
                } 
   
                return v; 
            } 
        } 
   
        public bool UserExists(string loginID) 
        { 
            using (DbEntities db = new DbEntities()) 
            { 
                int count = db.Users.Where(p => p.LoginID == loginID).Count(); 
                return count > 0; 
            } 
        } 
   
        public string GetSafeKey(string loginID) 
        { 
            using (DbEntities db = new DbEntities()) 
            { 
                var v = db.Users.Where(p => p.LoginID == loginID).FirstOrDefault(); 
                if (v != null) 
                { 
                    return v.SafeKey; 
                } 
                else 
                { 
                    return string.Empty; 
                } 
            } 
        } 
   
        public string GetSafeResult(string loginID) 
        { 
            using (DbEntities db = new DbEntities()) 
            { 
                var v = db.Users.Where(p => p.LoginID == loginID).FirstOrDefault(); 
                if (v != null) 
                { 
                    return v.SafeResult; 
                } 
                else 
                { 
                    return string.Empty; 
                } 
            } 
        } 
   
   
        public void ChangePassword(string loginID, string password) 
        { 
            using (DbEntities db = new DbEntities()) 
            { 
                db.Users.Update(p => new User { Password = password }, p => p.LoginID == loginID); 
            } 
        } 
    } 
} 
 

七、关于在线用户清单的管理

系统中如何知道目有那些用户在线，参考以上六节的内容我们可以知道，用户的主键是账号ID，与SocketServer之中在线清单NetSession没有特定的关系，那么如何建立这种关系，多而得到目前有那些用户在线呢，在ChatRoom.Socket项目之中我们定义了LoginInfo对象：

 
using EAS.Sockets; 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using ChatRoom.Entities; 
   
namespace ChatRoom.Socket 
{ 
    /// <summary> 
    /// 消息信息类。 
    /// </summary> 
    public class LoginInfo 
    { 
        /// <summary> 
        /// 登录账号。 
        /// </summary> 
        public string LoginID 
        { 
            get; 
            set; 
        } 
   
        /// <summary> 
        /// 用户对象。 
        /// </summary> 
        public User User 
        { 
            get; 
            set; 
        } 
   
        /// <summary> 
        /// 会话。 
        /// </summary> 
        public NetSession Session { get; set; } 
    } 
   
} 
 

我们看源代码就可以明确的知道，他是一个用于建立NetSession与登录用户LoginID/User对象的影射类，即某个登录用户是在那个网络会话这上，我们在ChatRoom.Socket项目之中定义了一个ChatRoomContext上下文辅助类：

 
using EAS.Sockets; 
using ChatRoom.Messages; 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Runtime.CompilerServices; 
   
namespace ChatRoom.Socket 
{ 
    class ChatRoomContext 
    { 
        #region 单例模式 
   
        private static object m_Lock = new object(); 
        private static ChatRoomContext m_Instance = null; 
   
        public static ChatRoomContext Instance 
        { 
            get 
            { 
                if (m_Instance == null) 
                { 
                    lock (m_Lock) 
                    { 
                        if (m_Instance == null) 
                        { 
                            m_Instance = new ChatRoomContext(); 
                        } 
                    } 
                } 
   
                return m_Instance; 
   
            } 
        } 
   
        ChatRoomContext() 
        { 
            this.m_LoginInfos = new List<LoginInfo>(); 
            this.m_OnLineMessage = new OnLineMessage(); 
        } 
   
        #endregion 
   
        ISocketServerBase m_SocketServer = null; 
        List<LoginInfo> m_LoginInfos = null; 
        OnLineMessage m_OnLineMessage = null; 
   
        /// <summary> 
        /// Socket服务器。 
        /// </summary> 
        public ISocketServerBase SocketServer 
        { 
            get 
            { 
                return this.m_SocketServer; 
            } 
            set 
            { 
                this.m_SocketServer = value; 
            } 
        } 
   
        /// <summary> 
        /// 会话集合。 
        /// </summary> 
        public List<LoginInfo> LoginInfos 
        { 
            get 
            { 
                return this.m_LoginInfos; 
            } 
        } 
   
        /// <summary> 
        /// 在线清单信息。 
        /// </summary> 
        public OnLineMessage OnLineMessage 
        { 
            get 
            { 
                return this.m_OnLineMessage; 
            } 
        } 
         
        /// <summary> 
        /// 根据Socket会话求上下文信息。 
        /// </summary> 
        /// <param name="sessionID"></param> 
        /// <returns></returns> 
        public LoginInfo GetLoginInfo(Guid sessionID) 
        { 
            LoginInfo v = null; 
            lock (this.m_LoginInfos) 
            { 
                v = this.m_LoginInfos.Where(p => p.Session.SessionID == sessionID).FirstOrDefault(); 
            } 
   
            return v; 
        } 
   
        /// <summary> 
        /// 根据账号求上下文信息。 
        /// </summary> 
        /// <param name="LoginID"></param> 
        /// <returns></returns> 
        public LoginInfo GetLoginInfo(string LoginID) 
        { 
            LoginInfo v = null; 
            lock (this.m_LoginInfos) 
            { 
                v = this.m_LoginInfos.Where(p => p.LoginID == LoginID).FirstOrDefault(); 
            } 
   
            return v; 
        }         
        
        /// <summary> 
        /// 登录注册上下文。 
        /// </summary> 
        /// <param name="info"></param> 
        public void Add(LoginInfo info) 
        { 
            lock (this.m_LoginInfos) 
            { 
                int count = this.m_LoginInfos.Where 
                    (p => p.Session.SessionID == info.Session.SessionID 
                        && p.LoginID == info.LoginID 
                    ).Count(); 
   
                if (count == 0) 
                { 
                    this.m_LoginInfos.Add(info); 
                    info.Session.ClientClosed += Session_ClientClosed; 
                } 
            } 
   
            this.CreateOnLineMesssage(); 
        } 
   
        /// <summary> 
        /// 链接关机上下文。 
        /// </summary> 
        /// <param name="session"></param> 
        public void Remove(Guid session) 
        { 
            lock (this.m_LoginInfos) 
            { 
                LoginInfo info = this.m_LoginInfos.Where(p => p.Session.SessionID == session).FirstOrDefault(); 
   
                if (info != null) 
                { 
                    this.m_LoginInfos.Remove(info); 
                    info.Session.ClientClosed -= new EventHandler(Session_ClientClosed); 
                } 
            } 
        } 
   
        /// <summary> 
        /// 生成在线清单信息。 
        /// </summary> 
        [MethodImpl(MethodImplOptions.Synchronized)] 
        void CreateOnLineMesssage() 
        { 
            this.m_OnLineMessage = new OnLineMessage(); 
            lock (this.m_LoginInfos) 
            { 
                foreach (var item in this.m_LoginInfos) 
                { 
                    OnLine onLine = new OnLine(); 
                    onLine.LoginID = item.LoginID; 
                    onLine.Name = item.User.Name; 
                    this.m_OnLineMessage.OnLines.Add(onLine); 
                } 
            } 
        } 
   
        /// <summary> 
        /// 客户段连接断开，用户下线。 
        /// </summary> 
        /// <param name="sender"></param> 
        /// <param name="e"></param> 
        private void Session_ClientClosed(object sender, EventArgs e) 
        { 
            NetSession session = sender as NetSession; 
            LoginInfo loginInfo = this.GetLoginInfo(session.SessionID); 
            this.Remove(session.SessionID); 
            this.CreateOnLineMesssage(); 
   
            //向其他用户发生下线通稿。 
            UserStateMessage userState = new UserStateMessage(); 
            userState.OnLine = false; 
            userState.User = loginInfo.User; 
   
            lock (this.m_LoginInfos) 
            { 
                foreach (var item in this.m_LoginInfos) 
                { 
                    ChatRoomContext.Instance.SocketServer.Send(item.Session.SessionID, userState); 
                } 
            } 
        } 
    } 
} 
 

其中public List<LoginInfo> LoginInfos属性即为当前在线的用户与网络会话（NetSession）的映射清单。

八、服务端处理登录/上线、下线流程

客户端在处理用户登录时执行以下流程：

执行本流程的具体代码在ChatRoom.Socket项目之中的登录消息处理器LoginMessageHandler之中：

 
using EAS.Sockets; 
using EAS.Sockets.Messages; 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Data; 
using EAS.Data.Access; 
using ChatRoom.Messages; 
using EAS.Loggers; 
using ChatRoom.BLL; 
using ChatRoom.Entities; 
using EAS.Services; 
   
namespace ChatRoom.Socket 
{ 
    /// <summary> 
    /// 用户登录消息处理程序。 
    /// </summary> 
    public class LoginMessageHandler : AbstractMessageHandler<LoginMessage> 
    { 
        public override void Process(NetSession context, uint instanceId, LoginMessage message) 
        { 
            LoginResultMessage result = new LoginResultMessage(); 
            IUserService services = ServiceContainer.GetService<IUserService>(); 
            try 
            { 
                result.User = services.UserLogin(message.LoginID, message.PassWord); 
            } 
            catch (System.Exception exc) 
            { 
                result.Error = exc.Message; 
            } 
   
            //X.登录失败。 
            if (!string.IsNullOrEmpty(result.Error)) 
            { 
                context.Reply(result); 
                return; 
            } 
   
            //A.登录成功，做如下处理 
             
            #region //1.向其发送登录成功消息 
   
            context.Reply(result); 
   
            #endregion 
   
            #region //2.向其他用户发送上线通告 
   
            UserStateMessage userState = new UserStateMessage(); 
            userState.OnLine = true; 
            userState.User = result.User; 
   
            var vList = ChatRoomContext.Instance.LoginInfos; 
            if (vList.Count > 0) 
            { 
                lock (vList) 
                { 
                    foreach (var item in vList) 
                    { 
                        ChatRoomContext.Instance.SocketServer.Send(item.Session.SessionID, userState); 
                    } 
                } 
            } 
   
            #endregion 
   
            #region //3.注册到上下文环境 
   
            LoginInfo loginInfo = new LoginInfo(); 
            loginInfo.LoginID = message.LoginID; 
            loginInfo.User = result.User; 
            loginInfo.Session = context; 
            ChatRoomContext.Instance.Add(loginInfo); 
            #endregion 
   
            #region //4.向客户段发送在线清单 
   
            context.Reply(ChatRoomContext.Instance.OnLineMessage); 
   
            #endregion 
        } 
    } 
} 
 

当客户端下线/断开链接之后服务端会向其他在线的客户段发送一个UserStateMessage状态通告消息，告诉其他在线客户端，某人已经下线。

九、服务端聊天消息转发流程

当服务端接收到客户端发来的聊天消息之后，如何转发呢，请参见下图：

关于这一部分的代码请参考ChatRoom.Socket项目之中的聊天消息处理器ChatMessageHandler之中：：

 
using EAS.Sockets; 
using EAS.Sockets.Messages; 
using ChatRoom.Messages; 
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
   
namespace ChatRoom.Socket 
{ 
    /// <summary> 
    /// 服务器收到聊天消息处理程序。 
    /// </summary> 
    public class ChatMessageHandler : AbstractMessageHandler<ChatMessage> 
    { 
        public override void Process(NetSession context, uint instanceId, ChatMessage message) 
        { 
            if (!message.Secret)  //广播消息。 
            { 
                lock (ChatRoomContext.Instance.LoginInfos) 
                { 
                    foreach (var p in ChatRoomContext.Instance.LoginInfos) 
                    { 
                        context.Server.Send(p.Session.SessionID, message); 
                    } 
                } 
            } 
            else 
            { 
                LoginInfo loginInfo = ChatRoomContext.Instance.GetLoginInfo(message.To); 
                if (loginInfo != null) 
                { 
                    context.Server.Send(loginInfo.Session.SessionID, message); 
                } 
            } 
        } 
    } 
} 
 

关于这一部分的代码请参考：

十、客户端界面的异步处理

因为AgileEAS.NET SOA 中间件平台Socket 通信框架何用的是异步消息处理模式，所以当客户端收到服务器发回的消息的时候其工作线程与界面UI线呢不一致，那么UI界面处理的时候我们就需要异步处理，比如在显示收到的ChatMessage的时候：

 
/// <summary> 
/// 显示聊天消息。 
/// </summary> 
/// <param name="chat"></param> 
internal void ShowMessage(ChatMessage chat) 
{ 
    Action action = () => 
    { 
        string form = "你"; 
        string to = "你"; 
   
        //其他人。 
        if (chat.From != AppContext.User.LoginID) 
        { 
            var v = this.m_OnLines.Where(p => p.LoginID == chat.From).FirstOrDefault(); 
            if (v != null) 
                form = v.Name; 
            else 
                form = chat.From; 
        } 
   
        //所有人 
        if (string.IsNullOrEmpty(chat.To)) 
        { 
            to = DEFAULT_ALL_USER; 
        } 
        else  // 
        { 
            var v = this.m_OnLines.Where(p => p.LoginID == chat.To).FirstOrDefault(); 
            if (v != null) 
                to = v.Name; 
            else 
                to = chat.From; 
        } 
   
        string face = string.IsNullOrEmpty(chat.Face) ? string.Empty : string.Format("{0}地", chat.Face); 
        string Text = string.Format("【{0}】{1}{2}对【{3}】说：{4}", form, chat.Action, face, to, chat.Content); 
   
        ListViewItem item = new ListViewItem(new string[] { string.Empty, Text }); 
        item.ForeColor = Color.FromArgb(chat.Color); 
        item.Tag = chat.From; 
   
        if (chat.Secret)  //密聊 
        { 
            this.lvSecret.Items.Add(item); 
            this.lvSecret.EnsureVisible(item.Index); 
        } 
        else 
        { 
            this.lvAll.Items.Add(item); 
            this.lvAll.EnsureVisible(item.Index); 
        } 
    }; 
   
    this.Invoke(action); 
} 
 

我们定义了一个名称为action的匿名方法，使用this.Invoke(action)进行界面的消息显示。

十一、联系我们

为了完善、改进和推广AgileEAS.NET而成立了敏捷软件工程实验室，是一家研究、推广和发展新技术，并致力于提供具有自主知识产权的业务基础平台软件，以及基于业务基础平台了开发的管理软件的专业软件提供商。主要业务是为客户提供软件企业研发管理解决方案、企业管理软件开发，以及相关的技术支持，管理及技术咨询与培训业务。

AgileEAS.NET平台自2004年秋呱呱落地一来，我就一直在逐步完善和改进，也被应用于保险、医疗、电子商务、房地产、铁路、教育等多个应用，但一直都是以我个人在推广，2010年因为我辞职休息，我就想到把AgileEAS.NET推向市场，让更多的人使用。

我的技术团队成员都是合作多年的老朋友，因为这个平台是免费的，所以也没有什么收入，都是由程序员的那种理想与信念坚持，在此我感谢一起奋斗的朋友。

团队网站：http://www.agilelab.cn，

AgileEAS.NET网站：http://www.smarteas.net

官方博客:http://eastjade.cnblogs.com

QQ:47920381,AgileEAS.NET

QQ群：113723486（AgileEAS SOA 平台）/上限1000人

199463175（AgileEAS SOA 交流）/上限1000人

120661978（AgileEAS.NET 平台交流）/上限1000人

212867943（AgileEAS.NET研究）/上限500人

147168308（AgileEAS.NET应用）/上限500人

172060626（深度AgileEAS.NET平台）/上限500人

116773358（AgileEAS.NET 平台）/上限500人

125643764（AgileEAS.NET探讨）/上限500人

193486983（AgileEAS.NET 平台）/上限500人

邮件:james@agilelab.cn,mail.james@qq.com,

电话：18629261335。

本文转自魏琼东博客园博客，原文链接：http://www.cnblogs.com/eastjade/p/3385699.html，如需转载请自行联系原作者

微信关注我们

原文链接：https://yq.aliyun.com/articles/376230

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

怎么界面整合IBM Tivoli

概述 IBM Tivoli是IBM的软件家族，IBM Tivoli Monitoring V6(以下简称ITM)是IBM公司Tivoli管理软件中一个重要的组成部分，在整个Tivoli管理软件中提供基本的系统资源监控功能。 Tivoli在中国市场拥有数量众多的用户，但是随着IT管理软件的发展和中国用户逐渐成熟，Tivoli在使用中的问题也显得更加突出，众多用户在部署Tivoli软件相当长一段时间内，一直无法有效的使用，并且在报表和界面使用习惯等众多方面无法很好的满足国内用户的要求。如何在保护用户原来投资的前提下，更好的满足国内用户的需求，就显得格外重要。软件集成什么是软件集成，软件集成是指为某特定的应用环境架构的工作平台。通俗地说，是为某一特定应用环境提供要解决问题的架构软件的相互接口，为提高工作效率而创造环境。现在许多软件制造商都在把自己的产品进行集成，为客户提供更好的服务。例如，美国微软公司将Windows操作系统软件与Web浏览器集成在一起，使得用户访问因特网更加方便，系统功能得到大大增强。企业管理软件领域，软件集成是指在保留本软件功能的基础上，将其它软件的功能集成到本软...

2017-11-06

545

雷锋网(公众号：雷锋网)·新智驾按：作为自动驾驶汽车中最重要的传感器组成之一，激光雷达因为前者的发展也迎来了一个行业集体向前迈步的高潮。成立于 2011 年的Trilumina 是这个队列里较为突出的玩家之一，它为自动驾驶提供支持的主要方式是以 LiDAR 照明模块替代其扫描系统，不仅尺寸更小、分辨率高、探测距离远，而且成本较低。 Trilumina 总部位于美国新墨西哥州阿尔伯克基，今年 5 月，公司宣布了新一轮 900 万美元的融资，由 Kickstart Seed Fund、Stage 1 Ventures、Cottonwood Technology Fund、DENSO Ventures和Sun Mountain Capital 共同投资。而这只是其从成立至今 2620 万的总投资额中的一部分。 2016 年，B

2017-11-06

594

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Oracle

Oracle Database，又名Oracle RDBMS，或简称Oracle。是甲骨文公司的一款关系数据库管理系统。它是在数据库领域一直处于领先地位的产品。可以说Oracle数据库系统是目前世界上流行的关系数据库管理系统，系统可移植性好、使用方便、功能强，适用于各类大、中、小、微机环境。它是一种高效率、可靠性好的、适应高吞吐量的数据库方案。

JDK

JDK是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心，它包含了JAVA的运行环境（JVM+Java系统类库）和JAVA工具。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。