Explicação detalhada de vários métodos de consulta para agregação de Java MongoDB

1. BasicdBObject

Toda a consulta de agregação é contar o número de usuários em vários estados de usuários como cenários:

1. Critérios de filtro:

Data é a data da consulta:

 Consulta BasicDBObject = new BasicDBObject (); Query.put ("time", new BasicDBObject ("$ gte", data + "00:00:00") .append ("$ lte", data + "23:59:59"));

Se houver várias condições: adicione query.put ("status", 0);

Se houver ou filtro:

 Valores BasicDblist = new BasicDBlist (); valores.add (new BasicDBObject ("Status", new BasicDBObject ("$ existe", false))); valores.add (new BasicDBObject ("status", 0)); query.put ("$ ou", valores);

Onde o novo BasicDBObject ("$ existe", false)) significa que "status" não existe (o documento do MongoDB não pode ser igual a um campo de entidade)

2. Combinação de emenda

 DbObject Match = new BasicDBObject ("$ Match", Query);

Coloque a consulta anterior no filtro MacTh

3. Condições de emenda e agrupamento

Esta etapa é equivalente ao grupo SQL por

 BasicDBObject Groupby = new BasicDBObject (); // Condições de agrupamento Groupby.put ("UserID", "$ userID"); // Grupo de acordo com o ID do usuário

Como a etapa de filtragem na primeira etapa, se houver vários grupos, você poderá adicioná -los diretamente ao seguinte: groupby.put ("status", "$ status");

4. Consulta pós-grupo

Primeira emenda os agrupamentos:

 DbObject Select = new BasicDBObject ("_ Id", Groupby);

Se queremos operar nos dados agrupados: (aqui estão as estatísticas dos usuários)

 Select.put ("count", new BasicDBObject ("$ SUM", 1));

5. Splice $ Group

 DBObject Group = new BasicDBObject ("$ GRUPO", SELECT);

Até aqui. Vamos ceder a declaração do MongoDB.

Vamos começar a operação de consulta:

 importar com.mongodb.agregationOutput; importar org.springframework.data.mongodb.core.mongotemplate; agregationOutput output = mongotemplate.getCollection ("Aqui está o nome da tabela de dados de mongodb") .agregate (correspondência, grupo);

Leia o resultado da consulta:

 Iterable <dBObject> map = output.Results (); // MAPFOR DE TRANSIP (dBObject dbObject: map) {// O mapa lido aqui é {"_id": {"userID": 1, "status" 0}} ... map <string> resultMap = (map <string, object> dbobject "; //Transfer.0 Inteiro UserID = Integer.parseint (Commutil.toString (ausgmap.get ("userID")). Substituir (". 0", "")); // Aqui podemos operar em nossos dados; Count inteiro = Integer.parseInt (Commutil.ToString (dbObject.get ("count"))); }

2. DBObject

Sem mais delongas, se você acha que o primeiro método é particularmente de longo prazo, trarei uma consulta de agregação mais concisa com um código mais conciso:

Basta fazer upload do código.

1. Preste atenção ao pacote importado:

 importação com.mongodb.dbobject; importar com.mongodb.util.json;

2. $ macth:

(Data de início de Beginday-Query; Data final do fim de dia)

 DbObject Match = (dbObject) json.parse ("{$ Match: {'status': '1', 'time': {$ gte: '"+beginDay+"', $ lte: '"+fim de dia+"'}}}");

3. Grupo $:

(Agrupado pelo UserID, conte o número de usuários, acumule o valor do campo AMUT e assuma o valor máximo do campo de amout)

 DBObject Group = (dbObject) json.parse ("{$ Group: {_ id: '$ userID', count: {$ sum: 1}, total: {$ sum: '$ valor'}, maxsigle: {$ max: '$' '}}}});

Depois que as condições forem emendas, comece a consultar:

 List <dBObject> list = new ArrayList <DBObject> (); list.add (Match); list.add (grupo); agregationOutput Output = Mongotemplate.getCollection ("Nome da tabela"). Agregado (List);

Não há necessidade de falar sobre o resultado da travessia. O acima foi descrito em detalhes

O segundo método é muito mais simples que o outro? Mas ele testa a familiaridade com as declarações do MongoDB.

【Estendido】

Então o método acima se expande

 // O status é 0 ou 1; tipo não 11; time dbObject Match = (dbObject) json.parse ("{$ Match: {'status': {$ in: ['0', '1']}, tipo: {$ ne: 11}, 'time': {$ gte: '+BegindAy+"', $ lte: '+endday+"'}}}}} A última vez que o grupo dbObject = (dbObject) json.parse ("{$ Group: {_ Id: '$ userID', contagem: {$ sum: 1}, última hora: {$ max: '$ time'}}}}}"); // nos resultados contados no passo anterior, dados com tempo de filtragem maior que 100 tempos dbb "); JSON.PARSE ("{$ MATCH: {contagem: {$ gte: 100}}}"); // $ Project ---- Quais campos devem ser exibidos no resultado da consulta, e a tela é definida como 1. O campo (campo) não precisa ser exibido da seguinte Nome da coleção.Agregre. JSON.PARSE ("{$ Sort: {'count':-1}}"); // Lista de classificação <DBObject> list = new ArrayList <DBObject> (); list.add (match); list.add (group); list.add (groupMatch); list.add (project); list.add (tipo); agreg.add (groupMatch); nome ") .AGregre (list); // Resultados da consulta

3. BasicDBObject+Declaração de script

 BasicDBObject GroupIndex = new BasicDBObject (); BasicDBObject DistinctQuery = new BasicDBObject (); DistinctQuery.put ("UserID", new BasicDBObject ("$ in", UserIDS); InitindEx. // UserIDS Array BasicDbobject "CountS = New BasicDBObject (); InitInDinds; Representa os dados do banco de dados.Prev representa o resultado da consulta // prev.Count A contagem aqui está a contagem da etapa anterior initIndex) string Reduced = "function (doc, prev) {if (doc.status == 0) {prev.count+= 1;};}"; list <pap> <string)) {prev.count+= 1;};} "; list <pap>) getCollection ("Coleção"). Grupo (GroupIndex, DistinctQuery, InitIndex, Reduce, NULL);

Finalmente, você pode obter o resultado ao longo da lista. [PS: Há uma restrição nesse método de agregação de grupo ---> haverá um erro se exceder 20.000 dados]

O exposto acima é o que eu uso o processamento de agregação do MongoDB no processamento de negócios comuns. Se houver um método melhor ou algo que precise de melhorias, deixe -me uma mensagem ~