spring实现多数据源

配置文件数据的装配

spring boot基于完全注解的开发模式，默认的配置文件会自动读取并装配到IoC容器。

三种主要的读取方式：

默认配置文件：

method.title=spring boot读取配置文件的三种方式
method.header=three methods
method.one=@ConfigurationProperties读取配置文件并转java类
method.two=@Value读取某个属性

1. @Value直接读取属性
2. @ConfigurationProperties读取配置文件再IoC容器装配到java对象
3. Environment对象遍历封装

import com.example.demo.pojo.Method;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    //@ConfigurationProperties读取配置文件转java对象
    @Autowired
    private Method method;

    //@Value直接读取属性
    @Value("${method.header}")
    private String header;

    //Environment对象遍历读取
    @Autowired
    private Environment environment;


    @GetMapping(value = "/title")
    public String method3(){
        String title = method.getTitle();
        return title;
    }

    @GetMapping(value = "/header")
    public String method4(){
        return header;
    }

    @GetMapping(value = "/one")
    public String method5(){
        return environment.getProperty("method.one");
    }
}

多环境开发

properties文件的多环境开发：

由于spring boot的配置文件的读取是约定大于依赖所以并不会读取到一个配置文件后就不再读取其他的了，凡是application前缀的都会读取，重复或不同的会有优先级覆盖，同时命令行和配置参数都会改变配置，那么就有如下规则：

• SpringApplication会默认将命令行选项参数转换为配置信息：

java -jar myproject.jar --server.port = 9000

从命令行指定配置项的优先级最高，不过你可以通过setAddCommandLineProperties来禁用：

SpringApplication.setAddCommandLineProperties(false)

• 外部配置

外部配置主要借助idea等工具，通过该工具覆盖配置代码：

• 自定义配置文件

自定义配置文件，对于已经上线或编码好的应用，再重新配置打包部署会很麻烦，spring boot支持自定义配置文件来代替即spring boot可以使用不在项目目录下的配置文件作为主配置文件。

1. 指定同级目录下的配置文件

java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties

2. 指定任意位置下的配置文件

java -jar -Dspring.config.location=D:\config\config.properties springbootrestdemo-0.0.1-SNAPSHOT.jar

3. 还能在代码里指定

@SpringBootApplication
@PropertySource(value={"file:config.properties"})
public class SpringbootrestdemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootrestdemoApplication.class, args);
    }
}

• 外部配置文件

Spring程序会按优先级从下面这些路径来加载application.properties配置文件

1. 当前目录下的/config目录
2. 当前目录
3. classpath里的/config目录
4. classpath 跟目录

因此，要外置配置文件就很简单了，在jar所在目录新建config文件夹，然后放入配置文件，或者直接放在配置文件在jar目录

• 按Profile不同环境读取不同配置

不同环境的配置设置一个配置文件，例如：

• dev环境下的配置配置在application-dev.properties中；
• prod环境下的配置配置在application-prod.properties中；
• test环境下的配置配置在application-test.properties中。

在application.properties中指定使用哪一个文件：

spring.profiles.active = dev

当然，你也可以在运行的时候手动指定：

java -jar myproject.jar --spring.profiles.active = prod

• 配置文件的存放目录

SpringBoot配置文件默认可以放到以下目录中，可以自动读取到：

1. 项目根目录下
2. 项目根目录中config目录下
3. 项目的resources目录下
4. 项目resources目录中config目录下

• 配置文件的读取循序

如果在不同的目录中存在多个配置文件，它的读取顺序是：

    1、config/application.properties（项目根目录中config目录下）
    2、config/application.yml
    3、application.properties（项目根目录下）
    4、application.yml
    5、resources/config/application.properties（项目resources目录中config目录下）
    6、resources/config/application.yml
    7、resources/application.properties（项目的resources目录下）
    8、resources/application.yml

注：
1、如果同一个目录下，有application.yml也有application.properties，默认先读取application.properties。
2、如果同一个配置属性，在多个配置文件都配置了，默认使用第1个读取到的，后面读取的不覆盖前面读取到的。
3、创建SpringBoot项目时，一般的配置文件放置在“项目的resources目录下

中文乱码问题

中文乱码问题主要是后台编码的字符集与浏览器解码的字符集不一致造成的。如何将其改为一致呢？

• 方法一（接口声明编码集）

在接口处改变编码及，声明浏览器用utf-8的字符1解码。

@GetMapping(value = "/title", produces = "application/string;charset=UTF-8")
public String method3(){
    String title = method.getTitle();
    return title;
}

• 方法二（更改properties文件的编码格式）

server.servlet.encoding.charset=UTF-8
server.servlet.encoding.force=true
server.servlet.encoding.enabled=true

热部署

每次写完程序后都需要重启服务器，需要大量的时间，spring boot提供了一款工具devtools帮助实现热部署。

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-devtools</artifactId>
     <optional>true</optional> <!-- 可选 -->
 </dependency>

导入插件的以来后每次点击 ---->构建------>构建项目就可以了，相比重启要快的多。

整合第三方bean

在spring boot中有时需要整合第三框架，需要用到新的bean作为赋值对象，例如在整合driud框架时使用的是druid的DataSource，但spring boot整合了该框架，著需要在配置文件中声明即可：

但是如果spring boot中没有整合的第三方框架呢，就需要自己通过配置文件注入到IoC容器，再将配置信息注入到该对象中了。

例如如果不使用该方法开发者自己整合该如何做呢？

1. 新建配置类
2. 通过@ConfigurationProperties注入数据即可

@Configuration
public class MyDataSource {

    @Bean
    @ConfigurationProperties(prefix = "datasource")
    public DruidDataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl("${url}");
        dataSource.setUsername("${username}");
        dataSource.setPassword("${password}");
        dataSource.setDriverClassName("${com.mysql.jdbc.cj.Driver}");
        return dataSource;
    }
}

Spring boot整合Redis和Mongodb

在pom文件中华加入依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

spring 操作redis不像mysql那样，本生非常简洁，Spring容器中存在默认的datasource，因此不管是mybatis，druid，redis等数据库，配置那种数据源，和驱动就连接那种数据库。

因此对于Redis的操作也很简单，导入依赖，配置数据源，创建操作对象：

<dependency>
	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

spring.redis.url=localhost

在配置了spring jdbc数据源是使用了，JdbcTemplate模板，配置mybatis数据源使用@Mapper注解，在Redis中也有一个RedisTemplate模板用于操作redis数据库：

@Test
    public void method1(){
        //普通值操作
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("hello","Hello World");
        Object hello = valueOperations.get("hello");
        System.out.println(hello);

    }

redisTemplate对象有很多操作对象都是针对java 不同的数据类型的。在spring boot中使用set，存的数据发现用在redis客户端用get获取不到，原因是在spring boot中是使用redis的内置对象Object来操作的，而在客户端存取时都是字符串，因此无法直接获取，此时就需要另一个对象StringRedisTemplate如下：

@Test
    public void method1(){
        //普通值操作
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("hello","Hello World");
        Object hello = valueOperations.get("hello");
        System.out.println(hello);

    }


    @Test
    public void method2(@Autowired StringRedisTemplate redisTemplate){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("city","beijing");
        System.out.println(valueOperations.get("city"));

    }

如果用第一个模板指定范型即可

整合MongoDB

MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。

带入MongoDB的依赖：

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

配置数据源：

spring.data.mongodb.uri=mongodb://localhost/runoob

编写测试类：

插入数据：

使用java 对象作为赋值对象，进行拆查询：

@Test
    public void method1(){
        List<Book> all = mongoTemplate.findAll(Book.class,"col");
        System.out.println(all);
    }

//col是集合的名称

代码插入：

@Test
    public void method2(){
        Book book = new Book();
        book.setId(2);
        book.setTitle("hello");
        book.setUrl("http://localhost/hello");
        mongoTemplate.save(book);
        List<Book> all = mongoTemplate.findAll(Book.class);
        System.out.println(all);
    }

//代码插入的时候尽量声明集合名，默认是java bean的名称