InMemoryResponse.java

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *   http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing,
  13.  * software distributed under the License is distributed on an
  14.  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  15.  * KIND, either express or implied.  See the License for the
  16.  * specific language governing permissions and limitations
  17.  * under the License.
  18.  */
  19. package org.apache.commons.jcs3.jcache.extras.web;

  20. import java.io.IOException;
  21. import java.io.OutputStream;
  22. import java.io.OutputStreamWriter;
  23. import java.io.PrintWriter;
  24. import java.io.Serializable;
  25. import java.util.ArrayList;
  26. import java.util.Collection;
  27. import java.util.LinkedList;
  28. import java.util.List;
  29. import java.util.Map;
  30. import java.util.TreeMap;
  31. import java.util.concurrent.CopyOnWriteArraySet;
  32. import javax.servlet.ServletOutputStream;
  33. import javax.servlet.http.Cookie;
  34. import javax.servlet.http.HttpServletResponse;
  35. import javax.servlet.http.HttpServletResponseWrapper;

  36. public class InMemoryResponse extends HttpServletResponseWrapper implements Serializable
  37. {
  38.     private final OutputStream buffer;

  39.     private final Collection<Cookie> cookies = new CopyOnWriteArraySet<>();
  40.     private final Map<String, List<Serializable>> headers = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
  41.     private int status = SC_OK;
  42.     private String contentType;
  43.     private PrintWriter writer;
  44.     private int contentLength;

  45.     public InMemoryResponse(final HttpServletResponse response, final OutputStream baos)
  46.     {
  47.         super(response);
  48.         this.buffer = baos;
  49.     }

  50.     private List<Serializable> ensureHeaderExists(final String s)
  51.     {
  52.         return headers.computeIfAbsent(s, k -> new LinkedList<>());
  53.     }

  54.     @Override
  55.     public void addCookie(final Cookie cookie)
  56.     {
  57.         super.addCookie(cookie);
  58.         cookies.add(cookie);
  59.     }

  60.     @Override
  61.     public void addDateHeader(final String s, final long l)
  62.     {
  63.         super.addDateHeader(s, l);
  64.         ensureHeaderExists(s).add(l);
  65.     }

  66.     @Override
  67.     public void addHeader(final String s, final String s2)
  68.     {
  69.         super.addHeader(s, s2);
  70.         ensureHeaderExists(s).add(s2);
  71.     }

  72.     @Override
  73.     public void addIntHeader(final String s, final int i)
  74.     {
  75.         super.addIntHeader(s, i);
  76.         ensureHeaderExists(s).add(i);
  77.     }

  78.     @Override
  79.     public boolean containsHeader(final String s)
  80.     {
  81.         return headers.containsKey(s);
  82.     }

  83.     @Override
  84.     public String getHeader(final String s)
  85.     {
  86.         final List<Serializable> serializables = headers.get(s);
  87.         if (serializables.isEmpty())
  88.         {
  89.             return null;
  90.         }
  91.         return serializables.iterator().next().toString();
  92.     }

  93.     @Override
  94.     public Collection<String> getHeaderNames()
  95.     {
  96.         return headers.keySet();
  97.     }

  98.     @Override
  99.     public Collection<String> getHeaders(final String s)
  100.     {
  101.         final List<Serializable> serializables = headers.get(s);
  102.         final Collection<String> strings = new ArrayList<>(serializables.size());
  103.         for (final Serializable ser : serializables)
  104.         {
  105.             strings.add(ser.toString());
  106.         }
  107.         return strings;
  108.     }

  109.     @Override
  110.     public int getStatus()
  111.     {
  112.         return status;
  113.     }

  114.     @Override
  115.     public void sendError(final int i) throws IOException
  116.     {
  117.         status = i;
  118.         super.sendError(i);
  119.     }

  120.     @Override
  121.     public void sendError(final int i, final String s) throws IOException
  122.     {
  123.         status = i;
  124.         super.sendError(i, s);
  125.     }

  126.     @Override
  127.     public void sendRedirect(final String s) throws IOException
  128.     {
  129.         status = SC_MOVED_TEMPORARILY;
  130.         super.sendRedirect(s);
  131.     }

  132.     @Override
  133.     public void setDateHeader(final String s, final long l)
  134.     {
  135.         super.setDateHeader(s, l);
  136.         final List<Serializable> serializables = ensureHeaderExists(s);
  137.         serializables.clear();
  138.         serializables.add(l);
  139.     }

  140.     @Override
  141.     public void setHeader(final String s, final String s2)
  142.     {
  143.         super.setHeader(s, s2);
  144.         final List<Serializable> serializables = ensureHeaderExists(s);
  145.         serializables.clear();
  146.         serializables.add(s2);
  147.     }

  148.     @Override
  149.     public void setIntHeader(final String s, final int i)
  150.     {
  151.         super.setIntHeader(s, i);
  152.         final List<Serializable> serializables = ensureHeaderExists(s);
  153.         serializables.clear();
  154.         serializables.add(i);
  155.     }

  156.     @Override
  157.     public void setStatus(final int i)
  158.     {
  159.         status = i;
  160.         super.setStatus(i);
  161.     }

  162.     @Override
  163.     public void setStatus(final int i, final String s)
  164.     {
  165.         status = i;
  166.         super.setStatus(i, s);
  167.     }

  168.     @Override
  169.     public String getContentType()
  170.     {
  171.         return contentType;
  172.     }

  173.     @Override
  174.     public ServletOutputStream getOutputStream() throws IOException
  175.     {
  176.         return new ServletOutputStream()
  177.         {
  178.             @Override
  179.             public void write(final int b) throws IOException
  180.             {
  181.                 buffer.write(b);
  182.             }
  183.         };
  184.     }

  185.     @Override
  186.     public PrintWriter getWriter() throws IOException
  187.     {
  188.         if (writer == null) {
  189.             writer = new PrintWriter(new OutputStreamWriter(buffer, getCharacterEncoding()), true);
  190.         }
  191.         return writer;
  192.     }

  193.     @Override
  194.     public void reset()
  195.     {
  196.         super.reset();
  197.         status = SC_OK;
  198.         headers.clear();
  199.         cookies.clear();
  200.         contentType = null;
  201.         contentLength = 0;
  202.     }

  203.     @Override
  204.     public void setContentLength(final int i)
  205.     {
  206.         super.setContentLength(i);
  207.         contentLength = i;
  208.     }

  209.     @Override
  210.     public void setContentType(final String s)
  211.     {
  212.         contentType = s;
  213.         super.setContentType(s);
  214.     }

  215.     @Override
  216.     public void flushBuffer() throws IOException
  217.     {
  218.         if (writer != null)
  219.         {
  220.             writer.flush();
  221.         }
  222.         else
  223.         {
  224.             buffer.flush();
  225.         }
  226.     }

  227.     public int getContentLength()
  228.     {
  229.         return contentLength;
  230.     }

  231.     public Collection<Cookie> getCookies()
  232.     {
  233.         return cookies;
  234.     }

  235.     public Map<String, List<Serializable>> getHeaders()
  236.     {
  237.         return headers;
  238.     }
  239. }