前边有一篇记录过不使用spring，直接在java代码中连接和操作mongodb数据库，这里就紧随其后记录一下使用spring的情况下，在java中简单操作mongodb。
 
maven导包配置：
因为涉及了sping以及springmvc，因此也需要导入它们相关的包：
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  3. <modelVersion>4.0.0</modelVersion>
  4. <groupId>spring_mongo</groupId>
  5. <artifactId>spring_mongo</artifactId>
  6. <packaging>war</packaging>
  7. <version>0.0.1-SNAPSHOT</version>
  8. <name>spring_mongo Maven Webapp</name>
  9. <url>http://maven.apache.org</url>
  10. <dependencies>
  11. <dependency>
  12. <groupId>org.springframework.data</groupId>
  13. <artifactId>spring-data-mongodb</artifactId>
  14. <version>1.8.0.RELEASE</version>
  15. </dependency>
  16. <dependency>
  17. <groupId>org.mongodb</groupId>
  18. <artifactId>mongo-java-driver</artifactId>
  19. <version>3.0.3</version>
  20. </dependency>
  21. <dependency>
  22. <groupId>commons-logging</groupId>
  23. <artifactId>commons-logging</artifactId>
  24. <version>1.2</version>
  25. </dependency>
  26. <dependency>
  27. <groupId>org.springframework</groupId>
  28. <artifactId>spring-test</artifactId>
  29. <version>4.1.6.RELEASE</version>
  30. </dependency>
  31. <dependency>
  32. <groupId>junit</groupId>
  33. <artifactId>junit</artifactId>
  34. <version>4.11</version>
  35. </dependency>
  36. <dependency>
  37. <groupId>org.springframework</groupId>
  38. <artifactId>spring-context</artifactId>
  39. <version>4.1.7.RELEASE</version>
  40. </dependency>
  41. <dependency>
  42. <groupId>org.springframework</groupId>
  43. <artifactId>spring-context-support</artifactId>
  44. <version>4.0.9.RELEASE</version>
  45. </dependency>
  46. </dependencies>
  47. <build>
  48. <plugins>
  49. <plugin>
  50. <artifactId>maven-compiler-plugin</artifactId>
  51. <version>2.3.2</version>
  52. <configuration>
  53. <source>1.7</source>
  54. <target>1.7</target>
  55. <encoding>UTF-8</encoding>
  56. <compilerArguments>
  57. <verbose />
  58. <bootclasspath>${java.home}/lib/rt.jar;${java.home}/lib/jce.jar</bootclasspath>
  59. </compilerArguments>
  60. </configuration>
  61. </plugin>
  62. </plugins>
  63. <finalName>spring_mongo</finalName>
  64. </build>
  65. </project>
 
spring基础配置：
主要是开启注解扫描等：
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns:task="http://www.springframework.org/schema/task"
  3. xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xsi:schemaLocation="
  6. http://www.springframework.org/schema/beans
  7. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  8. http://www.springframework.org/schema/context
  9. http://www.springframework.org/schema/context/spring-context-3.0.xsd
  10. http://www.springframework.org/schema/task
  11. http://www.springframework.org/schema/task/spring-task-3.1.xsd">
  12. <!-- 自动扫描(自动注入) -->
  13. <context:component-scan base-package="spring_mogo.dao.daoImp" />
  14. <!-- 导入mongodb的配置文件 -->
  15. <import resource="spring-mongodb305.xml" />
  16. <!-- 开启注解 -->
  17. <context:annotation-config />
  18. </beans>
spring连接mongodb以及建立相关工厂的配置：
  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. <!-- spring连接mongodb数据库的配置 -->
  10. <mongo:mongo-client host="192.168.0.201" port="27017" credentials="tuzongxun:123456@mongoTest" id="mongo">
  11. <mongo:client-options write-concern="SAFE"/>
  12. </mongo:mongo-client>
  13. <mongo:db-factory  id="mongoDbFactory" dbname="mongoTest" mongo-ref="mongo" />
  14. <!-- 只要使用这个调用相应的方法操作 -->
  15. <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
  16. <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
  17. </bean>
  18. </beans>
与数据库对应的实体类：
需要注意的是这里需要实现序列化的接口并设置uid的属性，否则不能在操作中直接把数据库返回结果转换成对象属性：
  1. package spring_mongo.models;
  2. import java.io.Serializable;
  3. public class UserModel implements Serializable {
  4. private static final long serialVersionUID = 1L;
  5. private String userName;
  6. private String password;
  7. public UserModel(String userName, String password) {
  8. super();
  9. this.userName = userName;
  10. this.password = password;
  11. }
  12. public String getUserName() {
  13. return userName;
  14. }
  15. public void setUserName(String userName) {
  16. this.userName = userName;
  17. }
  18. public String getPassword() {
  19. return password;
  20. }
  21. public void setPassword(String password) {
  22. this.password = password;
  23. }
  24. }
根据spring配置获取操作mongodb的MongoTemplete，需要实现ApplicationContextAware接口：
  1. package spring_mogo.dao.daoImp;
  2. import org.springframework.beans.BeansException;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.ApplicationContextAware;
  5. import org.springframework.data.mongodb.core.MongoTemplate;
  6. public abstract class AbstractBaseMongoTemplete implements
  7. ApplicationContextAware {
  8. protected MongoTemplate mongoTemplate;
  9. /**
  10. * @Description 根据配置文件设置mongoTemplate
  11. * @param mongoTemplate
  12. */
  13. public void setMongoTemplate(MongoTemplate mongoTemplate) {
  14. this.mongoTemplate = mongoTemplate;
  15. }
  16. @Override
  17. public void setApplicationContext(ApplicationContext applicationContext)
  18. throws BeansException {
  19. MongoTemplate mongoTemplate = applicationContext.getBean(
  20. "mongoTemplate", MongoTemplate.class);
  21. setMongoTemplate(mongoTemplate);
  22. }
  23. }
 
操作数据库的接口以及对应的实现类：
演示了最基础的增删改查，需要注意的地方在于参数的声明以及接收返回数据时和实体类的转换：
（1）接口：
  1. package spring_mogo.dao;
  2. import java.util.List;
  3. import spring_mongo.models.UserModel;
  4. public interface UserDao {
  5. /**
  6. * 查询数据
  7. *
  8. * @author：tuzongxun
  9. * @Title: findAll
  10. * @param @return
  11. * @return List<UserModel>
  12. * @date May 13, 2016 3:07:39 PM
  13. * @throws
  14. */
  15. public List<UserModel> findAll();
  16. /**
  17. * 新增数据
  18. *
  19. * @author：tuzongxun
  20. * @Title: insertUser
  21. * @param @param user
  22. * @return void
  23. * @date May 13, 2016 3:09:45 PM
  24. * @throws
  25. */
  26. public void insertUser(UserModel user);
  27. /**
  28. * 删除数据
  29. *
  30. * @author：tuzongxun
  31. * @Title: removeUser
  32. * @param @param userName
  33. * @return void
  34. * @date May 13, 2016 3:09:55 PM
  35. * @throws
  36. */
  37. public void removeUser(String userName);
  38. /**
  39. * 修改数据
  40. *
  41. * @author：tuzongxun
  42. * @Title: updateUser
  43. * @param @param user
  44. * @return void
  45. * @date May 13, 2016 3:10:06 PM
  46. * @throws
  47. */
  48. public void updateUser(UserModel user);
  49. /**
  50. * 按条件查询
  51. *
  52. * @author：tuzongxun
  53. * @Title: findForRequery
  54. * @param
  55. * @return void
  56. * @date May 13, 2016 3:23:37 PM
  57. * @throws
  58. */
  59. public List<UserModel> findForRequery(String userName);
  60. }
（2）实现类，这里要继承AbstractBaseMongoTemplete类，从而获得mongoTemplete进行各种操作：
  1. package spring_mogo.dao.daoImp;
  2. import java.util.List;
  3. import org.springframework.data.mongodb.core.query.Criteria;
  4. import org.springframework.data.mongodb.core.query.Query;
  5. import org.springframework.data.mongodb.core.query.Update;
  6. import org.springframework.stereotype.Component;
  7. import spring_mogo.dao.UserDao;
  8. import spring_mongo.models.UserModel;
  9. import com.mongodb.BasicDBObject;
  10. import com.mongodb.DBObject;
  11. @Component("UserDaoImp")
  12. public class UserDaoImp extends AbstractBaseMongoTemplete implements UserDao {
  13. /**
  14. * 查询所有数据
  15. *
  16. * @author：tuzongxun
  17. * @Title: findAll
  18. * @Description: TODO
  19. * @param @return
  20. * @date May 13, 2016 3:10:29 PM
  21. * @throws
  22. */
  23. @Override
  24. public List<UserModel> findAll() {
  25. // 需要设置集合对应的尸体类和相应的集合名，从而查询结果直接映射
  26. List<UserModel> userList = mongoTemplate.findAll(UserModel.class,
  27. "user");
  28. return userList;
  29. }
  30. /**
  31. * 新增数据
  32. *
  33. * @author：tuzongxun
  34. * @Title: insertUser
  35. * @Description: TODO
  36. * @param @param user
  37. * @date May 13, 2016 3:10:45 PM
  38. * @throws
  39. */
  40. @Override
  41. public void insertUser(UserModel user) {
  42. // 设置需要插入到数据库的文档对象
  43. DBObject object = new BasicDBObject();
  44. object.put("userName", user.getUserName());
  45. object.put("password", user.getPassword());
  46. mongoTemplate.insert(object, "user");
  47. }
  48. /**
  49. * 按条件删除数据
  50. *
  51. * @author：tuzongxun
  52. * @Title: removeUser
  53. * @Description: TODO
  54. * @param @param userName
  55. * @date May 13, 2016 3:11:01 PM
  56. * @throws
  57. */
  58. @Override
  59. public void removeUser(String userName) {
  60. // 设置删除条件，如果条件内容为空则删除所有
  61. Query query = new Query();
  62. Criteria criteria = new Criteria("userName");
  63. criteria.is(userName);
  64. query.addCriteria(criteria);
  65. mongoTemplate.remove(query, "user");
  66. }
  67. /**
  68. * 修改数据
  69. *
  70. * @author：tuzongxun
  71. * @Title: updateUser
  72. * @Description: TODO
  73. * @param @param user
  74. * @date May 13, 2016 3:11:12 PM
  75. * @throws
  76. */
  77. @Override
  78. public void updateUser(UserModel user) {
  79. // 设置修改条件
  80. Query query = new Query();
  81. Criteria criteria = new Criteria("userName");
  82. criteria.is(user.getUserName());
  83. query.addCriteria(criteria);
  84. // 设置修改内容
  85. Update update = Update.update("password", user.getPassword());
  86. // 参数：查询条件，更改结果，集合名
  87. mongoTemplate.updateFirst(query, update, "user");
  88. }
  89. /**
  90. * 根据条件查询
  91. *
  92. * @author：tuzongxun
  93. * @Title: findForRequery
  94. * @Description: TODO
  95. * @param @param userName
  96. * @date May 13, 2016 4:08:15 PM
  97. * @throws
  98. */
  99. @Override
  100. public List<UserModel> findForRequery(String userName) {
  101. Query query = new Query();
  102. Criteria criteria = new Criteria("userName");
  103. criteria.is(userName);
  104. query.addCriteria(criteria);
  105. // 查询条件，集合对应的实体类，集合名
  106. List<UserModel> userList = mongoTemplate.find(query, UserModel.class,
  107. "user");
  108. return userList;
  109. }
  110. }

测试类：

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

使用spring连接及操作mongodb3.0的更多相关文章

  1. spring boot 1.5.2 操作mongodb3.4.0

    1:build.gradle 添加mongodb依赖 dependencies { compile('org.springframework.boot:spring-boot-starter-web' ...

  2. Swift3.0服务端开发(四) MySQL数据库的连接与操作

    本篇博客我们来聊聊MySQL数据库的连接与操作.如果你本地没有MySQL数据库的话,需要你先安装MySQL数据库.在Mac OS中使用brew包管理器进行MySQL的安装是及其方便的.安装MySQL的 ...

  3. 记录一次MongoDB3.0.6版本wiredtiger与MMAPv1引擎的写入耗时对比

    一.MongoDB3.0.x的版本特性(相对于MongoDB2.6及以下): 增加了wiredtiger引擎: 开源的存储引擎: 支持多核CPU.充分利用内存/芯片级别缓存(注:10月14日刚刚发布的 ...

  4. 修改mongodb3.0副本集用户密码遇到的坑

    最近公司对项目安全方面的问题很是重视,进行了多次各种安全漏洞的扫描,于是乎就扫到了mongodb弱口令的问题. 在项目部署初期,因为大家对这个都不是特别重视,大概是因为觉得反正是内网项目吧,所以mon ...

  5. Spring连接池的常用配置

    1.连接池概述 数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现得尤为突出.对数据库连接的管理能显著影响到整个 应用程序的伸缩性和健壮性,影响到程序的性能指标.数据库连接池正 ...

  6. mongodb3.0副本集搭建补充~~非admin数据库的用户权限

    之前有搭建mongodb3.0的副本集,不过当时直接使用的admin数据库,用户也是直接给的root. 链接:http://blog.csdn.net/tuzongxun/article/detail ...

  7. spring 学习（四）: spring 的 jdbcTemplate 操作

    spring 学习(四): spring 的 jdbcTemplate 操作 spring 针对 javaee 的每一层,都提供了相应的解决技术,jdbcTemplate 的主要操作在 dao 层. ...

  8. Spring Boot使用Spring Data Redis操作Redis（单机/集群）

    说明:Spring Boot简化了Spring Data Redis的引入,只要引入spring-boot-starter-data-redis之后会自动下载相应的Spring Data Redis和 ...

  9. 使用Spring Data Redis操作Redis（集群版）

    说明:请注意Spring Data Redis的版本以及Spring的版本!最新版本的Spring Data Redis已经去除Jedis的依赖包,需要自行引入,这个是个坑点.并且会与一些低版本的Sp ...

随机推荐

  1. HTML标签整理

    第一次接触动态网站的相关代码,对程序里HTML的标签不理解.在这里会把碰到的HTML标签整理出来,持续更新. 1.<form></form>:用于声明表单,定义采集数据的范围, ...

  2. 30+有用的CSS代码片段

    在一篇文章中收集所有的CSS代码片段几乎是不可能的事情,但是我们这里列出了一些相对于其他的更有用的代码片段,不要被这些代码的长度所吓到,因为它们都很容易实现,并且具有良好的文档.除了那些解决常见的恼人 ...

  3. matlab mesh visualization

    1. matlab color specification http://au.mathworks.com/help/matlab/ref/colorspec.html

  4. Java中获取键盘输入值的三种方法

    Java中获取键盘输入值的三种方法     Java程序开发过程中,需要从键盘获取输入值是常有的事,但Java它偏偏就没有像c语言给我们提供的scanf(),C++给我们提供的cin()获取键盘输入值 ...

  5. struts2 配置拦截器

    第一步:继承MethodFilterInterceptor写自己的自定义拦截器 import org.apache.struts2.ServletActionContext; import com.o ...

  6. jQuery：cookie插件的使用

    Jquery插件就是在Jquery基础之上,开发的基于Jquery的javascript库. 在Jquery中,引入cookie插件后,可以很方便的定义某个cookie的名称,并设置cookie值.通 ...

  7. 学习RaphaelJS矢量图形包--Learning Raphael JS Vector Graphics中文翻译（一）

    (原文地址:http://www.cnblogs.com/idealer3d/p/LearningRaphaelJSVectorGraphics.html) 前面3篇博文里面,我们讲解了一本叫做< ...

  8. OpenGL坐标变换及其数学原理，两种摄像机交互模型（附源程序）

    实验平台:win7,VS2010 先上结果截图(文章最后下载程序,解压后直接运行BIN文件夹下的EXE程序): a.鼠标拖拽旋转物体,类似于OGRE中的“OgreBites::CameraStyle: ...

  9. Mac MySQL 转移 datadir

    mysql默认的datadir在启动盘上面,有时database太大,于是决定将datadir迁到存储盘中 Step 1 将原datadir迁到存储盘 mv /usr/local/var/mysql ...

  10. Javascript 自动计算生日

    首先调用方法需要注意 //inner_page为外围大层,确保时间可以实时修改  $(".inner_page").mouseover(function() {        va ...