第一次使用MongoDB,spring MVC框架整合MongoDB

Ⅰ、win7安装MongoDB
MongoDB最新文档地址:

http://docs.mongoing.com/manual-zh/reference/configuration-options.html#security-options

  1. 安装MongoDB
    官网下载window 64的版本,傻瓜式安装,按步骤next就行
    这里写图片描述

https://www.mongodb.com/download-center?jmp=nav#community

  1. 创建根目录下的data目录、log、etc文件夹
  2. 创建mongodb.conf配置文件
    etc目录下创建mongodb.conf配置文件,dbPath:改成新建的data/db目录,logPath:改成新建log目录下的.log文件。简略文档内容如下
# mongod.conf

# for documentation of all options, see:
#   http://docs.mongodb.org/manual/reference/configuration-options/

# Where and how to store data.
storage:
  dbPath: d:\data\db
  journal:
    enabled: true
#  engine:
#  mmapv1:
#  wiredTiger:

# where to write logging data.
systemLog:
  destination: file
  logAppend: true
  path: d:\log\MongoDB.log

# network interfaces
net:
  port: 27017
  #bindIp: 127.0.0.1


# how the process runs
#processManagement:
  #timeZoneInfo: /usr/share/zoneinfo

#security:
  #authorization: enabled

#operationProfiling:

#replication:

#sharding:

## Enterprise-Only Options:

#auditLog:

#snmp:

5.第一次启动, 注意要注释掉

#security:
  #authorization: enabled

首先打开cmd,进入D:\Program Files (x86)\MongoDB\Server\3.4\bin,运行命令
mongod.exe –config d:\data\etc\mongodb.conf,启动MongoDB
然后启动MongoDB服务:net start mongoDB
这里写图片描述

6.进入MongoDB的后台管理shell:mongo,然后运行命令show dbs,提示错误,没有权限
这里写图片描述
因为没有创建用户,未认证。
创建超级管理员:首先进入admin数据库,use admin,然后创建用户:
db.createUser({user:"admin",pwd:"password",roles:[{role:"userAdminAnyDatabase",db:"admin"}]})
创建成功后,使用db.auth(‘admin’,’password’),认证
这里写图片描述
7. 创建数据库:use test
数据test数据的读写用户:
db.createUser({user:"test",pwd:"password",roles:[{role:"readWrite",db:"test"}]})
db.auth(‘test’,’password’),认证
8. 重启MongoDB服务
net stop mongoDB
将mongodb.conf中的
security:
authorization: enabled

去掉备注,重启MongoDB

mongod.exe --config d:\data\etc\mongodb.conf

启动服务:net start mongoDB

9.MongoDB可视化管理工具
robomongo

链接:

http://www.cnblogs.com/zhoujinyi/p/4610050.html
http://www.cnblogs.com/silentjesse/p/4676440.html
http://blog.csdn.net/victor_cindy1/article/details/52151439


Ⅱ、Linux安装MongoDB
方式一:
1、配置yum

vim /etc/yum.repos.d/MongoDB-org-3.4.repo
[mongodb-org-3.4]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/testing/x86_64/
gpgcheck=1
enabled=1 
gpgkey=https://www.mongodb.org/static/pgp/server-3.4.asc

2、安装

yum -y install mongodb-org

方式二:
1、选择对应版本下载

https://www.mongodb.com/download-center?jmp=nav#community
这里写图片描述

2、复制到linux系统 解压 tar -xvzf mongodb-linux-x86_64-3.6.3.tgz

3、创建data、etc、log目录,创建mongodb.conf文件
文件内容为:

dbpath=/data/java/mongodb/data
logpath=/data/java/mongodb/log/MongoDB.log
port=27017
fork=true
journal=false
storageEngine=mmapv1

4、启动mongodb

./mongod --config /data/java/mongodb/etc/mongodb.conf

这里写图片描述

5、进入mongo shell
这里写图片描述
创建数据库:

user test
db.createUser({user:"test",pwd:"password",roles:[{role:"readWrite",db:"test"}]})
db.auth("test","password") 

这里写图片描述

6、关闭mongodb

use admin
db.shutdownServer()

配置文件添加

auth:true

开启认证后,重启服务

参考:

这里写链接内容

Ⅲ、Spring 集成MongoDB,已有springMVC框架

1、 maven添加MongoDB依赖

            <!-- mongoDB支持jar -->  
            <dependency>  
                <groupId>org.springframework.data</groupId>  
                <artifactId>spring-data-mongodb</artifactId>  
                <version>1.8.2.RELEASE</version>  
            </dependency>
            <dependency>  
                <groupId>org.springframework.data</groupId>  
                <artifactId>spring-data-commons</artifactId>  
                <version>1.10.0.RELEASE</version>  
            </dependency>  
            <dependency>  
                <groupId>org.mongodb</groupId>  
                <artifactId>mongo-java-driver</artifactId>  
                <version>3.4.2</version>  
            </dependency> 

2、 新建mongodb-context.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:p="http://www.springframework.org/schema/p"  
    xmlns:mongo="http://www.springframework.org/schema/data/mongo"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans   
            http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
            http://www.springframework.org/schema/data/mongo  
            http://www.springframework.org/schema/data/mongo/spring-mongo.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd"
>

    <!-- 加载mongodb的属性配置文件 -->
    <context:property-placeholder location="classpath:jeesite.properties"/>

    <!-- spring连接mongodb数据库的配置 -->  
    <mongo:mongo-client id="mongo" host="${mongo.url}" port="${mongo.port}" credentials="${mongo.credentials}">    
       <mongo:client-options write-concern="SAFE"/>    
    </mongo:mongo-client>   

    <mongo:db-factory id="mongoDbFactory" dbname="${mongo.database}" mongo-ref="mongo" />    

    <!-- 只要使用这个调用相应的方法操作 -->  
    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">    
       <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />    
    </bean> 

    <!-- 映射转换器,扫描back-package目录下的文件,根据注释,把它们作为mongodb的一个collection的映射 -->
    <mongo:mapping-converter base-package="com.thinkgem.jeesite"/>

    <!-- mongodb bean的仓库目录,会自动扫描扩展了MongoRepository接口的接口进行注入 -->
    <mongo:repositories base-package="com.thinkgem.jeesite"/>
</beans>

jeesite.properties属性配置文件如下:

mongo.url=127.0.0.1
mongo.port=27017
mongo.credentials=username:password@database
mongo.database=test

3、在spring的配置文件spring-context.xml中导入MongoDB配置文件

    <!-- 导入mongodb的配置文件 -->  
    <import resource="mongodb-context.xml" />

启动Tomcat,没有报错则基本上没有问题

4、新建类BaseMongoTemplate.java

package com.thinkgem.jeesite.common.mongodb;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.data.mongodb.core.MongoTemplate;

/**
 * MongoDB 
 * @author zhengyingshun
 * @Data 2017年7月18日
 */
public abstract class BaseMongoTemplate implements ApplicationContextAware {

    protected MongoTemplate mongoTemplate;

    /**
     * 根据配置文件设置mongoTemplate
     * @param mongoTemplate
     * @author zhengyingshun
     * @Data 2017年7月18日
     */
    public void setMongoTemplate(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException{
        MongoTemplate mongoTemplate = applicationContext.getBean(  
                "mongoTemplate", MongoTemplate.class);  
        setMongoTemplate(mongoTemplate);
    }
}

5、编写MongoDB的baseDao

package com.thinkgem.jeesite.common.mongodb;

import java.util.List;

import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;

/**
 * MongoDB 封装BaseDao
 * @author zhengyingshun
 * @Data 2017年7月18日
 */
public abstract class MongoBaseDao<T> extends BaseMongoTemplate {

    /**
     * 插入任意类型
     * @param entity
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void insert(Object entity) {
        mongoTemplate.insert(entity);
    }

    /**
     * 插入一个实体对象
     * @param bean
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public T save(T bean) {
        mongoTemplate.insert(bean);
        return bean;
    }

    /**
     * 批量新增
     * @param list
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void insert(List<T> list) {
        mongoTemplate.insertAll(list);
    }

    /**
     * 插入特定集合
     * @param bean
     * @param collectionName 集合名
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void insert(T bean, String collectionName) {
        mongoTemplate.insert(bean, collectionName);
    }

    /**
     * 批量新增到特定集合
     * @param list
     * @param collectionName 集合名
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void insert(List<T> list, String collectionName) {
        mongoTemplate.insert(list, collectionName);
    }

    /**
     * 查询并删除满足条件的第一个记录
     * @param key
     * @param value
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public T findAndRemove(String key, Object value) {
        Query query = Query.query(Criteria.where(key).is(value));
        return mongoTemplate.findAndRemove(query, this.getEntityClass());
    }

    /**
     * 获取query
     * @param key
     * @param value
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public Query getQuery(String key, Object value) {
        Query query = new Query(Criteria.where(key).is(value));
        return query;
    }

    /**
     * 获取多条件的query
     * @param key
     * @param value
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public Query getQuery(String[] key, Object[] value) {
        if (key.length == 0 || key.length != value.length) {
            return null;
        }

        Criteria criteria = Criteria.where(key[0]).is(value[0]);
        for (int i = 1; i < key.length; i++) {
            criteria.and(key[i]).is(value[i]);
        }

        Query query = new Query(criteria);

        return query;
    }

    /**
     * 查询并删除满足条件的第一个记录
     * @param key
     * @param value
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public T findAndRemove(Query query) {
        return mongoTemplate.findAndRemove(query, this.getEntityClass());
    }

    /**
     * 查询并删除满足条件的所有记录
     * @param key
     * @param value
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public List<T> findAllAndRemove(String key, Object value) {
        Query query = Query.query(Criteria.where(key).is(value));
        return mongoTemplate.findAllAndRemove(query, this.getEntityClass());
    }

    /**
     * 查询并删除满足条件的所有记录
     * @param query
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public List<T> findAllAndRemove(Query query) {
        return mongoTemplate.findAllAndRemove(query, this.getEntityClass());
    }

    /**
     * 删除满足条件的记录
     * @param key
     * @param value
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void remove(String key, Object value) {
        Query query = Query.query(Criteria.where(key).is(value));
        mongoTemplate.remove(query, this.getEntityClass());
    }

    /**
     * 删除满足条件的记录
     * @param query
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void remove(Query query) {
        mongoTemplate.remove(query, this.getEntityClass());
    }

    /**
     * 删除集合满足条件的记录
     * @param key
     * @param value
     * @param collectionName
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void remove(String key, Object value, String collectionName) {
        Query query = Query.query(Criteria.where(key).is(value));
        mongoTemplate.remove(query, collectionName);
    }

    /**
     * 删除集合满足条件的记录
     * @param query
     * @param collectionName
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void remove(Query query, String collectionName) {
        mongoTemplate.remove(query, collectionName);
    }

    /**
     * 删除实体类的集合
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void removeCollection() {
        mongoTemplate.dropCollection(this.getEntityClass());
    }

    /**
     * 删除集合
     * @param collectionName
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void removeCollection(String collectionName) {
        mongoTemplate.dropCollection(collectionName);
    }

    /**
     * 更新满足条件的第一个记录
     * @param query
     * @param update
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void updateFirst(Query query, Update update) {
        mongoTemplate.updateFirst(query, update, this.getEntityClass());
    }

    /**
     * 更新集合满足条件的第一个记录
     * @param query
     * @param update
     * @param collectionName
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void updateFirst(Query query, Update update, String collectionName) {
        mongoTemplate.updateFirst(query, update, collectionName);
    }

    /**
     * 更新满足条件的全部记录
     * @param query
     * @param update
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void updateMulti(Query query, Update update) {
        mongoTemplate.updateMulti(query, update, this.getEntityClass());
    }

    /**
     * 更新集合满足条件的全部记录
     * @param query
     * @param update
     * @param collectionName
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public void updateMulti(Query query, Update update, String collectionName) {
        mongoTemplate.updateMulti(query, update, this.getEntityClass());
    }

    /**
     * 查询符合条件的第一条数据
     * @param query
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public T find(Query query) {
        return mongoTemplate.findOne(query, this.getEntityClass());
    }

    /**
     * 查询所有符合条件的所有数据
     * @param query
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public List<T> findList(Query query) {
        return mongoTemplate.find(query, this.getEntityClass());
    }

    /**
     * 查询集合的全部数据
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public List<T> findAll() {
        return mongoTemplate.findAll(this.getEntityClass());
    }

    /**
     * 查询满足条件的记录数
     * @param query
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public int count(Query query) {
        return (int) mongoTemplate.count(query, this.getEntityClass());
    }

    /**
     * 根据主键id查询
     * @param id
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    public T findById(String id) {
        return mongoTemplate.findById(id, this.getEntityClass());
    }

    /**
     * 获取需要操作的实体类class
     * @return
     * @author zhengyingshun
     * @Data 2017年7月19日
     */
    protected abstract Class<T> getEntityClass();  
}

更新文档操作可参考:

http://www.jianshu.com/p/dd7b5a0e2f64

文档查询操作可参考:

http://www.jianshu.com/p/502dbdb7613e

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值