标签: middleware

我想知道，如何使用django中间件，它们的用途是什么？什么事情我不能没有他们。

django 的 HttpRequest 和 HttpResponse 不是足以处理我可能需要的各种事情吗？

最后，当我开始思考我需要去 django 的中间件时。

谢谢！

我有一个简单的中间件:

public class MiddlewareInterceptor
{
    RequestDelegate _next;
    public MiddlewareInterceptor(RequestDelegate next)
    {
        _next = next;
    }

    public Task Invoke(HttpContext ctx)
    {
        ctx.Response.WriteAsync("<h2>From SomeMiddleWare</h2>");
        return _next(ctx);
    }
}

在我的Startup.cs配置方法中,我像这样挂钩:

app.UseMiddleware<MiddlewareInterceptor>();

上面的构建和应用程序似乎运行正常,但我在拦截器Invoke方法中的断点永远不会命中.同样,从来没有任何产出.我也试过了Debug.WriteLine.

现在,我也试过这个方法:

public class MiddlewareInterceptor : OwinMiddleware
{
    public MiddlewareInterceptor(OwinMiddleware next) : base(next){}

    public override async Task Invoke(IOwinContext context)
    {
        Debug.WriteLine(context.Request.Uri.ToString());
        await Next.Invoke(context);
    }
}

在我的Startup.cs配置方法中,我像这样挂钩:

app.Use(next => new MiddlewareInterceptor(next).Invoke);

不幸的是,基础OwinMiddleware构造函数正在寻找下一个OwinMiddleware作为参数,与你不同RequestDelegate.所以我的app.Use实例化MiddlewareInterceptor失败是因为next类型RequestDelegate.

最后,我在Configure方法中直接尝试了一个内联函数,它也永远不会遇到断点:

app.Use(async (ctx, next) => …

我正在 node.js 中构建一个应用程序。

我编写了一个中间件函数钩子，每当有人在我的应用程序上发出 GET 请求时都会执行该钩子，比如他们进入主页、个人资料页面等。该钩子从另一个 API 发出 HTTP 请求以收集数据。

我的问题是如何在客户端访问该数据？这是我的中间件钩子：

var request = require('request');

module.exports = {
    authentication: function (req, res, next) {
       if (req.method === 'GET') { 
        console.log('This is a GET request');
         request("http://localhost:3000/api/employee", function(err, res, body) {
            console.log(res.body);
         });
       }
       next();
    }
};

它用于我的所有路线：

app.use(middleware.authentication)

示例路线：

router.get('/', function(req, res, next) {
    res.render('../views/home');
});

注意我使用了console.log(res.body)，但我想在客户端打印它的内容。有谁知道如何做到这一点？

我们有一个 NodeJS Express 应用程序，我们已经为其实现了自定义分析后端。现在，我们正在决定如何为功能手机等禁用 JS 的浏览器实现跟踪机制。

我们正在考虑的一种设计方法是创建一个中间件，它拦截每个请求，从请求/上下文中提取参数并将它们发送到后端。这是非常可扩展的，对于像我们这样的自定义分析解决方案非常有意义。

另一种方法是像谷歌分析一样创建一个跟踪像素，然后从中提取数据。但对于自定义跟踪解决方案来说，这似乎是一个可扩展性较差的解决方案，因为与 GA 不同，参数和数据结构可以随时更改或扩展。

我的问题是 - 制作发出异步请求的中间件是否有任何反面？在创建它时我们需要注意什么，因为对我们服务器的每个请求都将通过这个中间件？我们是一个相当大的应用程序，每分钟有数十万的流量。

我按照教程,但是,我收到控制台错误:

" 错误:期望减速器成为一个功能 "

这是我的(相关)配置:

WEBPACK.CONFIG.JS:

...
const TARGET = process.env.npm_lifecycle_event;
process.env.BABEL_ENV = TARGET;
...
if( TARGET === "start" || !TARGET ) {
    module.exports = merge( common, {
        devtool : "inline-source-map",
        devServer : {
            contentBase : PATHS.build,
            hot : true,
            progress : true,
            stats : "errors-only"
        },
        plugins : [
            new webpack.HotModuleReplacementPlugin(),
            new webpack.DefinePlugin({
                "process.env.NODE_ENV" : JSON.stringify( "production" )
            })
        ]
    } );
}

INDEX.JS:

import React from "react";
import { render } from "react-dom";
import { Provider …

我使用python Selenium和Scrapy来抓取一个网站.

但我的剧本很慢,

Crawled 1 pages (at 1 pages/min)

我使用CSS SELECTOR而不是XPATH来优化时间.我改变了中间件

'tutorial.middlewares.MyCustomDownloaderMiddleware': 543,

是Selenium太慢还是我应该在Setting中改变一些东西？

我的代码:

def start_requests(self):
    yield Request(self.start_urls, callback=self.parse)
def parse(self, response):
    display = Display(visible=0, size=(800, 600))
    display.start()
    driver = webdriver.Firefox()
    driver.get("http://www.example.com")
    inputElement = driver.find_element_by_name("OneLineCustomerAddress")
    inputElement.send_keys("75018")
    inputElement.submit()
    catNums = driver.find_elements_by_css_selector("html body div#page div#main.content div#sContener div#menuV div#mvNav nav div.mvNav.bcU div.mvNavLk form.jsExpSCCategories ul.mvSrcLk li")
    #INIT
    driver.find_element_by_css_selector(".mvSrcLk>li:nth-child(1)>label.mvNavSel.mvNavLvl1").click()
    for catNumber in xrange(1,len(catNums)+1):
        print "\n IN catnumber \n"
        driver.find_element_by_css_selector("ul#catMenu.mvSrcLk> li:nth-child(%s)> label.mvNavLvl1" % catNumber).click()
        time.sleep(5)
        self.parse_articles(driver)
        pages = driver.find_elements_by_xpath('//*[@class="pg"]/ul/li[last()]/a')

        if(pages):
            page = driver.find_element_by_xpath('//*[@class="pg"]/ul/li[last()]/a')

            checkText = …

我的 API 服务器具有从请求标头获取令牌的中间件。如果访问正确，则执行下一个功能。

但是请求去了中间件，然后去了下一个函数，c.Request.Body变成了0。

中间件

func getUserIdFromBody(c *gin.Context) (int) {
    var jsonBody User

    length, _ := strconv.Atoi(c.Request.Header.Get("Content-Length"))
    body := make([]byte, length)
    length, _ = c.Request.Body.Read(body)
    json.Unmarshal(body[:length], &jsonBody)

    return jsonBody.Id
}

func CheckToken() (gin.HandlerFunc) {
    return func(c *gin.Context) {
        var userId int

        config := model.NewConfig()

        reqToken := c.Request.Header.Get("token")

        _, resBool := c.GetQuery("user_id")
        if resBool == false {
            userId = getUserIdFromBody(c)
        } else {
            userIdStr := c.Query("user_id")
            userId, _ = strconv.Atoi(userIdStr)
        }
    ...
        if ok {
            c.Nex()
            return …

假设我有以下类，受Django文档的启发：

class SimpleMiddleware(object):

    def __ init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):


        response = self.get_response(request)


        return response

    def process_view(self, request, view_func, view_args, view_kwargs):

        return None

Run Code Online (Sandbox Code Playgroud)

在阅读Daniel Rubio的书“ Beginning Django”时，他解释说执行的顺序是：

1. __ init __ 触发方法（服务器启动时）
2. __ call __ 触发方法（针对每个请求）
3. 如果声明，则process_view()触发方法
4. 查看方法以中的self.get_response(request)语句开头__ call __

“ __ call __（在每个请求上触发）方法”到底是什么意思？不会“触发”该__ call __方法实际上self.get_respone(request)自动触发“ ”，从而调用另一个中间件或类吗？

Django文档指出：

process_view() 在Django调用视图之前被调用。

对我来说，这将意味着Django检查'SimpleMiddleware'类的实例是否包含方法'process_view()'，然后在继续调用该__ call __()方法之前触发该方法，即“调用视图”？否则，如果__ call __立即触发该方法，process_view()由于该__ call __ …

我有以下Go代码：

package main

import (
  "encoding/json"
  "fmt"
  "github.com/gorilla/mux"
  "github.com/gorilla/handlers"
  "log"
  "net/http"
  "io/ioutil"
)

type rLog struct {
  Method string
  URI string
  FormParam string
}

func commonMiddleware(next http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Header().Add("Content-Type", "application/json")
    formBs, err := ioutil.ReadAll(r.Body)
    if err != nil {
      log.Fatalf("Failed to decode postFormByteSlice: %v", err)
    }
    rl := rLog{Method: r.Method, URI: r.RequestURI, FormParam: string(formBs)}
    log.Printf("%+v", rl)
    next.ServeHTTP(w, r)
  })
}

func main() {
  port := ":3000"
  var router = mux.NewRouter()
  router.Use(commonMiddleware)
  router.HandleFunc("/m/{msg}", handleMessage).Methods("GET") …

而不是在 main() 下写每条路线，比如

func main() {
    e := echo.New()
    e.GET("/api", sayHello)
    e.GET("/api/music", getMusic)
    e.GET("/api/user/:id", getDetail)
    e.POST("/api/user", addUser)
    // ...
}

如何从名为 的文件中导入所有这些子路由api.go，并在主函数中使用这些子路由？相似

import "./API"
func main() {
    e := echo.New()
    e.UseSubroute(API.Routes) // <-- similar to this
    // ...
}