Mongodb学习笔记(二)

最新推荐文章于 2021-12-28 22:38:45 发布

sd4422739

最新推荐文章于 2021-12-28 22:38:45 发布

阅读量716

点赞数

分类专栏： Mongodb

本文链接：https://blog.csdn.net/sd4422739/article/details/49863081

版权

Mongodb 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

第一部分：

一个普通的java项目操作mongodb，添加了mongo-2.8.0.jar

代码如下：

package com.demo;

import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;

import org.bson.types.ObjectId;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.MongoException;

public class MongoDB {
	//1.建立一个Mongo的数据库连接对象
	static Mongo connection = null;
	//2.创建相关数据库的连接
	static DB db = null;
	public MongoDB(String dbName) throws UnknownHostException, MongoException{
		connection = new Mongo("127.0.0.1:27017");
		db = connection.getDB(dbName);
	}
	public static void main(String[] args) throws UnknownHostException, MongoException {
		//实例化(调用构造函数)
		MongoDB mongoDb = new MongoDB("foobar");
	    /**
	     * 1.创建一个名字叫javadb的集合
	     */
		mongoDb.createCollection("javadb");
		/**
		 * 2.为集合javadb添加一条数据
		 *   每条记录都是DBObject，可以看做每条记录都是一个Map
		 */
		DBObject dbs = new BasicDBObject();
		dbs.put("name", "uspcat.com");
		dbs.put("age", 2);
		List<String>  books = new ArrayList<String>();
		books.add("EXTJS");
		books.add("MONGODB");
		dbs.put("books", books);
		mongoDb.insert(dbs, "javadb");
		/**
		 * 3.批量插入数据
		 */
		List<DBObject> dbObjects = new ArrayList<DBObject>();
		DBObject jim = new BasicDBObject("name","jim");
		DBObject lisi = new BasicDBObject("name","lisi");
		dbObjects.add(jim);
		dbObjects.add(lisi);
		mongoDb.insertBatch(dbObjects, "javadb");
		/**
		 * 4.根据ID删除数据
		 */
		mongoDb.deleteById("502870dab9c368bf5b151a04", "javadb");
		/**
		 * 5.根据条件删除数据    
		 */
		DBObject lisi2 = new BasicDBObject();
		lisi2.put("name", "lisi");
		int count = mongoDb.deleteByDbs(lisi2, "javadb");
		System.out.println("删除数据的条数是: "+count);
		/**
		 * 6.更新操作,为集合增加email属性
		 *         使用$set  (修改器中的set修改器)
		 */
		DBObject update = new BasicDBObject();
		update.put("$set", new BasicDBObject("eamil","uspcat@126.com"));
		//因为查询器为空，所以为所以的数据都加上email属性
		mongoDb.update(new BasicDBObject(),update,false,true,"javadb");
		/**
		 * 7.查询出persons集合中的name和age
		 */
		DBObject keys = new BasicDBObject();
		keys.put("_id", false);
		keys.put("name", true);
		keys.put("age", true);
		DBCursor cursor = mongoDb.find(null, keys, "persons");
	    while (cursor.hasNext()) {
		    DBObject object = cursor.next();
		    System.out.println(object.get("name"));
	    }
	    /**
	     * 8.查询出年龄大于26岁并且英语成绩小于80分
	     */
		DBObject ref = new BasicDBObject();
		ref.put("age", new BasicDBObject("$gte",26));
		ref.put("e", new BasicDBObject("$lte",80));
		DBCursor cursor2 = mongoDb.find(ref, null, "persons");
	    while (cursor2.hasNext()) {
		    DBObject object = cursor2.next();
		    System.out.print(object.get("name")+"-->");
		    System.out.print(object.get("age")+"-->");
		    System.out.println(object.get("e"));
	    }
		/**
		 * 9.分页例子
		 */
		DBCursor cursor3 = mongoDb.find(null, null, 0, 3, "persons");
	    while (cursor3.hasNext()) {
		    DBObject object = cursor3.next();
		    System.out.print(object.get("name")+"-->");
		    System.out.print(object.get("age")+"-->");
		    System.out.println(object.get("e"));
	    }		
		//关闭连接对象
		connection.close();
	}
	/**
	 * 创建一个数据库集合
	 * @param collName 集合名称
	 * @param db  数据库实例
	 */
	public void createCollection(String collName){
		db.createCollection(collName, new BasicDBObject());
	}
	/**
	 * 为相应的集合添加数据
	 * @param dbs
	 * @param collName
	 */
	public void insert(DBObject dbs,String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		//2.插入操作
		coll.insert(dbs);
	}
	/**
	 * 为集合批量插入数据
	 * @param dbses
	 * @param collName
	 */
	public void insertBatch(List<DBObject> dbses,String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		//2.插入操作
		coll.insert(dbses);
	}
	/**
	 * 根据id删除数据
	 * @param id
	 * @param collName
	 * @return 返回影响的数据条数
	 */
	public int deleteById(String id,String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		//DBObject是接口。同时要注意数据库中id是ObjectId类型的，所以要new ObjectId(id)
		DBObject dbs = new BasicDBObject("_id", new ObjectId(id));
		int count = coll.remove(dbs).getN();
		return count;
	}
	/**
	 * 根据条件删除数据
	 * @param id
	 * @param collName
	 * @return 返回影响的数据条数
	 */	
	public int deleteByDbs(DBObject dbs,String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		int count = coll.remove(dbs).getN();
		return count;
	}
	/**
	 * 更新数据
	 * @param find 查询器
	 * @param update 更新器
	 * @param upsert 是否是更新或插入操作
	 * @param multi 是否批量更新
	 * @param collName 集合名称
	 * @return 返回影响的数据条数
	 */
	public int update(DBObject find,DBObject update,boolean upsert,boolean multi,String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		int count = coll.update(find, update, upsert, multi).getN();
		return count;
	}
	/**
	 * 查询器(分页)
	 * @param ref
	 * @param keys
	 * @param start
	 * @param limit
	 * @return
	 */
	public DBCursor find(DBObject ref, 
			DBObject keys,
			int start,
			int limit,
			String collName){
		DBCursor cur = find(ref, keys, collName);
		return cur.limit(limit).skip(start);
	}
	/**
	 * 查询器(不分页)
	 * @param ref
	 * @param keys
	 * @param start
	 * @param limit
	 * @param collName
	 * @return
	 */
	public DBCursor find(DBObject ref,
			DBObject keys,
			String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		DBCursor cur = coll.find(ref, keys);
		return cur;
	}	
}

第二部分：一个Springmvc+hibernate+mysql+mongodb项目

导入了mongo-java-driver-2.10.1.jar

（1）spring-mongodb.xml：

<?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:context="http://www.springframework.org/schema/context"  
    xmlns:mongo="http://www.springframework.org/schema/data/mongo"  
    xsi:schemaLocation="http://www.springframework.org/schema/context   
          http://www.springframework.org/schema/context/spring-context-3.0.xsd   
          http://www.springframework.org/schema/data/mongo   
          http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd   
          http://www.springframework.org/schema/beans   
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
          
          
        <!-- 加载属性配置文件 -->   
        <context:property-placeholder location="classpath*:properties/mongodb.properties"/>
          
        <!-- 定义mongo对象，对应的是mongodb官方jar包中的Mongo，replica-set设置集群副本的ip地址和端口 -->  
        <mongo:mongo id="mongo" replica-set="localhost:27017">  
            <!-- 一些连接属性的设置 -->      
            <mongo:options  
                 connections-per-host="${mongo.connectionsPerHost}"  
                 threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}"  
                 connect-timeout="${mongo.connectTimeout}" 
                 max-wait-time="${mongo.maxWaitTime}"  
                 auto-connect-retry="${mongo.autoConnectRetry}"  
                 socket-keep-alive="${mongo.socketKeepAlive}" 
                 socket-timeout="${mongo.socketTimeout}" 
                 write-number="1"  
                 write-timeout="0"  
                 write-fsync="true"/>  
        </mongo:mongo>  
                      
        <!-- mongo的工厂，通过它来取得mongo实例,dbname为mongodb的数据库名，没有的话会自动创建 -->  
        <mongo:db-factory dbname="testmongodb" mongo-ref="mongo"/>  
      
        <!-- mongodb的主要操作对象，所有对mongodb的增删改查的操作都是通过它完成 -->  
        <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">  
          <constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>  
        </bean>  
    </beans>

（2）mongodb.properties参数文件

mongo.connectionsPerHost=4  
mongo.threadsAllowedToBlockForConnectionMultiplier=20  
mongo.connectTimeout=0  
mongo.maxWaitTime=10000  
mongo.autoConnectRetry=true  
mongo.socketKeepAlive=true  
mongo.socketTimeout=0

（3）Mongodb的daoImpl实现类：

package com.mongodb.dao;

import java.util.List;
import java.util.regex.Pattern;

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.stereotype.Component;

import com.mongodb.entity.Company;


@Component("dataManager")
public class RepositoryImpl<T> implements AbstractRepository {
    @Autowired
	private MongoTemplate mongoTemplate;

    /***
     * 查找所有对象；
     */
	@Override
	public List<?> findAll(Class<?> entity) {
		return mongoTemplate.findAll(entity);

	}

	/**
	 * 
	 */
	public void findAndModify(String id) {
		//mongoTemplate.find(new Query(Criteria.where("id").is(id)), new Update().inc("age", 3));
	}

	@Override
	public List<Company> findByRegex(String regex) {
		 Pattern pattern = Pattern.compile(regex,Pattern.CASE_INSENSITIVE);   
	      Criteria criteria = new Criteria("name").regex(pattern.toString());   
	        return mongoTemplate.find(new Query(criteria), Company.class);   

	}

	/***
	 * 根据ID查找对象；
	 */
	@Override
	public Company findOne(String id,Class<?> entity) {
		 return (Company) mongoTemplate.findOne(new Query(Criteria.where("id").is(id)), entity);   
	}

	/***
	 * 添加一个实体；
	 */
	@Override
	public void insert(Object entity) {
		mongoTemplate.insert(entity);   
	}


	/***
	 * 根据ID删除一个对象；
	 */
	@Override
	public void removeOne(String id,Class<?> entity) {
		Criteria criteria = Criteria.where("id").in(id);   
        if(criteria != null){   
             Query query = new Query(criteria);   
             if(query != null && mongoTemplate.findOne(query, entity) != null)   
                 mongoTemplate.remove(mongoTemplate.findOne(query, entity));   
        }   

	}

	/***
	 * 更新实体；
	 */
	@Override
	public void updateEntity(Object entity) {
		mongoTemplate.save(entity);
	}

	/***
	 * 根据Criteria查询一个实体；
	 */
	@SuppressWarnings("hiding")
	@Override
	public <T> T findEntityByCriteria(Criteria criteria, Class<T> entity) {
		Query query=new Query();
		query.addCriteria(criteria);
		return  mongoTemplate.findOne(query, entity);
	}
	


}

（4）service层：

package com.mongodb.service;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.stereotype.Service;

import com.mongodb.entity.Company;
import com.mongodb.dao.AbstractRepository;
@Service("companyService")
public class CompanyImpl implements ICompany {
	@Autowired
	private AbstractRepository dataManager;
    /***
     * 得到全部内容
     */
	@SuppressWarnings("unchecked")//该批注的作用是给编译器一条指令，告诉它对被批注的代码元素内部的某些警告保持静默
	@Override
	public List<Company> findCompanys() {
		return (List<Company>) dataManager.findAll(Company.class);
	}
	/***
	 * 通过ID得到对象
	 */
	@Override
	public Company findCompany(String id) {
		return dataManager.findOne(id,Company.class);
	}
	/***
	 * 更新实体对象
	 */
	@Override
	public void updateCompany(Company entity) {
		 dataManager.updateEntity(entity);
	}
	/***
	 * 增加对象
	 */
	@Override
	public void addCompany(Company entity) {
		dataManager.insert(entity);
	}
	/***
	 * 根据ID号删除一个对象
	 */
	@Override
	public void delCompany(String id) {
		dataManager.removeOne(id, Company.class);
	}
	/**
	 * 根据url判断该公司是否存在
	 */
	@Override
	public Company searchCompanyByUrl(String ip){
		Company company=dataManager.findEntityByCriteria(Criteria.where("ip").ne(ip), Company.class);
		return company;
	}
}

sd4422739

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mongodb学习笔记(二)

第一部分：一个普通的java项目操作mongodb，添加了mongo-2.8.0.jar代码如下：package com.demo;import java.net.UnknownHostException;import java.util.ArrayList;import java.util.List;import org.bson.types.ObjectId;imp
复制链接

扫一扫