mongdb的使用

805 阅读2分钟

一、docker安装mongdb

1、从dockerHub官网获取镜像

  • docker pull mongo

2、这里的--name 放在前面并映射端口

  • docker run --name some-mongo -p 27017:27017 -d mongo --auth

3、进入容器

  • docker exec -it 容器ID /bin/bash

4、进入容器内部,创建用户,然后退出

mongo  
 
use admin
 
db.createUser({user:"root",pwd:"root",roles:[{role:'root',db:'admin'}]})   //创建用户,此用户创建成功,则后续操作都需要用户认证
 
exit  

二、mongdb插入文档

1、插入文档

>db.user.insert({title: '人员信息', 
    description: '人员描述',
    by: '身份证获取',
    url: 'http://www.fhero.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})

以上实例中 col 是我们的集合名,如果该集合不在该数据库中, MongoDB 会自动创建该集合并插入文档

三、Morphia 框架的使用

1、加入依赖

<dependencies>
    <dependency>
        <groupId>xyz.morphia</groupId>
        <artifactId>morphia</artifactId>
        <version>1.4.0</version>
    </dependency>
</dependencies>

2、加载实体和

@Configuration
public Datastore morphiaConfig(){
    @Value("${host}")
    private String host;
    @Value("${port}")
    private String port
    @Value("${Database}")
    private String Database;
     final Morphia morphia = new Morphia();
        // tell morphia where to find your classes
        // can be called multiple times with different packages or classes
        morphia.mapPackage("xyz.morphia.example");

        // create the Datastore connecting to the database running on the default port on the local host
        final Datastore datastore = morphia.createDatastore(new MongoClient(host),port,Database);
        datastore.getDB().dropDatabase();
        datastore.ensureIndexes();
        return datastore;
}

3、实体

@Entity("employees")
@Indexes(@Index(value = "salary", fields = @Field("salary")))
class Employee {
    @Id
    private ObjectId id;
    private String name;
    private Integer age;
    @Reference
    private Employee manager;
    @Reference
    private List<Employee> directReports = new ArrayList<Employee>();
    @Property("wage")
    private Double salary;

    public Employee() {
    }

    public Employee(final String name, final Double salary) {
        this.name = name;
        this.salary = salary;
    }

    public List<Employee> getDirectReports() {
        return directReports;
    }

    public void setDirectReports(final List<Employee> directReports) {
        this.directReports = directReports;
    }

    public ObjectId getId() {
        return id;
    }

    public Employee getManager() {
        return manager;
    }

    public void setManager(final Employee manager) {
        this.manager = manager;
    }

    public String getName() {
        return name;
    }

    public void setName(final String name) {
        this.name = name;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(final Double salary) {
        this.salary = salary;
    }
}

必须加无参构造器,不然会报错

4、持久层

 final Employee elmer = new Employee("Elmer Fudd", 50000.0);
        datastore.save(elmer);

        final Employee daffy = new Employee("Daffy Duck", 40000.0);
        datastore.save(daffy);

        final Employee pepe = new Employee("Pepé Le Pew", 25000.0);
        datastore.save(pepe);

        elmer.getDirectReports().add(daffy);
        elmer.getDirectReports().add(pepe);

        datastore.save(elmer);

        Query<Employee> query = datastore.find(Employee.class);
        final List<Employee> employees = query.asList();

        Assert.assertEquals(3, employees.size());

        List<Employee> underpaid = datastore.find(Employee.class)
                                            .filter("salary <=", 30000)
                                            .asList();
        Assert.assertEquals(1, underpaid.size());

        underpaid = datastore.find(Employee.class)
                             .field("salary").lessThanOrEq(30000)
                             .asList();
        Assert.assertEquals(1, underpaid.size());

        final Query<Employee> underPaidQuery = datastore.find(Employee.class)
                                                        .filter("salary <=", 30000);
        final UpdateOperations<Employee> updateOperations = datastore.createUpdateOperations(Employee.class)
                                                                     .inc("salary", 10000);

        final UpdateResults results = datastore.update(underPaidQuery, updateOperations);

        Assert.assertEquals(1, results.getUpdatedCount());

        final Query<Employee> overPaidQuery = datastore.find(Employee.class)
                                                       .filter("salary >", 100000);
        datastore.delete(overPaidQuery);

四、Morphia使用示例

1、插入文档

 @Resource
 private Datastore datastore;
 
 datastore.save(sendSmsModel);

2、查看已插入文档

单个条件查询:
Query<UserDTO> query = datastore.createQuery(UserDTO.class);
    return query.field(FIELD_TASK_ID).equal(taskId).asList();
    
    List<UserDTO> taskTraceList =  datastore.createQuery(UserDTO.class)
            .search(String.valueOf(taskId))
            .order("_id")
            .asList();
            
多个条件查询:
 UserDTO userDTO=datastore.find(UserDTO.class).field("wstBusinessNo").equal(wstBusinessNo)
        .field("wstTaskTypeCd").equal(wstTaskTypeCd)
        .field("wstTaskStatusCd").equal(wstTaskStatusCd).get();

3、更新数据

UserDTO userDTO =datastore.find(UserDTO.class).field("wstBusinessNo").equal(wstBusinessNo)
        .field("wstTaskTypeCd").equal(wstTaskTypeCd)
        .field("wstTaskStatusCd").equal(wstTaskStatusCd)
        .get();
    UpdateOperations<UserDTO> updateOperations = datastore.createUpdateOperations(UserDTO.class).set("wstTaskStatusCd",newTaskStatusCd);
    UpdateResults results = datastore.update(userDTO,updateOperations);
    }

4、删除数据

      if(StringUtils.isNotBlank(userDTO.getCertNo())){
        datastore.delete(datastore.createQuery(UserDTO.class).field("userId").equal(userDTO.getUserId()));
      }