用solr做项目已经有一年有余，但都是使用层面，只是利用solr现有机制，修改参数，然后监控调优，从没有对solr进行源码级别的研究。但是，最近手头的一个项目，让我感觉必须把solrn内部原理和扩展机制弄熟，才能把这个项目做好。今天分享的就是：Solr是如何启动并且初始化的。大家知道，部署solr时，分两部分：一、solr的配置文件。二、solr相关的程序、插件、依赖lucene相关的jar包、日志方面的jar。因此，在研究solr也可以顺着这个思路：加载配置文件、初始化各个core、初始化各个core中的requesthandler…

　　研究solr的启动，首先从solr war程序的web.xml分析开始，下面是solr的web.xml片段：

  1. <web-app xmlns="http://java.sun.com/xml/ns/javaee"
  2.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  4.          version="2.5"
  5.          metadata-complete="true"
  6. >
  7.  
  8.  
  9.   <!-- Uncomment if you are trying to use a Resin version before 3.0.19.
  10.     Their XML implementation isn\'t entirely compatible with Xerces.
  11.     Below are the implementations to use with Sun\'s JVM.
  12.   <system-property javax.xml.xpath.XPathFactory=
  13.              "com.sun.org.apache.xpath.internal.jaxp.XPathFactoryImpl"/>
  14.   <system-property javax.xml.parsers.DocumentBuilderFactory=
  15.              "com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl"/>
  16.   <system-property javax.xml.parsers.SAXParserFactory=
  17.              "com.sun.org.apache.xerces.internal.jaxp.SAXParserFactoryImpl"/>
  18.    -->
  19.  
  20.   <!-- People who want to hardcode their "Solr Home" directly into the
  21.        WAR File can set the JNDI property here...
  22.    -->
  23.     <!--  Solr配置文件的参数,用于Solr初始化使用  -->
  24.     <env-entry>
  25.        <env-entry-name>solr/home</env-entry-name>
  26.        <env-entry-value>R:/solrhome1/solr</env-entry-value>
  27.        <env-entry-type>java.lang.String</env-entry-type>
  28.     </env-entry>
  29.  
  30.    
  31.   
  32.   <!-- org.apache.solr.servlet.SolrDispatchFilter  Solr启动最重要的东东，所以针对solr源码分析，要对这个Filter开始，它主要的作用：加载solr配置文件、初始化各个core、初始化各个requestHandler和component -->
  33.   <filter>
  34.     <filter-name>SolrRequestFilter</filter-name>
  35.     <filter-class>org.apache.solr.servlet.SolrDispatchFilter</filter-class>
  36.     <!-- If you are wiring Solr into a larger web application which controls
  37.          the web context root, you will probably want to mount Solr under
  38.          a path prefix (app.war with /app/solr mounted into it, for example).
  39.          You will need to put this prefix in front of the SolrDispatchFilter
  40.          url-pattern mapping too (/solr/*), and also on any paths for
  41.          legacy Solr servlet mappings you may be using.
  42.          For the Admin UI to work properly in a path-prefixed configuration,
  43.          the admin folder containing the resources needs to be under the app context root
  44.          named to match the path-prefix.  For example:
  45.  
  46.             .war
  47.                xxx
  48.                  js
  49.                    main.js
  50.     -->
  51.     <!--
  52.     <init-param>
  53.       <param-name>path-prefix</param-name>
  54.       <param-value>/xxx</param-value>
  55.     </init-param>
  56.     -->
  57.   </filter>

　　SolrDispatchFilter 是继承BaseSolrFilter的一个Filter（Filter的作用是啥，大家应该清楚吧，一般web框架级别的产品源码分析都是从filter或者servlet开始）。在介绍SolrDispatchFilter之前，先介绍一下BaseSolrFilter（也许程序员都有刨根问底的习惯）。BaseSolrFilter，是一个实现Filter接口的抽象类，功能很简单，就是判断当前程序是否已经加载日志方面的jar。代码片段如下：

　　

  1. /**
  2.  * All Solr filters available to the user\'s webapp should
  3.  * extend this class and not just implement {@link Filter}.
  4.  * This class ensures that the logging configuration is correct
  5.  * before any Solr specific code is executed.
  6.  */
  7. abstract class BaseSolrFilter implements Filter {
  8.   
  9.   static {//
  10.     CheckLoggingConfiguration.check();
  11.   }
  12.   
  13. }

　　着于篇幅，我就不介绍CheckLoggingConfiguration.check() 这里面的东东了。OK，我们回到SolrDispatchFilter上。由于BaseSolrFilter是一个抽象类，所有作为非抽象类的SolrDispatchFilter必须要实现Filter接口。Filter接口如下：

　　

  1. public interface Filter {
  2.  
  3.     //进行初始化
  4.     public void init(FilterConfig filterConfig) throws ServletException;
  5. 	
  6.    //拦截所有的http请求
  7.     public void doFilter(ServletRequest request, ServletResponse response,
  8.                          FilterChain chain)
  9.             throws IOException, ServletException;
  10.  
  11.    //进行注销的动作
  12.     public void destroy();
  13. }

　　根据上面的注释，我们知道在init方法中是进行初始化的。因此，今天咱们研究SolrDispatchFilter是如何初始化，是离不开这个方法的。接下来，咱们看看SolrDispatchFilter的init方法吧：

　　

  1.   @Override
  2.   public void init(FilterConfig config) throws ServletException
  3.   {
  4.     log.info("SolrDispatchFilter.init()");
  5.  
  6.     try {
  7.       // web.xml configuration
  8.       this.pathPrefix = config.getInitParameter( "path-prefix" );
  9.       //各位看客，乾坤尽在此方法中
  10.       this.cores = createCoreContainer();
  11.       log.info("user.dir=" + System.getProperty("user.dir"));
  12.     }
  13.     catch( Throwable t ) {
  14.       // catch this so our filter still works
  15.       log.error( "Could not start Solr. Check solr/home property and the logs");
  16.       SolrCore.log( t );
  17.       if (t instanceof Error) {
  18.         throw (Error) t;
  19.       }
  20.     }
  21.  
  22.     log.info("SolrDispatchFilter.init() done");
  23.   }

　　咱们顺藤摸瓜，来看看createCoreContainer这个方法到底干了些什么。

　　

  1.   protected CoreContainer createCoreContainer() {
    　　//看好了SolrResourceLoader 是用来加载solr home中的配置文件文件的 
  2.     SolrResourceLoader loader = new SolrResourceLoader(SolrResourceLoader.locateSolrHome());
  3.     //加载配置文件
        ConfigSolr config = loadConfigSolr(loader);
  4.     CoreContainer cores = new CoreContainer(loader, config);
    　　 //初始化Core 
  5.     cores.load();
  6.     return cores;
  7.   }

　　createCoreContainer这个方法是决定咱们今天能否弄懂Solr初始化和启动的关键。我们顺便简单分析一下这个方法中用到的几个类和方法：

　　SolrResourceLoader  类如其名，是solr资源加载器。

     ConfigSolr 是通过SolrResourceLoader来读取solr配置文件的中信息的。

    loadConfigSolr，加载配置信息的方法：

  1.   private ConfigSolr loadConfigSolr(SolrResourceLoader loader) {
  2.     //优先读取solr.solrxml.location配置的信息，往往是通过读取zookeeper中的配置信息进行初始化的，如果没有配置，就会读取solrhome配置项配置的信息（记得web.xml第一个配置项否，就是它）
  3.     String solrxmlLocation = System.getProperty("solr.solrxml.location", "solrhome");
  4.     
  5.     if (solrxmlLocation == null || "solrhome".equalsIgnoreCase(solrxmlLocation))
  6.       return ConfigSolr.fromSolrHome(loader, loader.getInstanceDir());
  7.      //ok 从zookeeper中读取配置信息吧，这是在solrcloud集群下用来solr初始化的
  8.     if ("zookeeper".equalsIgnoreCase(solrxmlLocation)) {
  9.       String zkHost = System.getProperty("zkHost");
  10.       log.info("Trying to read solr.xml from " + zkHost);
  11.       if (StringUtils.isEmpty(zkHost))
  12.         throw new SolrException(ErrorCode.SERVER_ERROR,
  13.             "Could not load solr.xml from zookeeper: zkHost system property not set");
  14.       SolrZkClient zkClient = new SolrZkClient(zkHost, 30000);
  15.       try {
  16.         if (!zkClient.exists("/solr.xml", true))//solr.xml里有描述的zookeeper相关的配置信息
  17.           throw new SolrException(ErrorCode.SERVER_ERROR, "Could not load solr.xml from zookeeper: node not found");
  18.         byte[] data = zkClient.getData("/solr.xml", null, null, true);
             //加载配置信息
  19.         return ConfigSolr.fromInputStream(loader, new ByteArrayInputStream(data));
  20.       } catch (Exception e) {
  21.         throw new SolrException(ErrorCode.SERVER_ERROR, "Could not load solr.xml from zookeeper", e);
  22.       } finally {
  23.         zkClient.close();//关闭zookeeper连接
  24.       }
  25.     }
  26.  
  27.     throw new SolrException(ErrorCode.SERVER_ERROR,
  28.         "Bad solr.solrxml.location set: " + solrxmlLocation + " - should be \'solrhome\' or \'zookeeper\'");
  29.   }

　　CoreContainer  就是进行Core初始化工作的。我们主要看看load方法吧，这段方法有点长，代码如下：

　　

  1. public void load()  {
  2.  
  3.     log.info("Loading cores into CoreContainer [instanceDir={}]", loader.getInstanceDir());
  4.      //加载solr共享jar包库
  5.     // add the sharedLib to the shared resource loader before initializing cfg based plugins
  6.     String libDir = cfg.getSharedLibDirectory();
  7.     if (libDir != null) {
  8.       File f = FileUtils.resolvePath(new File(solrHome), libDir);
  9.       log.info("loading shared library: " + f.getAbsolutePath());
          //对classloader不熟的，可以进去看看
  10.       loader.addToClassLoader(libDir, null, false);
  11.       loader.reloadLuceneSPI();
  12.     }
  13.  
  14.     //分片相关的handler加载以及初始化
  15.     shardHandlerFactory = ShardHandlerFactory.newInstance(cfg.getShardHandlerFactoryPluginInfo(), loader);
  16.     
  17.     updateShardHandler = new UpdateShardHandler(cfg);
  18.  
  19.     solrCores.allocateLazyCores(cfg.getTransientCacheSize(), loader);
  20.  
  21.     logging = LogWatcher.newRegisteredLogWatcher(cfg.getLogWatcherConfig(), loader);
  22.  
  23.     hostName = cfg.getHost();
  24.     log.info("Host Name: " + hostName);
  25.  
  26.     zkSys.initZooKeeper(this, solrHome, cfg);
  27.  
  28.     collectionsHandler = createHandler(cfg.getCollectionsHandlerClass(), CollectionsHandler.class);
  29.     infoHandler        = createHandler(cfg.getInfoHandlerClass(), InfoHandler.class);
  30.     coreAdminHandler   = createHandler(cfg.getCoreAdminHandlerClass(), CoreAdminHandler.class);
  31.     //zookeeper 配置信息初始化solr core
  32.     coreConfigService = cfg.createCoreConfigService(loader, zkSys.getZkController());
  33.  
  34.     containerProperties = cfg.getSolrProperties("solr");
  35.  
  36.     // setup executor to load cores in parallel
  37.     // do not limit the size of the executor in zk mode since cores may try and wait for each other.
        //多线程初始化core  不熟悉多线的可以驻足研究一会
  38.     ExecutorService coreLoadExecutor = Executors.newFixedThreadPool(
  39.         ( zkSys.getZkController() == null ? cfg.getCoreLoadThreadCount() : Integer.MAX_VALUE ),
  40.         new DefaultSolrThreadFactory("coreLoadExecutor") );
  41.  
  42.     try {
  43.       CompletionService<SolrCore> completionService = new ExecutorCompletionService<>(
  44.           coreLoadExecutor);
  45.  
  46.       Set<Future<SolrCore>> pending = new HashSet<>();
  47.  
  48.       List<CoreDescriptor> cds = coresLocator.discover(this);
  49.       checkForDuplicateCoreNames(cds);
  50.  
  51.       for (final CoreDescriptor cd : cds) {
  52.  
  53.         final String name = cd.getName();
  54.         try {
  55.  
  56.           if (cd.isTransient() || ! cd.isLoadOnStartup()) {
  57.             // Store it away for later use. includes non-transient but not
  58.             // loaded at startup cores.
  59.             solrCores.putDynamicDescriptor(name, cd);
  60.           }
  61.           if (cd.isLoadOnStartup()) { // The normal case
  62.  
  63.             Callable<SolrCore> task = new Callable<SolrCore>() {
  64.               @Override
  65.               public SolrCore call() {
  66.                 SolrCore c = null;
  67.                 try {
  68.                   if (zkSys.getZkController() != null) {//zookeeper模式
  69.                     preRegisterInZk(cd);
  70.                   }
  71.                   c = create(cd);//普通创建模式
  72.                   registerCore(cd.isTransient(), name, c, false, false);
  73.                 } catch (Exception e) {
  74.                   SolrException.log(log, null, e);
  75.                   try {
  76.               /*    if (isZooKeeperAware()) {
  77.                     try {
  78.                       zkSys.zkController.unregister(name, cd);
  79.                     } catch (InterruptedException e2) {
  80.                       Thread.currentThread().interrupt();
  81.                       SolrException.log(log, null, e2);
  82.                     } catch (KeeperException e3) {
  83.                       SolrException.log(log, null, e3);
  84.                     }
  85.                   }*/
  86.                   } finally {
  87.                     if (c != null) {
  88.                       c.close();
  89.                     }
  90.                   }            
  91.                 }
  92.                 return c;
  93.               }
  94.             };
  95.             pending.add(completionService.submit(task));
  96.  
  97.           }
  98.         } catch (Exception e) {
  99.           SolrException.log(log, null, e);
  100.         }
  101.       }
  102.  
  103.       while (pending != null && pending.size() > 0) {
  104.         try {
  105.           //获取创建完成的core
  106.           Future<SolrCore> future = completionService.take();
  107.           if (future == null) return;
  108.           pending.remove(future);
  109.  
  110.           try {
  111.             SolrCore c = future.get();
  112.             // track original names
  113.             if (c != null) {
  114.               solrCores.putCoreToOrigName(c, c.getName());
  115.             }
  116.           } catch (ExecutionException e) {
  117.             SolrException.log(SolrCore.log, "Error loading core", e);
  118.           }
  119.  
  120.         } catch (InterruptedException e) {
  121.           throw new SolrException(SolrException.ErrorCode.SERVICE_UNAVAILABLE,
  122.               "interrupted while loading core", e);
  123.         }
  124.       }

  125.       //solr core的守护线程，在容器关闭或者启动失败的时候，进行资源注销
  126.       // Start the background thread
  127.       backgroundCloser = new CloserThread(this, solrCores, cfg);
  128.       backgroundCloser.start();
  129.  
  130.     } finally {
  131.       if (coreLoadExecutor != null) {
            //初始化完成，关闭线程池
  132.         ExecutorUtil.shutdownNowAndAwaitTermination(coreLoadExecutor);
  133.       }
  134.     }
  135.     
  136.     if (isZooKeeperAware()) {//如果zookeeper可用 也就是solrcloud模式
  137.       // register in zk in background threads
  138.       Collection<SolrCore> cores = getCores();
  139.       if (cores != null) {
  140.         for (SolrCore core : cores) {
  141.           try {
                //讲core的状态信息注册到zookeeper中
  142.             zkSys.registerInZk(core, true);
  143.           } catch (Throwable t) {
  144.             SolrException.log(log, "Error registering SolrCore", t);
  145.           }
  146.         }
  147.       }
          //
  148.       zkSys.getZkController().checkOverseerDesignate();
  149.     }
  150.   }

　　在这段代码，关键部分我都做了注释。当你需要优化你的solr启动速度时，你还会来研究这段代码。下面，我们将研究solr的请求过滤处理的部分，我们需要关注doFilter那个方法了（关键部分我作以注释，就不细讲了）：

     

  1.  if( abortErrorMessage != null ) {//500错误处理
  2.       ((HttpServletResponse)response).sendError( 500, abortErrorMessage );
  3.       return;
  4.     }
  5.     
  6.     if (this.cores == null) {//solr core初始化失败或者已经关闭
  7.       ((HttpServletResponse)response).sendError( 503, "Server is shutting down or failed to initialize" );
  8.       return;
  9.     }
  10.     CoreContainer cores = this.cores;
  11.     SolrCore core = null;
  12.     SolrQueryRequest solrReq = null;
  13.     Aliases aliases = null;
  14.     
  15.     if( request instanceof HttpServletRequest) {//如果是http请求
  16.       HttpServletRequest req = (HttpServletRequest)request;
  17.       HttpServletResponse resp = (HttpServletResponse)response;
  18.       SolrRequestHandler handler = null;
  19.       String corename = "";
  20.       String origCorename = null;
  21.       try {
  22.         // put the core container in request attribute
  23.         req.setAttribute("org.apache.solr.CoreContainer", cores);
  24.         String path = req.getServletPath();
  25.         if( req.getPathInfo() != null ) {
  26.           // this lets you handle /update/commit when /update is a servlet
  27.           path += req.getPathInfo();
  28.         }
  29.         if( pathPrefix != null && path.startsWith( pathPrefix ) ) {
  30.           path = path.substring( pathPrefix.length() );
  31.         }
  32.         // check for management path
  33.         String alternate = cores.getManagementPath();
  34.         if (alternate != null && path.startsWith(alternate)) {
  35.           path = path.substring(0, alternate.length());
  36.         }
  37.         // unused feature ?
  38.         int idx = path.indexOf( \':\' );
  39.         if( idx > 0 ) {
  40.           // save the portion after the \':\' for a \'handler\' path parameter
  41.           path = path.substring( 0, idx );
  42.         }
  43.  
  44.         // Check for the core admin page
  45.         if( path.equals( cores.getAdminPath() ) ) {//solr admin 管理页面请求
  46.           handler = cores.getMultiCoreHandler();
  47.           solrReq =  SolrRequestParsers.DEFAULT.parse(null,path, req);
  48.           handleAdminRequest(req, response, handler, solrReq);
  49.           return;
  50.         }
  51.         boolean usingAliases = false;
  52.         List<String> collectionsList = null;
  53.         // Check for the core admin collections url
  54.         if( path.equals( "/admin/collections" ) ) {//管理collections 
  55.           handler = cores.getCollectionsHandler();
  56.           solrReq =  SolrRequestParsers.DEFAULT.parse(null,path, req);
  57.           handleAdminRequest(req, response, handler, solrReq);
  58.           return;
  59.         }
  60.         // Check for the core admin info url
  61.         if( path.startsWith( "/admin/info" ) ) {//查看admin info
  62.           handler = cores.getInfoHandler();
  63.           solrReq =  SolrRequestParsers.DEFAULT.parse(null,path, req);
  64.           handleAdminRequest(req, response, handler, solrReq);
  65.           return;
  66.         }
  67.         else {
  68.           //otherwise, we should find a core from the path
  69.           idx = path.indexOf( "/", 1 );
  70.           if( idx > 1 ) {
  71.             // try to get the corename as a request parameter first
  72.             corename = path.substring( 1, idx );
  73.             
  74.             // look at aliases
  75.             if (cores.isZooKeeperAware()) {//solr cloud状态
  76.               origCorename = corename;
  77.               ZkStateReader reader = cores.getZkController().getZkStateReader();
  78.               aliases = reader.getAliases();
  79.               if (aliases != null && aliases.collectionAliasSize() > 0) {
  80.                 usingAliases = true;
  81.                 String alias = aliases.getCollectionAlias(corename);
  82.                 if (alias != null) {
  83.                   collectionsList = StrUtils.splitSmart(alias, ",", true);
  84.                   corename = collectionsList.get(0);
  85.                 }
  86.               }
  87.             }
  88.             
  89.             core = cores.getCore(corename);
  90.  
  91.             if (core != null) {
  92.               path = path.substring( idx );
  93.             }
  94.           }
  95.           if (core == null) {
  96.             if (!cores.isZooKeeperAware() ) {
  97.               core = cores.getCore("");
  98.             }
  99.           }
  100.         }
  101.         
  102.         if (core == null && cores.isZooKeeperAware()) {
  103.           // we couldn\'t find the core - lets make sure a collection was not specified instead
  104.           core = getCoreByCollection(cores, corename, path);
  105.           
  106.           if (core != null) {
  107.             // we found a core, update the path
  108.             path = path.substring( idx );
  109.           }
  110.           
  111.           // if we couldn\'t find it locally, look on other nodes
  112.           if (core == null && idx > 0) {
  113.             String coreUrl = getRemotCoreUrl(cores, corename, origCorename);
  114.             // don\'t proxy for internal update requests
  115.             SolrParams queryParams = SolrRequestParsers.parseQueryString(req.getQueryString());
  116.             if (coreUrl != null
  117.                 && queryParams
  118.                     .get(DistributingUpdateProcessorFactory.DISTRIB_UPDATE_PARAM) == null) {
  119.               path = path.substring(idx);
  120.               remoteQuery(coreUrl + path, req, solrReq, resp);
  121.               return;
  122.             } else {
  123.               if (!retry) {
  124.                 // we couldn\'t find a core to work with, try reloading aliases
  125.                 // TODO: it would be nice if admin ui elements skipped this...
  126.                 ZkStateReader reader = cores.getZkController()
  127.                     .getZkStateReader();
  128.                 reader.updateAliases();
  129.                 doFilter(request, response, chain, true);
  130.                 return;
  131.               }
  132.             }
  133.           }
  134.           
  135.           // try the default core
  136.           if (core == null) {
  137.             core = cores.getCore("");
  138.           }
  139.         }
  140.  
  141.         // With a valid core...
  142.         if( core != null ) {//验证core
  143.           final SolrConfig config = core.getSolrConfig();
  144.           // get or create/cache the parser for the core
  145.           SolrRequestParsers parser = config.getRequestParsers();
  146.  
  147.           // Handle /schema/* and /config/* paths via Restlet
  148.           if( path.equals("/schema") || path.startsWith("/schema/")
  149.               || path.equals("/config") || path.startsWith("/config/")) {//solr rest api 入口  
  150.             solrReq = parser.parse(core, path, req);
  151.             SolrRequestInfo.setRequestInfo(new SolrRequestInfo(solrReq, new SolrQueryResponse()));
  152.             if( path.equals(req.getServletPath()) ) {
  153.               // avoid endless loop - pass through to Restlet via webapp
  154.               chain.doFilter(request, response);
  155.             } else {
  156.               // forward rewritten URI (without path prefix and core/collection name) to Restlet
  157.               req.getRequestDispatcher(path).forward(request, response);
  158.             }
  159.             return;
  160.           }
  161.  
  162.           // Determine the handler from the url path if not set
  163.           // (we might already have selected the cores handler)
  164.           if( handler == null && path.length() > 1 ) { // don\'t match "" or "/" as valid path
  165.             handler = core.getRequestHandler( path );
  166.             // no handler yet but allowed to handle select; let\'s check
  167.             if( handler == null && parser.isHandleSelect() ) {
  168.               if( "/select".equals( path ) || "/select/".equals( path ) ) {//solr 各种查询过滤入口 
  169.                 solrReq = parser.parse( core, path, req );
  170.                 String qt = solrReq.getParams().get( CommonParams.QT );
  171.                 handler = core.getRequestHandler( qt );
  172.                 if( handler == null ) {
  173.                   throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "unknown handler: "+qt);
  174.                 }
  175.                 if( qt != null && qt.startsWith("/") && (handler instanceof ContentStreamHandlerBase)) {
  176.                   //For security reasons it\'s a bad idea to allow a leading \'/\', ex: /select?qt=/update see SOLR-3161
  177.                   //There was no restriction from Solr 1.4 thru 3.5 and it\'s not supported for update handlers.
  178.                   throw new SolrException( SolrException.ErrorCode.BAD_REQUEST, "Invalid Request Handler (\'qt\').  Do not use /select to access: "+qt);
  179.                 }
  180.               }
  181.             }
  182.           }
  183.  
  184.           // With a valid handler and a valid core...
  185.           if( handler != null ) {
  186.             // if not a /select, create the request
  187.             if( solrReq == null ) {
  188.               solrReq = parser.parse( core, path, req );
  189.             }
  190.  
  191.             if (usingAliases) {
  192.               processAliases(solrReq, aliases, collectionsList);
  193.             }
  194.             
  195.             final Method reqMethod = Method.getMethod(req.getMethod());
  196.             HttpCacheHeaderUtil.setCacheControlHeader(config, resp, reqMethod);
  197.             // unless we have been explicitly told not to, do cache validation
  198.             // if we fail cache validation, execute the query
  199.             if (config.getHttpCachingConfig().isNever304() ||
  200.                 !HttpCacheHeaderUtil.doCacheHeaderValidation(solrReq, req, reqMethod, resp)) {//solr http 缓存 在header控制失效时间的方式
  201.                 SolrQueryResponse solrRsp = new SolrQueryResponse();
  202.                 /* even for HEAD requests, we need to execute the handler to
  203.                  * ensure we don\'t get an error (and to make sure the correct
  204.                  * QueryResponseWriter is selected and we get the correct
  205.                  * Content-Type)
  206.                  */
  207.                 SolrRequestInfo.setRequestInfo(new SolrRequestInfo(solrReq, solrRsp));
  208.                 this.execute( req, handler, solrReq, solrRsp );
  209.                 HttpCacheHeaderUtil.checkHttpCachingVeto(solrRsp, resp, reqMethod);
  210.               // add info to http headers
  211.               //TODO: See SOLR-232 and SOLR-267.  
  212.                 /*try {
  213.                   NamedList solrRspHeader = solrRsp.getResponseHeader();
  214.                  for (int i=0; i<solrRspHeader.size(); i++) {
  215.                    ((javax.servlet.http.HttpServletResponse) response).addHeader(("Solr-" + solrRspHeader.getName(i)), String.valueOf(solrRspHeader.getVal(i)));
  216.                  }
  217.                 } catch (ClassCastException cce) {
  218.                   log.log(Level.WARNING, "exception adding response header log information", cce);
  219.                 }*/
  220.                QueryResponseWriter responseWriter = core.getQueryResponseWriter(solrReq);
  221.                writeResponse(solrRsp, response, responseWriter, solrReq, reqMethod);
  222.             }
  223.             return; // we are done with a valid handler
  224.           }
  225.         }
  226.         log.debug("no handler or core retrieved for " + path + ", follow through...");
  227.       } 
  228.       catch (Throwable ex) {
  229.         sendError( core, solrReq, request, (HttpServletResponse)response, ex );
  230.         if (ex instanceof Error) {
  231.           throw (Error) ex;
  232.         }
  233.         return;
  234.       } finally {
  235.         try {
  236.           if (solrReq != null) {
  237.             log.debug("Closing out SolrRequest: {}", solrReq);
  238.             solrReq.close();
  239.           }
  240.         } finally {
  241.           try {
  242.             if (core != null) {
  243.               core.close();
  244.             }
  245.           } finally {
  246.             SolrRequestInfo.clearRequestInfo();
  247.           }
  248.         }
  249.       }
  250.     }
  251.  
  252.     // Otherwise let the webapp handle the request
  253.     chain.doFilter(request, response);
  254.   }

　　

 

 

 

文章转载请注明出处：http://www.cnblogs.com/likehua/p/4353608.html

 

　　

版权声明：本文为likehua原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/likehua/p/4353608.html