Hinzufügen von header in der Antwort im filter?

Muss ich fügen Sie die Kopfzeile in jeder Antwort. Ich bin Planung zu tun, unter

public class MyFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        filterChain.doFilter(request, response);
            response.addHeader("Access-Control-Allow-Origin", "*"); 
    }

}

Möchte ich es tun, nachdem filterChain.doFilter(request, response) so dass, wenn controller Sie verarbeiten kann, ich nur hinzufügen header vor der Rückkehr
an den client. Ist es richtig ?

Aber pro Wie auf Antwort schreiben filter?

Nach chain.doFilter zurückgegeben hat, ist es zu spät, etwas zu tun mit
die Antwort. An diesem Punkt, die gesamte Antwort wurde bereits an die
client und dein code hat keinen Zugriff darauf.

Obige Aussage nicht gut aussieht für mich. Ich kann nicht hinzufügen header nach filterChain.doFilter(request, response) ? Wenn nicht, warum nicht ?

bin ich mit spring mvc.

Kannst du nicht mit einem Spring MVC interceptor statt einen filter?

InformationsquelleAutor emilly | 2015-09-28

  1. 14

    Nach filterChain.doFilter heißt, es ist zu spät, etwas zu tun mit der Antwort. An diesem Punkt, die gesamte Antwort wurde bereits an den client gesendet.

    Müssen Sie erstellen eine wrap-Antwort in Ihren eigenen Klassen, übergeben Sie diese Wrapper in doFilter Methode, um jegliche Verarbeitung in Ihrer Wrapper.

    Es ist schon ein Antwort wrapper: HttpServletResponseWrapper, die Sie erweitern können. Zum Beispiel:

    public class MyResponseRequestWrapper extends HttpServletResponseWrapper{
    public MyResponseRequestWrapper(HttpServletResponse response) {
        super(response);
    }
}

    Dein filter:

    @Override
protected void doFilterInternal(HttpServletRequest request,
                                HttpServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {

    HttpServletResponse myResponse = (HttpServletResponse) response;
    MyResponseRequestWrapper responseWrapper = new MyResponseRequestWrapper(myResponse);
    responseWrapper.addHeader("Access-Control-Allow-Origin", "*");
    filterChain.doFilter(request, myResponse);
}
    Gründe für die Verwendung von wrapper in deinem Beispiel, anstatt nur das hinzufügen von header-zu original-Implementierung übergeben container? Ich denke wrapper macht nur Sinn, wenn Sie implementieren, einige Logik-innen, um sicherzustellen, dass Sie Ihren Kopf nicht entfernt werden/überschrieben, irgendwo auf der Filterkette.
    in Ihrer Antwort oben sollte Sie nicht vorbei responseWrapper zu filterChain.doFilter?
    Danke für die Antwort Luan!! In meinem Fall wollte ich den header nur für die 404 Art der Reaktion, so wie bereits in der Antwort habe ich den folgenden code in meinem wrapper-Klasse: @Override public void sendError(int sc) throws IOException { if (sc == 404) { this.setHeader("X-ServiceFabric", "ResourceNotFound"); } super.sendError(sc); }

    InformationsquelleAutor Luan

  2. 0

    Vom perfekten Artikel

    Einen filter, ändert, muss die Antwort in der Regel das erfassen der Antwort, bevor es an den client zurückgegeben. Um dies zu tun, übergeben Sie einen stand-in-stream des servlet generiert die Antwort. Die stand-in-stream verhindert, dass das servlet aus dem schließen der original-Antwort stream, wenn es abgeschlossen ist und ermöglicht, den filter zu ändern Sie die servlet-Antwort.

    Passieren diese stand-stream, um das servlet, das filter erzeugt ein Antwort-wrapper, der überschreibt die getWriter oder getOutputStream-Methode zum zurückgeben dieser stand-stream. Der wrapper übergeben wird, der doFilter Methode des filter-Kette. Wrapper-Methoden, die standardmäßig ruft die gewickelten request-oder response-Objekt. Dieser Ansatz folgt dem bekannten Wrapper oder Dekorator-Muster beschrieben, in Design-Patterns,

    InformationsquelleAutor M Sach

  3. 0

    Dies ist ein wenig spät, aber unten könnte helfen, einige
    Also, wenn Sie wirklich wollten, um Anhängen von Werten an eine vorhandene Kopf-oder neue Werte hinzufügen, eine vorhandene Kopf -, der beste Weg möglich zu schreiben, eine Schutzfolie, und legen Sie den Wert wrapper.

    Dann Kette die Resonanz im filter

    HttpServletResponse response = (HttpServletResponse) servletResponse;
ByteArrayPrinter pw = new ByteArrayPrinter();

//Create a wrapper
HttpServletResponse wrappedResp = new HttpServletResponseWrapper(response) {

    @Override
    public void setContentType(final String type) {
        super.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
    }

    @Override
    public PrintWriter getWriter() {
        return pw.getWriter();
    }

    //set the outputstream content type to JSON
    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        ServletResponse response = this.getResponse();

        String ct = (response != null) ? response.getContentType() : null;
        if (ct != null && ct.contains(APPLICATION_XHTML)) {
            response.setContentType(ct + AppConstants.CONSTANT_COMMA + MediaType.APPLICATION_JSON_UTF8_VALUE);
        }
        return pw.getStream();
    }

};
chain.doFilter(httpRequest, wrappedResp);

    Hier ist die ByteArrayPrinter.java

    public class ByteArrayPrinter {

    private ByteArrayOutputStream baos = new ByteArrayOutputStream();

    private PrintWriter pw = new PrintWriter(baos);

    private ServletOutputStream sos = new ByteArrayServletStream(baos);

    public PrintWriter getWriter() {
        return pw;
    }

    public ServletOutputStream getStream() {
        return sos;
    }

    byte[] toByteArray() {
        return baos.toByteArray();
    }
}

    Und hier ist die ByteArrayServletOutputStream

    public class ByteArrayServletStream extends ServletOutputStream {

    ByteArrayOutputStream baos;

    ByteArrayServletStream(ByteArrayOutputStream baos) {
        this.baos = baos;
    }

    @Override
    public void write(int param) throws IOException {
        baos.write(param);
    }

    @Override
    public boolean isReady() {
        //TODO Auto-generated method stub
        return false;
    }

    @Override
    public void setWriteListener(WriteListener listener) {
        //TODO Auto-generated method stub

    }

}

    InformationsquelleAutor Joey587

Schreibe einen Kommentar