SpringBoot26-spingboot数据访问-NoSQL（MongDB）

         NoSQL是对于不使用关系作为数据管理的数据库系统的统称。NoSQL的主要特点是不使用SQL语言作为查询语言，数据存储也不是固定的表，字段。

        NoSQL数据库主要有文档存储型（MongoDB），图形关系存储型（Neo4j）和键值对存储型（Redis）。

        本篇先演示基于MongoDB的数据访问，下一篇将演示基于Redis的数据访问。

一，MongoDB

        MongoDB是一个基于文档（Document）的存储型的数据库，使用面向对象的思想，每条数据记录都是文档的对象。

        关于MongoDB数据库本身的知识，可以网上找资料学习，下面主要学习Spring及Spring Boot对MongoDB的支持，以及基于Spring Boot和MongoDB的实战例子。

1，Spring的支持

      Spring对MongoDB的支持主要是通过Spring Data MongoDB来实现的，Spring Data MongoDB为我们提供了如下功能。

1）Object/Document映射注解支持

       JPA提供了一套Object/Relation映射的注解（@Entity，@Id），而Spring Data MongoDB也提供了下面的注解：

@Document：映射领域对象与MongoDB的一个文档

@Id：映射当前属性是ID

@DbRef：当前属性将参考其他的文档

@Field：为文档的属性定义名称

@Version：将当前属性作为版本

2）MongoTemplate

     像JdbcTemplate一样，Spring Data MongoDB也为我们提供了一个MongoTemplate，MongoTemplate为我们提供了数据访问的方法。我们还需要为MongoClient以及MongoDbFactory来配置数据库连接属性，例如：

package com.jack.springboot9mongodb.controller;

import com.mongodb.MongoClient;
import com.mongodb.ServerAddress;
import org.springframework.context.annotation.Bean;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;

import java.net.UnknownHostException;

/**
 * create by jack 2017/10/10
 */
public class Test {
    @Bean
    public MongoClient client()throws UnknownHostException{
        MongoClient client = new MongoClient(new ServerAddress("127.0.0.1", 27017));
        return client;
    }

    @Bean
    public MongoDbFactory mongoDbFactory() throws Exception{
        String database = new MongoClientURL("mongodb://localhost/test").getDatabase();
        return new SimpleMongoDbFactory(client(), database);
    }
    
    @Bean
    public MongoTemplate mongoTemplate(MongoDbFactory mongoDbFactory)throws UnknownHostException{
        return new MongoTemplate(mongoDbFactory);
    }
    
    
}

3）Repository的支持

        类似于Spring Data JPA，Spring Data MongoDB也提供了Repository的支持，使用方式和Spring Data JPA一致，定义如下：

package com.jack.springboot9mongodb.dao;


/**
 * create by jack 2017/10/10
 */
public interface PersonRepository extends MongoRepository<Person,Integer>{
}

    类似于Spring Data JPA的开启支持方式，MongoDB的Repository的支持开启在配置类上注解@EnableMongoRepositories，例如：

package com.jack.springboot9mongodb.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;

/**
 * create by jack 2017/10/10
 */
@Configuration
@EnableMongoRepositories
public class AppConfig {
}

2，Spring Boot的支持

      Spring Boot对MongoDB的支持，分别位于：

       org.springframework.boot.autoconfigure.mongo

       主要配置数据库连接，MongoTemplate。我们可以使用以“spring.data.mongodb”为前缀的属性来配置MongoDB相关的信息。Spring Boot为我们提供了一些默认属性，如默认MongoDB的端口为27017，默认服务器为localhost，默认数据库为test。Spring Boot的主要配置如下：

spring.data.mongodb.host=#数据库主机地址，默认localhost
#数据库连接端口默认27017
spring.data.mongodb.port=27017
spring.data.mongodb.uri=mongodb://localhost/test #connection URL
spring.data.mongodb.database=
spring.data.mongodb.authentication-database=
spring.data.mongodb.grid-fs-database=
spring.data.mongodb.username=
spring.data.mongodb.password=
#repository支持是否开启，默认为已开启
spring.data.mongodb.repositories.enabled=true
spring.data.mongodb.field-naming-strategy=org.springframework.boot.autoconfigure.data.mongo

      为我们开启了对Repository的支持，即自动为我们配置了@EnableMongoRepositories。

      所以我们在Spring Boot下使用MongoDB只需引入spring-boot-starter-mongodb依赖即可，无须任何配置。

3，实战

 1）非Docker安装。若不使用Docker作为安装方式，则我们可以访问https://www.mongodb.org/downloads来下载适合自己当前操作系统的版本来安装MongoDB。

2）Docker安装。下面的例子使用的是Docker安装的方式，下载MongoDB的Docker镜像，

docker pull hub.c.163.com/public/mongodb:3.2.0

然后接下来需要通过下面命令运行Docker容器。

docker run -d -p 27017:27017 镜像id

MongoDB数据库管理软件可使用Robomongo，下载地址是http://www.robomongo.org，如下所：

2）创建Spring boot项目

      创建一个Spring Boot项目，依赖为MongoDB和web，pom.xml的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.jack</groupId>
	<artifactId>springboot9mongodb</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springboot9mongodb</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.7.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-mongodb</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.39</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

     application.properties配置信息如下：

server.port=9090
#数据库主机地址，默认localhost
#spring.data.mongodb.host=192.168.0.102
#数据库连接端口默认27017
#spring.data.mongodb.port=27017
#connection URL
spring.data.mongodb.uri=mongodb://192.168.0.102:27017/jackmongodb
#spring.data.mongodb.database=
#spring.data.mongodb.authentication-database=
#spring.data.mongodb.grid-fs-database=
#spring.data.mongodb.username=
#spring.data.mongodb.password=
#repository支持是否开启，默认为已开启
#spring.data.mongodb.repositories.enabled=true
#spring.data.mongodb.field-naming-strategy=org.springframework.boot.autoconfigure.data.mongo

3）领域模型

      本例的领域模型是人（Person），包含他工作过的地点（Location）。这个虽然和关系模型数据库的一对多类似，但还是不一样的，Location的数据只属于某个人。

      Person源码：

package com.jack.springboot9mongodb.entity;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

import java.util.Collection;
import java.util.LinkedHashSet;

/**
 * create by jack 2017/10/10
 */

/**
 * @Document注解映射领域模型和MongoDB的文档
 * 
 */
@Document
public class Person {
    /**
     * @Id注解表明这个属性为文档的Id
     */
    @Id
    private String id;
    private String name;
    private Integer age;
    /**
     * @Field注解此属性在文档中的名称为locs，location属性将以数组形式存在当前数据记录中
     */
    @Field("locs")
    private Collection<Location> locations = new LinkedHashSet<>();

    public Person(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Collection<Location> getLocations() {
        return locations;
    }

    public void setLocations(Collection<Location> locations) {
        this.locations = locations;
    }
}

Location源码如下：

package com.jack.springboot9mongodb.entity;

/**
 * create by jack 2017/10/10
 */
public class Location {
    private String place;
    private String year;

    public Location(String place, String year) {
        super();
        this.place = place;
        this.year = year;
    }

    public String getPlace() {
        return place;
    }

    public void setPlace(String place) {
        this.place = place;
    }

    public String getYear() {
        return year;
    }

    public void setYear(String year) {
        this.year = year;
    }
}

4）数据访问

package com.jack.springboot9mongodb.dao;


import com.jack.springboot9mongodb.entity.Person;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;

import java.util.List;

/**
 * create by jack 2017/10/10
 */
public interface PersonRepository extends MongoRepository<Person,Integer> {
    /**
     * 支持方法名查询
     * @param name
     * @return
     */
    Person findByName(String name);

    /**
     * 支持@Query查询，查询参数构造JSON字符串即可
     * @param age
     * @return
     */
    @Query("{'age': ?0}")
    List<Person> withQueryFindByAge(Integer age);
}

5）控制器

package com.jack.springboot9mongodb.controller;

import com.jack.springboot9mongodb.dao.PersonRepository;
import com.jack.springboot9mongodb.entity.Location;
import com.jack.springboot9mongodb.entity.Person;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;

/**
 * create by jack 2017/10/10
 */
@RestController
@RequestMapping("mongo")
public class MongoDBController {
    @Autowired
    private PersonRepository personRepository;

    /**
     * 测试保存数据
     * @return
     */
    @RequestMapping("/save")
    public Person save(){
        Person p = new Person("jack",18);
        Collection<Location> locations = new LinkedHashSet<>();
        Location loc1 = new Location("北京","2008");
        Location loc2 = new Location("上海","2009");
        Location loc3 = new Location("深圳","2010");
        Location loc4 = new Location("广州","2011");
        Location loc5 = new Location("杭州","2012");
        locations.add(loc1);
        locations.add(loc2);
        locations.add(loc3);
        locations.add(loc4);
        locations.add(loc5);
        p.setLocations(locations);
        return personRepository.save(p);
    }

    /**
     * 测试方法名查询
     * @param name
     * @return
     */
    @RequestMapping("/q1")
    public Person q1(String name){
        return personRepository.findByName(name);
    }

    /**
     * 测试@Query查询
     * @param age
     * @return
     */
    @RequestMapping("q2")
    public List<Person> q2(Integer age){
        return personRepository.withQueryFindByAge(age);
    }


}

6）运行

测试保存数据：

     访问：http://localhost:9090/mongo/save，返回如下：

    我们可以在Robomongo中查看保存后的数据，如下所示：

测试方法名查询：

       访问http://localhost:9090/mongo/q1?name=jack，返回如下图：

测试@Query查询：

       访问：http://localhost:9090/mongo/q2?age=18，返回如下所示：

代码地址：https://github.com/wj903829182/SpringCloudTwo/tree/master/springboot9mongodb