Spring整合MongoDB

最新推荐文章于 2024-10-08 17:39:57 发布
最新推荐文章于 2024-10-08 17:39:57 发布
阅读量87 收藏
点赞数
文章标签： 数据库 java 测试
原文链接：https://yq.aliyun.com/articles/559018
版权




版本：

spring：4.1.3.RELEASE

mongo-java-driver.version：3.4.1

spring-data-mongodb.version：1.7.0.RELEASE


配置：

1、pom.xml中添加核心依赖（两个）

+++++++++++++++++++++++++++++++++++++++++++++++++++++

1
2
3
4
5
6
7
8
9
10
11
12
                 <!-- mongo-java-dirver -->
         <dependency>
             <groupId>org.mongodb</groupId>
             <artifactId>mongo-java-driver</artifactId>
             <version> 3.4 . 1 </version>
         </dependency>
         <!-- spring-data-mongodb -->
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-mongodb</artifactId>
             <version> 1.7 . 0 .RELEASE</version>
         </dependency>

++++++++++++++++++++++++++++++++++++++++++++++++++++++

完整pom.xml文件内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
<project xmlns= "http://maven.apache.org/POM/4.0.0"  xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation= "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" >
     <modelVersion> 4.0 . 0 </modelVersion>
     <groupId>com.fwmagic.mongo</groupId>
     <artifactId>fwmagic-mongo</artifactId>
     <version> 1.0 . 0 -SNAPSHOT</version>
 
     <properties>
         <junit.version> 4.12 </junit.version>
         <spring.version> 4.1 . 3 .RELEASE</spring.version>
         <fastjson.version> 1.2 . 15 </fastjson.version>
         <slf4j.version> 1.6 . 4 </slf4j.version>
         <joda-time.version> 2.5 </joda-time.version>
         <commons-lang3.version> 3.3 . 2 </commons-lang3.version>
         <commons-io.version> 1.3 . 2 </commons-io.version>
         <mongo-java-driver.version> 3.4 . 1 </mongo-java-driver.version>
         <spring-data-mongodb.version> 1.7 . 0 .RELEASE</spring-data-mongodb.version>
 
         <env>dev</env>
         <project.build.sourceEncoding>UTF- 8 </project.build.sourceEncoding>
         <maven.compiler.encoding>UTF- 8 </maven.compiler.encoding>
     </properties>
 
     <dependencies>
         <!--junit -->
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>${junit.version}</version>
         </dependency>
 
         <!-- fastjson -->
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>fastjson</artifactId>
             <version>${fastjson.version}</version>
         </dependency>
 
         <!-- Spring -->
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context</artifactId>
             <version>${spring.version}</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context-support</artifactId>
             <version>${spring.version}</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-beans</artifactId>
             <version>${spring.version}</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-webmvc</artifactId>
             <version>${spring.version}</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-aspects</artifactId>
             <version>${spring.version}</version>
         </dependency>
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-test</artifactId>
             <version>${spring.version}</version>
         </dependency>
         <!-- slf4j日志 -->
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-log4j12</artifactId>
             <version>${slf4j.version}</version>
         </dependency>
         <!-- Apache工具组件 -->
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
             <version>${commons-lang3.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-io</artifactId>
             <version>${commons-io.version}</version>
         </dependency>
         <!-- 时间操作组件 -->
         <dependency>
             <groupId>joda-time</groupId>
             <artifactId>joda-time</artifactId>
             <version>${joda-time.version}</version>
         </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-pool2</artifactId>
             <version> 2.0 </version>
         </dependency>
         <!-- mongo-java-dirver -->
         <dependency>
             <groupId>org.mongodb</groupId>
             <artifactId>mongo-java-driver</artifactId>
             <version>${mongo-java-driver.version}</version>
         </dependency>
         <!-- spring-data-mongodb -->
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-mongodb</artifactId>
             <version>${spring-data-mongodb.version}</version>
             <exclusions>
                 <exclusion>
                     <artifactId>slf4j-api</artifactId>
                     <groupId>org.slf4j</groupId>
                 </exclusion>
             </exclusions>
         </dependency>
     </dependencies>
     <build>
         <plugins>
             <!-- java编译插件 -->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version> 3.2 </version>
                 <configuration>
                     <source> 1.7 </source>
                     <target> 1.7 </target>
                     <encoding>UTF- 8 </encoding>
                 </configuration>
             </plugin>
             <!-- 配置Tomcat插件 -->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-war-plugin</artifactId>
                 <version> 2.6 </version>
                 <configuration>
                     <archiveClasses> true </archiveClasses>
                     <packagingExcludes>WEB-INF/classes/**</packagingExcludes>
                     <webResources>
                         <resource>
                             <directory>src/main/webapp/WEB-INF</directory>
                             <includes>
                                 <include>applicationContext.xml</include>
                             </includes>
                             <filtering> true </filtering>
                             <targetPath>WEB-INF</targetPath>
                         </resource>
                     </webResources>
                 </configuration>
             </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <version> 2.7 . 1 </version>
             </plugin>
         </plugins>
     </build>
</project>


2、mongo.properties

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
####################################################
###MongoDB configuration
####################################################
mongo.host=localhost
mongo.port= 27017
mongo.dbname=demodb
mongo.username=admin
mongo.password= 123456
#一个线程变为可用的最大阻塞数
mongo.connectionsPerHost= 8
#线程队列数,它与以上面connectionsPerHost值相乘的结果就是线程队列最大值
mongo.threadsAllowedToBlockForConnectionMultiplier= 4
#连接超时时间（毫秒） 
mongo.connectTimeout= 1500
#最大等待时间
mongo.maxWaitTime= 1500
#自动重连
mongo.autoConnectRetry= true
#scoket保持活动
mongo.socketKeepAlive=  true
#scoket超时时间
mongo.socketTimeout= 1500
#读写分离
mongo.slaveOk= true


3、applicationContext.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<?xml version= "1.0"  encoding= "UTF-8" ?>
<beans xmlns= "http://www.springframework.org/schema/beans"
     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"
     xmlns:mvc= "http://www.springframework.org/schema/mvc"  xmlns:mongo= "http://www.springframework.org/schema/data/mongo"
     xsi:schemaLocation="http: //www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
         http: //www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
         http: //www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
         http: //www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo.xsd">
         
     <!--配置service的包扫描，自动注入Service -->
     <context:component-scan base- package = "com.fwmagic"  />
 
     <!-- 使用spring自带的占位符替换功能 -->
     <bean
         class = "org.springframework.beans.factory.config.PropertyPlaceholderConfigurer" >
         <!-- 允许JVM参数覆盖 -->
         <property name= "systemPropertiesModeName"  value= "SYSTEM_PROPERTIES_MODE_OVERRIDE"  />
         <!-- 忽略没有找到的资源文件 -->
         <property name= "ignoreResourceNotFound"  value= "true"  />
         <!-- 配置资源文件 -->
 
         <property name= "locations" >
             <list>
                 <value>classpath:mongo.properties</value>
                 <value>classpath:log4j.properties</value>
             </list>
         </property>
     </bean>
     
         <!--credentials的配置形式是：用户名:密码@默认数据库 -->
     <mongo:mongo-client id= "mongoClient"  host= "${mongo.host}"
         port= "${mongo.port}"  credentials= "${mongo.username}:${mongo.password}@${mongo.dbname}" >
         <mongo:client-options write-concern= "SAFE"
             connections-per-host= "${mongo.connectionsPerHost}"
             threads-allowed-to-block- for -connection-multiplier= "${mongo.threadsAllowedToBlockForConnectionMultiplier}"
             connect-timeout= "${mongo.connectTimeout}"  max-wait-time= "${mongo.maxWaitTime}"
             socket-timeout= "${mongo.socketTimeout}"  />
     </mongo:mongo-client>
 
     <mongo:db-factory id= "mongoDbFactory"  dbname= "${mongo.dbname}"
         mongo-ref= "mongoClient"  />
 
     <bean id= "mongoTemplate"  class = "org.springframework.data.mongodb.core.MongoTemplate" >
         <constructor-arg name= "mongoDbFactory"  ref= "mongoDbFactory"  />
     </bean>
</beans>


单元测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
package  com.fwmagic.dao;
 
import  java.util.Date;
import  java.util.List;
 
import  org.junit.Test;
import  org.junit.runner.RunWith;
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.data.mongodb.core.MongoTemplate;
import  org.springframework.data.mongodb.core.query.Criteria;
import  org.springframework.data.mongodb.core.query.CriteriaDefinition;
import  org.springframework.data.mongodb.core.query.Query;
import  org.springframework.data.mongodb.core.query.Update;
import  org.springframework.test.context.ContextConfiguration;
import  org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import  com.fwmagic.pojo.Notice;
 
@RunWith (SpringJUnit4ClassRunner. class )
@ContextConfiguration ( "classpath:spring/applicationContext*.xml" )
public  class  NoticeDAOTest {
 
     @Autowired
     private  NoticeDAO dao;
     
     /**
      * 查询所有文档
      */
     @Test
     public  void  testList() {
         Query query =  new  Query();
         List<Notice> notice = dao.list(query, Notice. class );
         for  (Notice n : notice) {
             System.out.println(n);
         }
     }
 
     /**
      * 插入文档
      */
     @Test
     public  void  testInsert(){
         Notice notice =  new  Notice();
         notice.setSiteId( 7 );
         notice.setCreator( "diaochan" );
         notice.setTitle( "今天星期一" );
         notice.setUpdateTime( new  Date());
         dao.insert(notice);
     }
     
     /**
      * 更新文档
      */
     @Test
     public  void  testUpdate(){
         Criteria criteria =  new  Criteria();
         criteria.and( "creator" ).is( "zhaojun" );
         Query query =  new  Query(criteria);
         dao.update(query, Update.update( "createTime" ,  new  Date()), Notice. class );
     }
     
     /**
      * 删除一行文档
      */
     @Test
     public  void  testRemove(){
         Criteria criteria =  new  Criteria();
         criteria.and( "creator" ).is( "zhaojun" );
         Query query =  new  Query(criteria);
         dao.remove(query, Notice. class );
     }
     
     //未完待续……
}


NoticeDAO.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package  com.fwmagic.dao;
 
import  java.util.List;
 
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.data.mongodb.core.MongoTemplate;
import  org.springframework.data.mongodb.core.query.Query;
import  org.springframework.data.mongodb.core.query.Update;
import  org.springframework.stereotype.Repository;
 
import  com.fwmagic.pojo.Notice;
import  com.mongodb.WriteResult;
 
@Repository
public  class  NoticeDAO  implements  BaseDAO<Notice>{
 
     @Autowired
     private  MongoTemplate mt;
     
     @Override
     public  List<Notice> list(Query query, Class<Notice> entityClass) {
         return  mt.find(query, entityClass);
     }
 
     @Override
     public  Notice findOne(Query query, Class<Notice> entityClass) {
         return  mt.findOne(query, entityClass);
     }
     
     @Override
     public  void  insert(Notice notice){
         mt.insert(notice);
     }
     
     @Override
     public  WriteResult update(Query query, Update update, Class<?> entityClass){
         return  mt.updateFirst(query, update, entityClass);
     }
     
     @Override
     public  void  remove(Query query, Class<?> entityClass){
         mt.remove(query, entityClass);
     }
}


完整demo请移步此处查看.



本文转自 兴趣e族 51CTO博客，原文链接:http://blog.51cto.com/simplelife/1932408

weixin_33863087
关注
Springdata-mongodb的基本使用
haptony的博客
12-09 6291
文章目录一、 SpringData介绍二、 SpringData操作MongoDB的两种方式及实战1. MongoTemplate1.1 Mongodb Driver Api操作MongoDB1.1.2 基本CRUD1.1.3 连接选项1.2 MongoTemplate的基本CRUD1.3 MongoTemplate的聚合查询1.3.1 Aggregate1.3.2 MapReduce1.3.3 聚合操作和MapReduce对比1.3.4 Group操作1.3.5 Bucket聚合2. MongoRepos
SpringBoot开发——整合Spring Data MongoDB
bjzhang75的博客
09-10 1260
SpringBoot开发整合Spring Data MongoDB
springboot系列十一 Spring-Data-MongoDB
weixin_33949359的博客
12-04 202
2019独角兽企业重金招聘Python工程师标准>>> ...
centos7安装MongoDB3.4 以及spring data mongodb的配置使用
billluffy的博客
09-11 613
试了几个教程还是这个比较清晰，简单，易操作。 简介 MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功
Spring Data MongoDB 与 mongo java driver 与 spring Framework 的版本兼容情况
YHJ
05-13 4300
近期基于业务和成本的考虑，需要对MongoDB进行升级。 使用方式上只要是用spring-data-mongodb 对mongodb 操作。所以后续操作都是基于spring-data-mongodb 该组件来讨论 调研过程中发现了些问题，特此分享一下。 后续调研发现支持升级的版本有： MongoDB 与 java Driver 兼容性，如下图： 发现 如果要升级到最新的版本MongoDB4.4 ，则java Driver 需要4.1， 而目前（2020-09-...
Spring 集成MongoDB
书香水墨
08-26 454
一、Spring集成MongoDB 1.1 启用MongoDB 为了有效地使用Spring Data MongoDB，我们需要在Spring配置中添加几个必要的bean。首先，我们需要配置MongoClient，以便于访问MongoDB数据库。同时，我们还需要有一个MongoTemplate bean，实现基于模板的数据库访问。此外，不是必须，但是强烈推荐启用 Spring Data Mongo...
Spring集成MongoDB实战
weixin_39080216的博客
07-13 852
Springboot集成MongoDB简单例子
Spring 整合Mongodb
洋葱花瓣的专栏
09-28 378
1、项目采用Maven 的方式。所需要的jar包只需要配置即可。 2、与Mongodb，spring整合相关的两个jar包：<dependency> <groupId>org.mongodb</groupId> <artifactId>mongo-java-driver</artifactId> <version>${mongo-java-drive
Spring 整合MongoDB
Cloud-Future的博客
05-18 860
目录 1、在pom.xml文件中添加mongoDB的依赖： 2、通过xml配置MongoTemplate 3、AbstractMongodbDao类，实现MongoDb的CRUD操作 4、测试 4.1 MongoUser 实体类，对应db中的集合user 4.2 UserMongoDao 4.3MongoUserManageService 4.4 MongoUserManage(controller) 5、启动MongoDB Server，为数据库testdb，添加一个用户 6、启动项.
spring 整合mongodb
08-11
总结，Spring整合MongoDB提供了强大的数据访问支持，通过简单的接口和注解，可以让开发者专注于业务逻辑，而不是底层数据库操作。在实际开发中，了解并熟练运用这些知识点，能显著提升开发效率和代码质量。
spring整合mongodb
03-05
在Spring框架中集成MongoDB，可以利用Spring的数据访问抽象层，简化数据操作，并与Spring的其他模块无缝配合。 首先，为了整合Spring和MongoDB，我们需要在项目中引入相关依赖。通常，这可以通过在`pom.xml`或`...
Spring Data MongoDB中文文档
02-22
- 这些特性极大地丰富了与 MongoDB 交互的方式，使得 **Spring Data MongoDB** 成为了与 MongoDB 集成的理想选择。 总之，**Spring Data MongoDB** 是一个强大的工具，它不仅简化了与 MongoDB 数据库的交互，还提供...
鲁班到家上门安装维修系统源码开发之结构功能解析
weixin_43744973的博客
10-08 582
鲁班到家上门安装维修系统的源码开发是一个复杂但富有成效的过程。通过详细的需求分析、技术选型、功能模块设计以及前后端分离开发，该系统不仅提升了服务效率，还通过数字化管理优化了用户体验。未来，该系统有望在智能家居售后服务领域发挥更加重要的作用，引领行业向更加高效、专业、透明的方向发展。
ATAM需求说明-系统架构师（七十六）
ke1ying的博客
10-08 778
1体系结构权衡分析法ATAM(Architecture Trade Off Analyzer Method)是一种常见的结构权衡分析法，该框架主要关注系统的（），针对性能、安全性、可用性和可修改性，在系统开发前进行分析、评价和这种。A共享数据库的集成方式通常将应用程序的数据存储在一个共享数据库中，通过制定统一的数据库模式来处理不同应用集成需求。场景和需求的收集，架构视图和场景的实现，属性模型的构造和分析，架构评价和折中。7企业信息资源集成管理的前提是对企业（）的集成，其核心是对企业（）的集成。
World of Warcraft [CLASSIC][80][Grandel] Call to Arms: Victory in Wintergrasp
qq 117791303
10-02 346
Wintergrasp 冬拥湖 120 VS 120
同城O2O系统源码与跑腿配送平台的架构设计与开发方案详解
最新发布
meihusdk的博客
10-08 393
同城O2O系统与跑腿配送平台的开发，既是技术的挑战，也是商业机会的探索。通过合理的架构设计与清晰的开发方案，开发者可以构建出高效、稳定且易于扩展的平台，为用户提供更为便捷的服务。
思迅商云开启货号修改语句
xushugang007的博客
10-03 239
insert into t_sys_system (sys_var_id,sys_var_name,sys_var_value,is_changed,sys_ver_flag) values('itemnoisedit','货号、供应商、客户编码修改','1','否','1')use hbposv10 --分店数据库名改成： hbposv10_branch。--开启 货号、供应商、客户编码修改。
Spring 整合 MongoDB 开发指南
Spring-MongoDB整合文档 本文档旨在介绍Spring与MongoDB的整合技术，旨在帮助开发者快速了解Spring Data MongoDB的使用方法和实现原理。 Spring Data MongoDB简介 Spring Data MongoDB是Spring Framework的一部分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值