mongodb单机搭建

参考网站：http://www.runoob.com/mongodb/mongodb-linux-install.html

 

１.下载

https://www.mongodb.com/download-center/community

我下载的Linux版本　4.0.8　release版本

.tgz文件，通过rz命令上传到linux服务器

>tar -zxvf mongodb-linux-x86_64-4.0.8.tgz 解压

>mv mongodb-linux-x86_64-4.0.8  /  

 

２.配置环境变量

将mongodb/bin目录加入到path

>vi /etc/profile

# Mongodb Config
export MONGODB_HOME=/mongodb-linux-x86_64-4.0.8

export PATH=.:$JAVA_HOME/bin:$HADOOP_HOME/bin:$HADOOP_HOME/sbin:$HBASE_HOME/bin:$MONGODB_HOME/bin:$PATH

>source /etc/profile

 

3.创建数据库目录

MongoDB的数据存储在data目录的db目录下，但是这个目录在安装过程不会自动创建，所以你需要手动创建data目录，并在data目录中创建db目录。

以下实例中我们将data目录创建于根目录下(/)。

注意：/data/db 是 MongoDB 默认的启动的数据库路径(--dbpath)。

mkdir -p /mongodb-linux-x86_64-4.0.8/data/mongodata  数据库存放目录
mkdir -p /mongodb-linux-x86_64-4.0.8/data/mongologs\mongo.log　　日志存放目录

 

４.启动mongodb服务

>cd bin

>./mongod

好慢，日志在慢慢打印，以为启动成功了，可浏览器访问不了：

http://192.168.1.197:28017

可查看端口，显示

> netstat -lanp | grep "27017"

显示启动成功了，

>./mongo　连接客户端，

显示连接成功了，

原来

./mongod是启动服务

./mongo是启动客户端

但http://192.168.1.197:28017　还是访问不了，不知道默认端口是啥，明天再研究下。

 

 

５.配置使用过程中遇到的一些问题：

把配置信息写到配置文件中，启动服务时指定文件：

>./mongod -f ../mongodb.conf

关闭服务：指定配置文件

mongod  --shutdown　 -f 　../mongodb.conf

 

配置文件如下，在mongodb主目录下：

##端口
port=27017
##数据文件路径 需自己创建
dbpath=/mongodb-linux-x86_64-4.0.8/data/mongodata
##日志文件路径 需自己创建
logpath=/mongodb-linux-x86_64-4.0.8/data/mongologs/mongodb.log
##日志文件是否追加
logappend=true
#以后台方式运行进程
#fork=true
#开启用户认证
auth=true
#关闭http接口，默认关闭http端口访问
#httpinterface=true
#mongodb所绑定的ip地址
bind_ip =0.0.0.0
#启用日志文件，默认启用
journal=true
#这个选项可以过滤掉一些无用的日志信息，若需要调试使用请设置为false
quiet=true

　　

客户端连接：

>./mongo

 

命令区别：

./mongod　启动mongodb服务

./mongo　　客户端连接服务

 

>show dbs;   显示所有数据库

> use hz_studentroll;　　如果数据已经存在，切换到该数据库，使用该数据库；如果不存在，创建该数据库

> db    显示当前数据库

 hz_studentroll

如果真的想把这个数据库创建成功，那么必须插入一个数据。 
数据库中不能直接插入数据，只能往集合(collections)中插入数据。不需要专门创建集合，只 需要写点语法插入数据就会创建集合：

db.data_sys_log.insert({"name":"测试"})

db.data_sys_log 系统发现 data_sys_log 是一个陌生的集合名字，所以就自动创建了集合。

集合，就相当于mysql中的表

 

但是，却报错：

WriteCommandError

not authorized on hz_studentroll to execute command

看错误信息，好像是没有授权的意思

 

 

用java连接mongodb服务器，往里写数据：报错信息：

java.lang.NoSuchMethodError: org.springframework.util.Assert.isInstanceOf(Ljava/lang/Class;Ljava/lang/Object;Ljava/util/function/Supplier;)V

网上说把spring-data-mongodb的包从2.x换成1.x，

我mongodb安装的是4.0.8，spring用的是4.3.7，不想把spring-data-mongodb降版本呢，网上说spring-data-commons包冲突，一查，果然redis里也有spring-data-commons包，

一个是2.x，一个是1.x

 

Interrupted acquiring a permit to retrieve an item from the pool

　　

 

 

 

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'mongoMappingContext': 
Failed to introspect bean class [org.springframework.data.mongodb.core.mapping.MongoMappingContext] 
for lookup method metadata: could not find class that it depends on; nested exception is java.lang.NoClassDefFoundError:
 org/springframework/data/mapping/model/Property

　　

Caused by: java.lang.NoSuchMethodError: org.springframework.data.mongodb.core.MongoTemplate.save(Ljava/lang/Object;Ljava/lang/String;)V

　　

org.springframework.web.util.NestedServletException: Handler dispatch failed; nested exception is java.lang.NoSuchMethodError: 
org.springframework.data.mongodb.core.MongoTemplate.save(Ljava/lang/Object;)V

　　

各种报错，无论怎么搞都调用不了　MongoTemplate的insert,save方法

网上查的结果都是说要把版本从2.x降到1.x，可我降了，还是没用

想着调不通，就写个spring测试类利用spring-test和junit测试一下

"errmsg" : "command update requires authentication" , "code" : 13 , "codeName" : "Unauthorized"

　　

意思是没用授权，我才想起来，我配置文件加了　auth=true　这句，把这句注释掉，重新启动，再测试就ＯＫ了

 

错误信息误报啊，浪费大把的时间。

 

org.springframework.dao.DataAccessResourceFailureException: Timed out after 1000 ms while waiting to connect. 
Client view of cluster state is {type=Unknown, servers=[{address=192.168.1.197:27017, type=Unknown, state=Connecting,
exception={com.mongodb.MongoException$Network: Exception opening the socket}, caused by {java.net.ConnectException: Connection refused: connect}}]; 
nested exception is com.mongodb.MongoTimeoutException: Timed out after 1000 ms while waiting to connect. 
Client view of cluster state is {type=Unknown, servers=[{address=192.168.1.197:27017, type=Unknown, state=Connecting, 
exception={com.mongodb.MongoException$Network: Exception opening the socket}, caused by {java.net.ConnectException: 
Connection refused: connect}}]

　　

服务停了，重启下就好了。

mongod通过以下命令启动，每天连接中断了，服务也停了，又要重启，每天早上来，要先启服务，也是麻烦。

>./mongod -f ../mongo.conf　

想办法把它做成服务吧。

 

６.Linux下注册mongodb服务

进入 /etc/init.d/ 目录

>cd /etc/init.d/

创建mongodb文件

>vim mongodb

#!/bin/sh
#
# ### BEGIN INIT INFO 
# Short-Description: mongodb    
# Description: mongo db server    
### END INIT INFO    


PROGRAM=/mongodb-linux-x86_64-4.0.8/bin/mongod
MONGOPID=`ps -ef | grep 'mongod' | grep -v grep | awk '{print $2}'`

test -x $PROGRAM || exit 0

case "$1" in
  start)
     ulimit -n 3000
     echo "Starting MongoDB server"
     $PROGRAM --fork --quiet -f /mongodb-linux-x86_64-4.0.8/mongodb.conf
     echo "Started MongoDB server"
     ;;
  stop)
     echo "Stopping MongoDB server"
     if [ ! -z "$MONGOPID" ]; then
        kill -15 $MONGOPID
     fi
     echo "Stopped MongoDB server"
     ;;
  status)
     ;;
  *)
     echo "Usage: mongodb {start|stop|status}"
     exit 1
esac

exit 0

保存完毕，在执行以下几条命令即可：

# chmod +x /etc/init.d/mongodb
# chkconfig --add mongodb
# chkconfig mongodb on

执行报：mongodb 服务不支持 chkconfig

在vim mongodb开机脚本文件头加上下面两句，再执行就好了

#chkconfig: 2345 80 90
#description:auto_run

 

就可以用服务命令启动mongodb服务了　

>service mongodb start 　启动服务

>service mongodb stop　停止服务

>service mongodb status 查看状态

 

 

７.java中使用mongodb读写数据

 

１）多个字段排序：用query.with...and

query.with(new Sort(new Order(Direction.DESC, "sort"))
             .and(new Sort(Direction.DESC,"ct")));       

 

mongo基础接口类：MongoDao

import java.util.List;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;

public interface MongoDao {
    
    public <T> List<T> find(Class<T> clazz); 
  
    public <T> T findOne(Query query, Class<T> clazz);
    
    public <T> void update(Query query, Update update, Class<T> T);
    
    //批量更新
    public <T> void updatemulti(Query query, Update update, Class<T> clazz); 
   
    public <T> void save(T entity);
  
    public <T> void save(T entity,String collectionName);
    
    public <T> T findById(String id, Class<T> clazz);
  
      
    public <T> long count(Query query, Class<T> clazz);
      
    public <T> void remove(Query query, Class<T> clazz);
}

 

　

 具体业务实现类：

import java.util.Date;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
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;
import org.springframework.transaction.annotation.Transactional;

import com.mongodb.WriteResult;
import com.uws.base.model.SysLogMongo;
import com.uws.commons.utils.DateTools;
import com.uws.commons.utils.PageInfo;
import com.uws.commons.utils.StringUtils;

@Transactional(rollbackFor=Exception.class) 
public class SysLogMongoDao<T> implements MongoDao{  
    
    @Autowired
    private MongoTemplate mongoTemplate;

    @Override
    public <T> List<T> find(Class<T> clazz) {
        return mongoTemplate.findAll(clazz);
    }

    @Override
    public <T> T findOne(Query query, Class<T> clazz) {
        return mongoTemplate.findOne(query, clazz);
    }

    @Override
    public <T> void update(Query query, Update update, Class<T> T) {
        mongoTemplate.updateFirst(query, update, T);
    }

    @Override
    public <T> void updatemulti(Query query, Update update, Class<T> clazz) {
        mongoTemplate.updateMulti(query, update, clazz);
    }

    @Override
    public <T> void save(T entity) {
        mongoTemplate.save(entity);
    }

    @Override
    public <T> T findById(String id, Class<T> clazz) {
        return mongoTemplate.findById(id, clazz);
    }

    @Override
    public <T> long count(Query query, Class<T> clazz) {
        return mongoTemplate.count(query, clazz);
    }

    @Override
    public <T> void remove(Query query, Class<T> clazz) {
        mongoTemplate.remove(query, clazz);
    }

    @Override
    public void save(Object objectToSave, String collectionName) {
        mongoTemplate.save(objectToSave, collectionName);
    }

    public void findByPage(PageInfo pageInfo,Class clazz, String collectionName) {
        Query query = Query.query(Criteria.where("loginName").is("系统管理员"));
        // 每页五个
        //mongodb页面从0开始
        Pageable pageable = new PageRequest(pageInfo.getNowpage()-1, pageInfo.getPagesize());
        query.with(pageable);
        // 排序
        query.with(new Sort(Direction.DESC, "createTime"));
        // 查询总数
        int count = (int) mongoTemplate.count(query, clazz, collectionName);
        List list = (List) mongoTemplate.find(query, clazz, collectionName);
        
        pageInfo.setRows(list);
        pageInfo.setTotal(count);
    }
public void insertOne(Object object) {
        this.mongoTemplate.insert(object);
    }

    /**
     * 系统日志删除
     * @param flag
     * @return
     */
    public boolean deleteSysLog(String flag) {
        int result=-1;
        if("all".equals(flag)) {
            Query query = new Query();
            WriteResult res = this.mongoTemplate.remove(query, "data_sys_log");
            result = res.getN();
        }else {//最近三个月
            Date dateTime = DateTools.addMonth(new Date(),-3);
            Query query = Query.query(Criteria.where("createTime").lte(dateTime));
            WriteResult res = this.mongoTemplate.remove(query, "data_sys_log");
            result = res.getN();
        }
        return result>=0;
    }

    public void findByPage(PageInfo pageInfo, SysLogMongo syslogVo, String collectionName) {
        Criteria criteria = new Criteria();
        Criteria criteriaName = new Criteria();
        Criteria criteriaIp = new Criteria();
        Criteria criteriaTime = new Criteria();
        Query query = new Query();
        if(StringUtils.isNotBlank(syslogVo.getLoginName())){
            criteriaName = Criteria.where("loginName").is(syslogVo.getLoginName());
        }
        if(StringUtils.isNotBlank(syslogVo.getClientIp())) {
            criteriaIp = Criteria.where("clientIp").is(syslogVo.getClientIp());
        }
        if(syslogVo.getStartTime()!=null && syslogVo.getEndTime()!=null) {
            criteriaTime = Criteria.where("createTime").gte(syslogVo.getStartTime()).lte(syslogVo.getEndTime());
        }else if(syslogVo.getStartTime()!=null && syslogVo.getEndTime()==null) {
            criteriaTime = Criteria.where("createTime").gte(syslogVo.getStartTime());
        }else if(syslogVo.getStartTime()==null && syslogVo.getEndTime()!=null) {
            criteriaTime = Criteria.where("createTime").lte(syslogVo.getEndTime());
        }
        criteria.andOperator(criteriaName,criteriaIp,criteriaTime);
        query.addCriteria(criteria);
        //mongodb页面从0开始
        Pageable pageable = new PageRequest(pageInfo.getNowpage()-1, pageInfo.getPagesize());
        query.with(pageable);
        // 排序
        if(StringUtils.isNotBlank(pageInfo.getSort()) && StringUtils.isNotBlank(pageInfo.getOrder())) {
            Sort sort = new Sort(pageInfo.getSort(),pageInfo.getOrder());
            query.with(sort);
        }
        // 查询总数
        int count = (int) mongoTemplate.count(query, SysLogMongo.class, collectionName);
        List list = (List) mongoTemplate.find(query, SysLogMongo.class, collectionName);
        
        pageInfo.setRows(list);
        pageInfo.setTotal(count);
    }
} 

注意：mongondb分页是从０开始的，我前台传参数是从1开始，所以要-1

 

ＭongoService基础服务类：

import java.util.Map;
import com.uws.commons.utils.PageInfo;

public interface MongoService {

    public void save(Object object);
    
    public void save(Object object,String collectionName);
    
    /**
     * 没有查询条件，不排序，查询所有的
     * @param pageInfo
     * @param clazz
     * @param collectionName
     */
    public void findByPage(PageInfo pageInfo,Class clazz, String collectionName);
    
    /**
     * 有查询条件，有排序字段
     * @param pageInfo
     * @param clazz
     * @param collectionName
     * @param parameter
     * @param order
     */
    public void findByPage(PageInfo pageInfo,Class clazz, String collectionName,Map parameter,Map order);
}

具体服务类：

import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;

import com.uws.base.model.SysLogMongo;
import com.uws.commons.mongo.dao.SysLogMongoDao;
import com.uws.commons.utils.PageInfo;

public class SysLogMongoService implements MongoService{

    
    @Autowired
    private SysLogMongoDao mongoDao;
    
    public void save(Object object) {
        this.mongoDao.insertOne(object);
    }
    
    public void save(Object object,String collectionName) {
        this.mongoDao.save(object,collectionName);
    }
    
    /**
     * @param pageInfo
     * @param clazz
     * @param collectionName
     */
    public void findByPage(PageInfo pageInfo,Class clazz, String collectionName){
        this.mongoDao.findByPage(pageInfo,clazz,collectionName);
    }
    
    /**
     * 有查询条件，有排序字段
     * @param pageInfo
     * @param clazz
     * @param collectionName
     * @param parameter
     * @param order
     */
    public void findByPage(PageInfo pageInfo,Class clazz, String collectionName,Map parameter,Map order){
        this.mongoDao.findByPage(pageInfo,clazz,collectionName,parameter,order);
    }

    public boolean deleteSysLog(String flag) {
        return this.mongoDao.deleteSysLog(flag);
    }

    public void findByPage(PageInfo pageInfo, SysLogMongo syslogVo, String collectionName) {
        this.mongoDao.findByPage(pageInfo, syslogVo, collectionName);
    }
}