MongoDB DBObject和JavaBean实体转换

来源：互联网发布：能看禁播动漫的软件编辑：程序博客网时间：2024/05/16 08:02

MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。它的特点是高性能、易部署、易使用，存储数据非常方便。

MongoDB服务端可运行在Linux、Windows或OS X平台，支持32位和64位应用，默认端口为27017。

一个CRUD例子，虽然简单，不过也算是覆盖了大多数核心内容了，
一边看代码一边看注释吧，挺简单的。

import java.util.*;  
import com.mongodb.*; //com.mongodb包类似于java.sql，大多数与数据库相关的类都在这里  
  
public class MongoTest {  
    public static void out(Object o) {  
        System.err.println(o);  
    }  
    public static void out() {  
        System.err.println();  
    }  
  
    public static void main(String[] args) throws Exception {  
        //Mongo是与java.sql.Connection同等级别的概念，  
        //默认是链接到127.0.0.1:27017/test，  
        //见getConnectPoint()的输出结果，其中27017是端口号，test是数据库名  
        Mongo mongo = new Mongo();  
        out("mongo.getConnectPoint() = "+mongo.getConnectPoint());  
  
        //查看所有的数据库名  
        for(String dbName : mongo.getDatabaseNames()) {  
            out("dbName = "+dbName);  
        }  
  
        //DB类用来表示一个数据库，如果数据库不存在则创建一个  
        DB db = mongo.getDB( "test" );   
  
        //查看所有的Collection名  
        for(String collectionName : db.getCollectionNames()) {  
            out("collectionName = "+collectionName);  
        }  
  
        out();  
  
        //DBCollection类用来存放对象，类似数据库表的概念  
        DBCollection coll = db.getCollection("testCollection");  
  
        //插入10个User对象到coll  
        //插入DBCollection中的对象必需实现DBObject接口(见User类的注释)  
        for(int i=1; i<=10; i++) {  
            User user = new User();  
            user.setName("user "+(10+i));  
            user.setAge(10+i);  
            user.setDate(new Date());  
  
            coll.insert(user);  
        }  
  
        findAll(coll); //查找出coll中的所有对象并打印输出  
  
        //查找出第一条记录，在内部会自动转换成User类型  
        coll.setObjectClass(User.class);  
        User user = (User)coll.findOne();  
        out("user.name="+user.getName());  
        out("user.age="+user.getAge());  
        out("user.getDate()="+user.getDate());  
        coll.setObjectClass(BasicDBObject.class); //还原最初的对象类型  
  
        out();  
  
        user.setAge(100);  
        coll.save(user); //保存更新  
        findAll(coll); //确认第一条记录的"Age"是否变成100了?  
  
        coll.remove(user); //删除第一条记录  
  
        findAll(coll);  
  
        //查找年纪大于等于15小于等于18的记录(15<=age<=18)  
        //(查询条件的组合方式很啰嗦，这方面就没sql方便)  
        BasicDBObject query = new BasicDBObject();  
        //注意这里的"Age"第一个字母要大写，如果把User类替换成UserNoReflection类就用小写，  
        //这是因为ReflectionDBObject类的内部实现在截取setter和getter方法的"set"和"get"前缀后  
        //没有进行大小写转换，比如"setAge"得到的key值就是"Age"  
        query.put("Age", new BasicDBObject("$gte", 15).append("$lte", 18));  
          
  
        DBCursor cur = coll.find(query);  
        while(cur.hasNext()) {  
            out(cur.next());  
        }  
  
        out();  
  
        //跳过前面3条记录，然后显示总共5条记录  
        cur = coll.find().skip(3).limit(5);  
        while(cur.hasNext()) {  
            out(cur.next());  
        }  
  
        coll.drop(); //删除coll这个DBCollection  
    }  
  
    public static void findAll(DBCollection coll) {  
        DBCursor cur = coll.find();  
        while(cur.hasNext()) {  
            out(cur.next());  
        }  
        out();  
    }  
  
    //插入DBCollection中的java对象必需实现DBObject接口，  
    //ReflectionDBObject实现了DBObject接口，在内部是采用反射来完成的  
    public static class User extends ReflectionDBObject {  
        private String name;  
        private int age;  
        private Date date;  
  
        public void setName(String name) {  
            this.name = name;  
        }  
  
        public String getName() {  
            return name;  
        }  
  
        public void setAge(int age) {  
            this.age = age;  
        }  
  
        public int getAge() {  
            return age;  
        }  
  
        public void setDate(Date date) {  
            this.date = date;  
        }  
  
        public Date getDate() {  
            return date;  
        }  
    }  
  
    //如果不想用反射的方式，又不想手工实现DBObject接口的方法，  
    //可以直接继承BasicDBObject，但是需要做额外的工作，  
    //就像下面这样:  
    public static class UserNoReflection extends BasicDBObject {  
        private String name;  
        private int age;  
        private Date date;  
  
        public void setName(String name) {  
            this.name = name;  
  
            super.put("name", name);  
        }  
  
        public String getName() {  
            return name;  
        }  
  
        public void setAge(int age) {  
            this.age = age;  
  
            super.put("age", age);  
        }  
  
        public int getAge() {  
            return age;  
        }  
  
        public void setDate(Date date) {  
            this.date = date;  
  
            super.put("date", date);  
        }  
  
        public Date getDate() {  
            return date;  
        }  
  
        public Object put(String key, Object v) {  
            if(key.equals("name")) name = (String)v;  
            else if(key.equals("age")) age = (Integer)v;  
            else if(key.equals("date")) date = (Date)v;  
  
            return super.put(key, v);  
        }  
    }  
}  

把MongoTest.java文件放到D:\MongoDB目录

编译:
javac -cp D:\MongoDB\mongo-1.3.jar D:\MongoDB\MongoTest.java

运行:
java -cp D:\MongoDB\mongo-1.3.jar;D:\MongoDB MongoTest

Douyu也支持MongoDB了，比上面的代码还简洁

Java代码  
//对应上面的User类(或UserNoReflection类)，  
//在Douyu中如下所示，不需要任何setter和getter代码  
  
import douyu.mvc.Model;  
  
@Model  
public class User {  
    private String name;  
    private int age;  
    private Date date;  
}  

然后在conf/server.java中配置一个MongoDB的数据源(跟普通的关系型数据库类似)

最后是Controller

Java代码  
import java.util.Date;  
import douyu.mvc.Controller;  
import douyu.mvc.ModelManager;  
  
@Controller  
public class MongoTest {  
    public void index(ModelManager modelManager) {  
        User user = new User();  
        //下面三个setter方法虽然没有在User类中声明，  
        //但是编译器在编译User类时发现User类带有@Model，就会自动生成setter、getter方法  
        user.setName("user 10");  
        user.setAge(10);  
        user.setDate(new Date());  
  
        modelManager.insert(user);  
  
        user.setAge(20);  
        modelManager.save(user);  
  
        modelManager.delete(user);  
        //....  
    }  
}  
 
bean和DBObject相互转换的方法 
Java代码
package com.iqbon.spider.util;  
  
import java.lang.reflect.Field;  
import java.lang.reflect.InvocationTargetException;  
import java.util.Date;  
  
import org.apache.commons.beanutils.BeanUtils;  
  
import com.mongodb.BasicDBObject;  
import com.mongodb.DBObject;  
  
public class BeanUtil {  
  
  /** 
   * 把实体bean对象转换成DBObject 
   * @param bean 
   * @return 
   * @throws IllegalArgumentException 
   * @throws IllegalAccessException 
   */  
  public static <T> DBObject bean2DBObject(T bean) throws IllegalArgumentException,  
      IllegalAccessException {  
    if (bean == null) {  
      return null;  
    }  
    DBObject dbObject = new BasicDBObject();  
    // 获取对象对应类中的所有属性域  
    Field[] fields = bean.getClass().getDeclaredFields();  
    for (Field field : fields) {  
      // 获取属性名  
      String varName = field.getName();  
      // 修改访问控制权限  
      boolean accessFlag = field.isAccessible();  
      if (!accessFlag) {  
        field.setAccessible(true);  
      }  
      Object param = field.get(bean);  
      if (param == null) {  
        continue;  
      } else if (param instanceof Integer) {//判断变量的类型  
        int value = ((Integer) param).intValue();  
        dbObject.put(varName, value);  
      } else if (param instanceof String) {  
        String value = (String) param;  
        dbObject.put(varName, value);  
      } else if (param instanceof Double) {  
        double value = ((Double) param).doubleValue();  
        dbObject.put(varName, value);  
      } else if (param instanceof Float) {  
        float value = ((Float) param).floatValue();  
        dbObject.put(varName, value);  
      } else if (param instanceof Long) {  
        long value = ((Long) param).longValue();  
        dbObject.put(varName, value);  
      } else if (param instanceof Boolean) {  
        boolean value = ((Boolean) param).booleanValue();  
        dbObject.put(varName, value);  
      } else if (param instanceof Date) {  
        Date value = (Date) param;  
        dbObject.put(varName, value);  
      }  
      // 恢复访问控制权限  
      field.setAccessible(accessFlag);  
    }  
    return dbObject;  
  }  
  
  /** 
   * 把DBObject转换成bean对象 
   * @param dbObject 
   * @param bean 
   * @return 
   * @throws IllegalAccessException 
   * @throws InvocationTargetException 
   * @throws NoSuchMethodException 
   */  
  public static <T> T dbObject2Bean(DBObject dbObject, T bean) throws IllegalAccessException,  
      InvocationTargetException, NoSuchMethodException {  
    if (bean == null) {  
      return null;  
    }  
    Field[] fields = bean.getClass().getDeclaredFields();  
    for (Field field : fields) {  
      String varName = field.getName();  
      Object object = dbObject.get(varName);  
      if (object != null) {  
        BeanUtils.setProperty(bean, varName, object);  
      }  
    }  
    return bean;  
  }  
}  

阅读全文

0 0