String fulltextSearchTerm = "Geometrixx";

// create query description as hash map (simplest way, same as form post)
Map<String, String> map = new HashMap<String, String>();

// create query description as hash map (simplest way, same as form post)
map.put("path", "/content");
map.put("type", "cq:Page");
map.put("group.p.or", "true"); // combine this group with OR
map.put("group.1_fulltext", fulltextSearchTerm);
map.put("group.1_fulltext.relPath", "jcr:content");
map.put("group.2_fulltext", fulltextSearchTerm);
map.put("group.2_fulltext.relPath", "jcr:content/@cq:tags");

// can be done in map or with Query methods
map.put("p.offset", "0"); // same as query.setStart(0) below
map.put("p.limit", "20"); // same as query.setHitsPerPage(20) below

Query query = builder.createQuery(PredicateGroup.create(map), session);
query.setStart(0);
query.setHitsPerPage(20);

SearchResult result = query.getResult();

// paging metadata
int hitsPerPage = result.getHits().size(); // 20 (set above) or lower
long totalMatches = result.getTotalMatches();
long offset = result.getStartIndex();
long numberOfPages = totalMatches / 20;

//Place the results in XML to return to client
DocumentBuilderFactory factory =     DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.newDocument();

//Start building the XML to pass back to the AEM client
Element root = doc.createElement( "results" );
doc.appendChild( root );

// iterating over the results
for (Hit hit : result.getHits()) {
   String path = hit.getPath();

  //Create a result element
  Element resultel = doc.createElement( "result" );
  root.appendChild( resultel );

  Element pathel = doc.createElement( "path" );
  pathel.appendChild( doc.createTextNode(path ) );
  resultel.appendChild( pathel );
}

void storeQuery(Query query, String path, boolean createFile, Session session) throws RepositoryException, IOException;

builder.storeQuery(query, "/mypath/getfiles", true, session);

Query loadQuery(String path, Session session) throws RepositoryException, IOException

Query loadedQuery = builder.loadQuery("/mypath/getfiles", session);

Map<String, Facet> facets = result.getFacets();
for (String key : facets.keySet()) {
    Facet facet = facets.get(key);
    if (facet.getContainsHit()) {
        for (Bucket bucket : facet.getBuckets()) {
            long count = bucket.getCount();
            Map<String, String> params = bucket.getPredicate().getParameters();
            for (String k : params.keySet()) {
                out.println("<br>k:"+k);
            }
        }
    }
}

import org.apache.felix.scr.annotations.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.day.cq.search.Predicate;
import com.day.cq.search.eval.AbstractPredicateEvaluator;
import com.day.cq.search.eval.EvaluationContext;

/**
* <code>OriginPredicateEvaluator</code>queries the Livecopy status of a page.

*This property is used to find the Livecopy status of the page.
*origin.value=disconnected gives the XPATH query as jcr:content/@jcr:mixinTypes='cq:LiveSyncCancelled'
*origin.value=locally gives the XPATH query as jcr:content/@jcr:mixinTypes!='cq:LiveSync'
*origin.value=inheritted gives the XPATH query as jcr:content/@jcr:mixinTypes='cq:LiveSync'
*/

@Component(metatype = false, factory = "com.day.cq.search.eval.PredicateEvaluator/origin")
public class OriginPredicateEvaluator extends AbstractPredicateEvaluator {
    static final String PE_NAME = "origin";
    static final String JCRCONTENT_JCRMIXIN = "jcr:content/@jcr:mixinTypes";

    static final String PREDICATE_VALUE = "value";
    static final String PREDICATE_LIVESYNCCANC = "'cq:LiveSyncCancelled'";
    static final String PREDICATE_LIVESYNC = "'cq:LiveSync'";

    static final String OP_EQUALS = "=";
    static final String OP_NOT_EQUALS = "!=";

    private static final Logger logger = LoggerFactory.getLogger(OriginPredicateEvaluator.class);

    @Override
    public String getXPathExpression(Predicate predicate, EvaluationContext context) {

        String value = predicate.get(PREDICATE_VALUE);

        StringBuilder sb = new StringBuilder();

        if(value != null){
            if (value.equalsIgnoreCase("inheritted")) {
                sb.append(JCRCONTENT_JCRMIXIN).append(OP_EQUALS);
                sb.append(PREDICATE_LIVESYNC);
            }
            if (value.equalsIgnoreCase("disconnected")) {
                sb.append(JCRCONTENT_JCRMIXIN).append(OP_EQUALS);
                sb.append(PREDICATE_LIVESYNCCANC);
            }
            if (value.equalsIgnoreCase("locally")) {
                sb.append(JCRCONTENT_JCRMIXIN).append(OP_NOT_EQUALS);
                sb.append(PREDICATE_LIVESYNC);
            }
        }

        String xpath = sb.toString();

        logger.debug("**********XPATH*******" + xpath);

        return xpath;
    }

    @Override
    public boolean canXpath(Predicate predicate, EvaluationContext context) {
        return true;
    }

    @Override
    public boolean canFilter(Predicate predicate, EvaluationContext context) {
        return false;
    }
}

import javax.jcr.query.Row;

import org.apache.felix.scr.annotations.Component;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.resource.collection.ResourceCollection;

import com.day.cq.search.Predicate;

@Component(metatype = false, factory = "com.day.cq.search.eval.PredicateEvaluator/samplepredicate")
public class SampleFilterPredicateEvaluator extends AbstractPredicateEvaluator {
    public static final String SAMPLE = "samplepredicate";

    @Override
    public boolean includes(Predicate p, Row row, EvaluationContext context) {
        if (!p.hasNonEmptyValue(SAMPLE)) {
        return true;
        }
        /* Write some code logic here as per the condition:
        Return true for a favourable Condition for keeping the entity in Search Results.
        Return false for an unfavourable Condition for removing the entity from the Search Results.
        */

        return false;
    }
    @Override
    public boolean canXpath(Predicate predicate, EvaluationContext context) {
        return false;
    }

    @Override
    public boolean canFilter(Predicate predicate, EvaluationContext context) {
        return true;
    }

}