利用反射实现简单的Class对象和Bson文档的转换

最新推荐文章于 2025-05-16 16:37:24 发布
转载 最新推荐文章于 2025-05-16 16:37:24 发布 · 4.2k 阅读 · 2
文章标签：

#java #MongoDB #Bson

本文介绍了一种基于 Java 的 MongoDB 操作方案，利用 ORM 技术实现了对象与 MongoDB 数据库之间的映射，包括对象持久化、查询等功能，并提供了完整的示例代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

http://www.cnblogs.com/maybo/p/5182439.html 

import java.util.List;

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

import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

/*
 * 创建一个会话实现对mongoDB的原子操作
 * 
 * @author:maybo
 * 
 * @date:2016-2-1
 */
public abstract class AbstractMongoSession {
    private MongoDatabase db;
    private Class<?> clazz;
    private MongoCollection<Document> collection;

    public MongoCollection<Document> getCollection() {
        return this.collection;
    }

    public Class<?> getClazz() {
        return clazz;
    }

    public void setDb(MongoDatabase db) {
        this.db = db;
    }

    public MongoDatabase getDb() {
        return db;
    }

    protected MongoCollection<Document> Collection(Class<?> clazz) {
        this.clazz = clazz;
        Table table = (Table) clazz.getAnnotation(Table.class);
        String col = null;
        if (null != table && null != table.name()) {
            col = table.name();
        } else {
            col = clazz.getName();
        }
        this.collection = db.getCollection(col);
        return this.collection;
    }

    /*
     * 保存
     * 
     * @param:实体
     * 
     * @return:void
     */
    public abstract void save(Object obj);

    public abstract void saveMany(List<Object> obj);

    // 删除数据
    public abstract long delete(Object obj) throws Exception;

    public abstract long delete(Bson bson) throws Exception;

    // 删除数据
    public abstract long deleteMany(List<Object> objs);

    public abstract long deleteMany(Bson bson);

    // 修改数据
    public abstract long upate(Bson bson, Object obj);

    public abstract long update(Object obj);

    public abstract long upateMany(Bson bson, Object obj);

    public abstract long upateMany(Bson bson, List<Object> objs);

    public abstract long upateMany(List<Object> objs);

    // 查询数据
    public abstract Object find(Object obj);

    // 获取所有的数据
    public abstract List<Object> finds();

    // 条件查询数据
    public abstract List<Object> query(Bson bson);

    public abstract Object queryOne(Bson bson);

    public abstract List<Object> query(Bson bson, Bson sort);

    public abstract Object queryOne(Bson bson, Bson sort);

    public abstract List<Object> query(Bson bson, Bson sort, int limit);

    public abstract List<Object> query(Bson bson, Bson sort, int limit, int skip);

    public abstract List<Object> query(Bson bson, Bson sort, Bson filter);

    public abstract Object queryOne(Bson bson, Bson sort, Bson Filter);

    public abstract long count();

    public abstract long count(Bson bson);

}


import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;

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

import com.mongodb.client.FindIterable;
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;

public class MongoSession extends AbstractMongoSession {
    public MongoSession(Class<?> clazz, MongoDatabase db) {
        this.setDb(db);
        this.Collection(clazz);
    }

    /*
     * (non-Javadoc)
     * 
     * @see AbstractMongoSession#save(java.lang.Object)
     */
    @Override
    public void save(Object obj) {
        try {
            this.getCollection().insertOne(BsonUtil.toBson(obj));
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public long delete(Object obj) throws Exception {
        try {
            DeleteResult result = this.getCollection().deleteOne(
                    BsonUtil.toBson(obj));
            long count = result.getDeletedCount();
            return count;
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return 0;
    }

    @Override
    public void saveMany(List<Object> obj) {
        try {
            this.getCollection().insertMany(BsonUtil.toBsons(obj));
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    @Override
    public long delete(Bson bson) throws Exception {
        DeleteResult deleteResult = this.getCollection().deleteOne(bson);
        return deleteResult.getDeletedCount();
    }

    @Override
    public long deleteMany(List<Object> objs) {
        List<Document> documents;
        int count = 0;
        try {
            documents = BsonUtil.toBsons(objs);
            for (int i = 0; null != documents && i < documents.size(); i++) {
                DeleteResult deleteResult = this.getCollection().deleteOne(
                        documents.get(i));
                count += deleteResult.getDeletedCount();
            }
            return count;
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return count;
    }

    @Override
    public long deleteMany(Bson bson) {
        DeleteResult deleteResult = this.getCollection().deleteMany(bson);
        return deleteResult.getDeletedCount();
    }

    @Override
    public long upate(Bson bson, Object obj) {
        try {
            UpdateResult result = this.getCollection().updateOne(bson,
                    new Document("$set", BsonUtil.toBson(obj)));
            return result.getMatchedCount();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return 0;
    }

    @Override
    public long update(Object obj) {
        Document document;
        try {
            document = BsonUtil.toBson(obj);
            UpdateResult updateResult = this.getCollection().updateOne(
                    Filters.eq("_id", document.get("_id")),
                    new Document("$set", document));
            return updateResult.getMatchedCount();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return 0;
    }

    @Override
    public long upateMany(Bson bson, Object obj) {
        try {
            UpdateResult updateResult = this.getCollection().updateMany(bson,
                    new Document("$set", BsonUtil.toBson(obj)));
            return updateResult.getMatchedCount();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return 0;
    }

    @Override
    public long upateMany(Bson bson, List<Object> obj) {
        for (int i = 0; null != obj && i < obj.size(); i++) {
            try {
                UpdateResult result = this.getCollection().updateMany(bson,
                        new Document("$set", BsonUtil.toBson(obj)));
                return result.getMatchedCount();
            } catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (NoSuchFieldException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return 0;
    }

    @Override
    public long upateMany(List<Object> objs) {
        long count = 0;
        for (int i = 0; null != objs && i < objs.size(); i++) {
            try {
                UpdateResult result = this.getCollection().updateMany(
                        Filters.eq("_id",
                                BsonUtil.toBson(objs.get(i)).get("_id")),
                        new Document("$set", BsonUtil.toBson(objs.get(i))));
                count += result.getMatchedCount();
            } catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (NoSuchFieldException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return count;
    }

    @Override
    public Object find(Object obj) {
        try {
            Document document = this.getCollection()
                    .find(Filters.eq("_id", BsonUtil.toBson(obj).get("_id")))
                    .first();
            return BsonUtil.toBean(document, this.getClazz());
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public List<Object> finds() {
        FindIterable<Document> doIterable = this.getCollection().find();
        MongoCursor<Document> cursor = doIterable.iterator();
        List<Object> objects = new ArrayList<Object>();
        while (cursor.hasNext()) {
            Document document = cursor.next();
            try {
                objects.add(BsonUtil.toBean(document, this.getClazz()));
            } catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InstantiationException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return objects;
    }

    @Override
    public List<Object> query(Bson bson) {
        FindIterable<Document> doIterable = this.getCollection().find(bson);
        MongoCursor<Document> cursor = doIterable.iterator();
        List<Object> objects = new ArrayList<Object>();
        while (cursor.hasNext()) {
            Document document = cursor.next();
            try {
                objects.add(BsonUtil.toBean(document, this.getClazz()));
            } catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InstantiationException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return objects;
    }

    @Override
    public Object queryOne(Bson bson) {
        Document document = this.getCollection().find(bson).first();
        try {
            return BsonUtil.toBean(document, this.getClazz());
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public List<Object> query(Bson bson, Bson sort) {
        FindIterable<Document> doIterable = this.getCollection().find(bson)
                .sort(sort);
        MongoCursor<Document> cursor = doIterable.iterator();
        List<Object> objects = new ArrayList<Object>();
        while (cursor.hasNext()) {
            Document document = cursor.next();
            try {
                objects.add(BsonUtil.toBean(document, this.getClazz()));
            } catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InstantiationException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return objects;
    }

    @Override
    public Object queryOne(Bson bson, Bson sort) {
        Document document = this.getCollection().find(bson).sort(sort).first();
        try {
            return BsonUtil.toBean(document, this.getClazz());
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public List<Object> query(Bson bson, Bson sort, int limit) {
        FindIterable<Document> doIterable = this.getCollection().find(bson)
                .sort(sort);
        if (limit > 0) {
            doIterable = doIterable.limit(limit);
        }
        MongoCursor<Document> cursor = doIterable.iterator();
        List<Object> objects = new ArrayList<Object>();
        while (cursor.hasNext()) {
            Document document = cursor.next();
            try {
                objects.add(BsonUtil.toBean(document, this.getClazz()));
            } catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InstantiationException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return objects;
    }

    @Override
    public List<Object> query(Bson bson, Bson sort, int limit, int skip) {
        FindIterable<Document> doIterable = this.getCollection().find(bson)
                .sort(sort);
        if (limit > 0) {
            doIterable = doIterable.limit(limit);
        }
        if (skip > 0) {
            doIterable = doIterable.skip(skip);
        }
        MongoCursor<Document> cursor = doIterable.iterator();
        List<Object> objects = new ArrayList<Object>();
        while (cursor.hasNext()) {
            Document document = cursor.next();
            try {
                objects.add(BsonUtil.toBean(document, this.getClazz()));
            } catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InstantiationException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return objects;
    }

    @Override
    public List<Object> query(Bson bson, Bson sort, Bson filter) {
        FindIterable<Document> doIterable = this.getCollection().find(bson)
                .sort(sort).filter(filter);
        MongoCursor<Document> cursor = doIterable.iterator();
        List<Object> objects = new ArrayList<Object>();
        while (cursor.hasNext()) {
            Document document = cursor.next();
            try {
                objects.add(BsonUtil.toBean(document, this.getClazz()));
            } catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InstantiationException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return objects;
    }

    @Override
    public Object queryOne(Bson bson, Bson sort, Bson Filter) {
        Document document = this.getCollection().find(bson).sort(sort)
                .filter(Filter).first();

        try {
            return BsonUtil.toBean(document, this.getClazz());
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public long count() {

        return this.getCollection().count();
    }

    @Override
    public long count(Bson bson) {
        // TODO Auto-generated method stub
        return this.getCollection().count(bson);
    }
}



3. 帮助类:实现Document到Object 以及Object到Document的转换．使用反射技术和注解．



import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;

import org.bson.Document;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;

/*
 * 将mongo的文档转化为对象将对象转化为mongo文档
 * @author:maybo
 * @data:2016-2-1
 */
public class BsonUtil {
    public static <T> List<T> toBeans(List<Document> documents, Class<T> clazz)
            throws IllegalArgumentException, InstantiationException,
            IllegalAccessException, InvocationTargetException {
        List<T> list = new ArrayList<T>();
        for (int i = 0; null != documents && i < documents.size(); i++) {
            list.add(toBean(documents.get(i), clazz));
        }
        return list;
    }

    /*
     * 将Bson 转化为对象
     * 
     * @param:Bson文档
     * 
     * @param:类pojo
     * 
     * @param:返回对象
     */
    public static <T> T toBean(Document document, Class<T> clazz)
            throws InstantiationException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException {
        T obj = clazz.newInstance();// 声明一个对象
        Field[] fields = clazz.getDeclaredFields();// 获取所有属性
        Method[] methods = clazz.getMethods();// 获取所有的方法
        /*
         * 查找所有的属性，并通过属性名和数据库字段名通过相等映射
         */
        for (int i = 0; i < fields.length; i++) {
            String fieldName = fields[i].getName();
            Column column = fields[i].getAnnotation(Column.class);
            Object bson = null;
            if (null != column && null != column.name()) {
                bson = document.get(column.name());
            } else if ("id".equals(fieldName)) {
                bson = document.get("_id");
            } else {
                bson = document.get(fieldName);
            }
            if (null == bson) {
                continue;
            } else if (bson instanceof Document) {// 如果字段是文档了递归调用
                bson = toBean((Document) bson, fields[i].getType());
            } else if (bson instanceof MongoCollection) {// 如果字段是文档集了调用colTOList方法

                bson = colToList(bson, fields[i]);
            }
            for (int j = 0; j < methods.length; j++) {// 为对象赋值
                String metdName = methods[j].getName();
                if (equalFieldAndSet(fieldName, metdName)) {
                    methods[j].invoke(obj, bson);
                    break;
                }
            }
        }
        return obj;
    }

    public static List<Document> toBsons(List<Object> objs)
            throws IllegalArgumentException, SecurityException,
            IllegalAccessException, InvocationTargetException,
            NoSuchFieldException {
        List<Document> documents = new ArrayList<Document>();
        for (int i = 0; null != objs && i < objs.size(); i++) {
            documents.add(toBson(objs.get(i)));
        }
        return documents;
    }

    /*
     * 将对象转化为Bson文档
     * 
     * @param:对象
     * 
     * @param:类型
     * 
     * @return:文档
     */
    public static Document toBson(Object obj) throws IllegalArgumentException,
            IllegalAccessException, InvocationTargetException,
            SecurityException, NoSuchFieldException {
        if (null == obj) {
            return null;
        }
        Class<? extends Object> clazz = obj.getClass();
        Document document = new Document();
        Method[] methods = clazz.getDeclaredMethods();
        Field[] fields = clazz.getDeclaredFields();
        for (int i = 0; null != fields && i < fields.length; i++) {
            Column column = fields[i].getAnnotation(Column.class);// 获取列注解内容
            NotColumn notColumn = fields[i].getAnnotation(NotColumn.class);// 获取否列
            String key = null;// 对应的文档键值
            if (null != column && null != column.name()) {// 存在列映射取值
                key = column.name();
            } else if (null != notColumn) {// 不是列的情况
                continue;
            } else {
                key = fields[i].getName();// 默认情况通过属性名映射
                if ("id".equals(key)) {// 替换id为_id
                    key = "_id";
                }
            }
            String fieldName = fields[i].getName();
            /*
             * 获取对象属性值并映射到Document中
             */
            for (int j = 0; null != methods && j < methods.length; j++) {
                String methdName = methods[j].getName();
                if (null != fieldName && equalFieldAndGet(fieldName, methdName)) {
                    Object val = methods[j].invoke(obj);// 得到值
                    if (null == val) {
                        continue;
                    }
                    if (isJavaClass(methods[j].getReturnType())) {
                        if (methods[j].getReturnType().getName()
                                .equals("java.util.List")) {// 列表处理
                            @SuppressWarnings("unchecked")
                            List<Object> list = (List<Object>) val;
                            List<Document> documents = new ArrayList<Document>();
                            for (Object obj1 : list) {
                                documents.add(toBson(obj1));
                            }
                            document.append(key, documents);
                        } else {// 其它对象处理，基本类型
                            document.append(key, val);
                        }
                    } else {// 自定义类型
                        document.append(key, toBson(val));
                    }
                }
            }
        }
        return document;
    }

    /*
     * 是否是自定义类型】
     * 
     * false:是自定义
     */
    private static boolean isJavaClass(Class<?> clz) {
        return clz != null && clz.getClassLoader() == null;
    }

    /*
     * 将文档集转化为列表
     * 
     * @param:文档集
     * 
     * @param:属性类型
     * 
     * @return:返回列表
     */
    private static List<Object> colToList(Object bson, Field field)
            throws InstantiationException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException {
        ParameterizedType pt = (ParameterizedType) field.getGenericType();// 获取列表的类型
        List<Object> objs = new ArrayList<Object>();
        @SuppressWarnings("unchecked")
        MongoCollection<Document> cols = (MongoCollection<Document>) bson;
        MongoCursor<Document> cursor = cols.find().iterator();
        while (cursor.hasNext()) {
            Document child = cursor.next();
            @SuppressWarnings("rawtypes")
            Class clz = (Class) pt.getActualTypeArguments()[0];// 获取元素类型
            @SuppressWarnings("unchecked")
            Object obj = toBean(child, clz);
            System.out.println(child);
            objs.add(obj);

        }
        return objs;
    }

    /*
     * 比较setter方法和属性相等
     */
    private static boolean equalFieldAndSet(String field, String name) {
        if (name.toLowerCase().matches("set" + field.toLowerCase())) {
            return true;
        } else {
            return false;
        }
    }

    /*
     * 比较getter方法和属性相等
     */
    private static boolean equalFieldAndGet(String field, String name) {
        if (name.toLowerCase().matches("get" + field.toLowerCase())) {
            return true;
        } else {
            return false;
        }
    }
}


４．用到的注解Column ,NotColumn,Table






Column:



import java.lang.annotation.ElementType;



import java.lang.annotation.Retention;



import java.lang.annotation.RetentionPolicy;



import java.lang.annotation.Target;



 



@Target(ElementType.FIELD)



@Retention(RetentionPolicy.RUNTIME)



public @interface Column
 {



    public String
 name();



 



    public String
 text() default "这是一个属性映射";



}



N
 otColumn:



import java.lang.annotation.ElementType;



import java.lang.annotation.Retention;



import java.lang.annotation.RetentionPolicy;



import java.lang.annotation.Target;



 



@Target(ElementType.FIELD)



@Retention(RetentionPolicy.RUNTIME)



public @interface NotColumn
 {



    public String
 text() default "不是属性字段";



}



Table:



import java.lang.annotation.ElementType;



import java.lang.annotation.Retention;



import java.lang.annotation.RetentionPolicy;



import java.lang.annotation.Target;



 



@Target(ElementType.TYPE)



@Retention(RetentionPolicy.RUNTIME)



public @interface Table
 {



    public String
 name();



 



    public String
 text() default "表格映射";



}






　5. MongoObject 







import java.util.ArrayList;



import java.util.List;



import com.mongodb.MongoClient;



import com.mongodb.MongoClientOptions;



import com.mongodb.ReadPreference;



import com.mongodb.ServerAddress;



import com.mongodb.WriteConcern;



 



public class MongoObject
 {



    private List<String>
 hostPorts;



    private int port=27017;



    private String
 host="127.0.0.1";



    private int connectionsPerHost=5;//
 每个主机的连接数



    private int threadsAllowedToBlockForConnectionMultiplier=30;//
 线程队列数，它以上面connectionsPerHost值相乘的结果就是线程队列最大值。如果连接线程排满了队列就会抛出“Out



                                                                //
 // to get



                                                                //
 db”错误。



    private long maxWaitTime=5000;//
 最大等待连接的线程阻塞时间



    private long connectTimeout=5000;//
 连接超时的毫秒。0是默认和无限



    private long socketTimeout=5000;//
 socket超时。0是默认和无限



    private boolean autoConnectRetry=false;//
 这个控制是否在一个连接时，系统会自动



 



    public void setHostPorts(List<String>
 hostPorts) {



        this.hostPorts
 = hostPorts;



    }



 



    public MongoObject()
 {



        //
 TODO Auto-generated constructor stub



    }



    public int getPort()
 {



        return port;



    }



 



    public void setPort(int port)
 {



        this.port
 = port;



    }



 



    public String
 getHost() {



        return host;



    }



 



    public void setHost(String
 host) {



        this.host
 = host;



    }



 



    public int getConnectionsPerHost()
 {



        return connectionsPerHost;



    }



 



    public void setConnectionsPerHost(int connectionsPerHost)
 {



        this.connectionsPerHost
 = connectionsPerHost;



    }



 



    public int getThreadsAllowedToBlockForConnectionMultiplier()
 {



        return threadsAllowedToBlockForConnectionMultiplier;



    }



 



    public void setThreadsAllowedToBlockForConnectionMultiplier(



            int threadsAllowedToBlockForConnectionMultiplier)
 {



        this.threadsAllowedToBlockForConnectionMultiplier
 = threadsAllowedToBlockForConnectionMultiplier;



    }



 



    public long getMaxWaitTime()
 {



        return maxWaitTime;



    }



 



    public void setMaxWaitTime(long maxWaitTime)
 {



        this.maxWaitTime
 = maxWaitTime;



    }



 



    public long getConnectTimeout()
 {



        return connectTimeout;



    }



 



    public void setConnectTimeout(long connectTimeout)
 {



        this.connectTimeout
 = connectTimeout;



    }



 



    public long getSocketTimeout()
 {



        return socketTimeout;



    }



 



    public void setSocketTimeout(long socketTimeout)
 {



        this.socketTimeout
 = socketTimeout;



    }



 



    public boolean isAutoConnectRetry()
 {



        return autoConnectRetry;



    }



 



    public void setAutoConnectRetry(boolean autoConnectRetry)
 {



        this.autoConnectRetry
 = autoConnectRetry;



    }



 



    public MongoClient
 run() {



        if (null !=
 hostPorts) {



            if (null !=
 host && port > 0)
 {



                hostPorts.add(host
 + ":" +
 port);



            }



        } else {



            hostPorts
 = new ArrayList<String>();



            if (null !=
 host && port > 0)
 {



                hostPorts.add(host
 + ":" +
 port);



            } else {



                return null;



            }



        }



        List<ServerAddress>
 addresses = new ArrayList<ServerAddress>();



        for (String
 hostPort : hostPorts) {



            String[]
 spits = hostPort.split(":");



            ServerAddress
 address = new ServerAddress(spits[0],



                    Integer.valueOf(spits[1]));



            addresses.add(address);



        }



 



        MongoClient
 client = new MongoClient(addresses,
 getConfOptions());



        return client;



    }



 



    @SuppressWarnings("deprecation")



    private MongoClientOptions
 getConfOptions() {



        return new MongoClientOptions.Builder()



                .socketKeepAlive(true)



                //
 是否保持长链接



                .connectTimeout((int) this.connectTimeout)



                //
 链接超时时间



                .socketTimeout((int) this.socketTimeout)



                //
 read数据超时时间



                .readPreference(ReadPreference.primary())



                //
 最近优先策略



                .connectionsPerHost(this.connectionsPerHost)



                //
 每个地址最大请求数



                .maxWaitTime((int) this.maxWaitTime)



                //
 长链接的最大等待时间



                .threadsAllowedToBlockForConnectionMultiplier(



                        this.threadsAllowedToBlockForConnectionMultiplier) //
 一个socket最大的等待请求数



                .writeConcern(WriteConcern.NORMAL).build();



    }



}






6.
 MongoDB用于生产数据库对象







import com.mongodb.client.MongoDatabase;



 



 



public class MongoDB{



    private String
 db;



    private MongoObject
 client;



    public void setClient(MongoObject
 client) {



        this.client
 = client;



    }



    public void setDb(String
 db) {



        this.db
 = db;



    }



public MongoDB(MongoObject
 client,String db){



    this.client=client;



    this.db=db;



}



public MongoDatabase
 excute(){



    return client.run().getDatabase(db);



}



}




import java.util.List;


public class DaoImpl implements Dao{
    private MongoTemplate template;
private MongoSession session;
private String className;
public void setClassName(String className) {
    this.className = className;
}
public MongoSession getSession() {
    return session;
}
public DaoImpl(){}
public DaoImpl(MongoTemplate template,String className){
    this.template = template;
    this.className=className;
    try {
        this.session=template.session(Class.forName(className));
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
public void setTemplate(MongoTemplate template) {
    this.template = template;
    try {
        this.session=template.session(Class.forName(className));
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
    @Override
    public void save(Object obj) {
    this.session.save(obj);
    }

    @Override
    public void delete(Object obj) {
        try {
            this.session.delete(obj);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    @Override
    public void update(Object obj) {
        this.session.update(obj);
    }

    @Override
    public Object find(Object obj) {
        // TODO Auto-generated method stub
        return this.session.find(obj);
    }

    @Override
    public List<Object> finds() {
        // TODO Auto-generated method stub
        return this.session.finds();
    }

    @Override
    public long total() {
        // TODO Auto-generated method stub
        return this.session.count();
    }

    @Override
    public List<Object> finds(int index, int offset) {
        // TODO Auto-generated method stub
        return this.session.query(null, null, offset, index);
    }

}









10.Test 类





public class MongoDBTest
 {



    private static MongoTemplate
 template1;



    private static MongoTemplate
 template2;



    private static MongoTemplate
 template3;



    private static Dao
 dao1;



    private static Dao
 dao2;



    private static Dao
 dao3;



    static {



        MongoObject
 mongoObject = new MongoObject();



        mongoObject.setPort(12345);



        MongoDB
 demo1 = new MongoDB(mongoObject, "demo1");



        MongoDB
 demo2 = new MongoDB(mongoObject, "demo2");



        MongoDB
 demo3 = new MongoDB(mongoObject, "demo3");



        template1
 = new MongoTemplate(demo1);



        template2
 = new MongoTemplate(demo2);



        template3
 = new MongoTemplate(demo3);



        dao1
 = new DaoImpl(template1, "MidStu");



        dao2
 = new DaoImpl(template2, "MidStu");



        dao3
 = new DaoImpl(template3, "MidStu");



    }



 



    @Test



    public void save()
 {



 



        MidStu
 midStu = new MidStu();



        midStu.setHabit("zuqiu");



        midStu.setId("saflfgsddsf35");



        dao1.save(midStu);



        MidStu
 midStuFind = new MidStu();



        midStuFind.setId("saflfgsddsf35");



        System.out.println(dao1.find(midStuFind).toString());



 



        dao2.save(midStu);



 



        System.out.println(dao2.find(midStuFind).toString());



 



        dao3.save(midStu);



        System.out.println(dao3.find(midStuFind).toString());



    }



}










                

        

    

    
  



    



                



	

		

			

				
					
利用反射JavaBean和Document相互转换，Java方便操作插入MongoDB数据库

				
			

			

				

					路飞
				

				

					07-04
					
					1794
					
				

			

		

		

			
				
JavaBean和Document相互转换
引入依赖
  		<dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver</artifactId>
            <version>3.4.1</version>
        </dependency>
        &l

			
		

	



                

            
              



	

		

			

				
					
15 运行时反射：字符串和结构体之间如何转换

				
			

			

				

					周壮的博客
				

				

					09-07
					
					1161
					
				

			

		

		

			
				
在 Go 语言中，reflect.Value 被定义为一个 struct 结构体，它的定义如下面的代码所示：typ *rtypeflag我们发现 reflect.Value 结构体的字段都是私有的，也就是说，我们只能使用 reflect.Value 的方法。现在看看它有哪些常用方法，如下所示：//针对具体类型的系列方法//以下是用于获取对应的值BoolBytesComplexFloatIntStringUintCanSet //是否可以修改对应的值以下是用于修改对应的值Set。

			
		

	



              


  
              

                


	

		

			

				
					
MongoDb 将 BsonDocument 集合 转换为强类型 List

				
			

			

				

					布里渊区
				

				

					11-08
					
					1万+
					
				

			

		

		

			
				
var result = new List();
            var collection = MongoHelper.GetDocument(typeof(User).Name);
            var filterBuilder = Builders.Filter;
            var filter = filterBuilder.Eq("UserName",

			
		

	





	

		

			

				
					
java 利用反射对目标对象内属性的强制转换

				
			

			

				

					李阳阳的博客
				

				

					08-01
					
					8740
					
				

			

		

		

			
				
今天碰到一个问题：一个实体在进行序列化和反序列化后内部的字段类型发生了变化（比如枚举被转换为char类型），因此需要在运行时把类型给转换回来（因为后续方法会用到这个参数）。然后博主翻了翻反射api+论坛上逛了逛。找到一个解决方案。

1.利用反射可以拿到对象中属性对应的声明类型type


    //通过完整的类名（包名.类名）获得ZhangSan对应的的Class对象
    Class&lt...

			
		

	



		

			
		



	

		

			

				
					
MongoDB基础及Java实战 

					
最新发布

				
			

			

				

					weixin_44685984的博客
				

				

					05-16
					
					617
					
				

			

		

		

			
				
users.add(new Document("name", "李四").append("age", 30));users.add(new Document("name", "王五").append("age", 28));System.out.println("--- 查询 age > 25 ---");Filters.eq("name", "张三"),  // 查询条件。System.out.println("--- 查询 name=张三 ---");// insertMany 批量插入。

			
		

	





	

		

			

				
					
C# webform MongoDriver BsonDocument 转 List 并作为数据源绑定到 GridView

				
			

			

				

					qq_39213822的博客
				

				

					05-29
					
					945
					
				

			

		

		

			
				
BsonDocument转List并作为数据源绑定到GridView环境准备工作转换将得到的List作为数据源绑定到GridView运行结果
环境
IDE: vs 2019
框架：.NET Framework 4.5.2
(因为要使用的库对版本有要求，所以这里要注意.NET的版本)
项目类型：ASP.NET Web应用程序( .Net Framework)
使用到的库：
MongoDB.Bson 		v2.10.4
MongoDB.Driver		v2.10.4
(推荐使用NuGet安装，Nuget使用请百

			
		

	





	

		

			

				
					
C# MongoDB多条件查询，多集合查询示例。动态过滤方法使用。BsonDocument转成普通的实体对象

				
			

			

				

					zxb11c的博客
				

				

					04-04
					
					4559
					
				

			

		

		

			
				
直接上代码MongoDB.Driver包提供的LINQ查询语法。

			
		

	





	

		

			

				
					
java bsonobject_JAVA对象和BSON文档对象之间的相互转换

				
			

			

				

					weixin_31052141的博客
				

				

					02-13
					
					1088
					
				

			

		

		

			
				
支持 列表，哈希，数组和基本类型import java.lang.reflect.Array;import java.lang.reflect.Field;import java.lang.reflect.Modifier;import java.lang.reflect.ParameterizedType;import java.lang.reflect.TypeVariable;import ...

			
		

	





	

		

			

				
					
FlatBSON：实现Go结构体的BSON标签递归展平功能

				
			

			

				

					
				

			

		

		

			
				
无需手动构建更新的BSON文档，只需调用`flatbson.Flatten`函数并传递User结构体的实例。  下面是一个简化的使用示例：  ```go package main  import ( 	"***/huandu/flatbson" 	"gopkg.in/mgo.v2/bson" )  type User...

			
		

	





	

		

			

				
					
Java项目实现Excel数据导入MongoDB指南

				
			

			

				

					
				

			

		

		

			
				
 - 然后利用Jackson库将POJO对象转换为JSON格式，以便能够与MongoDB数据库进行交互。  - 最后，使用MongoDB Java驱动来建立连接，并将JSON数据插入到数据库中的相应集合（Collection）中。  5. 应用场景：  - 该方法...

			
		

	





	

		

			

				
					
java 连接 MongoDB 工具类示例

				
			

			

				

					10-13
				

			

		

		

			
				
 - 在MongoDB的Java驱动程序中，反射可能用于将Java对象转换为BSON文档，或者从BSON文档反序列化为Java对象。  5. **配置属性（Properties）**：  - Java `Properties`类用于处理属性列表，常用于读取和写入配置文件...

			
		

	





	

		

			

				
					
Bson:Bson是一个Java库，可用于将Java对象转换为二进制数据以进行存储传输使用更少的空间

				
			

			

				

					04-08
				

			

		

		

			
				
替代Json的数据格式
通过二进制的方式节省空间，相比Json，不保存key，只保存value。value根据实际的类型转换为二进制保存。
二级制保存
文件本身包含格式信息，但只包含层级和基本类型，不包含属性名
使用方式
Bson bson = new Bson();
文档梳理
【腾讯文档】Bson格式
设计
1字节Version +  对象数据
对象数据组成： 开头1字节+数据+结束1字节。起到括号作用
类型
用1字节代表类型数据
高2位有特殊含义  ——数组[10]，Map[11]，Set[01]，普通[00]
第3高位代表超长（非普通数据，后接1或4字节来表征数组长度，4字节全1代表不定长）
不定长只能用在最外层的数据中，中间的数据必须标识长度。
低5位(32中)为类型信息：Object，8种基础类型，null，字符串
比较特殊的是Set和Map；
Set和数组类似；
Map则是 k

			
		

	





	

		

			

				
					
JAVA对象和BSON文档对象之间的相互转换

				
			

			

				

					再试下的博客
				

				

					07-30
					
					3318
					
				

			

		

		

			
				
支持 列表，哈希，数组和基本类型
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.TypeVariable;
import java.util.ArrayList;
import java.util.HashMap;
imp

			
		

	





	

		

			

				
					
golang interface{}类型转换 bson.M 遇到莫名其妙的问题

				
			

			

				

					AlphaTao的博客
				

				

					09-27
					
					6675
					
				

			

		

		

			
				
背景
从mongo数据库中取出数据以interface{}格式返回，解析返回的数据。
1.从mongo中取数据
newSession := m.Session.Copy()
defer newSession.Close()
c := newSession.DB(database).C(collName)
if err := c.Find(bson.M{"time": occurtime}).One...

			
		

	





	

		

			

				
					
mongodb 字符串转bson_mongodb-go-driver / bson结构转换为bson.Document编码

				
			

			

				

					weixin_39939276的博客
				

				

					12-19
					
					693
					
				

			

		

		

			
				
type NoteUpdate struct {ID        string `json:"id,omitempty" bson:"_id,omitempty"`Title     string `json:"title" bson:"title,omitempty"`Content   string `json:"content" bson:"content,omitempty"`Chang...

			
		

	





	

		

			

				
					
MongoDB Java

				
			

			

				

					孤云博客
				

				

					02-01
					
					544
					
				

			

		

		

			
				
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666)、博主微信（guyun297890152）、QQ技术交流群(183198395)。



from：http://www.runoob.com/mongodb/mongodb-java.html

MongoDB Java



环境配置

在 Java 程序中如果要使用 MongoDB，你需要确保已...

			
		

	





	

		

			

				
					
MongoDB

					
热门推荐

				
			

			

				

					天地炫舞的博客
				

				

					12-28
					
					1万+
					
				

			

		

		

			
				
本文介绍MongoDB以下内容：
（1）Windows下安装MongoDB
（2）安装MongoDB可视化工具
（3）使用Java对MongoDB进行增删改查
学习教程：http://www.runoob.com/mongodb/mongodb-tutorial.html
官网：https://docs.mongodb.com/manual/
1、Windows下安装MongoDB

			
		

	





	

		

			

				
					
Java中使用MongoDB Document和ArrayList的示例

				
			

			

				

					Leon_Jinhai_Sun的博客
				

				

					11-07
					
					486
					
				

			

		

		

			
				
Java中使用MongoDB Document和ArrayList的示例

			
		

	





	

		

			

				
					
Java中使用MongoDB Document类获取嵌套文档

				
			

			

				

					Leon_Jinhai_Sun的博客
				

				

					11-05
					
					469
					
				

			

		

		

			
				
Java中使用MongoDB Document类获取嵌套文档

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值