MongoDb的Java客户端配置

最新推荐文章于 2023-10-07 21:41:13 发布

hxpjava1

最新推荐文章于 2023-10-07 21:41:13 发布

阅读量1.1k

点赞数

分类专栏： mongodb

mongodb 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

MongoDb的Java客户端配置

一 MongoDb介绍

二 Java客户端配置

三 MongoDB GridFS存取文件

一 MongoDb介绍

MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bjson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

二 java客户端配置

2.1 属性配置文件mongo.properties

[java]view plaincopy 
    
 mongo.databaseName = test_db  
 mongo.host = 192.168.13.127  
 mongo.port = 27017  

2.2 xml文件springMongoDb.xml

[java]view plaincopy 
    
 <?xml version="1.0" encoding="UTF-8"?>  
 <beans xmlns="http://www.springframework.org/schema/beans"  
     xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"  
     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"  
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd  
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd  
     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd  
     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.3.xsd">  
       
     <bean id="MongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">  
         <constructor-arg name="databaseName"  value="${mongo.databaseName}"/>  
         <constructor-arg name="mongo" ref="mongo"/>  
     </bean>  
       
     <bean id="mongo" class="org.springframework.data.mongodb.core.MongoFactoryBean">  
         <property name="host" value = "${mongo.host}"></property>  
         <property name="port" value = "${mongo.port}"></property>  
     </bean>  
 </beans>  

2.3 maven上添加mongodb的包

[java]view plaincopy 
    
 <!-- https://mvnrepository.com/artifact/org.mongodb/mongo-java-driver -->  
 <dependency>  
     <groupId>org.mongodb</groupId>  
     <artifactId>mongo-java-driver</artifactId>  
     <version>3.4.2</version>  
 </dependency>  
 <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-mongodb -->  
 <dependency>  
     <groupId>org.springframework.data</groupId>  
     <artifactId>spring-data-mongodb</artifactId>  
     <version>1.10.1.RELEASE</version>  
 </dependency>  

2.4 mongodb基础类

MongoIntf.java

[java]view plaincopy 
    
 package com.mycompany.mongo.dao;  
   
 import java.util.List;  
   
 import org.springframework.data.mongodb.core.query.Query;  
 import org.springframework.data.mongodb.core.query.Update;  
   
 public interface MongoIntf<T>{  
   
     /*保存一个对象*/  
     public void save(T t);  
       
     /*根据对象Id查找该对象*/  
     public T queryById(Class<T> cls,String id);  
       
     /*根据条件查询集合*/  
     public List<T> queryList(Class<T> cls,Query query);  
       
     /*通过条件查询单个实体*/  
     public T queryOne(Class<T> cls,Query query);  
       
     /*分页查询*/  
     public List<T> getPage(Class<T> cls,Query query, int start, int size);  
       
     /*查询符合条件的记录总数*/  
     public Long getPageCount(Class<T> cls,Query query);  
       
     /*根据id删除对象*/  
     public void deleteById(Class<T> cls,String id);  
       
     /*删除对象*/  
     public void delete(T t);  
       
     /*更新指定id的属性值*/  
     public void updateFirst(Class<T> cls,String id, String objName, String objValue);  
       
     /*查找更新*/  
     public void updateInser(Class<T> cls,Query query, Update update);  
       
 }  

MongoSupport.java

[java]view plaincopy 
    
 package com.mycompany.mongo.dao;  
   
 import java.util.List;  
   
 import org.slf4j.Logger;  
 import org.slf4j.LoggerFactory;  
 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.Query;  
 import org.springframework.data.mongodb.core.query.Update;  
   
 public class MongoSupport<T> implements MongoIntf<T>{  
   
     private Logger logger = LoggerFactory.getLogger(MongoSupport.class);  
      
     @Autowired  
     public MongoTemplate mongoTemplate;  
   
     /**@Description 
      * 保存一个对象 
      */  
     @Override  
     public void save(T t){  
         this.mongoTemplate.save(t);  
     }  
     /**@Description 
      * 查找对应id的对象,id对应Collection中记录的_id字段 
      */  
     public T queryById(Class<T> cls,String id) {  
         Query query = new Query();  
         Criteria criteria = Criteria.where("_id").is(id);  
         query.addCriteria(criteria);  
         logger.info(cls+"[Mongo]queryById:" + query);  
         return this.mongoTemplate.findOne(query, cls);  
     }  
     /**@Description 
      * 根据条件查询集合 
      */  
     public List<T> queryList(Class<T> cls,Query query){  
         logger.info(cls+"[Mongo]queryList:" + query);  
         return this.mongoTemplate.find(query, cls);  
     }  
     /**@Description 
      * 通过条件查询单个实体 
      * 查询单个用的是mongoTemplate.findOne方法,查询多条的用的是mongoTemplate.find 
      */  
     public T queryOne(Class<T> cls,Query query){  
         logger.info(cls+"[Mongo] queryOne:" + query);  
         return this.mongoTemplate.findOne(query, cls);  
     }  
     /**@Description 
      * 通过条件进行分页查询 
      * 类似mysql查询中的limit 
      */  
     public List<T> getPage(Class<T> cls,Query query, int start, int size){  
         query.skip(start);  
         query.limit(size);  
         List<T> lists = this.mongoTemplate.find(query, cls);  
         logger.info(cls+"[Mongo] queryPage:" + query + "(" + start +"," + size +")");  
         return lists;  
     }  
     /**@Description 
      * 根据条件查询库中符合记录的总数,为分页查询服务 
      */  
     public Long getPageCount(Class<T> cls,Query query){  
         logger.info(cls+"[Mongo]queryPageCount:" + query);  
         return this.mongoTemplate.count(query, cls);  
     }  
       
     /**@Description 
      * 根据id删除对象 
      */  
     public void deleteById(Class<T> cls,String id){  
         Criteria criteria = Criteria.where("_id").in(id);  
         if(null!=criteria){  
             Query query = new Query(criteria);  
             if(null!=query && this.queryOne(cls,query)!=null){  
                 this.mongoTemplate.remove(this.queryOne(cls,query));  
                 logger.info(cls+"[Mongo]deleteById:" + query);  
             }  
         }  
     }  
     /**@Description 
      * 删除对象 
      */  
     public void delete(T t){  
         this.mongoTemplate.remove(t);  
         logger.info("[Mongo]delete:" + t);  
     }  
     /**@Description 
      * 更新指定id的属性值 
      */  
     public void updateFirst(Class<T> cls,String id, String objName, String objValue){  
         Criteria criteria = Criteria.where("_id").in(id);  
         if(null!=criteria){  
             Query query = new Query(criteria);  
             if(null!=query && this.queryOne(cls,query)!=null){  
                  Update update=new Update();  
                  update.set(objName,objValue);  
                  this.mongoTemplate.updateFirst(query,update,cls);  
                  logger.info(cls+"[Mongo]updateFirst:query(" + query + "),update(" + update + ")");  
             }  
         }  
     }  
     /** 
      *  Created on 2017年3月27日  
      * <p>Discription:[查找更新,如果没有找到符合的记录,则将更新的记录插入库中]</p> 
      */  
     public void updateInser(Class<T> cls,Query query, Update update){  
         logger.info(cls+"[Mongo]updateInser:query(" + query + "),update(" + update + ")");  
         this.mongoTemplate.upsert(query, update, cls);  
     }  
   
 }  

2.5 然后在项目的dao层实现方法中，继承mongodb的实现类，如userDao

[java]view plaincopy 
    
 package com.mycompany.user.dao;  
   
 import java.util.List;  
 import java.util.Map;  
   
 import org.springframework.beans.factory.annotation.Autowired;  
 import org.springframework.data.mongodb.core.query.Query;  
 import org.springframework.data.mongodb.core.query.Update;  
 import org.springframework.stereotype.Repository;  
   
 import com.mycompany.mongo.dao.MongoSupport;  
 import com.mycompany.user.entity.User;  
 import com.mycompany.user.mapper.UserMapper;  
 @Repository("userDao")  
 public class UserDaoImpl extends MongoSupport<User> implements UserDao{  
   
     @Autowired  
     private UserMapper userMapper;  
       
     public User selectByUserId(Map<String,Object> map) {  
         return userMapper.selectByUserId(map);  
     }  
     public void insertUser(User user) {  
         userMapper.insertUser(user);  
     }  
   
     /*保存一个对象*/  
     @Override  
     public void saveUser(User user){  
         this.save(user);  
     }  
       
     /*根据对象Id查找该对象*/  
     @Override  
     public User queryUserById(String id){  
         return this.queryById(User.class, id);  
     }  
       
     /*根据条件查询集合*/  
     @Override  
     public List<User> queryUserList(Query query){  
         return this.queryList(User.class, query);  
     }  
       
     /*通过条件查询单个实体*/  
     @Override  
     public User queryOneUser(Query query){  
         return this.queryOne(User.class,query);  
     }  
       
     /*分页查询*/  
     @Override  
     public List<User> getPage(Query query, int start, int size){  
         return this.getPage(User.class, query, start, size);  
     }  
       
     /*查询符合条件的记录总数*/  
     @Override  
     public Long getPageCount(Query query){  
         return this.getPageCount(User.class, query);  
     }  
       
     /*根据id删除对象*/  
     @Override  
     public void deleteById(String id){  
         this.deleteById(User.class,id);  
     }  
       
     /*删除对象*/  
     @Override  
     public void deleteUser(User user){  
         this.delete(user);  
     }  
       
     /*更新指定id的属性值*/  
     @Override  
     public void updateFirst(String id, String objName, String objValue){  
         this.updateFirst(User.class, id, objName, objValue);  
     }  
       
     /*查找更新*/  
     @Override  
     public void updateInser(Query query, Update update){  
         this.updateInser(User.class, query, update);  
     }  
       
 }  

2.6 测试如下

[java]view plaincopy 
    
 package com.mycompany.mvc.quartz;  
   
 import java.util.ArrayList;  
 import java.util.List;  
   
 import org.springframework.beans.factory.annotation.Autowired;  
 import org.springframework.data.mongodb.core.query.Criteria;  
 import org.springframework.data.mongodb.core.query.Query;  
 import org.springframework.stereotype.Service;  
   
 import com.mycompany.user.dao.UserDao;  
 import com.mycompany.user.entity.User;  
   
 @Service("jedisClusterTest")  
 public class JedisClusterTest {  
       
     @Autowired  
     private UserDao userDao;  
       
     public void JedisClusterTestMain(){  
 //      jedisClusterClient.set("tStringCluster","helloCluster");  
 //      String tString  = jedisClusterClient.get("tStringCluster");  
 //      System.out.println("JedisTest.JedisTestMain():"+tString);  
           
         try {  
             /*新增一个对象*/  
 //          User user = new User();  
 //          user.setUserName("test");  
 //          user.setDescription("password");  
 //          userDao.saveUser(user);  
 //          System.out.println("save:"+user);  
               
             /*根据id查找一个对象*/  
             String id2 = "58e59fd9e4e0310210afac74";  
             User user2 = userDao.queryUserById(id2);  
             System.out.println("queryUserById:"+user2);  
               
             /*根据条件查询集合*/  
             List<User> userList3 = new ArrayList<User>();  
             Query query3 = new Query();  
             Criteria criteria3 = Criteria.where("userName").is("test");  
             query3.addCriteria(criteria3);  
             userList3 = userDao.queryUserList(query3);  
             System.out.println("queryUserList:"+userList3);  
               
             /*单循符合条件的单个*/  
             Query query4 = new Query();  
             Criteria criteria4 = Criteria.where("_id").is("58e59fd9e4e0310210afac74");  
             query4.addCriteria(criteria4);  
             User user4 = userDao.queryOneUser(query4);  
               
             /*查询符合条件的记录数*/  
             Query query5 = new Query();  
             Criteria criteria5 = Criteria.where("_id").is("58e59fd9e4e0310210afac74");  
             query5.addCriteria(criteria5);  
             Long count = userDao.getPageCount(query5);  
             System.out.println("getPageCount:"+count);  
               
             /*分页查询*/  
             List<User> userList6 = new ArrayList<User>();  
             Query query6 = new Query();  
             Criteria criteria6 = Criteria.where("userName").is("test");  
             query6.addCriteria(criteria6);  
             userList6 = userDao.getPage(query6,4,2);  
             System.out.println("queryUserList:"+userList6);  
               
             /*删除*/  
 //          String id7 = "58e59fd9e4e0310210afac74";  
 //          userDao.deleteById(id7);  
               
             /*更新指定id的属性值*/  
             String id8 = "58e5a017e4e0311fa0d501b7";  
             userDao.updateFirst(id8,"userName","test2");  
               
         } catch (Exception e) {  
             System.out.println(e.getStackTrace());  
             e.printStackTrace();  
         }  
     }  
   
 }  

三 MongoDB GridFS存取文件

[java]view plaincopy 
    
     /*使用GridFS来新增一个文件*/  
     GridFSBucket gridFSBucket = GridFSBuckets.create(testDb);  
     String file = "src/main/resources/20150315172324.png";  
     if(!new File(file).exists()){  
         System.out.println("file is not exists");  
     }  
     String filename = "20150315172324.png";  
     BasicDBObject pic = new BasicDBObject("_id",filename);  
     GridFSFindIterable gridFSFindIterable = gridFSBucket.find(pic);  
     if(gridFSFindIterable.first() == null){  
         Object id = gridFSBucket.uploadFromStream(filename,new FileInputStream(file));  
         /**files 
          * 集合有八个属性 
 *"_id" : ObjectId("4f4608844f9b855c6c35e298"),    唯一id，可以是用户自定义的类型   
 *"filename" : "CPU.txt",     文件名   
 *"length" : 778,      文件长度   
 *"chunkSize" : 262144,    chunk的大小   
 *"uploadDate" : ISODate("2012-02-23T09:36:04.593Z")   上传时间   
 *"md5" : "e2c789b036cfb3b848ae39a24e795ca6",      文件的md5值   
 *"contentType" : "text/plain"     文件的MIME类型   
 *"meta" : null    文件的其它信息，默认是没有”meta”这个key，用户可以自己定义为任意BSON对象  
 *其中_id、filename、chunkSize、contentType、meta是可以自定义的 
 *其他如length,uploadDate和md5自己生成的。 
          */  
           
         /**chunks集合有以下属性 
 * "_id" : ObjectId("4f4608844f9b855c6c35e299"),    chunk的id   
 * "files_id" : ObjectId("4f4608844f9b855c6c35e298"),  文件的id，对应fs.files中的对象，相当于fs.files集合的外键   
 * "n" : 0,     文件的第几个chunk块，如果文件大于chunksize的话，会被分割成多个chunk块   
 * "data" : BinData(0,"QGV...")     文件的二进制数据，这里省略了具体内容   
          */  
     }  
       
     /*查找文件*/  
     BasicDBObject query  = new BasicDBObject("filename", filename);    
     GridFSFile gridFSFile = gridFSBucket.find(query).first();    
     System.out.println(gridFSFile.getFilename());  

顶

踩

hxpjava1

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
MongoDb的Java客户端配置

MongoDb的Java客户端配置一 MongoDb介绍二 Java客户端配置三 MongoDB GridFS存取文件一 MongoDb介绍MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bjson格式，因此可以存储比较复杂的数据类型。Mongo最大的特
复制链接

扫一扫

专栏目录