WCF版的PetShop之三：实现分布式的Membership和上下文传递-阿里云开发者社区

通过上一篇了解了模块内基本的层次划分之后，接下来我们来聊聊PetShop中一些基本基础功能的实现，以及一些设计、架构上的应用如何同WCF进行集成。本篇讨论两个问题：实现分布式的Membership和客户端到服务端上下文（Context）的传递。

一、如何实现用户验证

对登录用户的验证是大部分应用所必需的，对于ASP.NET来说，用户验证及帐号管理实现在成员资格（Membership）模块中。同ASP.NET的其他模块一样，微软在设计Membership的时候，为了实现更好地可扩展性，采用了策略（Strategy）设计模式：将模块相关的功能定义在被称为Provider的抽象类型中，并通过继承它提供具体的Provider。如果这些原生的Provider不能满足你的需求，你也可以通过继承该抽象的Provider，创建自定义的Provider。通过ASP.NET提供的配置，你可以很轻易地把自定义的Provider应用到你的应用之中。在一般情况下，最终的编程人员并不通过Provider调用相关的功能，而是通过一个外观（Facade）类实现对相关功能的调用。

ASP.NET成员资格模块的设计基本上可以通过下面的类图1反映出来：最终的编程人员通过外观类型（Façade Class）Membership调用成员资格相关的功能，比如用户认证、用户注册、修改密码等；Membership通过抽象类MembershipProvider提供所有的功能，至于最终的实现，则定义在一个个具体的MembershipProvider中。基于成员资格信息不同的存储方式，ASP.NET提供了两个原生的MembershipProvider：SqlMembershipProvider和ActiveDirectoryMembershipProvider，前者基于SQL Server数据库，后者基于AD。如果这两个MembershipProvider均不能满足需求，我们还可以自定义MembershipProvider。

图1 ASP.NET Membership 设计原理

我们的案例并不会部署于AD之中，所以不能使用ActiveDirectoryMembershipProvider；直接通过Web服务器进行数据库的存取又不符合上述物理部署的要求（通过应用服务器进行数据库访问），所以SqlMembershipProvider也不能为我们所用。为此需要自定义MembershipProvider，通过WCF服务调用的形式提供成员资格所有功能的实现。我们将该自定义MembershipProvider称为RemoteMembershipProvider。图2揭示了RemoteMembershipProvider实现的原理：RemoteMembershipProvider通过调用WCF服务MembershipService提供对成员资格所有功能的实现；MembershipService则通过调用Membership实现服务；最终的实现还是落在了SqlMembershipProvider这个原生的MembershipProvider上。

图2 RemoteMembershipProvider实现原理

1、服务契约和服务实现

首先来看看MembershipService实现的服务契约的定义。由于MembershipService最终是为RemoteMembershipProvider这个自定义MembershipProvider服务的，所以服务操作的定义是基于MembershipProvider的API定义。MembershipProvider包含两种类型的成员：属性和方法，简单起见，我们可以为MembershipProvider每一个抽象方法定义一个匹配的服务操作；而对于所有属性，完全采用服务端（应用服务器）的MembershipProvider相关属性。在RemoteMembershipProvider初始化的时候通过调用MembershipService获取所有服务端MembershipProvider的配置信息。为此，我们为MembershipProvider的所有属性定义了一个数据契约：MembershipConfigData。在PetShop中，MembershipConfigData和服务契约一起定义在Infrastructures.Service.Interface项目中。

 
using System.Runtime.Serialization; 
using System.Web.Security; 
namespace Artech.PetShop.Infrastructures.Service.Interface 
{ 
    [DataContract(Namespace = "http://www.artech.com/")] 
    public class MembershipConfigData 
    { 
        [DataMember] 
        public  string ApplicationName 
        { get; set; } 
   
        [DataMember] 
        public bool EnablePasswordReset 
        { get; set; } 
   
        [DataMember] 
        public bool EnablePasswordRetrieval 
        { get; set; } 
   
        [DataMember] 
        public int MaxInvalidPasswordAttempts 
        { get; set; } 
   
        [DataMember] 
        public int MinRequiredNonAlphanumericCharacters 
        { get; set; } 
   
        [DataMember] 
        public int MinRequiredPasswordLength 
        { get; set; } 
   
        [DataMember] 
        public int PasswordAttemptWindow 
        { get; set; } 
   
        [DataMember] 
        public MembershipPasswordFormat PasswordFormat 
        { get; set; } 
   
        [DataMember] 
        public string PasswordStrengthRegularExpression 
        { get; set; } 
   
        [DataMember] 
        public bool RequiresQuestionAndAnswer 
        { get; set; } 
   
        [DataMember] 
        public bool RequiresUniqueEmail 
        { get; set; } 
    } 
} 
  

在服务契约中，定义了一个额外的方法GetMembershipConfigData获取服务端MembershipProvider的所有配置信息，而对于服务操作的定义，则与MembershipProvider同名抽象方法相对应。

 
using System.ServiceModel; 
using System.Web.Security; 
namespace Artech.PetShop.Infrastructures.Service.Interface 
{ 
    [ServiceContract(Namespace="http://www.artech.com/")] 
    public interface IMembershipService 
    { 
        [OperationContract] 
        bool ChangePassword(string username, string oldPassword, string newPassword); 
        [OperationContract] 
        bool ChangePasswordQuestionAndAnswer(string username, string password, string newPasswordQuestion, string newPasswordAnswer); 
        [OperationContract] 
        MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status); 
        [OperationContract] 
        bool DeleteUser(string username, bool deleteAllRelatedData); 
        [OperationContract] 
        MembershipUserCollection FindUsersByEmail(string emailToMatch, int pageIndex, int pageSize, out int totalRecords); 
        [OperationContract] 
        MembershipUserCollection FindUsersByName(string usernameToMatch, int pageIndex, int pageSize, out int totalRecords); 
        [OperationContract] 
        MembershipUserCollection GetAllUsers(int pageIndex, int pageSize, out int totalRecords); 
        [OperationContract] 
        int GetNumberOfUsersOnline(); 
        [OperationContract] 
        string GetPassword(string username, string answer); 
        [OperationContract(Name="GetUserByName")] 
        MembershipUser GetUser(string username, bool userIsOnline); 
        [OperationContract(Name="GetUserByID")] 
        MembershipUser GetUser(object providerUserKey, bool userIsOnline); 
        [OperationContract] 
        string GetUserNameByEmail(string email); 
        [OperationContract] 
        string ResetPassword(string username, string answer); 
        [OperationContract] 
        bool UnlockUser(string userName); 
        [OperationContract] 
        void UpdateUser(MembershipUser user); 
        [OperationContract] 
        bool ValidateUser(string username, string password); 
        [OperationContract] 
        MembershipConfigData GetMembershipConfigData(); 
    } 
} 
  

服务的实现，则异常简单，我们须要做的仅仅是通过Membership.Provider获得当前的MembershipProvider，调用同名的属性或方法即可。MembershipService定义在Infrastructures.Service中，定义如下：

 
using System.Web.Security; 
using Artech.PetShop.Infrastructures.Service.Interface; 
namespace Artech.PetShop.Infrastructures.Service 
{ 
    public class MembershipService : IMembershipService 
    { 
        #region IMembershipService Members 
   
        public bool ChangePassword(string username, string oldPassword, string newPassword) 
        { 
            return Membership.Provider.ChangePassword(username, oldPassword, newPassword); 
        } 
   
        public bool ChangePasswordQuestionAndAnswer(string username, string password, string newPasswordQuestion, string newPasswordAnswer) 
        { 
            return Membership.Provider.ChangePasswordQuestionAndAnswer(username, password, newPasswordQuestion, newPasswordAnswer); 
        } 
        //其他成员 
        public MembershipConfigData GetMembershipConfigData() 
        { 
            return new MembershipConfigData 
            { 
                ApplicationName = Membership.Provider.ApplicationName, 
                EnablePasswordReset = Membership.Provider.EnablePasswordReset, 
                EnablePasswordRetrieval = Membership.Provider.EnablePasswordRetrieval, 
                MaxInvalidPasswordAttempts = Membership.Provider.MaxInvalidPasswordAttempts, 
                MinRequiredNonAlphanumericCharacters = Membership.Provider.MinRequiredNonAlphanumericCharacters, 
                MinRequiredPasswordLength = Membership.Provider.MinRequiredPasswordLength, 
                PasswordAttemptWindow = Membership.Provider.PasswordAttemptWindow, 
                PasswordFormat = Membership.Provider.PasswordFormat, 
                PasswordStrengthRegularExpression = Membership.Provider.PasswordStrengthRegularExpression, 
                RequiresQuestionAndAnswer = Membership.Provider.RequiresQuestionAndAnswer, 
                RequiresUniqueEmail = Membership.Provider.RequiresUniqueEmail 
            }; 
        } 
   
        #endregion 
    } 
} 
  

2、RemoteMembershipProvider的实现

由于RemoteMembershipProvider完全通过调用WCF服务的方式提供对所有成员资格功能的实现，所以进行RemoteMembershipProvider配置时，配置相应的终结点就可以了。

 
<?xml version="1.0"?> 
<configuration>     
    <system.web>         
        <membership defaultProvider="RemoteProvider"> 
            <providers> 
                <add name="RemoteProvider" type="Artech.PetShop.Infrastructures.RemoteMembershipProvider,Artech.PetShop.Infrastructures, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" endpoint="membershipservice"/> 
            </providers> 
        </membership> 
      </system.web> 
    <system.serviceModel>     
        <client> 
            <endpoint address="http://localhost/PetShop/Infrastructures/MembershipService.svc" behaviorConfiguration="petShopBehavior" binding="ws2007HttpBinding"  contract="Artech.PetShop.Infrastructures.Service.Interface.IMembershipService" name="membershipservice"/> 
        </client> 
    </system.serviceModel>     
</configuration> 
  

在RemoteMembershipProvider中，通过Initialize方法获取配置的终结点名称并创建服务代理。通过该代理调用GetMembershipConfigData操作获取服务端MembershipProvider的配置信息，并对RemoteMembershipProvider进行初始化，RemoteMembershipProvider定义如下：

 
using System.Collections.Specialized; 
using System.Configuration; 
using System.Linq; 
using System.Web.Security; 
using Artech.PetShop.Common; 
using Artech.PetShop.Infrastructures.Service.Interface; 
   
namespace Artech.PetShop.Infrastructures 
{ 
    public class RemoteMembershipProvider : MembershipProvider 
    { 
        private bool _enablePasswordReset; 
        private bool _enablePasswordRetrieval; 
        //其他字段成员 
   
        public IMembershipService MembershipProxy 
        { get; private set; }         
   
        public override int MaxInvalidPasswordAttempts 
        { 
            get { return this._maxInvalidPasswordAttempts; } 
        }        
         
        //其他属性成员         
        public override void Initialize(string name, NameValueCollection config) 
        { 
            if (!config.AllKeys.Contains<string>("endpoint")) 
            { 
                throw new ConfigurationErrorsException("Missing the mandatory \"endpoint\" configuraiton property."); 
            } 
   
            this.MembershipProxy = ServiceProxyFactory.Create<IMembershipService>(config["endpoint"]); 
            base.Initialize(name, config); 
            MembershipConfigData configData = this.MembershipProxy.GetMembershipConfigData(); 
            this.ApplicationName = configData.ApplicationName; 
            this._enablePasswordReset = configData.EnablePasswordReset; 
            this._enablePasswordRetrieval = configData.EnablePasswordRetrieval;             
            //...... 
        } 
    } 
} 
  

对于其他抽象方法的实现，仅仅须要通过上面创建的服务代理，调用相应的服务操作即可。

注：为了避免在服务操作调用后频繁地进行服务代理的关闭（Close）和终止（Abort）操作，我们采用基于AOP的方式实现服务的调用，将这些操作封装到一个自定义的RealProxy中，并通过ServiceProxyFactory<T>创建该RealProxy的TransparentProxy。相关实现可以参考《WCF技术剖析（卷1）》第九章。

二、上下文的共享及跨域传递

在进行基于N-Tier的应用开发中，我们往往需要在多个层次之间共享一些上下文（Context）信息，比如当前用户的Profile信息；在进行远程服务调用时，也经常需要进行上下文信息的跨域传递。比如在PetShop中，服务端进行审核（Audit）的时候，须要获取当前登录的用户名。而登录用户名仅仅对于Web服务器可得，所以在每次服务调用的过程中，需要从客户端向服务端传递。

1、ApplicationContext

基于上下文的共享，我创建了一个特殊的类型：ApplicationContext。ApplicationContext定义在Common项目中，简单起见，直接将其定义成字典的形式。至于上下文数据的真正存储，如果当前HttpContext存在，将其存储与HttpSessionState中，否则将其存储于CallContext中。

注：由于CallConext将数据存储于当前线程的TLS（Thread Local Storage）中，实际上HttpContext最终也采用这样的存储方式，所以ApplicaitonContext并不提供上下文信息跨线程的传递。

 
using System.Collections.Generic; 
using System.Runtime.Remoting.Messaging; 
using System.Web; 
namespace Artech.PetShop.Common 
{ 
    public class ApplicationContext:Dictionary<string, object> 
    { 
        public const string ContextKey = "Artech.PetShop.Infrastructures.ApplicationContext"; 
        public const string ContextHeaderLocalName = "ApplicationContext"; 
        public const string ContextHeaderNamespace = "http://www.artech.com/petshop/"; 
        public static ApplicationContext Current 
        { 
            get 
            { 
                if (HttpContext.Current != null) 
                { 
                    if (HttpContext.Current.Session[ContextKey] == null) 
                    { 
                        HttpContext.Current.Session[ContextKey] = new ApplicationContext(); 
                    } 
   
                    return HttpContext.Current.Session[ContextKey] as ApplicationContext; 
                } 
   
                if (CallContext.GetData(ContextKey) == null) 
                { 
                    CallContext.SetData(ContextKey, new ApplicationContext()); 
                } 
   
                return CallContext.GetData(ContextKey) as ApplicationContext; 
            } 
           set 
            { 
                if (HttpContext.Current != null) 
                { 
                    HttpContext.Current.Session[ContextKey] = value; ; 
                } 
                else 
                { 
                    CallContext.SetData(ContextKey, value); 
                } 
            } 
        } 
        public string UserName 
        { 
            get 
            { 
                if (!this.ContainsKey("__UserName" )) 
                { 
                    return string.Empty; 
                } 
   
                return (string)this["__UserName"]; 
            } 
            set 
            { 
                this["__UserName"] = value; 
            } 
        } 
    } 
} 
  

2、ApplicationContext在WCF服务调用中的传递

下面我们来介绍一下如何实现上下文信息在WCF服务调用过程中的“隐式”传递。在PetShop中，我们通过WCF的扩展实现此项功能。上下文传递的实现原理很简单：在客户端，将序列化后的当前上下文信息置于出栈（Outgoing）消息的SOAP报头中，并为报头指定一个名称和命名空间；在服务端，在服务操作执行之前，通过报头名称和命名空间将上下文SOAP报头从入栈（Incoming）消息中提取出来，进行反序列化，并将其设置成服务端当前的上下文。

所以，上下文的传递实际上包含两个方面：SOAP报头的添加和提取。我们通过两个特殊的WCF对象来分别实现这两个功能：ClientMessageInspector和CallContextInitializer，前者在客户端将上下文信息封装成SOAP报头，并将其添加到出栈消息报头集合；后者则在服务端实现对上下文SOAP报头的提取和当前上下文的设置。关于ClientMessageInspector和CallContextInitializer，本书的下一卷关于客户端和服务端处理流程，以及WCF扩展的部分，还将进行详细的介绍。自定义的ClientMessageInspector和CallContextInitializer定义在Infrastructures项目中，下面是相关代码实现：

ContextSendInspector：

 
using System.ServiceModel; 
using System.ServiceModel.Channels; 
using System.ServiceModel.Dispatcher; 
using System.Threading; 
using Artech.PetShop.Common; 
namespace Artech.PetShop.Infrastructures 
{ 
    public class ContextSendInspector: IClientMessageInspector 
    { 
        public void AfterReceiveReply(ref Message reply, object correlationState) 
        {} 
   
        public object BeforeSendRequest(ref Message request, IClientChannel channel) 
        { 
            if (string.IsNullOrEmpty(ApplicationContext.Current.UserName)) 
            { 
                ApplicationContext.Current.UserName = Thread.CurrentPrincipal.Identity.Name; 
            } 
            request.Headers.Add(new MessageHeader<ApplicationContext>( 
                ApplicationContext.Current).GetUntypedHeader( 
                ApplicationContext.ContextHeaderLocalName, ApplicationContext.ContextHeaderNamespace)); 
   
            return null; 
        } 
    } 
} 
  

ContextReceivalCallContextInitializer：

 
using System.ServiceModel; 
using System.ServiceModel.Channels; 
using System.ServiceModel.Dispatcher; 
using Artech.PetShop.Common; 
namespace Artech.PetShop.Infrastructures 
{ 
    public class ContextReceivalCallContextInitializer : ICallContextInitializer 
    { 
        public void AfterInvoke(object correlationState) 
        { 
            ApplicationContext.Current.Clear(); 
        } 
   
        public object BeforeInvoke(InstanceContext instanceContext, IClientChannel channel, Message message) 
        { 
            ApplicationContext.Current = message.Headers.GetHeader<ApplicationContext>(ApplicationContext.ContextHeaderLocalName, ApplicationContext.ContextHeaderNamespace); 
            return null; 
        } 
    } 
} 
  

和应用大部分自定义扩展对象一样，上面自定义的ClientMessageInspector和CallContextInitializer可以通过相应的WCF行为（服务行为、终结点行为、契约行为或者操作行为）应用到WCF执行管道中。在这里我定义了一个行为类型：ContextPropagationBehaviorAttribute，它同时实现了IServiceBehavior和 IEndpointBehavior，所以既是一个服务行为，也是一个终结点行为。同时ContextPropagationBehaviorAttribute还继承自Attribute，所以可以通过特定的方式应用该行为。自定义ClientMessageInspector和CallContextInitializer分别通过ApplyClientBehavior和ApplyDispatchBehavior方法应用到WCF客户端运行时和服务端运行时。ContextPropagationBehaviorAttribute定义如下：

 
using System; 
using System.ServiceModel.Description; 
using System.ServiceModel.Dispatcher; 
namespace Artech.PetShop.Infrastructures 
{ 
   public class ContextPropagationBehaviorAttribute:Attribute, IServiceBehavior,IEndpointBehavior 
    { 
        #region IServiceBehavior Members 
        public void AddBindingParameters(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase, System.Collections.ObjectModel.Collection<ServiceEndpoint> endpoints, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) 
        { 
        } 
   
        public void ApplyDispatchBehavior(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase) 
        { 
            foreach (ChannelDispatcher channelDispatcher in serviceHostBase.ChannelDispatchers) 
            { 
                foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints) 
                { 
                    foreach (DispatchOperation operation in endpointDispatcher.DispatchRuntime.Operations) 
                    { 
                        operation.CallContextInitializers.Add(new ContextReceivalCallContextInitializer()); 
                    } 
                } 
            } 
        } 
   
        public void Validate(ServiceDescription serviceDescription, System.ServiceModel.ServiceHostBase serviceHostBase) 
        { 
        } 
   
        #endregion 
   
        #region IEndpointBehavior Members 
   
        public void AddBindingParameters(ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters) 
        { 
        } 
   
        public void ApplyClientBehavior(ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.ClientRuntime clientRuntime) 
        { 
            clientRuntime.MessageInspectors.Add(new ContextSendInspector()); 
        } 
   
        public void ApplyDispatchBehavior(ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.EndpointDispatcher endpointDispatcher) 
        { 
            foreach (DispatchOperation operation in endpointDispatcher.DispatchRuntime.Operations) 
            { 
                operation.CallContextInitializers.Add(new ContextReceivalCallContextInitializer()); 
            } 
        } 
   
        public void Validate(ServiceEndpoint endpoint) 
        { 
        } 
   
        #endregion 
    } 
} 
  

对于服务行为，我们既可以通过自定义特性的方式，也可以通过配置的方式进行行为的应用；而终结点行为的应用方式则仅限于配置（通过编程的形式除外）。为此我们还需要为行为定义一个特殊的类型：BehaviorExtensionElement。

 
using System; 
using System.ServiceModel.Configuration; 
namespace Artech.PetShop.Infrastructures 
{ 
   public class ContextPropagationBehaviorElement: BehaviorExtensionElement 
    { 
        public override Type BehaviorType 
        { 
            get { return typeof(ContextPropagationBehaviorAttribute); } 
        } 
   
        protected override object CreateBehavior() 
        { 
            return new ContextPropagationBehaviorAttribute(); 
        } 
    } 
} 
  

那么ContextPropagationBehaviorAttribute就可以通过下面的配置应用到具体的服务或终结点上了。

服务端（ServiceBehavior）：

 
<?xml version="1.0"?> 
<configuration>     
    <system.serviceModel> 
        <behaviors> 
            <serviceBehaviors> 
                <behavior name="petshopbehavior"> 
                    <contextPropagation/> 
                    <unity/> 
                </behavior> 
            </serviceBehaviors> 
        </behaviors> 
        <extensions> 
            <behaviorExtensions> 
                <add name="contextPropagation" type="Artech.PetShop.Infrastructures.ContextPropagationBehaviorElement, Artech.PetShop.Infrastructures, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>                 
            </behaviorExtensions> 
        </extensions> 
        <services> 
            <service behaviorConfiguration="petshopbehavior" name="Artech.PetShop.Products.Service.ProductService"> 
                <endpoint binding="ws2007HttpBinding" contract="Artech.PetShop.Products.Service.Interface.IProductService"/> 
            </service>             
        </services> 
    </system.serviceModel>     
</configuration> 
  

客户端（EndpointBehavior）

 
<?xml version="1.0"?> 
<configuration>     
    <system.serviceModel> 
        <behaviors> 
            <endpointBehaviors> 
                <behavior name="petShopBehavior"> 
                    <contextPropagation/> 
                </behavior> 
            </endpointBehaviors> 
        </behaviors> 
        <extensions> 
            <behaviorExtensions> 
                <add name="contextPropagation" type="Artech.PetShop.Infrastructures.ContextPropagationBehaviorElement, Artech.PetShop.Infrastructures, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/> 
            </behaviorExtensions> 
        </extensions> 
        <client> 
            <endpoint address="http://localhost/PetShop/Products/productservice.svc" behaviorConfiguration="petShopBehavior" binding="ws2007HttpBinding"  contract="Artech.PetShop.Products.Service.Interface.IProductService" name="productservice"/>             
        </client> 
    </system.serviceModel>     
</configuration> 
  

作者：蒋金楠
微信公众账号：大内老A
微博： www.weibo.com/artech
如果你想及时得到个人撰写文章以及著作的消息推送，或者想看看个人推荐的技术资料，可以扫描左边二维码（或者长按识别二维码）关注个人公众号（原来公众帐号蒋金楠的自媒体将会停用）。
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

原文链接

WCF版的PetShop之三：实现分布式的Membership和上下文传递

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件