morphia与spring的整合

首先我们需要一个生成和配置mongodb的工厂类：

 

 1 public class MongoFactoryBean extends AbstractFactoryBean<Mongo> {
 2 
 3     // 表示服务器列表(主从复制或者分片)的字符串数组
 4     private String[] serverStrings;
 5     // mongoDB配置对象
 6     private MongoOptions mongoOptions;
 7     // 是否主从分离(读取从库)，默认读写都在主库
 8     private boolean readSecondary = false;
 9     // 设定写策略(出错时是否抛异常)，默认采用SAFE模式(需要抛异常)
10     private WriteConcern writeConcern = WriteConcern.SAFE;
11 
12     @Override
13     public Class<?> getObjectType() {
14         return Mongo.class;
15     }
16 
17     @Override
18     protected Mongo createInstance() throws Exception {
19         Mongo mongo = initMongo();
20         
21         // 设定主从分离
22         if (readSecondary) {
23             mongo.setReadPreference(ReadPreference.secondaryPreferred());
24         }
25 
26         // 设定写策略
27         mongo.setWriteConcern(writeConcern);
28         return mongo;
29     }
30     
31     /**
32      * 初始化mongo实例
33      * @return
34      * @throws Exception
35      */
36     private Mongo initMongo() throws Exception {
37         // 根据条件创建Mongo实例
38         Mongo mongo = null;
39         List<ServerAddress> serverList = getServerList();
40 
41         if (serverList.size() == 0) {
42             mongo = new Mongo();
43         }else if(serverList.size() == 1){
44             if (mongoOptions != null) {
45                 mongo = new Mongo(serverList.get(0), mongoOptions);
46             }else{
47                 mongo = new Mongo(serverList.get(0));
48             }
49         }else{
50             if (mongoOptions != null) {
51                 mongo = new Mongo(serverList, mongoOptions);
52             }else{
53                 mongo = new Mongo(serverList);
54             }
55         }
56         return mongo;
57     }
58     
59     
60     /**
61      * 根据服务器字符串列表，解析出服务器对象列表
62      * <p>
63      * 
64      * @Title: getServerList
65      *         </p>
66      * 
67      * @return
68      * @throws Exception
69      */
70     private List<ServerAddress> getServerList() throws Exception {
71         List<ServerAddress> serverList = new ArrayList<ServerAddress>();
72         try {
73             for (String serverString : serverStrings) {
74                 String[] temp = serverString.split(":");
75                 String host = temp[0];
76                 if (temp.length > 2) {
77                     throw new IllegalArgumentException(
78                             "Invalid server address string: " + serverString);
79                 }
80                 if (temp.length == 2) {
81                     serverList.add(new ServerAddress(host, Integer
82                             .parseInt(temp[1])));
83                 } else {
84                     serverList.add(new ServerAddress(host));
85                 }
86             }
87             return serverList;
88         } catch (Exception e) {
89             throw new Exception(
90                     "Error while converting serverString to ServerAddressList",
91                     e);
92         }
93     }
94 
95     /* ------------------- setters --------------------- */
96 }

 

其次我们需要一个产生和配置morphia对象的工厂类：

 

 1 public class MorphiaFactoryBean extends AbstractFactoryBean<Morphia> {
 2     /**
 3      * 要扫描并映射的包
 4      */
 5     private String[] mapPackages;  
 6     
 7     /**
 8      * 要映射的类
 9      */
10     private String[] mapClasses;  
11     
12     /**
13      * 扫描包时，是否忽略不映射的类
14      * 这里按照Morphia的原始定义，默认设为false
15      */
16     private boolean ignoreInvalidClasses;
17     
18     @Override
19     protected Morphia createInstance() throws Exception {
20         Morphia m = new Morphia();
21         if (mapPackages != null) {
22             for (String packageName : mapPackages) {
23                 m.mapPackage(packageName, ignoreInvalidClasses);
24             }
25         }
26         if (mapClasses != null) {  
27             for (String entityClass : mapClasses) {
28                 m.map(Class.forName(entityClass));
29             }
30         }
31         return m;
32     }
33 
34     @Override
35     public Class<?> getObjectType() {
36         return Morphia.class;
37     }
38     
39     /*----------------------setters-----------------------*/
40 }

 

最后我们还需要一个产生和配置Datastore的工厂类：

 

 1 public class DatastoreFactoryBean extends AbstractFactoryBean<Datastore> {
 2     
 3     private Morphia morphia;    //morphia实例，最好是单例
 4     private Mongo mongo;    //mongo实例，最好是单例
 5     private String dbName;    //数据库名
 6     private String username;    //用户名，可为空
 7     private String password;    //密码，可为空
 8     private boolean toEnsureIndexes=false;    //是否确认索引存在，默认false
 9     private boolean toEnsureCaps=false;    //是否确认caps存在，默认false
10     
11 
12     @Override
13     protected Datastore createInstance() throws Exception {
14         //这里的username和password可以为null，morphia对象会去处理
15         Datastore ds = morphia.createDatastore(mongo, dbName, username,
16                 password==null?null:password.toCharArray());
17         if(toEnsureIndexes){
18             ds.ensureIndexes();
19         }
20         if(toEnsureCaps){
21             ds.ensureCaps();
22         }
23         return ds;
24     }
25 
26     @Override
27     public Class<?> getObjectType() {
28         return Datastore.class;
29     }
30 
31     @Override
32     public void afterPropertiesSet() throws Exception {
33         super.afterPropertiesSet();
34         if (mongo == null) {
35             throw new IllegalStateException("mongo is not set");
36         }
37         if (morphia == null) {
38             throw new IllegalStateException("morphia is not set");
39         }
40     }
41     
42     /*----------------------setters-----------------------*/
43 }

 

我们来仿照morphia文档，写两个测试的POJO：

 

 1 @Entity
 2 public class Hotel {
 3     @Id private ObjectId id;
 4     
 5     private String name;
 6     private int stars;
 7     
 8     @Embedded
 9     private Address address;    
10     
11     /*-----------gettters & setters----------*/
12 }

 

1 @Embedded
2 public class Address {
3     private String street;
4     private String city;
5     private String postCode;
6     private String country;
7     /*-----------gettters & setters----------*/
8 }

 

还需要一个为测试POJO专门服务的DAO，这里继承morphia里的BasicDAO：

 

1 public class HotelDAO extends BasicDAO<Hotel, ObjectId> {
2 
3     protected HotelDAO(Datastore ds) {
4         super(ds);
5     }
6     
7     /* ----------------以下是自定义的数据查询方法(finder)----------------- */
8 }

 

最后是spring的XML文件：

 

  1 <?xml version="1.0" encoding="UTF-8"?>  
  2 <beans xmlns="http://www.springframework.org/schema/beans"  
  3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" 
  4     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd 
  5     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">  
  6     
  7     <!-- 配置文件 -->
  8     <context:property-placeholder location="classpath:config.properties" />
  9     
 10     <!-- mongoDB的配置对象 -->
 11     <bean id="mongoOptions" class="com.mongodb.MongoOptions">
 12         <!-- 服务器是否自动重连，默认为false -->
 13         <property name="autoConnectRetry" value="false" />
 14         <!-- 对同一个服务器尝试重连的时间(毫秒)，设为0时默认使用15秒 -->
 15         <property name="maxAutoConnectRetryTime" value="0" />
 16         <!-- 与每个主机的连接数，默认为10 -->
 17         <property name="connectionsPerHost" value="10" />
 18         <!-- 连接超时时间(毫秒)，默认为10000 -->
 19         <property name="connectTimeout" value="10000" />
 20         <!-- 是否创建一个finalize方法，以便在客户端没有关闭DBCursor的实例时，清理掉它。默认为true -->
 21         <property name="cursorFinalizerEnabled" value="true" />
 22         <!-- 线程等待连接可用的最大时间(毫秒)，默认为120000 -->
 23         <property name="maxWaitTime" value="120000" />
 24         <!-- 可等待线程倍数，默认为5.例如connectionsPerHost最大允许10个连接，则10*5=50个线程可以等待，更多的线程将直接抛异常 -->
 25         <property name="threadsAllowedToBlockForConnectionMultiplier" value="5" />
 26         <!-- socket读写时超时时间(毫秒)，默认为0，不超时 -->
 27         <property name="socketTimeout" value="0" />
 28         <!-- 是socket连接在防火墙上保持活动的特性，默认为false -->
 29         <property name="socketKeepAlive" value="false" />
 30         <!-- 对应全局的WriteConcern.SAFE，默认为false -->
 31         <property name="safe" value="true" />
 32         <!-- 对应全局的WriteConcern中的w，默认为0 -->
 33         <property name="w" value="0" />
 34         <!-- 对应全局的WriteConcern中的wtimeout，默认为0 -->
 35         <property name="wtimeout" value="0" />
 36         <!-- 对应全局的WriteConcern.FSYNC_SAFE，如果为真，每次写入要等待写入磁盘，默认为false -->
 37         <property name="fsync" value="false" />
 38         <!-- 对应全局的WriteConcern.JOURNAL_SAFE，如果为真，每次写入要等待日志文件写入磁盘，默认为false -->
 39         <property name="j" value="false" />
 40     </bean>
 41     
 42     <!-- 使用工厂创建mongo实例 -->
 43     <bean id="mongo" class="me.watchzerg.test.morphia.spring.MongoFactoryBean">
 44         <!-- mongoDB的配置对象 -->
 45         <property name="mongoOptions" ref="mongoOptions"/>
 46         
 47         <!-- 是否主从分离(读取从库)，默认为false，读写都在主库 -->
 48         <property name="readSecondary" value="false"/>
 49         
 50         <!-- 设定写策略，默认为WriteConcern.SAFE，优先级高于mongoOptions中的safe -->
 51         <property name="writeConcern" value="SAFE"/>
 52         
 53         <!-- 设定服务器列表，默认为localhost:27017 -->
 54         <property name="serverStrings">
 55             <array>
 56                 <value>${mongoDB.server}</value>
 57             </array>
 58         </property>
 59     </bean>
 60     
 61     
 62     <!-- 使用工厂创建morphia实例，同时完成类映射操作 -->
 63     <bean id="morphia" class="me.watchzerg.test.morphia.spring.MorphiaFactoryBean" >
 64         <!-- 指定要扫描的POJO包路径 -->
 65         <property name="mapPackages">
 66             <array>
 67                 <value>me.watchzerg.test.morphia.pojo</value>
 68             </array>
 69         </property>
 70         
 71         <!-- 指定要映射的类 -->
 72         <!-- <property name="mapClasses">
 73             <array>
 74                 <value>me.watchzerg.test.morphia.pojo.Hotel</value>
 75                 <value>me.watchzerg.test.morphia.pojo.Address</value>
 76             </array>
 77         </property> -->
 78         
 79         <!-- 扫描包时是否忽略不可用的类，默认为false -->
 80         <!-- <property name="ignoreInvalidClasses" value="false"/> -->
 81     </bean>
 82     
 83     <!-- 使用工厂创建datastore，同时完成index和caps的确认操作 -->
 84     <bean id="datastore" class="me.watchzerg.test.morphia.spring.DatastoreFactoryBean" >
 85         <property name="morphia" ref="morphia"/>
 86         <property name="mongo" ref="mongo"/>
 87         
 88         <!-- collection的名称 -->
 89         <property name="dbName" value="${mongoDB.dbName}"/>
 90         
 91         <!-- 用户名和密码可以为空 -->
 92         <!-- <property name="username" value="my_username"/>
 93         <property name="password" value="my_password"/> -->
 94         
 95         <!-- 是否进行index和caps的确认操作，默认为flase -->
 96         <property name="toEnsureIndexes" value="true"/>
 97         <property name="toEnsureCaps" value="true"/>
 98     </bean>
 99     
100     <!-- ===============以下是具体DAO的实现===================== -->
101     
102     <bean id="hotelDAO" class="me.watchzerg.test.morphia.dao.impl.HotelDAO">
103         <constructor-arg ref="datastore"/>
104     </bean>
105     
106 </beans> 

 

最后写一个测试类看看我们的成果：

 

  1 public class MorphiaTest {
  2     private static HotelDAO hotelDAO;
  3 
  4     /**
  5      * 测试Morphia的DAO层
  6      * 
  7      * @param args
  8      * @throws Exception
  9      */
 10     public static void main(String[] args) throws Exception {
 11         // 初始化DAO
 12         initDAO();
 13 
 14         // 插入测试
 15         saveTest();
 16 
 17         // 更新测试
 18         // updateTest();
 19 
 20         // 删除测试
 21         // deleteTest();
 22 
 23         // 查询测试
 24         // queryHotel();
 25 
 26         System.out.println("done!");
 27     }
 28 
 29     /**
 30      * 初始化DAO
 31      * <p>
 32      * @Title: initDAO
 33      * </p>
 34      */
 35     private static void initDAO() {
 36         ApplicationContext context = new ClassPathXmlApplicationContext(
 37                 "config.xml");
 38         hotelDAO = (HotelDAO) context.getBean("hotelDAO");
 39     }
 40 
 41     /**
 42      * 生成指定个数的hotelList
 43      * <p>
 44      * @Title: getHotelList
 45      * </p>
 46      * 
 47      * @param num
 48      * @return
 49      */
 50     private static List<Hotel> getHotelList(int num) {
 51         List<Hotel> list = new ArrayList<Hotel>();
 52         for (int i = 0; i < num; i++) {
 53             Hotel hotel = new Hotel();
 54             hotel.setName("编号为[" + i + "]的旅店");
 55             hotel.setStars(i % 10);
 56             Address address = new Address();
 57             address.setCountry("中国");
 58             address.setCity("北京");
 59             address.setStreet("上帝南路");
 60             address.setPostCode("10000" + (i % 10));
 61             hotel.setAddress(address);
 62             list.add(hotel);
 63         }
 64         return list;
 65     }
 66 
 67     /**
 68      * 将hotelList插入数据库
 69      * <p>
 70      * @Title: saveHotelList
 71      * </p>
 72      * 
 73      * @param hotelDAO
 74      * @param hotelList
 75      */
 76     private static void saveTest() {
 77         List<Hotel> hotelList = getHotelList(100);
 78         for (Hotel hotel : hotelList) {
 79             // Key<Hotel> key=hotelDAO.save(hotel,WriteConcern.SAFE);
 80             Key<Hotel> key = hotelDAO.save(hotel);
 81             System.out.println("id为[" + key.getId() + "]的记录已被插入");
 82         }
 83     }
 84 
 85     /**
 86      * 更新操作测试
 87      * <p>
 88      * @Title: updateTest
 89      * </p>
 90      * 
 91      * @throws Exception
 92      */
 93     private static void updateTest() throws Exception {
 94         //生成查询条件
 95         Query<Hotel> q = hotelDAO.createQuery().field("stars")
 96                 .greaterThanOrEq(9);
 97         //生成更新操作
 98         UpdateOperations<Hotel> ops = hotelDAO.createUpdateOperations()
 99                 .set("address.city", "shanghai").inc("stars");
100         // UpdateResults<Hotel> ur=hotelDAO.update(q, ops);
101         UpdateResults<Hotel> ur = hotelDAO.updateFirst(q, ops);
102         if (ur.getHadError()) {
103             System.out.println(ur.getError());
104             throw new Exception("更新时发生错误");
105         }
106         if (ur.getUpdatedExisting()) {
107             System.out.println("更新成功，更新条数为[" + ur.getUpdatedCount()
108                     + "]，插入条数为[" + ur.getInsertedCount() + "]");
109         } else {
110             System.out.println("没有记录符合更新条件");
111         }
112     }
113 
114     /**
115      * 删除操作测试
116      * <p>
117      * @Title: deleteTest
118      * </p>
119      */
120     private static void deleteTest() {
121         ObjectId id = hotelDAO.findIds().get(0);
122         hotelDAO.deleteById(id);
123 
124         Query<Hotel> q = hotelDAO.createQuery().field("stars")
125                 .greaterThanOrEq(100);
126         hotelDAO.deleteByQuery(q);
127     }
128 
129     /**
130      * 查询测试
131      * <p>
132      * @Title: queryHotel
133      * </p>
134      */
135     private static void queryHotel() {
136         // 显示所有记录
137         System.out.println("\nhotelDAO.find()=");
138         for (Hotel hotel : hotelDAO.find()) {
139             System.out.println(hotel);
140         }
141 
142         // 统计star大于等于9的数目
143         System.out
144                 .println("\nhotelDAO.count(hotelDAO.createQuery().field(\"stars\").greaterThanOrEq(9))="
145                         + hotelDAO.count(hotelDAO.createQuery().field("stars")
146                                 .greaterThanOrEq(9)));
147 
148         // 显示符合条件的记录ID
149         List<ObjectId> ids = hotelDAO.findIds("stars", 8);
150         System.out.println("\nhotelDAO.findIds(\"stars\", 8)=");
151         for (ObjectId id : ids) {
152             System.out.println(id);
153         }
154     }
155 
156 }