当前位置：首页 » 网页前端 » 设立一个web框架
扩展阅读
提分平台的账号密码是什么 2023-08-31 22:07:10
webinf下怎么引入js 2023-08-31 21:54:13
堡垒机怎么打开web 2023-08-31 21:54:11

设立一个web框架

发布时间: 2023-01-19 05:40:29

A. 如何设计一个JavaWeb MVC框架

首先要明白mvc框架的主要目的:把视图和逻辑分开，就是降低界面和代码的耦合度。不知道问的是java的mvc还是点net的mvc，总之目的都一样。
1.重写路由和寻址，配置大于设计。MVC的C最重要，就是控制器最重要，尤其是自己的项目越来越大，模块越来越独立，更要注重路由和寻址。可以高效的管理和开发在同一项目里的不同子系统。
2.动态可配。凡事页面动态现实的信息，尽量抽取出来做成可配的数据，公共信息一般存在xml里面，其他存数据库。方便以后整体改版或升级。
3.分层开发，降低耦合度。把界面层，逻辑层，数据层的耦合度降到最低。例如: 想换一种数据库，只需要修改数据层的代码就行了，这样对项目改动最小。千万别数据库查出来的数据直接送到UI层，这样一改全改，一定要定义好每层之间的传输实体。
4.独立成块，可扩展。能独立成模块的尽量独立出来，方便以后维护和扩展。比如想为android和ios提供api。不需要再重写一遍相同的逻辑，直接把模块拿来用就可以了。

B. 如何搭建web前端框架

搭建web前端框架步骤如下：
1、确定项目使用的技术
根据项目的需求等来选择使用的技术（这里以angular4 + typsescript + nodejs+mongodb举例）
2、新建一个项目的工作文件夹
使用npm init初始化项目，根据问题配置，一般是直接回车使用默认配置,生成package.json文件
3、新建一个index.html页面
4、新建配置文件system.config.js
5、新建ts的配置文件tsconfig.json
npm install typescript

6、新建webApp目录，这里面放的是所有html页面和js代码，首先得有个入口文件，与system.config.js配置文件中的入口文件名一样，app.mole.ts，里面引入了所有js文件，不被引入的在加载时都不会被加载
7、打包(将代码压缩，使程序运行速度更快）

C. 谁可以教教我如何搭建一个java web框架

1，在MyEclipse新建出来的web project就是一个web项目，
2，假如你想使用别的开源框架，你开以下载相关jar包，比如可以下载Struts，hibernate和Spring的jar包，将jar包导入到项目中，最后配置xml文件，就是SSH项目了，

D. 如何用Python写一个web框架

STEP.1

我们首先得选择基于什么协议来写这种框架。我们可以选择CGI协议,或者是WSGI接口。如果使用CGI,实际上我们只是按着CGI的规范写了一个python程序，然后每次服务器收到请求,就fork一个程序来执行它，然后返回一个http文档，性能比较低下。对于WSGI，而是一个存在于服务器和应用间的接口，在WSGI之前，web应用都是依赖于服务器的，现在流行的python框架都支持WSGI接口。

STEP.2 PEP-333

这一段是PEP-333 所提供的样例代码。

def simple_app(environ, start_response):
"""Simplest possible application object"""
status = '200 OK'
response_headers = [('Content-type', 'text/plain')]
start_response(status, response_headers)
return ['Hello world! ']

这里的application被传入了两个值。

  • environ

  • start_response。
    environ是一个字典，保存了http请求的信息。
    start_response是一个函数，发送http响应。她有两个参数status 和 start_headers。

  • status必须是由状态编号和具体信息组成的字符串，必须符合RFC 2616。

  • start_headers是一个(header_name,header_value) 元组的列表元组列表。其中的hearder_name必须是合法的http header字段名。在RFC 2616, Section 4.2中有详细定义。
    当然官方还给出了类的实现。

  • def __init__(self, environ, start_response):


  • self.environ = environ


  • self.start = start_response

  • def __iter__(self):


  • status = '200 OK'


  • response_headers = [('Content-type','text/plain')]


  • self.start(status, response_headers)


  • yield "Hello world! "

    • 了解了如上信息后，基本上可以开始了。我们就到官方给的代码上进行修改吧。

    STEP.3 将路径链接到函数

    首先我们得把用户请求的路径，链接到函数。我们可以实现一个getPage方法，专门做这件事。我们所拥有的信息，只有environ['PATH_INFO']。

  • urls = [('^/index/$','func_index'),

  • ('^/comment/$','func_comment'),

  • ('^/environ/$','get_environ'),

  • ('^/post/$','post_test')]#urls是提供给app开发者来做链接的。

  • def getPage(self):

  • path = self.environ['PATH_INFO']

  • for pattern in self.urls:

  • m = re.match(pattern[0],path)#将urls元素的第0项和path进行比对，如果匹配上了，返回函数名

  • if m:

  • function = getattr(self,pattern[1])#getattr方法来得到函数

  • return function()

  • return '404 not found'#没匹配上任何东西

    • 写到这里之后，每次添加页面，就只需要在urls列表中添加一个元祖就行了。

    STEP.4 获取模版

    既然是写web app，模版肯定是得有的。这里我提供了一种getTemplate方法来做这件事。不过我只提供了变量的替换。

  • def getTemplate(self,tem_name,rep=0):

  • #这个函数返回内容,tem_name是文件名字

  • #参数rep是一个字典，默认为0

  • f = open('template/'+tem_name)

  • html = f.read()

  • if(rep!=0):

  • for to_replace in rep:

  • strinfo = re.compile('{\%s*'+str(to_replace)+'s*\%}')

  • html = strinfo.sub(rep[to_replace],html)

  • return html

    • STEP.5 POST数据的处理

    要想获取POST数据，我们得通过environ['wsgi.input']来处理。而他实际上就是系统的标准输入。

  • environ['wsgi.input'] = sys.stdin

    • 知道这点后就很好写了。

  • def getPost(self):

  • if(self.environ['REQUEST_METHOD'] == 'POST'):

  • try:

  • request_body_size = int(self.environ.get('CONTENT_LENGTH', 0))#读出content_length的值

  • except:

  • request_body_size = 0

  • request_body = self.environ['wsgi.input'].read(request_body_size) #请求的body

  • post_data = parse_qs(request_body)#parse_qs是cgi提供的方法，帮助我们处理请求

  • return post_data

    • 数据库的链接

  • import Mysqldb

  • class Model(object):

  • def __init__(self):

  • self.host = 'localhost'

  • self.port = 3306

  • self.user = 'admin'

  • self.passwd = 'admin'

  • self.db = 'xieyi'

  • def build_connect(self):

  • self.conn = MySQLdb.connect(

  • host = self.host,

  • port = self.port,

  • user = self.user,

  • passwd = self.passwd,

  • db = self.db

  • )

  • def exec_ins(self,ins):

  • cur = self.conn.cursor()

  • num = cur.execute(ins)

  • info = {}

  • if(num>0):

  • info = cur.fetchmany(num)

  • cur.close()

  • self.conn.commit()

  • return info

  • def close(self):

  • self.conn.close()

    • STEP.6 清理工作

    很多配置如果放到代码中，会增加阅读负担。于是把urls,model抽取出来。
    使得配置更加方便。



E. 如何开发一个Python web框架

首先你需要知道一个Web应用基本的请求处理流程。以最简单最原始的动态网页为例，你点击链接（GET），提交表单（POST），就是与服务器端建立了连接之后发送了一个HTTP请求（RFC2616 5.1节，之后都以HTTP 1.1为例），里面至少有方法（动词，就是GET啦POST什么的，详见RFC2616第9节），地址（URL），HTTP版本，还可能带上Cookie（会话的一般实现机制），缓存相关的信息（RFC2616 13节），User-Agent串等等一堆信息。对于POST请求我们还有表单内容作为请求实体（RFC2616 7.2节），里面是你填写的表单内容。

于是我们有了一些关于请求的数据，不过现在一般来讲这些数据还在前端服务器（反向代理，比如nginx，暂且忽略掉负载均衡，反正是透明的，也不考虑裸WSGI容器直接扛请求的情况）的手上，还没有传进后端语言（这里是Python）。我们就针对每一种语言都有特定的机制，用来将HTTP的请求信息映射到相应的编程语言范畴，叫做Web服务器界面（Web server interface），通用如CGI/FCGI/SCGI，特定于某一语言如WSGI/PSGI/Rack/...，特定于某一操作系统如ISAPI（这货还活着？），一些已经不再使用的就不提了。总之在Python世界里这就是WSGI（PEP 3333, Web Server Gateway Interface），它就定义了Python语言与Web服务器之间的界面。在WSGI里，

请求的处理过程被映射为对应用callable的调用（application(environ, start_response)，知乎不支持inline代码块？）；
请求信息被映射到environ字典中的相应键值，比如请求方法被映射到environ['REQUEST_METHOD']，请求的“相对路径”被映射到environ['PATH_INFO']（过度简化；暂且不提WSGI应用挂载点，框架层一般也不用关心这个，挂载WSGI应用一般是WSGI容器如gunicorn、uWSGI之类组件的工作）；
发送响应头的动作被映射到调用start_response(status, response_headers)（不考虑可选的第三个参数异常信息）；
返回响应数据被映射到application返回iterable的动作。
于是响应便从Python返回到Web服务器，再被发送回浏览器，浏览器将响应内容渲染，一个请求就完成啦。

有了这样的感性认识，那么我们作为Python Web开发框架的作者，要做的事情就是在WSGI规范的基础之上，提供尽可能便捷的开发手段和尽可能低的框架开销，也即我们的代码将要工作在WSGI与业务逻辑的中间层。架构上，Web开发框架或多或少都遵循MVC的设计模式（Django管它叫MTV，其实差不多）。同时，由于框架位于中间件的位置，加上其鼓励模块化与代码复用的性质，自然需要为常见的HTTP操作提供抽象。这里就可以展开一些话题：
请求路径到view/controller的映射，请求参数的解析（routing，也叫路由）。
正则匹配的方案，比如Django内置了一个简单的正则表达式解析组件，能解析一般常见语法的正则表达式，把capturing groups解析成位置参数，named capturing groups解析成关键字参数。
也有DSL的方案，比如Werkzeug的路由组件。
请求实体的处理。表单解析，配合Web服务器进行上传文件处理。
正常的urlencoded表单，JSON表单，text/plain数据，multi-part表单
multi-part附件，附件操作API
大文件上传（这个一般会被前端服务器保存在磁盘上的临时文件里，比方说nginx就是这么实现的）。
会话。HTTP是无状态（stateless）的，这个特点非常重要。如果没有会话，你连续做几个请求，却没有手段证明你们是同一个人/同一台机器（你完全可能是代理服务器）。
存储会话数据的会话后端（内存数据结构？文件？RDBMS？Redis？Memcache？）
安全机制（HMAC什么的，可以参考beaker的secure cookie实现）
请求处理流程中的会话中间件（从Cookie中提取会话，从query string中提取会话，从自定义头中提取会话，等等）
View/Controller界面。发挥你的创造力，用上你的工程经验。
Function-based or Class-based views? 参考：Django, Bottle, web.py, Tornado等一票框架的做法

框架的可选机制与服务如何暴露，
装饰器？（比如@login_required 这种额外要求）
回调？（能想到的只有Tornado和Twisted这种异步框架做事情的方式，还有整个JS生态系统都是回调（不考虑Promise什么的）的思路）
传入应用（业务逻辑）层的数据结构如何设计？（HttpRequest等价物，名字可能记不清了）
响应数据结构如何设计？（HttpResponse等价物，同上）
数据库操作封装。Web应用基本都是数据为中心，这个组件非常有必要，也是撰写可复用代码必须的一环，毕竟光是框架抽象了，数据库操作还是裸SQL什么的，到时候生产环境一换（比如MySQL变pgsql）还不是傻眼。
关系型数据库。一站式解决方案参考：Django ORM、SQLAlchemy；轻量级解决方案参考各数据库Python绑定。
非关系数据库。各数据库Python绑定（pymongo, riak, redis-py之类），这个没什么可替代方案了，因为本来各种NoSQL库都是适应某一特殊需求设计的，没什么互相替换的必要，那意味着重新进行技术选型。

F. 如何开发一个Python web框架

在Python中，WSGI（Web Server Gateway Interface）定义了Web服务器与Web应用（或Web框架）之间的标准接口。
在WSGI的规范下，各种各样的Web服务器和Web框架都可以很好的交互。
由于WSGI的存在，用Python写一个简单的Web框架也变得非常容易。然而，同很多其他的强大软件一样，要实现一个功能丰富、健壮高效的Web框架并非易事；如果您打算这么做，可能使用一个现成的Web框架（如 Django、Tornado、web.py 等）会是更合适的选择。

G. 如何从零开始搭建一个javaweb企业级应用开发框架

关于JAVAweb的框架，现在大多数无非都是基于SSH(Spring，Struts2/SpringMVC和Hibernate)或者SSM(Spring，Struts2/SpringMVC和Mybatis)
这些现在大多网络都有教程和Demo，参照着多弄几遍，就会用了，要理解还得反复推敲

建议：JAVA的基础打牢，学的就快

H. 如何开发一个Python web框架

  • 预备知识

    web框架主要是实现web服务器和web应用之间的交互。底层的网络协议主要有web服务器完成。譬如监听端口，填充报文等等。

  • Python内建函数__iter__和__call__和WSGI

  1. 迭代器iterator

    为类序列对象提供了类序列的接口，也就是说类序列对象可以通过迭代器像序列一样进行迭代。

  2. __call__

    在类定义的时候实现了__call__方法，那么该类的对象就是可调有的，即可以将对象当做函数来使用。

  3. WSGI

    用可调用的对象实现的：一个函数，一个方法或者一个可调用的实例。

    4. I. 搭建一个web框架需要哪些技术

    这需要看你的框架要达到什么样的标准：
    如果是静态HTML，那么需要掌握Html、css以及JS
    如果是动态的，那么除了上述的要求，还需要掌握相关的脚本语言，如PHP、C#等。
    如果是利用某些CMS二次开发，则需要掌握底层CMS标签或接口。

    J. 纯 Python 写一个 Web 框架，就是这么简单

    造轮子是最好的一种学习方式，本文尝试从0开始造个Python Web框架的轮子，我称它为 ToyWebF 。

    本文操作环境为：MacOS，文中涉及的命令，请根据自己的系统进行替换。

    ToyWebF的简单特性：

    下面我们来实现这些特性。

    首先，我们需要安装gunicorn，回忆一下Flask框架，该框架有内置的Web服务器，但不稳定，所以上线时通常会替换成uWSGI或gunicorn，这里不搞这个内置Web服务，直接使用gunicorn。

    我们创建新的目录与Python虚拟环境，在该虚拟环境中安装gunicorn

    在啥都没有的情况下，构建最简单的Web服务，在ToyWebF目录下，创建app.py与api.py文件，写入下面代码。

    运行 gunicorn app:app 访问 http://127.0.0.1:8000 ，可以看见 Hello, World! ，但现在请求体中的参数在environ变量中，难以解析，我们返回的response也是bytes形式。

    我们可以使用webob库，将environ中的数据转为Request对象，将需要返回的数据转为Response对象，处理起来更加直观方便，直接通过pip安装一下。

    然后修改一下API类的 __call__方法 ，代码如下。

    上述代码中，通过webob库的Request类将environ对象（请求的环境信息）转为容易处理的request，随后调用handle_request方法对request进行处理，处理的结果，通过response对象返回。

    handle_request方法在ToyWebF中非常重要，它会匹配出某个路由对应的处理方法，然后调用该方法处理请求并将处理的结果返回，在解析handle_request前，需要先讨论路由注册实现，代码如下。

    其实就是将路由和方法存到self.routes字典中，可以通过route装饰器的形式将路由和方法关联，也可以通过add_route方法关联，在app.py中使用一下。

    因为url中可以存在变量，如 @app.route("/hello/{name}") ，所以在匹配时，需要进行解析，可以使用正则匹配的方式进行匹配，parse这个第三方库已经帮我们实现了相应的正则匹配逻辑，pip安装使用一下则可。

    这里定义find_handler方法来实现对self.routes的遍历。

    了解了路由与方法关联的原理后，就可以实现handle_request方法，该方法主要的路径就是根据路由调度对应的方法，代码如下。

    在该方法中，首先实例化webob库的Response对象，然后通过self.find_handler方法获取此次请求路由对应的方法和对应的参数，比如。

    它将返回hello方法对象和name参数，如果是 /hello/二两 ，那么name就是二两。

    因为route装饰器可能装饰器的类对象，比如。

    此时self.find_handler方法返回的hanler就是个类，但我们希望调用的是类中的get、post、delete等方法，所以需要一个简单的判断逻辑，通过inspect.isclass方法判断handler如果是类对象，那么就通过getattr方法获取类对象实例的中对应的请求方法。

    如果类对象中没有该方法属性，则抛出该请求类型不被允许的错误，如果不是类对象或类对象中存在该方法属性，则直接调用则可。

    此外，如果方法的路由并没有注册到self.routes中，即404的情况，定义了defalut_response方法返回其中内容，代码如下。

    如果handle_request方法中调度的过程出现问题，则直接raise将错误抛出。

    至此，一个最简单的web服务就编写完成了。

    回顾Flask，Flask可以支持HTML、CSS、JavaScript等静态文件，利用模板语言，可以构建出简单但美观的Web应用，我们让TopWebF也支持这一功能，最终实现图中的网站，完美兼容静态文件。

    Flask使用了jinja2作为其html模板引擎，ToyWebF同样使用jinja2，jinja2其实实现一种简单的DSL（领域内语言），让我们可以在HTML中通过特殊的语法改变HTML的结构，该项目非常值得研究学习。

    首先 pip install jinja2 ，然后就可以使用它了，在ToyWebF项目目录中创建templates目录，以该目录作为默认的HTML文件根目录，代码如下。

    首先利用jinja2的FileSystemLoader类将file system中的某个文件夹作为loader，然后初始化Environment。

    在使用的过程中（即调用template方法），通过get_template方法获得具体的某个模板并通过render方法将对应的内容传递给模板中的变量。

    这里我们不写前端代码，直接去互联网中下载模板，这里下载了Bootstrap提供的免费模板，可以自行去 https://startbootstrap.com/themes/freelancer/ 下载，下载完后，你会获得index.html以及对应的css、jss、img等文件，将index.html移动到ToyWebF/templates中并简单修改了一下，添加一些变量。

    然后在app.py文件中为index.html定义路由以及需要的参数。

    至此html文件的支持就完成了，但此时的html无法正常载入css和js，导致页面布局非常丑陋且交互无法使用。

    接着就让ToyWebF支持css、js，首先在ToyWebF目录下创建static文件夹用于存放css、js或img等静态文件，随后直接将前面下载的模板，其中的静态文件复制到static中则可。

    通过whitenoise第三方库，可以通过简单的几行代码让web框架支持css和js，不需要依赖nginx等服务，首先 pip install whitenoise ，随后修改API类的 __init__ 方法，代码如下。

    其实就是通过WhiteNoise将self.wsgi_app方法包裹起来，在调用API的 __call__ 方法时，直接调用self.whitenoise。

    此时，如果请求web服务获取css、js等静态资源，WhiteNoise会获取其内容并返回给client，它在背后会匹配静态资源在系统中对应的文件并将其读取返回。

    至此，一开始的网页效果就实现好了。

    web服务如果出现500时，默认会返回 internal server error ，这显得比较丑，为了让框架使用者可以自定义500时返回的错误，需要添加一些代码。

    首先API初始化时，初始self.exception_handler对象并定义对应的方法添加自定义的错误

    在handler_request方法进行请求调度时，调度的方法执行逻辑时报500，此时不再默认将错误抛出，而是先判断是否有自定义错误处理。

    在app.py中，自定义错误返回方法，如下。

    custom_exception_handler方法只返回自定义的一段话，你完全可以替换成美观的template。

    我们可以实验性定义一个路由来看效果。

    Web服务的中间件也可以理解成钩子，即在请求前可以对请求做一些处理或者返回Response前对Response做一下处理。

    为了支持中间件，在TopWebF目录下创建middleware.py文件，在编写代码前，思考一下如何实现？

    回顾一下现在请求的调度逻辑。

    1.通过routes装饰器关联路由和方法 2.通过API.whitenoise处理 3.如果是请求API接口，那么会将参数传递给API.wsgi_app 4.API.wsgi_app最终会调用API.handle_request方法获取路由对应的方法并调用该方法执行相应的逻辑

    如果希望在request前以及response后做相应的操作，那么其实就需要让逻辑在API.handle_request前后执行，看一下代码。

    其中add方法会实例化Middleware对象，该对象会将当前的API类实例包裹起来。

    Middleware.handle_request方法其实就是在self.app.handle_request前调用self.process_request方法处理request前的数据以及调用self.process_response处理response后的数据，而核心的调度逻辑，依旧交由API.handle_request方法进行处理。

    这里的代码可能会让人感到疑惑， __call__ 方法和handle_request方法中都有self.app.handle_request(request)，但其调用对象似乎不同？这个问题暂时放一下，先继续完善代码，然后再回来解释。

    接着在api.py中为API创建middleware属性以及添加新中间件的方法。

    随后，在app.py中，自定义一个简单的中间件，然后调用add_middleware方法将其添加。

    定义好中间件后，在请求调度时，就需要使用中间件，为了兼容静态文件的情况，需要对css、js、ing文件的请求路径做一下兼容，在其路径中加上/static前缀

    紧接着，修改API的 __call__ ，兼容中间件和静态文件，代码如下。

    至此，中间件的逻辑就完成了。

    但代码中依旧有疑惑，Middleware类中的 __call__ 方法和handle_request方法其调用的self.app到底是谁？

    为了方便理解，这里一步步拆解。

    如果没有添加新的中间件，那么请求的调度逻辑如下。

    在没有添加中间件的情况下，self.app其实就是API本身，所以 middleware.__call__ 中的self.app.handle_request就是调用API.handle_request。

    如果添加了新的中间件，如上述代码中添加了名为SimpleCustomMiddleware的中间件，此时的请求调度逻辑如下。

    因为注册中间件时，Middleware.add方法替换了原始Middleware实例中的app对象，将其替换成了SimpleCustomMiddleware，而SimpleCustomMiddleware也有app对象，SimpleCustomMiddleware中的app对象，才是API类实例。

    在请求调度的过程中，就会触发Middleware类的handle_request方法，该方法就会执行中间件相应的逻辑去处理request和response中的数据。

    当然，你可以通过Middleware.add方法添加多个中间件，这就会构成栈式调用的效果，代码如下。

    启动web服务后，其执行效果如下。

阅读全文

与设立一个web框架相关的内容

本站内容整理源于互联网，如有问题请联系解决。
Copyright design: www.gotrillian.com since 2022