MVC项目不同域之间的UrlRouting

一、DomainAction，方便生成不同域下的url

1、新建3个MVC项目,一个公用类库WebCore

Demo.WebApplication0

　　绑定域名 www.demo.com demo.com t0.demo.com

Demo.WebApplication1（可不用建）

　　绑定域名 t1.demo.com

Demo.WebApplication2（可不用建）

　　绑定域名 t2.demo.com

Demo.WebCore

2、项目Demo.WebApplication0新增一个学生的Controller

     public class StudentController : Controller
     {
         public ActionResult Search(int gender, int degree, int pageSize, int page)
         {
             return Content(string.Format("查找学生，筛选条件。性别：{0},学历：{1},每页学生数量：{2},页码：{3}"
                 , (gender ==  ? "男" : (gender ==  ? "女" : "不限"))
                 ,degree, pageSize, page
                 ));
             //return View();
         }

     }

3、域名枚举

     public enum DemoDomain
     {
         /// <summary>
         /// www.demo.com
         /// demo.com
         /// t0.demo.com
         /// </summary>
         T0,

         /// <summary>
         /// t1.demo.com
         /// </summary>
         T1,

         /// <summary>
         /// t2.demo.com
         /// </summary>
         T2,

         /// <summary>
         /// demo.com
         /// </summary>
         Default,

     }

4、System.Web.Mvc.UrlHelper的静态扩展类DemoUrlExtensions

     public static class DemoUrlExtensions
     {
         public static string DomainAction(this UrlHelper urlHelper, string actionName, string controllerName)
         {
             return urlHelper.DomainAction(actionName, controllerName, DemoDomain.Default);
         }

         public static string DomainAction(this UrlHelper urlHelper, string actionName, string controllerName, object routeValues)
         {
             return urlHelper.DomainAction(actionName, controllerName, routeValues, DemoDomain.Default);
         }

         public static string DomainAction(this UrlHelper urlHelper, string actionName, string controllerName, DemoDomain Domain)
         {
             return urlHelper.DomainAction(actionName, controllerName, new { }, Domain);
         }

         public static string DomainAction(this UrlHelper urlHelper, string actionName, string controllerName, object routeValues, DemoDomain Domain)
         {
             return DomainAction(urlHelper, actionName, controllerName, new RouteValueDictionary(routeValues), Domain);
         }

         public static string DomainAction(this UrlHelper urlHelper, string actionName, string controllerName, RouteValueDictionary routeValues, DemoDomain Domain)
         {
             string subDomain = string.Empty;
             string HostName = string.Empty;
             switch (Domain)
             {
                 case DemoDomain.Default:
                     subDomain = string.Empty;
                     break;
                 case DemoDomain.T0:
                     subDomain = "t0";
                     break;
                 case DemoDomain.T1:
                     subDomain = "t1";
                     break;
                 case DemoDomain.T2:
                     subDomain = "t2";
                     break;
                 default:
                     subDomain = string.Empty;
                     break;
             }

             if (!string.IsNullOrEmpty(subDomain))
             {
                 HostName = subDomain + ".demo.com";
             }
             else
             {
                 HostName = "www.demo.com";
             }
             //核心的一行
             string url = urlHelper.Action(actionName, controllerName, routeValues, "http", HostName);
             if (url.Contains('?'))
             {
                 url = url.TrimEnd('/');
             }
             else
             {
                 if (url.EndsWith(".html/"))
                 {
                     url = url.TrimEnd('/');
                 }
             }
             return url;
         }

     }

5、修改Home/Index内容

 <div>
     <a href="@Url.DomainAction("Index","Home", DemoDomain.T1)">我要去t1.demo.com</a>
     <a href="@Url.DomainAction("Index","Home", DemoDomain.T2)">我要去t2.demo.com</a>
     <a href="@Url.DomainAction("Index", "Home", new { from = "www" }, DemoDomain.T2)">我要去t2.demo.com，我要带参数，表示我是从www过来的</a>

     <a href="@Url.DomainAction("Search", "Student", new { gender = 1, degree = 0, pageSize = 20, page = 1 }, DemoDomain.T0)">查找性别男的学生</a>

 </div>

对应的html源码

 <div>
     <a href="http://t1.demo.com/">我要去t1.demo.com</a>
     <a href="http://t2.demo.com/">我要去t2.demo.com</a>
     <a href="http://t2.demo.com/?from=www">我要去t2.demo.com，我要带参数，表示我是从www过来的</a>

     <a href="http://t0.demo.com/Student/Search?gender=1&amp;degree=0&amp;pageSize=20&amp;page=1">查找性别男的学生</a>

 </div>

二、注册路由，SEO优化

现在已经能做到

@Url.DomainAction("Search", "Student", new { gender = , degree = , pageSize = , page =  }, DemoDomain.T0)

对应的Url为

http://t0.demo.com/Student/Search?gender=1&degree=0&pageSize=20&page=1

，但这个链接不利于SEO，理想的情况可能是这样（请把t0当成student）

http://t0.demo.com/Search/1-0-20-1.html

定义路由

 public class DomainRoute : Route
     {
         private static 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_]*})*-?\.?\/?", RegexOptions.Compiled);
         private static Dictionary<string, Regex> domainRegDic = new Dictionary<string, Regex>();
         private static Dictionary<string, Regex> pathRegDic = new Dictionary<string, Regex>();

         /// <summary>
         ///
         /// </summary>
         public Regex PathRegex
         {
             get
             {
                 if (!pathRegDic.Keys.Contains(Url))
                 {
                     switch (Url)
                     {
                         case WebCoreConsts.URL_T0_SearchStudent:
                             pathRegDic[Url] = new Regex(ConvertToPattern("search/{gender}-{degree}-{pagesize}-{page}.html"), RegexOptions.Compiled | RegexOptions.IgnoreCase);
                             break;
                         default:
                             pathRegDic[Url] = CreateRegex(Url);
                             break;
                     }
                 }
                 return pathRegDic[Url];
             }
         }

         /// <summary>
         ///
         /// </summary>
         public Regex DomainRegex
         {
             get
             {
                 if (!domainRegDic.Keys.Contains(Domain))
                 {

                     domainRegDic[Domain] = CreateRegex(Domain);
                 }
                 return domainRegDic[Domain];
             }

         }

         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;
         }

         //new
         public DomainRoute(string domain, string url, object defaults, object constraints)
             : base(url, new RouteValueDictionary(defaults), new RouteValueDictionary(constraints), 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)
         {
             // 请求信息
             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;
                     }
                 }

                 // 匹配域名路由
                 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;
                             }
                         }
                     }
                 }

                 // 匹配域名路径
                 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;
                             }
                         }
                     }
                 }
             }

             return data;
         }

         public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
         {

             VirtualPathData pathData = base.GetVirtualPath(requestContext, RemoveDomainTokens(values));
             if (pathData != null && !string.IsNullOrEmpty(pathData.VirtualPath))
             {
                 if (pathData.VirtualPath.EndsWith(".html/"))
                 {
                     pathData.VirtualPath = pathData.VirtualPath.TrimEnd('/');
                 }
                 else if (!pathData.VirtualPath.EndsWith("/") && !pathData.VirtualPath.EndsWith(".html"))
                 {
                     pathData.VirtualPath = pathData.VirtualPath + "/";
                 }
             }
             return pathData;
         }

         private Regex CreateRegex(string source)
         {
             try
             {
                 string src = source;
                 // 替换
                 source = source.Replace("/", @"\/?");
                 source = source.Replace(".", @"\.?");
                 source = source.Replace("-", @"\-?");
                 source = source.Replace("{", @"(?<");
                 source = source.Replace("}", @">([a-zA-Z0-9_]*))");
                 return new Regex("^" + source + "$", RegexOptions.Compiled);
             }
             catch (Exception ex)
             {
                 //AppLogger.Error("创建正则出错：" + source + " 详情：" + ex.Message);
             }
             return new Regex("^" + source + "$", RegexOptions.Compiled);
         }

         private RouteValueDictionary RemoveDomainTokens(RouteValueDictionary values)
         {

             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;
         }

         private static string ConvertToPattern(string source)
         {
             try
             {
                 string src = source;
                 // 替换
                 source = source.Replace("/", @"\/?");
                 source = source.Replace(".", @"\.?");
                 source = source.Replace("-", @"\-?");
                 source = source.Replace("{", @"(?<");
                 source = source.Replace("}", @">([a-zA-Z0-9_]*))");
                 return "^" + source + "$";
             }
             catch (Exception ex)
             {
             }
             return source;
         }

     }

注册路由

             routes.LowercaseUrls = true;

             routes.Add("T0StudentSearchDomainRoute", new DomainRoute(
                 "t0.demo.com",  // Domain with parameters
                 WebCoreConsts.URL_T0_SearchStudent, // URL with parameters
                 new { controller = "Student", action = "Search" }
                         //, new { }
             ));

可能还需要在web.config的system.webServer项中增加一行配置，否则.html不会进入路由，会直接映射成本地路径

    <modules runAllManagedModulesForAllRequests="true" />

这时候

    <a href="@Url.DomainAction("Search", "Student", new { gender = 1, degree = 0, pageSize = 20, page = 1 }, DemoDomain.T0)" target="_blank">查找性别男的学生</a>

就会对应成

    <a href="http://t0.demo.com/search/1-0-20-1.html" target="_blank">查找性别男的学生</a>

　　附：源码下载