MVC动态二级域名解析

动态二级域名的实现:

应用场景：目前产品要实现block功能，因为工作需要实现二级域名:www.{CompanyUrl}.xxx.com

假设产品主域名入口为：www.xxx.com

公司员工管理：www.a.xxx.com

公司产品管理: www.b.xxx.com

Route简介：ASP.NET路由可以不用映射到网站特定文件的URL.由于该 URL 不必映射到文件，因此可以使用对用户操作进行描述因而更易于被用户理解的 URL。.NET Framework 3.5 SP1已经包含了ASP.NET Routing引擎。现在微软已经在ASP.NET WebForms 4.0中增加了对Routing引擎更好的支持，它使用表达式构造器进行双向Routing。
MVC 应用程序中的典型 URL 模式——来自MSDN

MVC 应用程序中用于路由的 URL 模式通常包括 {controller} 和 {action} 占位符。

当收到请求时，会将其路由到 UrlRoutingModule 对象，然后路由到 MvcHandler HTTP 处理程序。 MvcHandler HTTP 处理程序通过向 URL 中的控制器值添加后缀“Controller”以确定将处理请求的控制器的类型名称，来确定要调用的控制器。URL 中的操作值确定要调用的操作方法。

MVC项目中添加路由，Global.asax 文件默认的MVC 路由的代码。

默认配置:

public static void RegisterRoutes(RouteCollection routes)
{
    routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
    
    routes.MapRoute(
        "Default", // Route name
        "{controller}/{action}/{id}", // URL with parameters
        new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
    );
    
}

protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();
    
    RegisterGlobalFilters(GlobalFilters.Filters);
    RegisterRoutes(RouteTable.Routes);
}

涉及类参考

类	说明
Route	表示 Web 窗体或 MVC 应用程序中的路由。
RouteBase	用作表示 ASP.NET 路由的所有类的基类。
RouteTable	存储应用程序的路由。
RouteData	包含所请求路由的值。
RequestContext	包含有关对应于路由的 HTTP 请求的信息。
RouteValueDictionary	提供用于存储路由 Constraints、Defaults 和 DataTokens 对象的方法。
VirtualPathData	提供用于从路由信息生成 URL 的方法。

因为目前采用的是ASP.NET MVC 3进而可以利用扩展Route的方式实现。

首先定义DomainData、DomainRoute类

代码如下：

DomainRoute类:

    public class DomainRoute : Route
    {
        private Regex domainRegex;
        private Regex pathRegex;

        public string Domain { get; set; }

        public DomainRoute(string domain, string url, RouteValueDictionary defaults)
            : base(url, defaults, new MvcRouteHandler())
        {
            Domain = domain;
        }

        public DomainRoute(string domain, string url, RouteValueDictionary defaults, IRouteHandler routeHandler)
            : base(url, defaults, routeHandler)
        {
            Domain = domain;
        }

        public DomainRoute(string domain, string url, object defaults)
            : base(url, new RouteValueDictionary(defaults), new MvcRouteHandler())
        {
            Domain = domain;
        }

        public DomainRoute(string domain, string url, object defaults, IRouteHandler routeHandler)
            : base(url, new RouteValueDictionary(defaults), routeHandler)
        {
            Domain = domain;
        }

        public override RouteData GetRouteData(HttpContextBase httpContext)
        {
            // 构造 regex
            domainRegex = CreateRegex(Domain);
            pathRegex = CreateRegex(Url);

            // 请求信息
            string requestDomain = httpContext.Request.Headers["host"];
            if (!string.IsNullOrEmpty(requestDomain))
            {
                if (requestDomain.IndexOf(":") > 0)
                {
                    requestDomain = requestDomain.Substring(0, requestDomain.IndexOf(":"));
                }
            }
            else
            {
                requestDomain = httpContext.Request.Url.Host;
            }
            string requestPath = httpContext.Request.AppRelativeCurrentExecutionFilePath.Substring(2) + httpContext.Request.PathInfo;

            // 匹配域名和路由
            Match domainMatch = domainRegex.Match(requestDomain);
            Match pathMatch = pathRegex.Match(requestPath);

            // 路由数据
            RouteData data = null;
            if (domainMatch.Success && pathMatch.Success)
            {
                data = new RouteData(this, RouteHandler);

                // 添加默认选项
                if (Defaults != null)
                {
                    foreach (KeyValuePair<string, object> item in Defaults)
                    {
                        data.Values[item.Key] = item.Value;
                        if (item.Key.Equals("area") || item.Key.Equals("namespaces"))
                        {
                            data.DataTokens[item.Key] = item.Value;
                        }
                    }
                }

                // 匹配域名路由
                for (int i = 1; i < domainMatch.Groups.Count; i++)
                {
                    Group group = domainMatch.Groups[i];
                    if (group.Success)
                    {
                        string key = domainRegex.GroupNameFromNumber(i);

                        if (!string.IsNullOrEmpty(key) && !char.IsNumber(key, 0))
                        {
                            if (!string.IsNullOrEmpty(group.Value))
                            {
                                data.Values[key] = group.Value;
                                if (key.Equals("area"))
                                {
                                    data.DataTokens[key] = group.Value;
                                }
                            }
                        }
                    }
                }

                // 匹配域名路径
                for (int i = 1; i < pathMatch.Groups.Count; i++)
                {
                    Group group = pathMatch.Groups[i];
                    if (group.Success)
                    {
                        string key = pathRegex.GroupNameFromNumber(i);

                        if (!string.IsNullOrEmpty(key) && !char.IsNumber(key, 0))
                        {
                            if (!string.IsNullOrEmpty(group.Value))
                            {
                                data.Values[key] = group.Value;
                                if (key.Equals("area"))
                                {
                                    data.DataTokens[key] = group.Value;
                                }
                            }
                        }
                    }
                }
            }

            return data;
        }

        public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
        {
            return base.GetVirtualPath(requestContext, RemoveDomainTokens(values));
        }

        //public DomainData GetDomainData(RequestContext requestContext, RouteValueDictionary values)
        //{
        //    // 获得主机名
        //    string hostname = Domain;
        //    foreach (KeyValuePair<string, object> pair in values)
        //    {
        //        hostname = hostname.Replace("{" + pair.Key + "}", pair.Value.ToString());
        //    }

        //    // Return 域名数据
        //    return new DomainData
        //    {
        //        Protocol = "http",
        //        HostName = hostname,
        //        Fragment = ""
        //    };
        //}

        private Regex CreateRegex(string source)
        {
            // 替换
            source = source.Replace("/", @"/?");
            source = source.Replace(".", @".?");
            source = source.Replace("-", @"-?");
            source = source.Replace("{", @"(?<");
            source = source.Replace("}", @">([a-zA-Z0-9_]*))");

            return new Regex("^" + source + "$");
        }

        private RouteValueDictionary RemoveDomainTokens(RouteValueDictionary values)
        {
            Regex tokenRegex = new Regex(@"({[a-zA-Z0-9_]*})*-?.?/?({[a-zA-Z0-9_]*})*-?.?/?({[a-zA-Z0-9_]*})*-?.?/?({[a-zA-Z0-9_]*})*-?.?/?({[a-zA-Z0-9_]*})*-?.?/?({[a-zA-Z0-9_]*})*-?.?/?({[a-zA-Z0-9_]*})*-?.?/?({[a-zA-Z0-9_]*})*-?.?/?({[a-zA-Z0-9_]*})*-?.?/?({[a-zA-Z0-9_]*})*-?.?/?({[a-zA-Z0-9_]*})*-?.?/?({[a-zA-Z0-9_]*})*-?.?/?");
            Match tokenMatch = tokenRegex.Match(Domain);
            for (int i = 0; i < tokenMatch.Groups.Count; i++)
            {
                Group group = tokenMatch.Groups[i];
                if (group.Success)
                {
                    string key = group.Value.Replace("{", "").Replace("}", "");
                    if (values.ContainsKey(key))
                        values.Remove(key);
                }
            }

            return values;
        }
    }

然后注册我的产品管理系统

并且注册区域路由规则

    public class BlockAreaRegistration : AreaRegistration
    {
        public override string AreaName
        {
            get
            {
                return "Block";
            }
        }

        public override void RegisterArea(AreaRegistrationContext context)
        {
            context.Routes.Add(new DomainRoute(
               "us.block.com",     // Domain with parameters 需要配置host文件 
               "{controller}/{action}/{id}",    // URL with parameters 
               new
               {
                   area = "Block",
                   controller = "Default",
                   action = "Index",
                   id = UrlParameter.Optional,
                   namespaces = new[] { "Notify.Solution.WebMvc.Areas.Block.Controllers" }
               }));
        }
    }

当用户访问www.Block.com 时候就会访问主站点

当用户访问us.Block.com 时候就会访问二级域名站点