mongoDB3.0x版本spring集成配置文件

阳光穿透心脏的1/2处 2022-06-14 05:43 423阅读 0赞

spring连接mongodb以及建立相关工厂的配置：

\[html\]  [view plain][]   [copy][view plain]

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"  
4.      xmlns:mongo="http://www.springframework.org/schema/data/mongo"  
5.      xsi:schemaLocation="http://www.springframework.org/schema/beans   
6.                 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
7.                 http://www.springframework.org/schema/data/mongo  
8.              http://www.springframework.org/schema/data/mongo/spring-mongo.xsd">  
9.    
10.       
11.     <mongo:mongo-client host="192.168.0.201" port="27017" credentials="tuzongxun:123456@mongoTest" id="mongo">    
12.        <mongo:client-options write-concern="SAFE"/>    
13.     </mongo:mongo-client>   
14.   
15.     <mongo:db-factory  id="mongoDbFactory" dbname="mongoTest" mongo-ref="mongo" />    
16.   
17.       
18.     <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">    
19.        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />    
20.     </bean>     
21.   
22. </beans>

与数据库对应的实体类：

需要注意的是这里需要实现序列化的接口并设置uid的属性，否则不能在操作中直接把数据库返回结果转换成对象属性：

\[java\]  [view plain][]   [copy][view plain]

1.  package spring\_mongo.models;  
2.    
3.  import java.io.Serializable;  
4.    
5.  public class UserModel implements Serializable \{  
6.    
7.      private static final long serialVersionUID = 1L;  
8.      private String userName;  
9.      private String password;  
10.   
11.     public UserModel(String userName, String password) \{  
12.         super();  
13.         this.userName = userName;  
14.         this.password = password;  
15.     \}  
16.   
17.     public String getUserName() \{  
18.         return userName;  
19.     \}  
20.   
21.     public void setUserName(String userName) \{  
22.         this.userName = userName;  
23.     \}  
24.   
25.     public String getPassword() \{  
26.         return password;  
27.     \}  
28.   
29.     public void setPassword(String password) \{  
30.         this.password = password;  
31.     \}  
32.   
33. \}

根据spring配置获取操作mongodb的MongoTemplete，需要实现ApplicationContextAware接口：

\[java\]  [view plain][]   [copy][view plain]

1.  package spring\_mogo.dao.daoImp;  
2.    
3.  import org.springframework.beans.BeansException;  
4.  import org.springframework.context.ApplicationContext;  
5.  import org.springframework.context.ApplicationContextAware;  
6.  import org.springframework.data.mongodb.core.MongoTemplate;  
7.    
8.  public abstract class AbstractBaseMongoTemplete implements  
9.          ApplicationContextAware \{  
10.   
11.     protected MongoTemplate mongoTemplate;  
12.   
13.     /\*\* 
14.      \* @Description 根据配置文件设置mongoTemplate 
15.      \* @param mongoTemplate 
16.      \*/  
17.     public void setMongoTemplate(MongoTemplate mongoTemplate) \{  
18.         this.mongoTemplate = mongoTemplate;  
19.     \}  
20.   
21.     @Override  
22.     public void setApplicationContext(ApplicationContext applicationContext)  
23.             throws BeansException \{  
24.         MongoTemplate mongoTemplate = applicationContext.getBean(  
25.                 "mongoTemplate", MongoTemplate.class);  
26.         setMongoTemplate(mongoTemplate);  
27.     \}  
28. \}

操作数据库的接口以及对应的实现类：

演示了最基础的增删改查，需要注意的地方在于参数的声明以及接收返回数据时和实体类的转换：

（1）接口：

\[java\]  [view plain][]   [copy][view plain]

1.  package spring\_mogo.dao;  
2.    
3.  import java.util.List;  
4.    
5.  import spring\_mongo.models.UserModel;  
6.    
7.  public interface UserDao \{  
8.      /\*\* 
9.       \* 查询数据 
10.      \*  
11.      \* @author：tuzongxun 
12.      \* @Title: findAll 
13.      \* @param @return 
14.      \* @return List<UserModel> 
15.      \* @date May 13, 2016 3:07:39 PM 
16.      \* @throws 
17.      \*/  
18.     public List<UserModel> findAll();  
19.   
20.     /\*\* 
21.      \* 新增数据 
22.      \*  
23.      \* @author：tuzongxun 
24.      \* @Title: insertUser 
25.      \* @param @param user 
26.      \* @return void 
27.      \* @date May 13, 2016 3:09:45 PM 
28.      \* @throws 
29.      \*/  
30.     public void insertUser(UserModel user);  
31.   
32.     /\*\* 
33.      \* 删除数据 
34.      \*  
35.      \* @author：tuzongxun 
36.      \* @Title: removeUser 
37.      \* @param @param userName 
38.      \* @return void 
39.      \* @date May 13, 2016 3:09:55 PM 
40.      \* @throws 
41.      \*/  
42.     public void removeUser(String userName);  
43.   
44.     /\*\* 
45.      \* 修改数据 
46.      \*  
47.      \* @author：tuzongxun 
48.      \* @Title: updateUser 
49.      \* @param @param user 
50.      \* @return void 
51.      \* @date May 13, 2016 3:10:06 PM 
52.      \* @throws 
53.      \*/  
54.     public void updateUser(UserModel user);  
55.   
56.     /\*\* 
57.      \* 按条件查询 
58.      \*  
59.      \* @author：tuzongxun 
60.      \* @Title: findForRequery 
61.      \* @param 
62.      \* @return void 
63.      \* @date May 13, 2016 3:23:37 PM 
64.      \* @throws 
65.      \*/  
66.     public List<UserModel> findForRequery(String userName);  
67.   
68. \}

（2）实现类，这里要继承AbstractBaseMongoTemplete类，从而获得mongoTemplete进行各种操作：

\[java\]  [view plain][]   [copy][view plain]

1.  package spring\_mogo.dao.daoImp;  
2.    
3.  import java.util.List;  
4.    
5.  import org.springframework.data.mongodb.core.query.Criteria;  
6.  import org.springframework.data.mongodb.core.query.Query;  
7.  import org.springframework.data.mongodb.core.query.Update;  
8.  import org.springframework.stereotype.Component;  
9.    
10. import spring\_mogo.dao.UserDao;  
11. import spring\_mongo.models.UserModel;  
12.   
13. import com.mongodb.BasicDBObject;  
14. import com.mongodb.DBObject;  
15.   
16. @Component("UserDaoImp")  
17. public class UserDaoImp extends AbstractBaseMongoTemplete implements UserDao \{  
18.   
19.     /\*\* 
20.      \* 查询所有数据 
21.      \*  
22.      \* @author：tuzongxun 
23.      \* @Title: findAll 
24.      \* @Description: TODO 
25.      \* @param @return 
26.      \* @date May 13, 2016 3:10:29 PM 
27.      \* @throws 
28.      \*/  
29.     @Override  
30.     public List<UserModel> findAll() \{  
31.         // 需要设置集合对应的尸体类和相应的集合名，从而查询结果直接映射  
32.         List<UserModel> userList = mongoTemplate.findAll(UserModel.class,  
33.                 "user");  
34.         return userList;  
35.     \}  
36.   
37.     /\*\* 
38.      \* 新增数据 
39.      \*  
40.      \* @author：tuzongxun 
41.      \* @Title: insertUser 
42.      \* @Description: TODO 
43.      \* @param @param user 
44.      \* @date May 13, 2016 3:10:45 PM 
45.      \* @throws 
46.      \*/  
47.     @Override  
48.     public void insertUser(UserModel user) \{  
49.         // 设置需要插入到数据库的文档对象  
50.         DBObject object = new BasicDBObject();  
51.         object.put("userName", user.getUserName());  
52.         object.put("password", user.getPassword());  
53.         mongoTemplate.insert(object, "user");  
54.     \}  
55.   
56.     /\*\* 
57.      \* 按条件删除数据 
58.      \*  
59.      \* @author：tuzongxun 
60.      \* @Title: removeUser 
61.      \* @Description: TODO 
62.      \* @param @param userName 
63.      \* @date May 13, 2016 3:11:01 PM 
64.      \* @throws 
65.      \*/  
66.     @Override  
67.     public void removeUser(String userName) \{  
68.         // 设置删除条件，如果条件内容为空则删除所有  
69.         Query query = new Query();  
70.         Criteria criteria = new Criteria("userName");  
71.         criteria.is(userName);  
72.         query.addCriteria(criteria);  
73.         mongoTemplate.remove(query, "user");  
74.     \}  
75.   
76.     /\*\* 
77.      \* 修改数据 
78.      \*  
79.      \* @author：tuzongxun 
80.      \* @Title: updateUser 
81.      \* @Description: TODO 
82.      \* @param @param user 
83.      \* @date May 13, 2016 3:11:12 PM 
84.      \* @throws 
85.      \*/  
86.     @Override  
87.     public void updateUser(UserModel user) \{  
88.         // 设置修改条件  
89.         Query query = new Query();  
90.         Criteria criteria = new Criteria("userName");  
91.         criteria.is(user.getUserName());  
92.         query.addCriteria(criteria);  
93.         // 设置修改内容  
94.         Update update = Update.update("password", user.getPassword());  
95.         // 参数：查询条件，更改结果，集合名  
96.         mongoTemplate.updateFirst(query, update, "user");  
97.     \}  
98.   
99.     /\*\* 
100.      \* 根据条件查询 
101.      \*  
102.      \* @author：tuzongxun 
103.      \* @Title: findForRequery 
104.      \* @Description: TODO 
105.      \* @param @param userName 
106.      \* @date May 13, 2016 4:08:15 PM 
107.      \* @throws 
108.      \*/  
109.     @Override  
110.     public List<UserModel> findForRequery(String userName) \{  
111.         Query query = new Query();  
112.         Criteria criteria = new Criteria("userName");  
113.         criteria.is(userName);  
114.         query.addCriteria(criteria);  
115.         // 查询条件，集合对应的实体类，集合名  
116.         List<UserModel> userList = mongoTemplate.find(query, UserModel.class,  
117.                 "user");  
118.         return userList;  
119.     \}  
120.   
121. \}

测试类：

为了验证以上代码和配置的正确性，测试类代码如下：

\[java\]  [view plain][]   [copy][view plain]

1.  package spring\_mongo.test;  
2.    
3.  import java.util.List;  
4.    
5.  import org.junit.Test;  
6.  import org.junit.runner.RunWith;  
7.  import org.springframework.beans.factory.annotation.Autowired;  
8.  import org.springframework.test.context.ContextConfiguration;  
9.  import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
10.   
11. import spring\_mogo.dao.UserDao;  
12. import spring\_mongo.models.UserModel;  
13.   
14. @RunWith(SpringJUnit4ClassRunner.class)  
15. @ContextConfiguration(locations = \{ "classpath:spring.xml" \})  
16. public class mongoTest \{  
17.   
18.     @Autowired  
19.     private UserDao userDao;  
20.   
21.     /\*\* 
22.      \* 查询测试 
23.      \*  
24.      \* @author：tuzongxun 
25.      \* @Title: monFindTest 
26.      \* @param 
27.      \* @return void 
28.      \* @date May 13, 2016 3:27:51 PM 
29.      \* @throws 
30.      \*/  
31.     @Test  
32.     public void monFindTest() \{  
33.         List<UserModel> userModels = userDao.findAll();  
34.         if (userModels != null && userModels.size() > 0) \{  
35.             for (UserModel user : userModels) \{  
36.                 System.out.println(user.getUserName() + ":"  
37.                         + user.getPassword());  
38.             \}  
39.         \}  
40.     \}  
41.   
42.     /\*\* 
43.      \* 插入数据测试 
44.      \*  
45.      \* @author：tuzongxun 
46.      \* @Title: monInsertTest 
47.      \* @param 
48.      \* @return void 
49.      \* @date May 13, 2016 3:27:38 PM 
50.      \* @throws 
51.      \*/  
52.     @Test  
53.     public void monInsertTest() \{  
54.         UserModel user = new UserModel("test111", "123456");  
55.         userDao.insertUser(user);  
56.         this.monFindTest();  
57.     \}  
58.   
59.     /\*\* 
60.      \* 删除测试 
61.      \*  
62.      \* @author：tuzongxun 
63.      \* @Title: monRemoveTest 
64.      \* @param 
65.      \* @return void 
66.      \* @date May 13, 2016 3:28:06 PM 
67.      \* @throws 
68.      \*/  
69.     @Test  
70.     public void monRemoveTest() \{  
71.         String userName = "test111";  
72.         userDao.removeUser(userName);  
73.         this.monFindTest();  
74.     \}  
75.   
76.     /\*\* 
77.      \* 测试修改 
78.      \*  
79.      \* @author：tuzongxun 
80.      \* @Title: monUpdateTest 
81.      \* @param 
82.      \* @return void 
83.      \* @date May 13, 2016 3:50:08 PM 
84.      \* @throws 
85.      \*/  
86.     @Test  
87.     public void monUpdateTest() \{  
88.         UserModel user = new UserModel("test111", "test");  
89.         userDao.updateUser(user);  
90.         this.monFindTest();  
91.     \}  
92.   
93.     /\*\* 
94.      \* 按条件查询 
95.      \*  
96.      \* @author：tuzongxun 
97.      \* @Title: monFindForRuq 
98.      \* @param 
99.      \* @return void 
100.      \* @date May 13, 2016 4:10:53 PM 
101.      \* @throws 
102.      \*/  
103.     @Test  
104.     public void monFindForRuq() \{  
105.         String userName = "test111";  
106.         List<UserModel> userModels = userDao.findForRequery(userName);  
107.         if (userModels != null && userModels.size() > 0) \{  
108.             for (UserModel user : userModels) \{  
109.                 System.out.println(user.getUserName() + ":"  
110.                         + user.getPassword());  
111.             \}  
112.         \}  
113.     \}  
114.   
115. \}

[view plain]: http://blog.csdn.net/tuzongxun/article/details/51404529#