mongodb 学习

mongodb 学习

相关用户名密码

192.168.1.2 admin/xmwefun
localhost   test1/test1

mongodb://test1:test1@localhost:27017/admin

docker 中 mongo 操作

# 进入mongo的shell交互平台
mongo
# 查看当前的数据库
db
# 查看所有数据库--好像没效果--存在数据时才会展示
show dbs
# 插入数据
db.runoob.insert({'name': 'helloworld'})
# 使用test数据库-不存在时会直接创建数据库
use test
# 用户登录
db.auth('test1', 'test1')

# 创建集合创建表
db.createCollection('user')
# 展示所有表
show tables
show collections
# 删除表
db.user.drop()

# 插入数据
db.COLLECTION_NAME.insert
db.COLLECTION_NAME.save
# 查看数据
db.fmzh.find()
db.repo.find()

# 更新数据
db.collection.update(
   <query>,
   <update>,
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>
   }
)

db.fmzh.update({'test': 'test insert is first db'}, {$set:{'test': 'mongodb'}})

# 删除数据
db.collection.remove(
   <query>,
   {
     justOne: <boolean>,
     writeConcern: <document>
   }
)
 db.fmzh.remove({'test': 'mongodb'})

# 导入数据
mongoimport --authenticationDatabase admin  --username foursquare --password foursquare --db foursquare --collection foursquare_tips --file foursquare_tips.json --jsonArray

mongoimport --authenticationDatabase admin  --username foursquare --password foursquare --db foursquare --collection foursquare_user --file foursquare_user.json --jsonArray

spring 中 mongoTemplate 的使用

1. 工具类

## 使用MongoRepository
import org.jeecg.modules.foursquare.entity.FoursquareUser;
import org.springframework.data.mongodb.repository.MongoRepository;

public interface IFoursquareUserDao extends MongoRepository<FoursquareUser, String> {
}


## 使用mongoTemplate
import com.alibaba.fastjson.JSON;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.bson.Document;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.Pageable;
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 javax.annotation.Resource;
import java.lang.reflect.ParameterizedType;
import java.util.Collection;
import java.util.List;
import java.util.Map;

public class BaseDao<T> {

    @Resource
    private MongoTemplate mongoTemplate;

    /**
     * 获取泛型Class
     */
    private Class<T> clazz = (java.lang.Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];

    /**
     * 获取base template
     *
     * @return
     */
    public MongoTemplate getMongoTemplate() {
        return mongoTemplate;
    }

    /**
     * 分页查找数据
     *
     * @param query
     * @param pageable
     * @return
     */
    public Page<T> find(Query query, Pageable pageable) {
        long size = mongoTemplate.count(query, clazz);

        query.skip(pageable.getOffset());
        query.limit(pageable.getPageSize());

        List<T> listTips = find(query);

        return new PageImpl<T>(listTips, pageable, size);
    }

    /**
     * 根据条件查询记录
     *
     * @param query
     * @return
     */
    public List<T> find(Query query) {
        return mongoTemplate.find(query, clazz);
    }

    /**
     * 查询集合全部记录
     *
     * @return
     */
    public List<T> findAll() {
        return mongoTemplate.findAll(clazz);
    }

    /**
     * 根据ID获取记录
     *
     * @param id
     * @return
     */
    public T findById(String id) {
        return mongoTemplate.findById(id, clazz);
    }

    /**
     * 根据条件查询一条记录
     *
     * @param query
     * @return 即便多条记录也只会返回第一条
     */
    public T findOne(Query query) {
        return mongoTemplate.findOne(query, clazz);
    }

    /**
     * 新增记录
     *
     * @param t
     * @return
     */
    public T insert(T t) {
        return mongoTemplate.insert(t);
    }

    /**
     * 批量新增记录
     *
     * @param list
     * @return
     */
    public Collection<T> insertAll(Collection<? extends T> list) {
        return mongoTemplate.insertAll(list);
    }

    /**
     * 根据ID更新记录，对象属性全部更新
     *
     * @return
     */
    public UpdateResult updateById(T t) {
        Query query = new Query(Criteria.where("id").is(getIdByObject(t)));
        Update update = getUpdateByObjectAllField(t);
        return mongoTemplate.updateMulti(query, update, clazz);
    }

    /**
     * 根据ID更新记录，仅更新不为null属性的对象
     *
     * @return
     */
    public UpdateResult updateByIdSelective(T t) {
        Query query = new Query(Criteria.where("id").is(getIdByObject(t)));
        Update update = getUpdateByObjectNotNullField(t);
        return mongoTemplate.updateMulti(query, update, clazz);
    }

    /**
     * 根据条件批量更新记录
     *
     * @return
     */
    public UpdateResult update(Query query, Update update) {
        return mongoTemplate.updateMulti(query, update, clazz);
    }

    /**
     * 根据条件删除记录
     *
     * @param query
     * @return
     */
    public DeleteResult delete(Query query) {
        return mongoTemplate.remove(query, clazz);
    }

    /**
     * 根据ID删除记录
     *
     * @param id
     * @return
     */
    public DeleteResult deleteById(String id) {
        Query query = new Query(Criteria.where("id").is(id));
        return mongoTemplate.remove(query, clazz);
    }

    /**
     * 查询一条记录并删除这条记录
     *
     * @param query
     * @return
     */
    public T deleteOneAndReturn(Query query) {
        return mongoTemplate.findAndRemove(query, clazz);
    }

    /**
     * 根据条件查询全部记录并删除
     *
     * @param query
     * @return
     */
    public List<T> deleteAllAndReturn(Query query) {
        return mongoTemplate.findAllAndRemove(query, clazz);
    }

    /**
     * 根据ID，若数据库存在则更新数据，若数据库不存在则新增数据
     *
     * @param t
     * @return
     */
    public UpdateResult upsertById(T t) {
        Query query = new Query(Criteria.where("id").is(getIdByObject(t)));
        Update update = getUpdateByObjectAllField(t);
        return mongoTemplate.upsert(query, update, clazz);
    }

    /**
     * 从对象中获取ID属性值
     *
     * @return
     */
    private Object getIdByObject(T t) {
        try {
            return t.getClass().getDeclaredField("id");
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(clazz.getName() + "类不存在id属性");
        }
    }

    /**
     * 将对象的所有属性设置进update
     *
     * @param t
     * @return
     */
    private Update getUpdateByObjectAllField(T t) {
        Document document = Document.parse(JSON.toJSONString(t));
        Update update = new Update();
        for (Map.Entry<String, Object> entry : document.entrySet()) {
            update.set(entry.getKey(), entry.getValue());
        }
        return update;
    }

    /**
     * 将对象内不为null的属性设置进update
     *
     * @param t
     * @return
     */
    private Update getUpdateByObjectNotNullField(T t) {
        Document document = Document.parse(JSON.toJSONString(t));
        Update update = new Update();
        for (Map.Entry<String, Object> entry : document.entrySet()) {
            if (entry.getValue() != null) {
                update.set(entry.getKey(), entry.getValue());
            }
        }
        return update;
    }
}

2. 持久化类使用 Document、 Field 注解

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.bson.types.ObjectId;
import org.jeecgframework.poi.excel.annotation.Excel;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
import org.springframework.format.annotation.DateTimeFormat;

import java.io.Serializable;
import java.util.Date;

@Data
@Document("foursquare_tips")
@TableName("foursquare_tips")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@ApiModel(value = "foursquare_tips对象", description = "foursquare_tips")
public class MongoFoursquareTips implements Serializable {
    private static final long serialVersionUID = 1L;

    @Id
    @TableField(exist = false)
    private ObjectId objectId;

    /**
     * id
     */
    @TableId(type = IdType.AUTO)
    @ApiModelProperty(value = "id")
    private Integer id;
    /**
     * 场景ID
     */
    @Excel(name = "场景ID", width = 15)
    @ApiModelProperty(value = "场景ID")
    private String venueId;
    /**
     * 用户id
     */
    @Excel(name = "用户id", width = 15)
    @ApiModelProperty(value = "用户id")
    @Field(value = "user_id")
    private Integer userId;
    /**
     * 评论ID
     */
    @Excel(name = "评论ID", width = 15)
    @ApiModelProperty(value = "评论ID")
    @Field(value = "tips_id")
    private String tipsId;
    /**
     * 评论内容
     */
    @Excel(name = "评论内容", width = 15)
    @ApiModelProperty(value = "评论内容")
    @Field(value = "tips_text")
    private String tipsText;
    /**
     * 评论时间
     */
    @Excel(name = "评论时间", width = 15, format = "yyyy-MM-dd HH:mm:ss")
    @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @ApiModelProperty(value = "评论时间")
    @Field(value = "createdAt")
    private String createdat;
}

高阶用法

1. 关系引用
2. map reduce
3. 查询分析\索引
4. 读写分离

问题

1. command insert requires authentication
   ，，创建对应数据库的权限用户，，切换数据库，即可

# 切换admin数据库
use admin
# 管理员用户登录
db.auth('test1', 'test1')
# 创建对应数据库的权限用户
db.createUser({user: 'fmzh', pwd: 'fmzh', roles: [{role: 'readWrite', db: 'fmzh'}]})
# 重新用新用户登录
db.auth('fmzh', 'fmzh')
# 切换数据库
use fmzh
# 验证
db.repo.insert({'name': 'hello world'})

2. auth error: sasl conversation error: unable to authenticate using mechanism “SCRAM-SHA-1”

# 导入脚本添加参数

--authenticationDatabase admin

3. Failed: cannot decode array into a D

# 添加参数

 --jsonArray

4. Exception authenticating MongoCredential and Uncategorized Mongo Db Exception

spring.data.mongodb.authentication-database=admin

spring.data.mongodb.uri=mongodb://user:passwod@localhost/test?authSource=admin

5. converter found capable of converting from type [org.bson.types.ObjectId] to type [long]

import org.bson.types.ObjectId;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.format.annotation.DateTimeFormat;

@Document("foursquare_user")
public class FoursquareUser {

    @Id
    private ObjectId objectId;

6.

参考

1. 菜鸟教程
2. command insert requires authentication
3. mongo 之 java 驱动
4. mongo 之查询对照
5. mongo 之 java 示例
6. sasl c onversation error: unable to authenticate using mechanism…
7. Failed: cannot decode array into a D
8. Exception authenticating MongoCredential and Uncategorized Mongo Db Exception
9. How the ‘_id’ field is handled in the mapping layer