MongoDB DBObject和JavaBean实体转换

MongoDB DBObject和JavaBean实体转换

🗨

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

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

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

  1. import java.util.*;  
  2. import com.mongodb.*; //com.mongodb包类似于java.sql,大多数与数据库相关的类都在这里  
  3.   
  4. public class MongoTest {  
  5.     public static void out(Object o) {  
  6.         System.err.println(o);  
  7.     }  
  8.     public static void out() {  
  9.         System.err.println();  
  10.     }  
  11.   
  12.     public static void main(String[] args) throws Exception {  
  13.         //Mongo是与java.sql.Connection同等级别的概念,  
  14.         //默认是链接到127.0.0.1:27017/test,  
  15.         //见getConnectPoint()的输出结果,其中27017是端口号,test是数据库名  
  16.         Mongo mongo = new Mongo();  
  17.         out("mongo.getConnectPoint() = "+mongo.getConnectPoint());  
  18.   
  19.         //查看所有的数据库名  
  20.         for(String dbName : mongo.getDatabaseNames()) {  
  21.             out("dbName = "+dbName);  
  22.         }  
  23.   
  24.         //DB类用来表示一个数据库,如果数据库不存在则创建一个  
  25.         DB db = mongo.getDB( "test" );   
  26.   
  27.         //查看所有的Collection名  
  28.         for(String collectionName : db.getCollectionNames()) {  
  29.             out("collectionName = "+collectionName);  
  30.         }  
  31.   
  32.         out();  
  33.   
  34.         //DBCollection类用来存放对象,类似数据库表的概念  
  35.         DBCollection coll = db.getCollection("testCollection");  
  36.   
  37.         //插入10个User对象到coll  
  38.         //插入DBCollection中的对象必需实现DBObject接口(见User类的注释)  
  39.         for(int i=1; i<=10; i++) {  
  40.             User user = new User();  
  41.             user.setName("user "+(10+i));  
  42.             user.setAge(10+i);  
  43.             user.setDate(new Date());  
  44.   
  45.             coll.insert(user);  
  46.         }  
  47.   
  48.         findAll(coll); //查找出coll中的所有对象并打印输出  
  49.   
  50.         //查找出第一条记录,在内部会自动转换成User类型  
  51.         coll.setObjectClass(User.class);  
  52.         User user = (User)coll.findOne();  
  53.         out("user.name="+user.getName());  
  54.         out("user.age="+user.getAge());  
  55.         out("user.getDate()="+user.getDate());  
  56.         coll.setObjectClass(BasicDBObject.class); //还原最初的对象类型  
  57.   
  58.         out();  
  59.   
  60.         user.setAge(100);  
  61.         coll.save(user); //保存更新  
  62.         findAll(coll); //确认第一条记录的"Age"是否变成100了?  
  63.   
  64.         coll.remove(user); //删除第一条记录  
  65.   
  66.         findAll(coll);  
  67.   
  68.         //查找年纪大于等于15小于等于18的记录(15<=age<=18)  
  69.         //(查询条件的组合方式很啰嗦,这方面就没sql方便)  
  70.         BasicDBObject query = new BasicDBObject();  
  71.         //注意这里的"Age"第一个字母要大写,如果把User类替换成UserNoReflection类就用小写,  
  72.         //这是因为ReflectionDBObject类的内部实现在截取setter和getter方法的"set"和"get"前缀后  
  73.         //没有进行大小写转换,比如"setAge"得到的key值就是"Age"  
  74.         query.put("Age"new BasicDBObject("$gte"15).append("$lte"18));  
  75.           
  76.   
  77.         DBCursor cur = coll.find(query);  
  78.         while(cur.hasNext()) {  
  79.             out(cur.next());  
  80.         }  
  81.   
  82.         out();  
  83.   
  84.         //跳过前面3条记录,然后显示总共5条记录  
  85.         cur = coll.find().skip(3).limit(5);  
  86.         while(cur.hasNext()) {  
  87.             out(cur.next());  
  88.         }  
  89.   
  90.         coll.drop(); //删除coll这个DBCollection  
  91.     }  
  92.   
  93.     public static void findAll(DBCollection coll) {  
  94.         DBCursor cur = coll.find();  
  95.         while(cur.hasNext()) {  
  96.             out(cur.next());  
  97.         }  
  98.         out();  
  99.     }  
  100.   
  101.     //插入DBCollection中的java对象必需实现DBObject接口,  
  102.     //ReflectionDBObject实现了DBObject接口,在内部是采用反射来完成的  
  103.     public static class User extends ReflectionDBObject {  
  104.         private String name;  
  105.         private int age;  
  106.         private Date date;  
  107.   
  108.         public void setName(String name) {  
  109.             this.name = name;  
  110.         }  
  111.   
  112.         public String getName() {  
  113.             return name;  
  114.         }  
  115.   
  116.         public void setAge(int age) {  
  117.             this.age = age;  
  118.         }  
  119.   
  120.         public int getAge() {  
  121.             return age;  
  122.         }  
  123.   
  124.         public void setDate(Date date) {  
  125.             this.date = date;  
  126.         }  
  127.   
  128.         public Date getDate() {  
  129.             return date;  
  130.         }  
  131.     }  
  132.   
  133.     //如果不想用反射的方式,又不想手工实现DBObject接口的方法,  
  134.     //可以直接继承BasicDBObject,但是需要做额外的工作,  
  135.     //就像下面这样:  
  136.     public static class UserNoReflection extends BasicDBObject {  
  137.         private String name;  
  138.         private int age;  
  139.         private Date date;  
  140.   
  141.         public void setName(String name) {  
  142.             this.name = name;  
  143.   
  144.             super.put("name", name);  
  145.         }  
  146.   
  147.         public String getName() {  
  148.             return name;  
  149.         }  
  150.   
  151.         public void setAge(int age) {  
  152.             this.age = age;  
  153.   
  154.             super.put("age", age);  
  155.         }  
  156.   
  157.         public int getAge() {  
  158.             return age;  
  159.         }  
  160.   
  161.         public void setDate(Date date) {  
  162.             this.date = date;  
  163.   
  164.             super.put("date", date);  
  165.         }  
  166.   
  167.         public Date getDate() {  
  168.             return date;  
  169.         }  
  170.   
  171.         public Object put(String key, Object v) {  
  172.             if(key.equals("name")) name = (String)v;  
  173.             else if(key.equals("age")) age = (Integer)v;  
  174.             else if(key.equals("date")) date = (Date)v;  
  175.   
  176.             return super.put(key, v);  
  177.         }  
  178.     }  
  179. }  



把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代码  收藏代码
  1. //对应上面的User类(或UserNoReflection类),  
  2. //在Douyu中如下所示,不需要任何setter和getter代码  
  3.   
  4. import douyu.mvc.Model;  
  5.   
  6. @Model  
  7. public class User {  
  8.     private String name;  
  9.     private int age;  
  10.     private Date date;  
  11. }  



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

最后是Controller 

Java代码  收藏代码
  1. import java.util.Date;  
  2. import douyu.mvc.Controller;  
  3. import douyu.mvc.ModelManager;  
  4.   
  5. @Controller  
  6. public class MongoTest {  
  7.     public void index(ModelManager modelManager) {  
  8.         User user = new User();  
  9.         //下面三个setter方法虽然没有在User类中声明,  
  10.         //但是编译器在编译User类时发现User类带有@Model,就会自动生成setter、getter方法  
  11.         user.setName("user 10");  
  12.         user.setAge(10);  
  13.         user.setDate(new Date());  
  14.   
  15.         modelManager.insert(user);  
  16.   
  17.         user.setAge(20);  
  18.         modelManager.save(user);  
  19.   
  20.         modelManager.delete(user);  
  21.         //....  
  22.     }  
  23. }  

 

bean和DBObject相互转换的方法

 

Java代码
  1. package com.iqbon.spider.util;  
  2.   
  3. import java.lang.reflect.Field;  
  4. import java.lang.reflect.InvocationTargetException;  
  5. import java.util.Date;  
  6.   
  7. import org.apache.commons.beanutils.BeanUtils;  
  8.   
  9. import com.mongodb.BasicDBObject;  
  10. import com.mongodb.DBObject;  
  11.   
  12. public class BeanUtil {  
  13.   
  14.   /** 
  15.    * 把实体bean对象转换成DBObject 
  16.    * @param bean 
  17.    * @return 
  18.    * @throws IllegalArgumentException 
  19.    * @throws IllegalAccessException 
  20.    */  
  21.   public static <T> DBObject bean2DBObject(T bean) throws IllegalArgumentException,  
  22.       IllegalAccessException {  
  23.     if (bean == null) {  
  24.       return null;  
  25.     }  
  26.     DBObject dbObject = new BasicDBObject();  
  27.     // 获取对象对应类中的所有属性域  
  28.     Field[] fields = bean.getClass().getDeclaredFields();  
  29.     for (Field field : fields) {  
  30.       // 获取属性名  
  31.       String varName = field.getName();  
  32.       // 修改访问控制权限  
  33.       boolean accessFlag = field.isAccessible();  
  34.       if (!accessFlag) {  
  35.         field.setAccessible(true);  
  36.       }  
  37.       Object param = field.get(bean);  
  38.       if (param == null) {  
  39.         continue;  
  40.       } else if (param instanceof Integer) {//判断变量的类型  
  41.         int value = ((Integer) param).intValue();  
  42.         dbObject.put(varName, value);  
  43.       } else if (param instanceof String) {  
  44.         String value = (String) param;  
  45.         dbObject.put(varName, value);  
  46.       } else if (param instanceof Double) {  
  47.         double value = ((Double) param).doubleValue();  
  48.         dbObject.put(varName, value);  
  49.       } else if (param instanceof Float) {  
  50.         float value = ((Float) param).floatValue();  
  51.         dbObject.put(varName, value);  
  52.       } else if (param instanceof Long) {  
  53.         long value = ((Long) param).longValue();  
  54.         dbObject.put(varName, value);  
  55.       } else if (param instanceof Boolean) {  
  56.         boolean value = ((Boolean) param).booleanValue();  
  57.         dbObject.put(varName, value);  
  58.       } else if (param instanceof Date) {  
  59.         Date value = (Date) param;  
  60.         dbObject.put(varName, value);  
  61.       }  
  62.       // 恢复访问控制权限  
  63.       field.setAccessible(accessFlag);  
  64.     }  
  65.     return dbObject;  
  66.   }  
  67.   
  68.   /** 
  69.    * 把DBObject转换成bean对象 
  70.    * @param dbObject 
  71.    * @param bean 
  72.    * @return 
  73.    * @throws IllegalAccessException 
  74.    * @throws InvocationTargetException 
  75.    * @throws NoSuchMethodException 
  76.    */  
  77.   public static <T> T dbObject2Bean(DBObject dbObject, T bean) throws IllegalAccessException,  
  78.       InvocationTargetException, NoSuchMethodException {  
  79.     if (bean == null) {  
  80.       return null;  
  81.     }  
  82.     Field[] fields = bean.getClass().getDeclaredFields();  
  83.     for (Field field : fields) {  
  84.       String varName = field.getName();  
  85.       Object object = dbObject.get(varName);  
  86.       if (object != null) {  
  87.         BeanUtils.setProperty(bean, varName, object);  
  88.       }  
  89.     }  
  90.     return bean;  
  91.   }  
  92. }  

频道:Java