写一个简单的Web框架

　　在.Net中有两种常用的Web开发方式，一种是Asp.Net WebForm，另一种是Asp.Net MVC。我先简单的给大家介绍下这两种开发方式的特点，然后再应用自定义脚本映射，反射，json2template.js，htm等技术演示一个纯静态的Web框架。

　　Asp.Net WebForm

　　在Asp.Net WebForm中，请求大都以.aspx为后缀，那么.Net是如何处理.aspx请求呢? 打开.Net的配置文件，

　　.Net4.0配置文件地址(64位)：C:WindowsMicrosoft.NETFramework64v4.0.30319Configweb.config；

　　.Net4.0配置文件地址(32位)：C:WindowsMicrosoft.NETFrameworkv4.0.30319Configweb.config。

　　找到HttpHandlers的配置信息如下：

      <httpHandlers>
            <add path="eurl.axd" verb="*" type="System.Web.HttpNotFoundHandler" validate="True" />
            <add path="trace.axd" verb="*" type="System.Web.Handlers.TraceHandler" validate="True" />
            <add path="WebResource.axd" verb="GET" type="System.Web.Handlers.AssemblyResourceLoader" validate="True" />
            <add verb="*" path="*_AppService.axd" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" validate="False" />
            <add verb="GET,HEAD" path="ScriptResource.axd" type="System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" validate="False"/>
            <add path="*.axd" verb="*" type="System.Web.HttpNotFoundHandler" validate="True" />
            <add path="*.aspx" verb="*" type="System.Web.UI.PageHandlerFactory" validate="True" />　　     ................................................

从以上配置信息可以看出所有的*.aspx请求都是交给PageHandlerFactory处理工厂去处理的。PageHandlerFactory定义如下：

　　public class PageHandlerFactory : IHttpHandlerFactory2, IHttpHandlerFactory
    {
        public virtual IHttpHandler GetHandler(HttpContext context, string requestType, string virtualPath, string path);
        private IHttpHandler GetHandlerHelper(HttpContext context, string requestType, VirtualPath virtualPath, string physicalPath);
        public virtual void ReleaseHandler(IHttpHandler handler);
        IHttpHandler IHttpHandlerFactory2.GetHandler(HttpContext context, string requestType, VirtualPath virtualPath, string physicalPath);
    }

调用PageHandlerFactory的GetHandler会生成一个Page（IHttpHandler）类，然后调用Page类的ProcessRequest方法，再渲染*.aspx中的控件，最后生成Html给Response。如图：

 

　　Asp.Net MVC

    在Asp.Net MVC中，所有的请求都交给UrlRoutingModule处理。通过UrlRoutingModule得到一个MvcRouteHandler。调用MvcRouteHandler的GetHttpHandler方法返回MvcHandler。然后调用MvcHandler的ProcessRequest方法，通过反射创建Controller实例，并执行其方法。如图：

      

     

      在Asp.Net WebForm和Asp.Net Mvc中，其实都是生成一个IHttpHandler的类，并调用其ProcessRequest方法，通过不同的渲染方式，把最终结果返回给用户。

　　

　　框架

      好了，WebForm和MVC就介绍到这里，下面开始写自己的框架了。我们知道Asp.Net MVC 包括:UrlRoutingModule(Url处理) + View(*.aspx)+Controller+ViewEngine,而我的框架包括：
     WebMethodHttpHandler(处理中心)+View(*.htm)+Controller(业务类)+Js(json2template.js渲染器)，呵呵，跟Asp.Net MVC有点像。如图：

　　

      框架中，静态页面都是以.htm为后缀，如：login.htm。动态请求都是以mthd为后缀,如：/User/CheckLogin.mthd。动态请求URL地址有一定的含义：如：/User/CheckLogin.mthd中，User代表业务处理类 UserController,CheckLogin就是UserController的一个方法（验证用户登录的方法）。

     我们已经知道，不管是WebForm还是Mvc，最终都需要生成一个IHttpHandler的类去处理请求。在我的框架中，我打算模仿WebForm对于*.aspx的处理方式，定义一个IHttpHandler去处理*.mthd请求。这个IHttpHandler的类定义为 WebMethodHttpHandler。WebMethodHttpHandler定义如下：

　　

public class WebMethodHttpHandler : IHttpHandler, IRequiresSessionState
    {
        public bool IsReusable
        {
            get { return false; }
        }

        public void ProcessRequest(HttpContext context)
        {
            var request = context.Request;
            var arr = request.Path.Split('/');

            string controllerName = arr[arr.Length - 2];
            string methodName = Path.GetFileNameWithoutExtension(arr[arr.Length - 1]);

            var factory = ControllerBuilder.Current.GetControllerFactory();
            var obj = factory.CreateController(controllerName, methodName);
            var result = obj.Execute(request.Params);

            var js = new JavaScriptSerializer();
            string json = js.Serialize(result);
            context.Response.ContentType = "json/plain";
            context.Response.Write(json);
        }
    }

　　代码很简单，WebMethodHttpHandler实现了两个接口，分别是IHttpHandler和 IRequiresSessionState。在方法ProcessRequest中把请求的路径URL根据"/"拆分成一个数组，分别获得业务类Controller和它的方法名，再调用DefaultControllerFactory使用反射技术动态生成RemotingObject实例，最后调用RemotingObject的Execute方法返回Json数据。好了，我们看看ControllerBuilder 的定义：

  

 public class ControllerBuilder
    {
        private static ControllerBuilder _instance = null;
        private static object syncObj = new object();

        private Func<DefaultControllerFactory> func = null;

        private ControllerBuilder()
        {
            SetControllerFactory(new DefaultControllerFactory());
        }

        public static ControllerBuilder Current
        {
            get
            {
                if (_instance == null)
                {
                    lock (syncObj)
                    {
                        if (_instance == null)
                        {
                            _instance = new ControllerBuilder();
                        }
                    }
                }
                return _instance;
            }
        }

        public void SetControllerFactory(DefaultControllerFactory controllerFactory)
        {
            if (controllerFactory == null)
            {
                throw new ArgumentNullException("controllerFactory");
            }

            func = () => controllerFactory;
        }

        public DefaultControllerFactory GetControllerFactory()
        {
            return func();
        }
    }

     ControllerBuilder类定义很简单就是一个单例模式，用于返回DefaultControllerFactory。DefaultControllerFactory定义：

   

public sealed class DefaultControllerFactory
    {
        private static object _controllerTypeCacheLock = new object();
        private static ControllerTypeCache _controllerTypeCache = new ControllerTypeCache();
        private readonly string key = "{0}.{1}";

        /// <summary>
        /// 创建Controller-Method
        /// </summary>
        /// <param name="controllerName">Controller名称</param>
        /// <param name="methodName">方法名称</param>
        /// <returns></returns>
        public RemotingObject CreateController(string controllerName, string methodName)
        {
            if (string.IsNullOrEmpty(controllerName) || string.IsNullOrEmpty(methodName))
            {
                throw new Exception("controllerName or methodName is null");
            }

            if (!_controllerTypeCache.Initialized)
            {
                lock (_controllerTypeCacheLock)
                {
                    if (!_controllerTypeCache.Initialized)
                    {
                        _controllerTypeCache.Initialize();
                    }

                    var assemblies = BuildManager.GetReferencedAssemblies();

                    foreach (Assembly asm in assemblies)
                    {
                        foreach (Type t in asm.GetTypes())
                        {
                            //类型t是否继承IController
                            if (typeof(IController).IsAssignableFrom(t) && t.Name.EndsWith("Controller", StringComparison.OrdinalIgnoreCase)
                                && t != typeof(IController))
                            {
                                var methods = t.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.DeclaredOnly);

                                foreach (var method in methods)
                                {
                                    if (!_controllerTypeCache.ContainsController(string.Format(key, t.Name, method.Name)))
                                    {
                                        _controllerTypeCache.AddControllerType(CreateRemotingObject(t, method.Name));
                                    }
                                }
                            }
                        }
                    }
                }
            }

            controllerName = controllerName.EndsWith("Controller") ? controllerName : controllerName + "Controller";

            return _controllerTypeCache.GetControllerType(string.Format(key, controllerName, methodName));
        }

        public RemotingObject CreateRemotingObject(Type type, string methodName)
        {
            if (type == null)
            {
                throw new Exception(string.Format("类型null不存在!"));
            }

            var method = type.GetMethods().ToList().Find(p => p.Name.ToLowerInvariant() == methodName.ToLowerInvariant());

            if (method == null)
            {
                throw new Exception(string.Format("类：{0}不存在方法名：{1}", type.FullName, methodName));
            }

            return new RemotingObject
            {
                Request = string.Format(key, type.Name, methodName),
                ControlObject = (IController)Activator.CreateInstance(type),
                Method = method
            };
        }
    }

    RemotingObject定义如下：

public class RemotingObject
    {
        /// <summary>
        /// 请求地址
        /// </summary>
        public string Request { get; set; }

        /// <summary>
        /// control实例
        /// </summary>
        public IController ControlObject { get; set; }

        /// <summary>
        /// 所调用方法
        /// </summary>
        public MethodInfo Method { get; set; }

        public object Execute(NameValueCollection collection)
        {
            var parameters = new object[Method.GetParameters().Length];
            int i = 0;

            foreach (var parameter in Method.GetParameters())
            {
                var item =
                    collection.AllKeys.ToList().Find(
                        p => string.Equals(parameter.Name, p, StringComparison.OrdinalIgnoreCase));

                if (item != null)
                {
                    parameters[i] = Convert.ChangeType(collection[item], parameter.ParameterType);
                    i++;
                }
            }

            return Method.Invoke(ControlObject, parameters);
        }
    }

    ControllerTypeCache定义如下：

  

 /// <summary>
    /// Controller集合缓存
    /// </summary>
    internal sealed class ControllerTypeCache
    {
        private Dictionary<string, RemotingObject> _controllerCache = new Dictionary<string, RemotingObject>(StringComparer.OrdinalIgnoreCase);
        private bool _initialized;

        /// <summary>
        /// RemotingObject个数
        /// </summary>
        public int Count
        {
            get
            {
                return _controllerCache.Count;
            }
        }

        /// <summary>
        /// 是否已加载
        /// </summary>
        public bool Initialized
        {
            get
            {
                return _initialized;
            }
        }

        public void Initialize()
        {
            _initialized = true;
        }

        /// <summary>
        /// 添加controllerType
        /// </summary>
        /// <param name="name"></param>
        /// <param name="controllerType"></param>
        public void AddControllerType(RemotingObject controllerType)
        {
            _controllerCache[controllerType.Request] = controllerType;
        }

        public bool ContainsController(string name)
        {
            return _controllerCache.ContainsKey(name);
        }

        /// <summary>
        /// 根据name获取Controller-Method
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public RemotingObject GetControllerType(string name)
        {
            return _controllerCache[name];
        }
    }

    介绍完核心类后，在介绍下Controller，我的Controller结构如图：

　　UserController定义如下：

  

/// <summary>
    /// /用户Controller
    /// </summary>   

    public class UserController : IController
    {
        public object GetUserInfo()
        {
            return new
                       {
                           ID=1,
                           Name="喜羊羊",
                           Age=31,
                           Address="北京"
                       };
        }
    }

　 UserController定义很简单，跟普通类没什么区别，只是继承了IController,IController只是一个标志接口，定义如下：

  

 public interface IController
    {
    }

    好了，介绍完框架的核心类。要让网站运行起来，我们还需要再做两件事情。

　 第一步：在web.config的httpHandlers中注册处理mthd的Handler。

　　　　　　 <httpHandlers>
      　　　　　　<add path="*.mthd" verb="*" type="Elong.Sticker.Core.HttpHandlers.WebMethodHttpHandler,Elong.Sticker.Core" />
    　　　　　</httpHandlers>

  第二步：添加脚本映射。首先打开IIS，找到处理程序映射，双击打开，找到左边菜单“添加脚本映射”，编辑如下:

   

    "确定"完成，会在站点的web.config中添加

    <system.webServer>
      <modules runAllManagedModulesForAllRequests="true" />
        <handlers>
            <add name="aspnet4Method" path="*.mthd" verb="*" modules="IsapiModule" scriptProcessor="C:WindowsMicrosoft.NETFramework64v4.0.30319aspnet_isapi.dll" resourceType="Unspecified" preCondition="classicMode,runtimeVersionv4.0,bitness64" />
        </handlers>
    </system.webServer>

     新建UserInfo.htm文件，内容如下：

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title></title>
    <script src="lib/jquery-1.4.1.min.js" type="text/javascript"></script>
    <script src="lib/json2template.js" type="text/javascript"></script>
</head>
<body>
<div id="userlist">
<div id="template-userinfo">
<table width="400" align="center">
<tr><td>编号</td><td>姓名</td><td>年龄</td><td>地址</td></tr>
<tr>
<td width="100">{{ID}}</td>
<td width="100">{{Name}}</td>
<td width="100">{{Age}}</td>
<td width="100">{{Address}}</td>
</tr>
</table>
</div>
</div>

<script type="text/javascript">
    $(document).ready(function () {
        var dataSouce = {};
        $.ajax(
{
    url: '/User/GetUserInfo.mthd',
    dataType: "json",
    success: function (data) {
        dataSouce.item = data;
        $("#userlist").bindTemplate({ source: dataSouce, template: $("#template-userinfo") });
    }
});
    });
</script>
</body>
</html>

   现在可以预览了，在浏览器中输入UserInfo.htm页面地址，会等到如下结果：

  

　　好了，感谢阅读，希望这篇文章能给你带来帮助！

     源代码