Caching

• Configurable Query Result, Filter, and Document cache instances
• Pluggable Cache implementations
• Cache warming in background
  • When a new searcher is opened, configurable searches are run against it in order to warm it up to avoid slow first hits. During warming, the current searcher handles live requests.
• Autowarming in background
  • The most recently accessed items in the caches of the current searcher are re-populated in the new searcher, enabing high cache hit rates across index/searcher changes.
• Fast/small filter implementation
• User level caching with autowarming support

CREATE TABLE ProjectPaths(



VertexId INTEGER,



Depth INTEGER,



Path VARCHAR(300) 。







)

public void traverseDepthFirst( AST ast )

{

//  Root AST node cannot be null or

//  traversal of its subtree is impossible.

if ( ast == null )

{

throw new IllegalArgumentException(

"node to traverse cannot be null!" );

}

//  Map to hold parents of each

//  AST node.  Unfortunately the AST

//  interface does not provide a method

//  for finding the parent of a node, so

//  we use the Map to save them.



Map parentNodes = new HashMap();



//  Start tree traversal with first child

//  of the specified root AST node.



AST currentNode = ast.getFirstChild();



//  Remember parent of first child.



parentNodes.put( currentNode , ast );



//  Iterate through nodes, simulating

//  recursive tree traversal, and add them

//  to queue in proper order for later

//  linear traversal.  This "flattens" the

//  into a linear list of nodes which can

//  be visited non-recursively.



while ( currentNode != null )

{

//  Visit the current node.



strategy.visit( currentNode );



//  Move down to current node's first child

//  if it exists.



AST childNode   = currentNode.getFirstChild();



//  If the child is not null, make it

//  the current node.



if ( childNode != null )

{

//  Remember parent of the child.



parentNodes.put( childNode , currentNode );



//  Make child the current node.



currentNode = childNode;



continue;

}



while ( currentNode != null )

{

//  Move to next sibling if any.



AST siblingNode = currentNode.getNextSibling();



if ( siblingNode != null )

{

//  Get current node's parent.

//  This is also the parent of the

//  sibling node.



AST parentNode  = (AST)parentNodes.get( currentNode );



//  Remember parent of sibling.



parentNodes.put( siblingNode , parentNode );



//  Make sibling the current node.



currentNode     = siblingNode;



break;

}

//  Move up to parent if no sibling.

//  If parent is root node, we're done.



currentNode = (AST)parentNodes.get( currentNode );



if ( currentNode.equals( ast ) )

{

currentNode = null;

}

}

}

<jsp-property-group>
  <deferred-syntax-allowed-as-literal>
    true
  </deferred-syntax-allowed-as-literal>


</jsp-property-group>

<%@page  language="java" deferredSyntaxAllowedAsLiteral="true" %>

办法3 ：不用 jsp2.1 el

>   <jsp-config>
>     <jsp-property-group>
>       <url-pattern>*.jsp</url-pattern>
>       <el-ignored>true</el-ignored>
>     </jsp-property-group>
>   </jsp-config>


http://www.mail-archive.com/dev@struts.apache.org/msg28920.html

我现在的疑问
在一个页面中采用两个 el 引擎，是否会对性能造成一定影响？
较小。