Solr 6.0 学习（十）QueryResponseWriter 源码解析

QueryResponseWriter 源码解析

看到上一篇
中获取响应回写实例的时候返回类型为：QueryResponseWriter

public final QueryResponseWriter getQueryResponseWriter(String writerName)
QueryResponseWriter responseWriter = core.getQueryResponseWriter("upxiaofeng");

那我们看看QueryResponseWriter 源码

package org.apache.solr.response;

import java.io.IOException;
import java.io.Writer;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.request.SolrQueryRequest;
import org.apache.solr.util.plugin.NamedListInitializedPlugin;

public abstract interface QueryResponseWriter extends NamedListInitializedPlugin
{
  public static final String CONTENT_TYPE_XML_UTF8 = "application/xml; charset=UTF-8";
  public static final String CONTENT_TYPE_TEXT_UTF8 = "text/plain; charset=UTF-8";
  public static final String CONTENT_TYPE_TEXT_ASCII = "text/plain; charset=US-ASCII";
  //响应
  public abstract void write(Writer paramWriter, SolrQueryRequest paramSolrQueryRequest, SolrQueryResponse paramSolrQueryResponse)
    throws IOException;
  //获取响应数据类型
  public abstract String getContentType(SolrQueryRequest paramSolrQueryRequest, SolrQueryResponse paramSolrQueryResponse);
  //初始化
  public abstract void init(NamedList paramNamedList);
}

那该如何实现这个接口呢？我们找到solr6.0的包，在solr-6.0.0\solr-6.0.0\example\example-DIH\solr\solr\conf 找到solrconfig.xml
我们找到如下配置：

  <queryResponseWriter name="json" class="solr.JSONResponseWriter">
     <!-- For the purposes of the tutorial, JSON responses are written as
      plain text so that they are easy to read in *any* browser.
      If you expect a MIME type of "application/json" just remove this override.
     -->
    <str name="content-type">text/plain; charset=UTF-8</str>
  </queryResponseWriter>

QueryResponseWriter实现之 JSONResponseWriter

那我们看下JSONResponseWriter又是如何实现的，可以参考。下面是JSONResponseWriter的源码。

package org.apache.solr.response;

import java.io.IOException;
import java.io.Writer;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.request.SolrQueryRequest;

public class JSONResponseWriter
  implements QueryResponseWriter
{
  public static String CONTENT_TYPE_JSON_UTF8 = "application/json; charset=UTF-8";

  private String contentType = CONTENT_TYPE_JSON_UTF8;
//初始化
//获取配置文件中配置的数据字符类型
//<str name="content-type">text/plain; charset=UTF-8</str>
  public void init(NamedList namedList)
  {
    String contentType = (String)namedList.get("content-type");
    if (contentType != null)
      this.contentType = contentType;
  }

  public void write(Writer writer, SolrQueryRequest req, SolrQueryResponse rsp)
    throws IOException
  {
    JSONWriter w = new JSONWriter(writer, req, rsp);
    try {
      w.writeResponse();
    } finally {
      w.close();
    }
  }
  public String getContentType(SolrQueryRequest request, SolrQueryResponse response)
  {
    return this.contentType;
  }
}

如下是JSONWriter的源码

package org.apache.solr.response;

import java.io.IOException;
import java.io.Writer;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.params.SolrParams;
import org.apache.solr.common.util.NamedList;
import org.apache.solr.common.util.SimpleOrderedMap;
import org.apache.solr.request.SolrQueryRequest;
import org.apache.solr.search.ReturnFields;
import org.apache.solr.util.FastWriter;
//继承TextResponseWriter
class JSONWriter extends TextResponseWriter
{
  private String namedListStyle;
  private String wrapperFunction;
  private static final String JSON_NL_STYLE = "json.nl";
  private static final String JSON_NL_MAP = "map";
  private static final String JSON_NL_FLAT = "flat";
  private static final String JSON_NL_ARROFARR = "arrarr";
  private static final String JSON_NL_ARROFMAP = "arrmap";
  private static final String JSON_WRAPPER_FUNCTION = "json.wrf";
  private static char[] hexdigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

  public JSONWriter(Writer writer, SolrQueryRequest req, SolrQueryResponse rsp)
  {
    super(writer, req, rsp);
    this.namedListStyle = req.getParams().get("json.nl", "flat").intern();
    this.wrapperFunction = req.getParams().get("json.wrf");
  }

  public void writeResponse() throws IOException {
    if (this.wrapperFunction != null) {
      this.writer.write(this.wrapperFunction + "(");
    }
    Boolean omitHeader = this.req.getParams().getBool("omitHeader");
    if ((omitHeader != null) && (omitHeader.booleanValue())) this.rsp.removeResponseHeader();
    //this.rsp.getValues()
    //获取SolrQueryResponse返回的值
    writeNamedList(null, this.rsp.getValues());
    if (this.wrapperFunction != null) {
      this.writer.write(')');
    }
    this.writer.write('\n');
  }

  protected void writeKey(String fname, boolean needsEscaping) throws IOException {
    writeStr(null, fname, needsEscaping);
    this.writer.write(':');
  }

  protected void writeNamedListAsMapMangled(String name, NamedList val)
    throws IOException
  {
    //...
  }

  protected void writeNamedListAsMapWithDups(String name, NamedList val)
    throws IOException
  {
    //...
  }
  //将返回值处理成json格式
  protected void writeNamedListAsArrMap(String name, NamedList val)
    throws IOException
  {
    int sz = val.size();
    indent();
    writeArrayOpener(sz);
    incLevel();

    boolean first = true;
    for (int i = 0; i < sz; i++) {
      String key = val.getName(i);

      if (first)
        first = false;
      else {
        writeArraySeparator();
      }

      indent();

      if (key == null) {
        writeVal(null, val.getVal(i));
      } else {
        writeMapOpener(1);
        writeKey(key, true);
        writeVal(key, val.getVal(i));
        writeMapCloser();
      }

    }

    decLevel();
    writeArrayCloser();
  }

  protected void writeNamedListAsArrArr(String name, NamedList val)
    throws IOException
  {
    //...
  }

  protected void writeNamedListAsFlat(String name, NamedList val)
    throws IOException
  {
    //...
  }

  public void writeNamedList(String name, NamedList val)
    throws IOException
  {
    if ((val instanceof SimpleOrderedMap))
      writeNamedListAsMapWithDups(name, val);
    else if (this.namedListStyle == "flat")
      writeNamedListAsFlat(name, val);
    else if (this.namedListStyle == "map")
      writeNamedListAsMapWithDups(name, val);
    else if (this.namedListStyle == "arrarr")
      writeNamedListAsArrArr(name, val);
    else if (this.namedListStyle == "arrmap")
      writeNamedListAsArrMap(name, val);
  }

  public void writeSolrDocument(String name, SolrDocument doc, ReturnFields returnFields, int idx)
    throws IOException
  {
    if (idx > 0) {
      writeArraySeparator();
    }

    indent();
    writeMapOpener(doc.size());
    incLevel();

    boolean first = true;
    for (String fname : doc.getFieldNames()) {
      if ((returnFields == null) || (returnFields.wantsField(fname)))
      {
        if (first) {
          first = false;
        }
        else {
          writeMapSeparator();
        }

        indent();
        writeKey(fname, true);
        Object val = doc.getFieldValue(fname);

        if ((val instanceof List))
        {
          writeArray(name, ((Iterable)val).iterator());
        }
        else writeVal(fname, val);
      }
    }

    if (doc.hasChildDocuments()) {
      if (!first) {
        writeMapSeparator();
        indent();
      }
      writeKey("_childDocuments_", true);
      writeArrayOpener(doc.getChildDocumentCount());
      List childDocs = doc.getChildDocuments();
      for (int i = 0; i < childDocs.size(); i++) {
        writeSolrDocument(null, (SolrDocument)childDocs.get(i), null, i);
      }
      writeArrayCloser();
    }

    decLevel();
    writeMapCloser();
  }

  public void writeStartDocumentList(String name, long start, int size, long numFound, Float maxScore)
    throws IOException
  {
    writeMapOpener(maxScore == null ? 3 : 4);
    incLevel();
    writeKey("numFound", false);
    writeLong(null, numFound);
    writeMapSeparator();
    writeKey("start", false);
    writeLong(null, start);

    if (maxScore != null) {
      writeMapSeparator();
      writeKey("maxScore", false);
      writeFloat(null, maxScore.floatValue());
    }
    writeMapSeparator();

    writeKey("docs", false);
    writeArrayOpener(size);

    incLevel();
  }

  public void writeEndDocumentList()
    throws IOException
  {
    decLevel();
    writeArrayCloser();

    decLevel();
    indent();
    writeMapCloser();
  }

  public void writeMapOpener(int size)
    throws IOException, IllegalArgumentException
  {
    this.writer.write('{');
  }

  public void writeMapSeparator() throws IOException {
    this.writer.write(',');
  }

  public void writeMapCloser() throws IOException {
    this.writer.write('}');
  }

  public void writeArrayOpener(int size) throws IOException, IllegalArgumentException {
    this.writer.write('[');
  }

  public void writeArraySeparator() throws IOException {
    this.writer.write(',');
  }

  public void writeArrayCloser() throws IOException {
    this.writer.write(']');
  }

  public void writeStr(String name, String val, boolean needsEscaping)
    throws IOException
  {
    if (needsEscaping)
    {
      this.writer.write('"');

      for (int i = 0; i < val.length(); i++) {
        char ch = val.charAt(i);
        if (((ch > '#') && (ch != '\\') && (ch < '
')) || (ch == ' ')) {
          this.writer.write(ch);
        }
        else {
          switch (ch) {
          case '"':
          case '\\':
            this.writer.write('\\');
            this.writer.write(ch);
            break;
          case '\r':
            this.writer.write('\\'); this.writer.write('r'); break;
          case '\n':
            this.writer.write('\\'); this.writer.write('n'); break;
          case '\t':
            this.writer.write('\\'); this.writer.write('t'); break;
          case '\b':
            this.writer.write('\\'); this.writer.write('b'); break;
          case '\f':
            this.writer.write('\\'); this.writer.write('f'); break;
          case '
':
          case '
':
            unicodeEscape(this.writer, ch);
            break;
          default:
            if (ch <= '\037')
              unicodeEscape(this.writer, ch);
            else {
              this.writer.write(ch);
            }
            break;
          }
        }
      }
      this.writer.write('"');
    } else {
      this.writer.write('"');
      this.writer.write(val);
      this.writer.write('"');
    }
  }

  public void writeMap(String name, Map val, boolean excludeOuter, boolean isFirstVal)
    throws IOException
  {
    if (!excludeOuter) {
      writeMapOpener(val.size());
      incLevel();
      isFirstVal = true;
    }

    boolean doIndent = (excludeOuter) || (val.size() > 1);

    for (Map.Entry entry : val.entrySet()) {
      Object e = entry.getKey();
      String k = e == null ? "" : e.toString();
      Object v = entry.getValue();

      if (isFirstVal)
        isFirstVal = false;
      else {
        writeMapSeparator();
      }

      if (doIndent) indent();
      writeKey(k, true);
      writeVal(k, v);
    }

    if (!excludeOuter) {
      decLevel();
      writeMapCloser();
    }
  }

  public void writeArray(String name, Iterator val) throws IOException
  {
    writeArrayOpener(-1);
    incLevel();
    boolean first = true;
    while (val.hasNext()) {
      if (!first) indent();
      writeVal(null, val.next());
      if (val.hasNext()) {
        writeArraySeparator();
      }
      first = false;
    }
    decLevel();
    writeArrayCloser();
  }

  public void writeNull(String name)
    throws IOException
  {
    this.writer.write("null");
  }

  public void writeInt(String name, String val) throws IOException
  {
    this.writer.write(val);
  }

  public void writeLong(String name, String val) throws IOException
  {
    this.writer.write(val);
  }

  public void writeBool(String name, String val) throws IOException
  {
    this.writer.write(val);
  }

  public void writeFloat(String name, String val) throws IOException
  {
    this.writer.write(val);
  }

  public void writeDouble(String name, String val) throws IOException
  {
    this.writer.write(val);
  }

  public void writeDate(String name, String val) throws IOException
  {
    writeStr(name, val, false);
  }

  protected static void unicodeEscape(Appendable out, int ch) throws IOException
  {
    out.append('\\');
    out.append('u');
    out.append(hexdigits[(ch >>> 12)]);
    out.append(hexdigits[(ch >>> 8 & 0xF)]);
    out.append(hexdigits[(ch >>> 4 & 0xF)]);
    out.append(hexdigits[(ch & 0xF)]);
  }
}