Java 类com.mongodb.MapReduceOutput 实例源码

/**
 * Map reduce.
 *
 * @param mongoOperation
 *            the mongo operation
 * @param a
 *            the a
 * @param b
 *            the b
 * @param c
 *            the c
 * @param d
 *            the d
 * @throws UnknownHostException
 */
static void calcularLocalizaciones() throws UnknownHostException {

    String map = "function () { emit(this.localizacion, {count: 1}); }";
    String reduce = " function(key, values) { var result = 0; values.forEach(function(value){ result++ }); "
            + "return result; }";

    MongoClient mongoClient = new MongoClient("localhost", 27017);
    DB db = mongoClient.getDB("craulerdb");
    DBCollection ofertas = db.getCollection("ofertas");

    MapReduceCommand cmd = new MapReduceCommand(ofertas, map, reduce, null, MapReduceCommand.OutputType.INLINE,
            null);
    MapReduceOutput out = ofertas.mapReduce(cmd);

    for (DBObject o : out.results()) {
        System.out.println(o.toString());
    }
}

@Test
public void testMapReduce() throws Exception{
   MongoClient client = new MongoClient("localhost", 27017);
   DBCollection articles = client.getDB("ensim").getCollection("articles");

   // Write map function as Javascript.
   String map = "function() { " +
         "    emit('note', this.note);" +
         "}";
   // Write reduc function as Javascript.
   String reduce = "function(key, values) { " +
         "    return Array.sum(values) / values.length; " +
         "}";

   // Execute map/reduce job without finalize function and filter query.
   MapReduceOutput out = articles.mapReduce(map, reduce, null, MapReduceCommand.OutputType.INLINE, null);

   try{
      for (DBObject o : out.results()){
         System.err.println(o.toString());
      }
   } catch (Exception e){
      e.printStackTrace();
   }
}

/**
 * runs a map-reduce-job on the collection. The functions are read from the classpath in the folder mongodb. The systems reads them from
 * files called <name>.map.js, <name>.reduce.js and optionally <name>.finalize.js. After this the result is converted
 * using the given {@link MapReduceResultHandler}
 * 
 * @param <R> the type of the result class
 * @param name the name of the map-reduce functions
 * @param query the query to filter the elements used for the map-reduce
 * @param sort sort query to sort elements before running map-reduce
 * @param scope the global scope for the JavaScript run
 * @param conv the converter to convert the result
 * @return an {@link Iterable} with the result entries
 * @throws RuntimeException if resources cannot be read
 */
protected final <R> Iterable<R> mapReduce(String name, DBObject query, DBObject sort, Map<String, Object> scope, final MapReduceResultHandler<R> conv) {
    String map = this.getMRFunction(name, "map");
    String reduce = this.getMRFunction(name, "reduce");

    MapReduceCommand mrc = new MapReduceCommand(this.collection.getDBCollection(), map, reduce, null, OutputType.INLINE, query);
    String finalizeFunction = this.getMRFunction(name, "finalize");
    if (finalizeFunction != null) {
        mrc.setFinalize(finalizeFunction);
    }
    if (sort != null) {
        mrc.setSort(sort);
    }
    if (scope != null) {
        mrc.setScope(scope);
    }
    MapReduceOutput mr = this.collection.getDBCollection().mapReduce(mrc);
    return new ConverterIterable<R>(mr.results().iterator(), conv);
}

private synchronized Iterable<DBObject> mapReduce(String map, String reduce, String outputTarget, MapReduceCommand.OutputType outputType, String orderBy, DBObject query) {
    MapReduceOutput output = getCollection().mapReduce(map, reduce, outputTarget, outputType, query);
    DBCollection c = output.getOutputCollection();
    DBCursor cursor;
    if(orderBy != null){
        cursor = c.find().sort(SortUtil.getSort(orderBy));
    }else{
        cursor = c.find();
    }
    List<DBObject> list = new ArrayList<DBObject>();
    for(Iterator<DBObject> it = cursor.iterator(); it.hasNext(); ){
        list.add(it.next());
    }
    return list;
}

private synchronized Iterable<DBObject> mapReduce(String map, String reduce, String outputTarget, MapReduceCommand.OutputType outputType, String orderBy, int pageNum, int pageSize, DBObject query) {
    MapReduceOutput output = getCollection().mapReduce(map, reduce, outputTarget, outputType, query);
    DBCollection c = output.getOutputCollection();
    DBCursor cursor;
    if(orderBy != null){
        cursor = c.find().sort(SortUtil.getSort(orderBy)).skip((pageNum-1)*pageSize).limit(pageSize);
    }else{
        cursor = c.find().skip((pageNum-1)*pageSize).limit(pageSize);
    }
    List<DBObject> list = new ArrayList<DBObject>();
    for(Iterator<DBObject> it = cursor.iterator(); it.hasNext(); ){
        list.add(it.next());
    }
    return list;
}

@GET
@Path("movies/{id}")
@Produces(MediaType.APPLICATION_JSON)
public static String getMovies(@PathParam("id") String userId) {
    Logger.getLogger(XPostWS.class.getName()).log(Level.INFO, "retrieving movies for " + userId);

    final JsonObject result = new JsonObject();

    Mongo mongo = getActionMongo();
    final DB db = mongo.getDB("mydb");
    final DBCollection moviesCol = db.getCollection("movies");

    String map = "function () {" + "if (this.userId != this.friendId)" + "{emit(this.id, this);}" + "};";
    String reduce = "function (key, values) {" +
                        "var res = {};" +
                        "res.name = values[0].name;" +
                        "res.id = key;" +
                        "res.userId = values[0].userId;" +
                        "res.poster = values[0].poster;" +
                        "res.rating = values[0].rating;" +
                        "res.imdbId = values[0].imdbId;" +
                        "res.friendId = [];" +
                        "for (var i = 0; i<values.length; ++i) {" +
                            "res.friendId.push(String(values[i].friendId));" +
                        "}" +
                        "return res;}";

    final BasicDBObject searchObject = new BasicDBObject("userId", userId);
    MapReduceCommand mapReduceComand = new MapReduceCommand(moviesCol, map, reduce, null,
            MapReduceCommand.OutputType.INLINE, searchObject);
    final MapReduceOutput moviesReduced = moviesCol.mapReduce(mapReduceComand);
    JsonArray moviesInfo = new JsonArray();
    for (DBObject movie : moviesReduced.results()) {
        moviesInfo.put(new JsonObject(movie.toString()));
    }
    Logger.getLogger(XPostWS.class.getName()).log(Level.INFO,
            "retrieved " + moviesInfo.length() + " movies for user " + userId);
    if (moviesInfo.length() == 0) {
        result.put("movies", new JsonArray().toString());
    } else {
        sortMovies(moviesInfo, userId);
        result.put("movies", moviesInfo);
    }

    try {
        return new String(result.toString().getBytes("UTF-8"));
    } catch (UnsupportedEncodingException e) {
        Logger.getLogger(TAG).severe(e.getMessage());
        return result.toString();
    }
}

public List<JSONObject> getComments(String word) throws UnknownHostException, MongoException, SQLException, ClassNotFoundException, JSONException {
    // TODO Auto-generated method stub
    List<JSONObject> listeComments = new ArrayList<JSONObject>();

    Mongo mongoClient = new Mongo();
    DB db = mongoClient.getDB("social");
    DBCollection coll = db.getCollection("comments");   

    String m="function wordMap(){"+
            "var text = this.comment;"+
            "var words = text.match(/\\w+/g);"+
            "var tf = new Array();"+
            "for( var i=0; i< words.length ; i++ ){"+
            "if( tf[words[i]] == null){"+
            "tf[words[i]]=1;"+
            "}"+
            "else{"+    
            "tf[words[i]]++;"+
            "}"+
            "}"+
            "for( var i=0; i< words.length ; i++ ){"+
            "emit(this._id, { word : words[i], tf : tf[words[i]] } )}};";

    String r="function wordReduce(key, values){"+
            "return ( { \"tfs\" : values } )};";

    MapReduceOutput out = coll.mapReduce(m,r,null,MapReduceCommand.OutputType.INLINE,null);

    String[] tabWords = word.split(" ");
    SortedMap<String,String> map = new TreeMap<String,String>();


    for ( DBObject obj : out.results()){

        JSONObject jsonObj = new JSONObject(obj.toMap());


        String idObj = jsonObj.get("_id").toString();
        JSONObject jsonValue = new JSONObject(jsonObj.get("value").toString());
        JSONArray tfsTab = new JSONArray(jsonValue.get("tfs").toString());


        for(int i=0; i<tfsTab.length();i++){
            JSONObject tfsObj = tfsTab.getJSONObject(i);
            for(String w : tabWords){
                if(tfsObj.get("word").equals(w)){
                    String nbtf = tfsObj.get("tf").toString();
                    map.put(idObj,nbtf);
                }
            }
        }



    }

    mongoClient.close();


    Iterator iterator = map.keySet().iterator();
    while (iterator.hasNext()) {
        Object key = iterator.next();
        JSONObject objToAdd = new JSONObject();
        objToAdd.put("_id",key.toString());
        listeComments.add(objToAdd);
    }


    return listeComments;
}

public Iterable<DBObject> mapReduce(MapReduceCommand cmd) {
    MapReduceOutput output = getCollection().mapReduce(cmd);
    return output.results();
}

public Iterable<DBObject> mapReduce(String map, String reduce) {
    MapReduceOutput output = getCollection().mapReduce(map, reduce, null, MapReduceCommand.OutputType.INLINE, null);
    return output.results();
}

private Iterable<DBObject> mapReduce(String map, String reduce, DBObject query) {
    MapReduceOutput output = getCollection().mapReduce(map, reduce, null, MapReduceCommand.OutputType.INLINE, query);
    return output.results();
}

/**
 * Creates a results instance for the given output
 *
 * @param output the output of the operation
 */
public MapreduceResults(final MapReduceOutput output) {
    this.output = output;
    outputCollectionName = output.getCollectionName();
}