mogoDB 4.2.0安装部署及JAVA 客戶端应用

1、服务安装与卸载

cd C:Program FilesMongoDBServer4.2in

安装服务：mongod --config "C:/Program Files/MongoDB/Server/4.2/bin/mongod.cfg" --dbpath=D:MongoDBdatadb --logpath=D:MongoDBdatalogsMongoDB.log --install --serviceName "MongoDB"

卸载服务：mongod.exe --remove --serviceName "MongoDB"

2、创建数据库及用户

mogo
use admin
db.createUser({user:'myAdmin', pwd:'myAdmin111', roles:[{role:'root',db:'admin'}]})
db.auth('myAdmin','myAdmin111')

use myDB
db.createUser({user:"user1",pwd:"123",roles:[{ role: "readWrite", db: "myDB" }]})
db.grantRolesToUser("user1", [ { role:"dbAdmin", db: "myDB"} ])
db.grantRolesToUser("user1", [ { role:"readWrite", db: "myDB"} ])

MongoDB 目前内置了 7 个角色。

数据库用户角色：read、readWrite;
数据库管理角色：dbAdmin、dbOwner、userAdmin；
集群管理角色：clusterAdmin、clusterManager、clusterMonitor、hostManager；
备份恢复角色：backup、restore；
所有数据库角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase
超级用户角色：root；这里还有几个角色间接或直接提供了系统超级用户的访问（dbOwner 、userAdmin、userAdminAnyDatabase）
内部角色：__system

这些角色对应的作用如下：
Read：允许用户读取指定数据库
readWrite：允许用户读写指定数据库
dbAdmin：允许用户在指定数据库中执行管理函数，如索引创建、删除，查看统计或访问system.profile
userAdmin：允许用户向system.users集合写入，可以找指定数据库里创建、删除和管理用户
clusterAdmin：只在admin数据库中可用，赋予用户所有分片和复制集相关函数的管理权限。
readAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读权限
readWriteAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读写权限
userAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的userAdmin权限
dbAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的dbAdmin权限。
root：只在admin数据库中可用。超级账号，超级权限

3、验证用户

mongo 192.168.1.230:27017/myDB -u "user1" -p "123"
db.auth('user1','123')

db.collection1.insert({title: 'MongoDB 教程'})

4、mongod.cfg 配置

# mongod.conf

# for documentation of all options, see:
#   http://docs.mongodb.org/manual/reference/configuration-options/

# Where and how to store data.
storage:
  dbPath: D:MongoDBServer4.2data
  journal:
    enabled: true
#  engine:
#  mmapv1:
#  wiredTiger:

# where to write logging data.
systemLog:
  destination: file
  logAppend: true
  path:  D:MongoDBServer4.2logmongod.log

# network interfaces
net:
  port: 27017
  bindIp: 0.0.0.0


#processManagement:

#security:
#  authorization: enabled

#operationProfiling:

#replication:

#sharding:

## Enterprise-Only Options:

#auditLog:

#snmp:

 5、数据库管理工具：robmongo

 6、JAVA操作

package com.xrh.core.db;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
import java.util.regex.Pattern;

import org.bson.Document;
import org.bson.conversions.Bson;
import org.bson.types.ObjectId;

import com.mongodb.MongoClientSettings;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.xrh.base.config.DAO_Config;
import com.xrh.core.BN_Page;
import com.xrh.core.BN_Row;
import com.xrh.core.util.JsonUtil;
import com.xrh.core.util.ObjectUtil;

/**
 * mongoDB  数据持久层处理类
 * @author Li XiaoJia
 *
 */
public class MongoRunner {

    public static Logger logger = Logger.getLogger(MongoRunner.class.getName());
    private static MongoClient mongoClient = null;
    private static String userName = DAO_Config.getConfigValue("mongo-userName");
    private static String password = DAO_Config.getConfigValue("mongo-password");
    private static String serverAddress = DAO_Config.getConfigValue("mongo-serverAddress");//多个用,分隔
    private MongoRunner(){}
    
    /**
     * 获取客户端链接实例
     * @return MongoClient
     */
    public static MongoClient getMongoClient(){
        if ( mongoClient == null ){
            String database = DAO_Config.getConfigValue("mongo-database");
            MongoCredential credential = MongoCredential.createCredential(userName, database, password.toCharArray());
            List<ServerAddress> servers = new ArrayList();
            logger.info("serverAddress="+serverAddress);
            String[] serverAddressArr = serverAddress.split(",");
            for (String serverAddressStr : serverAddressArr){
                if (serverAddressStr.contains(":")){
                    servers.add(new ServerAddress(serverAddressStr.split(":")[0]
                            ,Integer.parseInt(serverAddressStr.split(":")[1])));
                }else{
                    servers.add(new ServerAddress(serverAddressStr));
                }
            }
            MongoClientSettings settings = MongoClientSettings.builder()
                    .credential(credential)
//                    .applyToSslSettings(builder -> builder.enabled(true))
                    .applyToClusterSettings(builder -> 
                        builder.hosts(servers))
                    .build();
            mongoClient = MongoClients.create(settings);
            return mongoClient;
        }
        return mongoClient;
    }
    
    private static MongoDatabase getDatabase(String database){
        if (ObjectUtil.isNull(database)){
            database = DAO_Config.getConfigValue("mongo-database");
        }
        return getMongoClient().getDatabase(database);
    }
    
    /**
     * 关闭客户端链接
     */
    public static void closeMongoClient(){
        if ( mongoClient != null ){
            logger.info("关闭mongoClient.");
            mongoClient.close();
            mongoClient = null;
        }
    }
    
    /**
     * 添加一条记录
     * @param table  表名
     * @param row    BN_Row行对象数据
     */
    public static void insertRow(String table, BN_Row row) {
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return ;
        }
        if (row == null){
            logger.warning("row 参数对象不能为空!");
            return ;
        }
        String database = DAO_Config.getConfigValue("mongo-database");
        insertRow(database, table, row);
    }
    
    
    
    /**
     * 添加一条记录
     * @param database 数据库名
     * @param table  表名
     * @param row    BN_Row行对象数据
     */
    public static void insertRow(String database, String table, BN_Row row) {
        if (ObjectUtil.isNull(database)){
            logger.warning("database 参数不能为空!");
            return ;
        }
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return ;
        }
        if (row == null){
            logger.warning("row 参数对象不能为空!");
            return ;
        }
        MongoDatabase db = getDatabase(database);
        MongoCollection<Document> collection = db.getCollection(table);
        Document document = new Document();
        document.putAll(row.columnMap);
        logger.info("insertRow document="+document.toJson());
        collection.insertOne(document);
    }
 
    /**
     * 添加一条记录
     * @param table  表名
     * @param row    map行对象数据
     */
    public static void insertRow(String table, Map row) {
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return ;
        }
        if (row == null){
            logger.warning("row 参数Map对象不能为空!");
            return ;
        }
        String database = DAO_Config.getConfigValue("mongo-database");
        insertRow(database, table, row);
    }
    
    /**
     * 添加一条记录
     * @param database 数据库名
     * @param table    表名
     * @param row      map行对象数据
     */
    public static void insertRow(String database, String table, Map row) {
        if (ObjectUtil.isNull(database)){
            logger.warning("database 参数不能为空!");
            return ;
        }
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return ;
        }
        if (row == null){
            logger.warning("row 参数Map对象不能为空!");
            return ;
        }
        MongoDatabase db = getDatabase(database);
        MongoCollection<Document> collection = db.getCollection(table);
        Document document = new Document();
        document.putAll(row);
        logger.info("insertRow document="+document.toJson());
        collection.insertOne(document);
    }
    
    /**
     * 批量添加数据
     * @param table    表名
     * @param rowList  多条数据
     */
    public static void insertList(String table, List<BN_Row> rowList) {
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return ;
        }
        if (rowList == null){
            logger.warning("rowList 参数List<BN_Row>对象不能为空!");
            return ;
        }
        String database = DAO_Config.getConfigValue("mongo-database");
        insertList(database, table, rowList);
    }
    
    /**
     * 批量添加数据
     * @param database 数据库名
     * @param table    表名
     * @param rowList  多条数据
     */
    public static void insertList(String database, String table, List<BN_Row> rowList) {
        if (ObjectUtil.isNull(database)){
            logger.warning("database 参数不能为空!");
            return ;
        }
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return ;
        }
        if (rowList == null){
            logger.warning("rowList 参数List<BN_Row>对象不能为空!");
            return ;
        }
        MongoDatabase db = getDatabase(database);
        MongoCollection<Document> collection = db.getCollection(table);
        List<Document> list = new ArrayList();
        for (BN_Row row : rowList){
            Document document = new Document();
            document.putAll(row.columnMap);
            list.add(document);
            logger.info("insertList document="+document.toJson());
        }
        collection.insertMany(list);
    }
    
    /**
     * 更新
     * @param table
     * @param row
     * @return
     */
    public static long updateRow(String table, BN_Row row) {
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return -1;
        }
        if (row == null){
            logger.warning("row 参数BN_Row对象不能为空!");
            return -1;
        }
        String database = DAO_Config.getConfigValue("mongo-database");
        return updateRow(database, table, row);
    }
    
    /**
     * 更新
     * @param database 数据库名
     * @param table
     * @param row
     * @return
     */
    public static long updateRow(String database, String table, BN_Row row) {
        if (ObjectUtil.isNull(database)){
            logger.warning("database 参数不能为空!");
            return -1;
        }
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return -1;
        }
        if (row == null){
            logger.warning("row 参数BN_Row对象不能为空!");
            return -1;
        }
        MongoDatabase db = getDatabase(database);
        MongoCollection<Document> collection = db.getCollection(table);
        String keyValue = row.columnMap.get("id").toString();
        Document document = new Document();
        row.removeColumn("id");
        document.putAll(row.columnMap);
        logger.info("updateRow _id=" + keyValue + " document="+document.toJson());
        Bson filter = Filters.eq("_id", new ObjectId(keyValue));
        UpdateResult updateResult = collection.updateOne(filter, 
                new Document("$set", document));
        return updateResult.getModifiedCount();
    }
    
    /**
     * 删除数据
     * @param table  表名
     * @param _id    _id值
     * @return
     */
    public static long deleteRow(String table, String id) {
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return -1;
        }
        if (ObjectUtil.isNull(id)){
            logger.warning("id 参数不能为空!");
            return -1;
        }
        String database = DAO_Config.getConfigValue("mongo-database");
        return deleteRow(database, table, id);
    }
    
    /**
     * 删除数据
     * @param database 数据库名
     * @param table    表名
     * @param _id      _id值
     * @return
     */
    public static long deleteRow(String database, String table, String id) {
        if (ObjectUtil.isNull(database)){
            logger.warning("database 参数不能为空!");
            return -1;
        }
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return -1;
        }
        if (ObjectUtil.isNull(id)){
            logger.warning("id 参数不能为空!");
            return -1;
        }
        MongoDatabase db = getDatabase(database);
        MongoCollection<Document> collection = db.getCollection(table);
        logger.info("deleteRow _id=" + id);
        DeleteResult deleteResult = collection.deleteOne(Filters.eq("_id", new ObjectId(id)));
        return deleteResult.getDeletedCount();
    }
    
    /**
     * 删除符合条件的数据表记录
     * @param table
     * @param queryJson  eg:"{"_id":"=@5e4f9f205291a2268e5576b8","osName":"LIKE@测试"}"
     * @return
     */
    public static long deleteMany(String table, String queryJson) {
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return -1;
        }
        if (ObjectUtil.isNull(queryJson)){
            logger.warning("queryJson 参数不能为空!");
            return -1;
        }
        String database = DAO_Config.getConfigValue("mongo-database");
        return deleteMany(database, table, queryJson);
    }
    
    /**
     * 删除符合条件的数据表记录
     * @param database
     * @param table
     * @param queryJson  eg:"{"_id":"=@5e4f9f205291a2268e5576b8","osName":"LIKE@测试"}"
     * @return
     */
    public static long deleteMany(String database, String table, String queryJson) {
        if (ObjectUtil.isNull(database)){
            logger.warning("database 参数不能为空!");
            return -1;
        }
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return -1;
        }
        if (ObjectUtil.isNull(queryJson)){
            logger.warning("queryJson 参数不能为空!");
            return -1;
        }
        MongoDatabase db = getDatabase(database);
        MongoCollection<Document> collection = db.getCollection(table);
        List<Bson> queryObject = queryBsonHandler(queryJson);
        logger.info("deleteMany queryJson=" + queryJson);
        DeleteResult deleteResult = collection.deleteMany(Filters.and(queryObject));
        return deleteResult.getDeletedCount();
    }
    
    /**
     * 删除指定表的所有数据
     * @param table
     * @return
     */
    public static boolean deleteAll(String table) {
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return false;
        }
        String database = DAO_Config.getConfigValue("mongo-database");
        return deleteAll(database, table);
    }
    
    /**
     * 删除指定表的所有数据
     * @param table
     * @return
     */
    public static boolean deleteAll(String database, String table) {
        if (ObjectUtil.isNull(database)){
            logger.warning("database 参数不能为空!");
            return false;
        }
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return false;
        }
        logger.info("deleteAll table=" + table);
        MongoDatabase db = getDatabase(database);
        MongoCollection<Document> collection = db.getCollection(table);
        collection.drop();
        return true;
    }
    
    /**
     * 查询单条记录
     * @param table
     * @param _id
     * @param beanClass
     * @return
     */
    public static BN_Row selectRow(String table, String id, Class beanClass){
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return null;
        }
        if (ObjectUtil.isNull(id)){
            logger.warning("id 参数不能为空!");
            return null;
        }
        if (beanClass == null){
            logger.warning("beanClass 参数Class对象不能为空!");
            return null;
        }
        String database = DAO_Config.getConfigValue("mongo-database");
        return selectRow(database, table, id, beanClass);
    }
    
    /**
     * 查询单条记录
     * @param database
     * @param table
     * @param _id
     * @param beanClass
     * @return
     */
    public static BN_Row selectRow(String database, String table, String id, Class beanClass){
        if (ObjectUtil.isNull(database)){
            logger.warning("database 参数不能为空!");
            return null;
        }
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return null;
        }
        if (ObjectUtil.isNull(id)){
            logger.warning("id 参数不能为空!");
            return null;
        }
        if (beanClass == null){
            logger.warning("beanClass 参数Class对象不能为空!");
            return null;
        }
        MongoDatabase db = getDatabase(database);
        MongoCollection<Document> collection = db.getCollection(table);
        String json = collection.find(Filters.eq("_id", new ObjectId(id))).first().toJson();
        logger.info("selectRow result=" + json);
        Map map = JsonUtil.json2Obj(json, Map.class);
        BN_Row row = null;
        try {
            row = (BN_Row) beanClass.newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        map.remove("_id");
        row.columnMap.putAll(map);
        row.columnMap.put("id", id);
        return row;
    }
    
    /**
     * 查询符合条件的多条记录
     * @param table       
     * @param queryJson  eg:{"osName":"=@微软操作系统1"}
     * @param sortColumn
     * @param order
     * @param limit
     * @param beanClass
     * @return
     */
    public static List<BN_Row> selectList(String table, String queryJson, String sortColumn, 
            String order, int limit, Class beanClass){
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return null;
        }
        if (beanClass == null){
            logger.warning("beanClass 参数Class对象不能为空!");
            return null;
        }
        String database = DAO_Config.getConfigValue("mongo-database");
        return selectList(database, table, queryJson, sortColumn, order, limit, beanClass);
    }
    
    /**
     * 查询符合条件的多条记录
     * @param database
     * @param table       
     * @param queryJson
     * @param sortColumn
     * @param order
     * @param limit
     * @param beanClass
     * @return
     */
    public static List<BN_Row> selectList(String database, String table, String queryJson, String sortColumn, 
            String order, int limit, Class beanClass){
        if (ObjectUtil.isNull(database)){
            logger.warning("database 参数不能为空!");
            return null;
        }
        if (ObjectUtil.isNull(table)){
            logger.warning("table 参数不能为空!");
            return null;
        }
        if (beanClass == null){
            logger.warning("beanClass 参数Class对象不能为空!");
            return null;
        }
        MongoDatabase db = getDatabase(database);
        MongoCollection<Document> collection = db.getCollection(table);
        List<Bson> queryObject = queryBsonHandler(queryJson);
        logger.info("queryObject="+queryObject.toString());
        
        FindIterable<Document> findIterable = null;
        if ( queryObject.size() == 0 ){
            findIterable = collection.find();
        } else {
            findIterable = collection.find(Filters.and(queryObject));
        }
        if (!ObjectUtil.isNull(sortColumn) 
                && !ObjectUtil.isNull(order) ){
            Bson sort = Filters.eq(sortColumn, order.equals("asc")? 1 : -1);
            findIterable = findIterable.sort(sort);
        }
        
        if (limit > 0){
            findIterable = findIterable.limit(limit);
        }
        MongoCursor<Document> iterator = null;
        List results = new ArrayList();
        try {
            iterator = findIterable.iterator();
            while (iterator.hasNext()){
                Document document = iterator.next();
                ObjectId objectId = document.getObjectId("_id");
                BN_Row row = (BN_Row) beanClass.newInstance();
                Map map = JsonUtil.json2Obj(document.toJson(), Map.class);
                map.remove("_id");
                row.columnMap.putAll(map);
                row.columnMap.put("id", objectId.toString());
                results.add(row);
            }
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if ( iterator != null ){
                iterator.close();
            }
        }
        return results;
    }

    /**
     * 查询翻页数据
     * @param page
     * @param beanClass
     * @return
     */
    public static BN_Page selectPage(BN_Page page, Class beanClass){
        if (page == null){
            logger.warning("page 参数BN_Page不能为空!");
            return null;
        }
        if (beanClass == null){
            logger.warning("beanClass 参数Class不能为空!");
            return null;
        }
        String database = DAO_Config.getConfigValue("mongo-database");
        return selectPage(database, page, beanClass);
    }
    
    /**
     * 查询翻页数据
     * @param database
     * @param page
     * @param beanClass
     * @return
     */
    public static BN_Page selectPage(String database, BN_Page page, Class beanClass){
        if (ObjectUtil.isNull(database)){
            logger.warning("database 参数不能为空!");
            return null;
        }
        if (page == null){
            logger.warning("page 参数不能为空!");
            return null;
        }
        if (beanClass == null){
            logger.warning("beanClass 参数Class对象不能为空!");
            return null;
        }
        MongoDatabase db = getDatabase(database);
        MongoCollection<Document> collection = db.getCollection(page.getTableName());
        List<Bson> queryObject = queryBsonHandler(page.getWhereCond());
        
        logger.info("collection="+page.getTableName());
        logger.info("queryObject="+queryObject.toString());
        logger.info("sort="+page.getSort());
        logger.info("order="+page.getOrder());
        logger.info("limit="+page.getRows());
        logger.info("skip="+page.getRowNo());
        
        Bson sort = Filters.eq(page.getSort(), page.getOrder().equals("asc")? 1 : -1);
        FindIterable<Document> findIterable = null;
        if ( queryObject.size() == 0 ){
            findIterable = collection.find();
            page.setRowCount(collection.countDocuments());
        } else {
            findIterable = collection.find(Filters.and(queryObject));
            page.setRowCount(collection.countDocuments(Filters.and(queryObject)));
        }
        findIterable = findIterable.sort(sort)
                    .limit(page.getRows())
                    .skip(page.getRowNo());
        MongoCursor<Document> iterator = null;
        try {
            iterator = findIterable.iterator();
            while (iterator.hasNext()){
                Document document = iterator.next();
                ObjectId objectId = document.getObjectId("_id");
                BN_Row row = (BN_Row) beanClass.newInstance();
                Map map = JsonUtil.json2Obj(document.toJson(), Map.class);
                map.remove("_id");
                row.columnMap.putAll(map);
                row.columnMap.put("id", objectId.toString());
                page.addRow(row);
            }
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if ( iterator != null ){
                iterator.close();
            }
        }
        return page;
    }
    
    /**
     * 转换为List<Bson>查询对象
     * @param queryJson
     * @return
     */
    private static List<Bson> queryBsonHandler(String queryJson){
        List<Bson> querys = new ArrayList();
        if (!ObjectUtil.isNull(queryJson)){
            logger.info("queryBsonHandler whereCond="+queryJson);
            List<Map<String, Object>> jsonList = JsonUtil.json2List("["+queryJson+"]");
            Map<String, Object> map = jsonList.get(0);
            Set<String> set = map.keySet();
            for (Iterator<String> it = set.iterator();it.hasNext();) {
                String queryColumn = it.next();
                String queryValue = map.get(queryColumn).toString();
                if (queryColumn.startsWith("B$_") || queryColumn.startsWith("E$_")){
                    queryColumn = queryColumn.substring(3);
                }
                if (queryValue.startsWith("LIKE@")){
                    querys.add(Filters.regex(queryColumn, 
                            Pattern.compile("^.*"+queryValue.substring(5)+".*$", Pattern.CASE_INSENSITIVE)));
                }else if (queryValue.startsWith("=@")){
                    if ("id".equals(queryColumn)){
                        querys.add(Filters.eq("_id", new ObjectId(queryValue.substring(2))));
                    }else{
                        querys.add(Filters.eq(queryColumn, queryValue.substring(2)));
                    }
                }else if (queryValue.startsWith("=INT@")){
                    querys.add(Filters.eq(queryColumn, new Long(queryValue.substring(5)).longValue()));
                }else if (queryValue.startsWith(">@")){
                    querys.add(Filters.gt(queryColumn, queryValue.substring(2)));
                }else if (queryValue.startsWith(">INT@")){
                    querys.add(Filters.gt(queryColumn, new Integer(queryValue.substring(5)).intValue()));
                }else if (queryValue.startsWith(">=@")){
                    querys.add(Filters.gte(queryColumn, queryValue.substring(3)));
                }else if (queryValue.startsWith(">=INT@")){
                    querys.add(Filters.gte(queryColumn, new Integer(queryValue.substring(6)).intValue()));
                }else if (queryValue.startsWith("<@")){
                    querys.add(Filters.lt(queryColumn, queryValue.substring(2)));
                }else if (queryValue.startsWith("<INT@")){
                    querys.add(Filters.lt(queryColumn, new Integer(queryValue.substring(5)).intValue()));
                }else if (queryValue.startsWith("<=@")){
                    querys.add(Filters.lte(queryColumn, queryValue.substring(3)));
                }else if (queryValue.startsWith("<=INT@")){
                    querys.add(Filters.lte(queryColumn, new Integer(queryValue.substring(6)).intValue()));
                }else if (queryValue.startsWith("!=@")){
                    querys.add(Filters.ne(queryColumn, queryValue.substring(3)));
                }else if (queryValue.startsWith("!=INT@")){
                    querys.add(Filters.ne(queryColumn, new Integer(queryValue.substring(6)).intValue()));
                }
            }
        }
        return querys;
    }
    
    public static void main(String[] args){
        
    }

}