重新定义cloud 第12章 Srping Cloud Config下篇

浅浅的花香味﹌ 2022-11-22 10:25 147阅读 0赞

*  客户端自动刷新
 *  客户端回退
 *  安全认证
 *  客户端高可用
 *  服务端高可用
 *  portal操作 apollo

# 服务店 git配置详细与 实战 #

*  git中 URI 占位符
 *  模式匹配 和 多个存储库
 *  路径搜索占位符

## 公共的依赖 ##

*  start-web
 *  starter-test
 *  starter-actuator

## config server ##

*  config-server 依赖
 *  @EnableConfigServer
 *  application.yml配置如下
    
        spring:
          cloud:
            config:
              server:
                git:
                  uri: https://gitee.com/zhongzunfa/{ application}
                  #username:
                  #password:
                  search-paths: SC-BOOK-CONFIG
          application:
            name: ch12-1-config-server-placeholders
        server:
            port: 9090
        logging:
          level:
            root: debug
 *  \{application\} 下面说明

## config client ##

*  pom 引用config-client

### 展示配置的代码不变 ###

@RestController
    public class ConfigClientController { 
    
        @Autowired
        private ConfigInfoProperties configInfoValue;
    
        @RequestMapping("/getConfigInfo")
        public String getConfigInfo(){ 
            return configInfoValue.getConfig();
        }
    }
    
    @Component
    @ConfigurationProperties(prefix = "cn.springcloud.book")
    public class ConfigInfoProperties { 
    
        private String config;
    
        public String getConfig() { 
            return config;
        }
    
        public void setConfig(String config) { 
            this.config = config;
        }
    }

### application.yml 是基础配置 ###

server:
      port: 9100
    
    spring:
      application:
        name: ch12-1-config-client-placeholders

### bootstrap.yml 拉去server的配置 ###

spring:
        cloud:
            config:
                label: master
                uri: http://localhost:9090
                name: spring-cloud-config
                profile: dev

*  uri是\{application\}匹配模式，添加了 search-paths
 *  仓库地址会变成：https://gitee.com/zhongzunfa/spring-cloud-config
 *  而server端 又配置了 SC-BOOK-CONFIG （不太懂）

## 测试 ##

*  启动 client ，server端 将会去拉去这个配置
 *  name=https://gitee.com/zhongzunfa/spring-cloud-config/SC-BOOK-CONFIG/spring-cloud-config.yml\]
 *  访问：http://localhost:9100/getConfigInfo 读取到配置
 *  仓库名称 和 仓库下面的配置文件 名称一致。spring.cloud.config.name 默认匹配 spring.application.name

### 总结为： ###

*  server在原来的基础上改动：
    
     *  uri: https://gitee.com/zhongzunfa/\{application\}
 *  client 指向的name改成：name: spring-cloud-config (读取的目录是这个，读取的文件也是这个)
 *  name文件会读取：
    
        spring-cloud-config/ SC-BOOK-CONFIG / spring-cloud-config.yml

# 模式匹配和多个存储库 #

*  \{application\}/\{profile\}匹配

## config server 的 application.yml ##

spring:
      cloud:
        config:
          server:
            git:
              uri: https://gitee.com/zhongzunfa/spring-cloud-config
              search-paths: SC-BOOK-CONFIG
              repos:
                simple: https://gitee.com/zhongzunfa/simple
                special:
                    pattern: special*/dev*,*special*/dev*
                    uri: https://gitee.com/zhongzunfa/spring-cloud-config-special
                local:
                  pattern: local*
                  uri: /Users/zhongzunfa/all_test/spring-cloud-config
    
      application:
        name: ch12-2-config-server-multiple-repositories
    server:
        port: 9090
    logging:
      level:
        root: debug

## config client ##

bootstrap.yml

spring:
        cloud:
            config:
                label: master
                uri: http://localhost:9090
                name: spring-cloud-config
                profile: config-info

## 路径搜索占位符 ##

search-paths: SC-BOOK-CONFIG*
    代表 所有这个开头的

spring:
      cloud:
        config:
          server:
            git:
              uri: https://gitee.com/zhongzunfa/spring-cloud-config
              search-paths: SC-BOOK-CONFIG
    
              clone-on-start: true //合法的将远程仓库，克隆到本地
              search-paths: *{ application}*
              //或者 searchPaths: '{application}'

# 关系型数据库的配置中心的实现 #

## config-server-db ##

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-config-server</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>

*  spring cloud config默认配置方式：spring-jdbc
 *  主 注解上依然是 开启configServer

@EnableConfigServer

### application.yml ###

server:
      port: 9090
    spring:
      application:
        name: ch12-3-config-server-db
      cloud:
        config:
          server:
            jdbc: #调用时，使用的sql
              sql: SELECT `KEY`, `VALUE` FROM PROPERTIES WHERE application =? AND profile =? AND lable =?
          label: master
        refresh:
            refreshable: none #解决DataSource循环依赖的问题
      profiles:
        active: jdbc #使用的激活方式是 jdbc
    
      ## 数据配置
      datasource:
        url: jdbc:mysql://127.0.0.1:3306/spring-cloud?useUnicode=true&characterEncoding=UTF-8
        username: root
        password: 123456
        driver-class-name: com.mysql.jdbc.Driver
    logging:
      level:
        org.springframework.jdbc.core: DEBUG
        org.springframework.jdbc.core.StatementCreatorUtils: Trace

### sql ###

-- 创建类型
    CREATE TABLE `PROPERTIES` (
      `ID` int(11) NOT NULL AUTO_INCREMENT,
      `KEY` TEXT DEFAULT NULL,
      `VALUE` TEXT DEFAULT NULL,
      `APPLICATION` TEXT DEFAULT NULL,
      `PROFILE` TEXT DEFAULT NULL,
      `LABLE` TEXT DEFAULT NULL,
      PRIMARY KEY (`ID`)
    ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
    
    INSERT INTO `spring-cloud`.`properties` (`ID`, `KEY`, `VALUE`, `APPLICATION`, `PROFILE`, `LABLE`) VALUES ('3', 'cn.springcloud.book.config', 'I am the mysql configuration file from dev environment.', 'config-info', 'dev', 'master');
    INSERT INTO `spring-cloud`.`properties` (`ID`, `KEY`, `VALUE`, `APPLICATION`, `PROFILE`, `LABLE`) VALUES ('4', 'cn.springcloud.book.config', 'I am the mysql configuration file from test environment.', 'config-info', 'test', 'master');
    INSERT INTO `spring-cloud`.`properties` (`ID`, `KEY`, `VALUE`, `APPLICATION`, `PROFILE`, `LABLE`) VALUES ('5', 'cn.springcloud.book.config', 'I am the mysql configuration file from prod environment.', 'config-info', 'prod', 'master');

## config-client ##

bootstrap.yml

spring:
        cloud:
            config:
                label: master
                uri: http://localhost:9090
                name: config-info
                profile: dev

application.yml

spring:
      application:
        name: ch12-3-config-client-db
    
    server:
      port: 9096
    
    logging:
          level:
              root: INFO

访问：

http://localhost:9096/configConsumer/getConfigInfo

# 菲关系型 数据库的配置中心的实现 #

## config server ##

*  使用mongoDB
    
        <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-config-server-mongodb</artifactId>
                    <version>0.0.2.BUILD-SNAPSHOT</version>
                </dependency>
 *  开启配置
    
        @EnableMongoConfigServer
 *  application.yml 配置
    
        server:
          port: 9090
        
        spring:
          application:
            name: ch12-4-config-server-mongodb
          data:
              mongodb:
                uri: mongodb://localhost/springcloud
 *  导入配置
    
        { 
          "label" : "master",
          "profile" : "prod",
          "source" : { 
            "cn" : { 
              "springcloud" : { 
                "book" : { 
                  "config" : "I am the mongdb configuration file from dev environment. I will edit."
                }
              }
            }
          }
        }

## config client ##

bootstrap.yml

spring:
        cloud:
            config:
                label: master
                uri: http://localhost:9090
                name: config
                profile: prod

*  当提交 db 后，调用 config-servcer的刷新接口，即可实现 自动刷新。感觉是client端的刷新接口才行啊。

# Spring Cloud Config 功能扩展 #

## 客户端自动刷新 (厉害了) ##

### config-client ###

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-autoconfigure</artifactId>
            </dependency>

#### 创建自动配置类 ####

@ConditionalOnClass(RefreshEndpoint.class) //如果这个类存在，才配置
    @ConditionalOnProperty("spring.cloud.config.refreshInterval") //如果这个属性存在 才配置
    @AutoConfigureAfter(RefreshAutoConfiguration.class) //自动配置 在这个类之后
    @Configuration //是个 配置类
    public class ConfigClientRefreshAutoConfiguration implements SchedulingConfigurer {  //继承定时器
    
        //打印日志
        private static final Log logger = LogFactory.getLog(ConfigClientRefreshAutoConfiguration.class);
    
        /** * 间隔刷新时间 */
        @Value("${spring.cloud.config.refreshInterval}")
        private long refreshInterval;
    
        /** * 刷新的端点 */
        @Autowired
        private RefreshEndpoint refreshEndpoint;
    
    
        @Override
        public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) { 
            //定时执行的间隔时间
            final long interval = getRefreshIntervalInMilliseconds();
    
            logger.info(String.format("Scheduling config refresh task with %s second delay", refreshInterval));
            scheduledTaskRegistrar.addFixedDelayTask(new IntervalTask(new Runnable() { 
                @Override
                public void run() { 
                    refreshEndpoint.refresh();
                } //执行的路基是刷新端点
            }, interval, interval));//两个参数 都是毫秒
        }
    
        /** * 以毫秒为单位返回刷新间隔。. * @return */
        private long getRefreshIntervalInMilliseconds() { 
            //配置的秒 * 1000 得到 毫秒
            return refreshInterval * 1000;
        }
    
        /** * 如果没有在上下文中注册，则启用调度程序。 */
        @ConditionalOnMissingBean(ScheduledAnnotationBeanPostProcessor.class)
        @EnableScheduling
        @Configuration //内部类，一个空类。在没有 ScheduledAnnotationBeanPostProcessor 这个类时 定时调用
        protected static class EnableSchedulingConfigProperties { 
            //这个类创建了，那么外部类 也会创建吧
        }
    }

#### spirng.factories ####

src/main/resources/META-INF/spring.factories
    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    com.sc.book.config.ConfigClientRefreshAutoConfiguration

### config-client-auto-refresh ###

*  就是上个项目的 子项目
    
        #config-client 依然必须引用
        #还要引用 starter-security
                <dependency>
                    <groupId>cn.springcloud.book</groupId>
                    <artifactId>ch12-5-config-client-refresh-autoconfig</artifactId>
                    <version>1.0-SNAPSHOT</version>
                </dependency>

#### 启动类和control代码 ####

@SpringBootApplication
    
    
    @RestController
    @RequestMapping("configConsumer")
    @RefreshScope
    public class ConfigClientController { 
    
        @Value("${cn.springcloud.book.config}")
        private String config;
    
        @RequestMapping("/getConfigInfo")
        public String getConfigInfo(){ 
            return config;
        }
    }

#### 配置文件 ####

bootstrap.yml 还是相同

spring:
        cloud:
            config:
                label: master
                uri: http://localhost:9090
                name: config-info
                profile: dev

application.yml 增加 父项目 需要的配置

server:
      port: 9012
    
    spring:
      application:
        name: ch12-5-config-client-auto-refresh
      cloud:
          config:
              refreshInterval: 60

访问：http://localhost:9012/configConsumer/getConfigInfo

到了 配置的时间，就会自动刷新

# 客户端回退 #

*  网络中断
 *  配置服务 因 维护而关闭
 *  启动回退：客户端适配器 缓存 ，本地文件系统中的计算 属性
 *  需要指定：缓存位置

## client-fallback-autoconfig ##

<dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-config</artifactId>
                    <version>2.0.0.RC2</version> //干嘛的？
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-config</artifactId>//这个是？
            </dependency>
    
            <dependency>
                <groupId>org.springframework.security</groupId>
                <artifactId>spring-security-rsa</artifactId> //rsa加密
                <version>1.0.1.RELEASE</version>
            </dependency>
        </dependencies>

### 创建配置类 ###

//客户端自动配置依赖启动
    @Configuration //配置类
    @EnableConfigurationProperties //开启属性配置
    @PropertySource(value = { "configClient.properties",
            "file:${spring.cloud.config.fallbackLocation:}/fallback.properties"}, //file回退本地配置文件所在的文件和名称
            ignoreResourceNotFound = true)//配置文件的目录。忽略没有发现的
    public class ConfigServerBootstrap { 
    
        public static final String FALLBACK_FILE_NAME = "fallback.properties";
    
        @Autowired//注入配置的环境
        private ConfigurableEnvironment environment;
    
        @Value("${spring.cloud.config.fallbackLocation:}")
        private String fallbackLocation;//回退配置文件的路径
    
        @Bean
        public ConfigClientProperties configClientProperties(){ 
            //创建配置环境
            ConfigClientProperties clientProperties = new ConfigClientProperties(this.environment);
            clientProperties.setEnabled(false);//不开启
            return clientProperties;
        }
    
        @Bean
        public FallbackableConfigServicePropertySourceLocator fallbackableConfigServicePropertySourceLocator(){ 
            //得到配置客户端
            ConfigClientProperties client = configClientProperties();
            //创建 回退 配置服务 属性资源加载
            FallbackableConfigServicePropertySourceLocator f
                    = new FallbackableConfigServicePropertySourceLocator(client, fallbackLocation);
            return f;
        }
    }

### 创建 回退 配置服务 属性源 加载 ###

//回退配置资源
    @Order(0)
    public class FallbackableConfigServicePropertySourceLocator extends ConfigServicePropertySourceLocator { 
    
        private boolean fallbackEnabled;
        private String fallbackLocation;
    
        @Autowired(required = false)
        TextEncryptor textEncryptor;
    
        public FallbackableConfigServicePropertySourceLocator(ConfigClientProperties defaultProperties, String fallbackLocation) { 
    
            super(defaultProperties);
            this.fallbackLocation = fallbackLocation;
            this.fallbackEnabled = !StringUtils.isEmpty(fallbackLocation);
        }
    
    
        public PropertySource<?> locate(Environment environment){ 
    
            PropertySource<?> propertySource = super.locate(environment);
            if(fallbackEnabled){ 
                if(propertySource != null){ 
                    storeLocally(propertySource);
                }
            }
            return propertySource;
        }
    
        private void storeLocally(PropertySource propertySource){ 
    
            StringBuilder sb = new StringBuilder();
            CompositePropertySource source = (CompositePropertySource)propertySource;
            for (String propertyName : source.getPropertyNames()) { 
                Object value = source.getProperty(propertyName);
                if (textEncryptor != null)
                    value = "{cipher}" + textEncryptor.encrypt(String.valueOf(value));
                sb.append(propertyName).append("=").append(value).append("\n");
            }
    
            System.out.println("file contents : " + sb.toString());
            saveFile(sb.toString());
        }
    
        private void saveFile(String contents){ 
    
            BufferedWriter output = null;
            File file = new File(fallbackLocation + File.separator + ConfigServerBootstrap.FALLBACK_FILE_NAME);
            try { 
                if(!file.exists()){ 
                    file.createNewFile();
                }
                output = new BufferedWriter(new FileWriter(file));
                output.write(contents);
            } catch (IOException e) { 
                e.printStackTrace();
            }finally { 
                if(output != null){ 
                    try { 
                        output.close();
                    } catch (IOException e) { 
                        System.out.print("Error" + e.getMessage());
                    }
                }
            }
        }
    }
    
    //将加载到的远程 配置文件 在本地 也创建一份

### 配置文件 ###

src/main/resources/META-INF/spring.factories
    org.springframework.cloud.bootstrap.BootstrapConfiguration=\
    cn.springcloud.book.config.client.fallback.ConfigServerBootstrap
    
    resources下，configClient.properties
    spring.cloud.config.enabled=false

## 创建 config-client-fallback ##

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-config-client</artifactId>
            </dependency>
    
            <dependency>
                <groupId>cn.springcloud.book</groupId>
                <artifactId>ch12-6-config-client-fallback-autoconfig</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>

### bootstrap.yml ###

spring:
        cloud:
            config:
                label: master
                uri: http://localhost:9090
                name: config-info
                profile: dev
                fallbackLocation: D:\\application_dev\\idea_workspace\\sc-book-local-config-test

*  http://localhost:9013/configConsumer/getConfigInfo

# 客户端的安全认证机制 jwt #

*  spring cloud config 用 jwt身份验证方法 替代标准的 基本身份验证
 *  客户端，服务端 都要改造

授权三部曲

*  客户端 发送请求带上 用户名 和 密码
 *  服务端返回 JWT token
 *  客户端 查询服务端配置 ，在 header带上 token

## config-client ##

<dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-autoconfigure</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-configuration-processor</artifactId>
                <optional>true</optional>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-config</artifactId>
            </dependency>
        </dependencies>

### 创建自动配置类 ###

//启动依赖配置
    @Configuration
    @Order(Ordered.LOWEST_PRECEDENCE)
    public class ConfigClientBootstrapConfiguration { 
    
        private static Log logger = LogFactory.getLog(ConfigClientBootstrapConfiguration.class);
    
        @Value("${spring.cloud.config.username}")
        private String jwtUserName;
    
        @Value("${spring.cloud.config.password}")
        private String jwtPassword;
    
        @Value("${spring.cloud.config.endpoint}")
        private String jwtEndpoint;
    
        private String jwtToken;
    
        @Autowired
        private ConfigurableEnvironment environment;
    
        @PostConstruct
        public void init(){ 
    
            RestTemplate restTemplate = new RestTemplate();
            LoginRequest loginBackend = new LoginRequest();
            loginBackend.setUsername(jwtUserName);
            loginBackend.setPassword(jwtPassword);
    
            String serviceUrl = jwtEndpoint;
            Token token;
    
            try { 
                token = restTemplate.postForObject(serviceUrl, loginBackend, Token.class);
                if(token.getToken() == null){ 
                    throw new Exception();
                }
    
                // 设置token
                setJwtToken(token.getToken());
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
        public String getJwtToken() { 
            return jwtToken;
        }
    
        public void setJwtToken(String jwtToken) { 
            this.jwtToken = jwtToken;
        }
    
        @Bean
        public ConfigServicePropertySourceLocator configServicePropertySourceLocator(ConfigClientProperties configClientProperties){ 
    
            ConfigServicePropertySourceLocator configServicePropertySourceLocator = new ConfigServicePropertySourceLocator(configClientProperties);
            configServicePropertySourceLocator.setRestTemplate(customRestTemplate());
            return configServicePropertySourceLocator;
        }
    
        @Bean
        public ConfigClientProperties configClientProperties(){ 
    
            ConfigClientProperties clientProperties = new ConfigClientProperties(this.environment);
            clientProperties.setEnabled(false);
            return clientProperties;
        }
    
        /** * 自定义restTemplate ， 在发送的时候带上token * @return */
        private RestTemplate customRestTemplate(){ 
    
            Map<String, String> headers = new HashMap<>();
            headers.put("token", "Bearer:" + jwtToken);
            SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
            requestFactory.setReadTimeout((60 * 1000 * 3) + 5000); // TODO 3m5s make
            RestTemplate template = new RestTemplate(requestFactory);
            if (!headers.isEmpty()) { 
                template.setInterceptors(
                        Arrays.<ClientHttpRequestInterceptor> asList(new GenericRequestHeaderInterceptor(headers)));
            }
    
            return template;
        }
    
        /** * 客户端请求过滤器 */
        public static class GenericRequestHeaderInterceptor implements ClientHttpRequestInterceptor{ 
    
            private final Map<String, String> headers;
    
            public GenericRequestHeaderInterceptor(Map<String, String> headers){ 
                this.headers = headers;
            }
    
            /** * 请求之前操作的方法 * @param httpRequest * @param bytes * @param clientHttpRequestExecution * @return * @throws IOException */
            @Override
            public ClientHttpResponse intercept(HttpRequest httpRequest, byte[] bytes, ClientHttpRequestExecution clientHttpRequestExecution) throws IOException { 
    
                headers.entrySet().stream().forEach(header -> { 
                    httpRequest.getHeaders().add(header.getKey(), header.getValue());
                });
                return clientHttpRequestExecution.execute(httpRequest, bytes);
            }
        }
    }
    
    
    	@PostConstruct
        public void init(){ }
    	//在servlet构造方法 和 Init方法之间 执行具体容器加载时序。
    	//如下

*  开始
 *  Web容器 加载Servlet
 *  servlet 构造函数
 *  PostConstruct 注解方法
 *  Init()

### 创建实体类 ###

@JsonIgnoreProperties(ignoreUnknown = true)
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public class LoginRequest { 
    
        @JsonProperty
        private String username;
    
        @JsonProperty
        private String password;
        
        //get set
    
        @Override
        public String toString() { 
            return "LoginRequest [username=" + username + ", password=" + password + "]";
        }
    }
    
    @JsonIgnoreProperties(ignoreUnknown = true)
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public class Token { 
    
        @JsonProperty
        private String token;
    
        //get set
        
        @Override
        public String toString() { 
            return "Token [token=" + token + "]";
        }
    }

### spring.factories ###

src/main/resources/META-INF/spring.factories
    
    org.springframework.cloud.bootstrap.BootstrapConfiguration=\
    cn.springcloud.book.config.jwt.config.ConfigClientBootstrapConfiguration

## config-client-auth-jwt ##

<dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-config-client</artifactId>
            </dependency>
            <dependency>
                <groupId>cn.springcloud.book</groupId>
                <artifactId>ch12-7-config-client-jwt</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>
        </dependencies>

### bootstrap.yml ###

spring:
        cloud:
            config:
                label: master
                uri: http://localhost:9090
                name: config-info
                profile: dev
                username: root
                password: 123
                enabled: false
                endpoint: http://localhost:9090/auth

## config-server ##

*  getUsernameFromToken()
 *  token存在调用 该方法 loadUserByname()
 *  doFilter 调用到 实际 control（）
 *  loadUserByname()

<dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-config-server</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-security</artifactId>
            </dependency>
    
            <dependency>
                <groupId>io.jsonwebtoken</groupId>
                <artifactId>jjwt</artifactId>
                <version>0.9.0</version>
            </dependency>
            <dependency>
                <groupId>com.google.code.gson</groupId>
                <artifactId>gson</artifactId>
                <version>2.7</version>
            </dependency>
        </dependencies>

*  jjwt gson 相关认证和转化参数 结构的依赖

### 创建实例 ###

//传递 用户名密码
    public class JwtAuthenticationRequest implements Serializable { 
    
    	private static final long serialVersionUID = -8445943548965154778L;
    
    	private String username;
    	private String password;
    
    	public JwtAuthenticationRequest() { 
    		super();
    	}
    
    	public JwtAuthenticationRequest(String username, String password) { 
    		this.setUsername(username);
    		this.setPassword(password);
    	}
    	//get set
    
    	@Override
    	public String toString() { 
    		return "JwtAuthenticationRequest [username=" + username + ", password=" + password + "]";
    	}
    
    }
    
    //返回 token
    public class JwtAuthenticationResponse implements Serializable { 
    
    	private static final long serialVersionUID = 1250166508152483573L;
    
    	private final String token;
    
    	public JwtAuthenticationResponse(String token) { 
    		this.token = token;
    	}
    
    	public String getToken() { 
    		return this.token;
    	}
    }
    
    
    //JWT用户认证信息
    public class JwtUser implements UserDetails { 
    
    	private static final long serialVersionUID = -1780004587184647821L;
    	private final String username;
    	private final String password;
    	private final Collection<? extends GrantedAuthority> authorities;
    
    	public JwtUser(String username, String password, Collection<? extends GrantedAuthority> authorities) { 
    		this.username = username;
    		this.password = password;
    		this.authorities = authorities;
    	}
    
    	@Override
    	public String getUsername() { 
    		return username;
    	}
    
    	@JsonIgnore
    	@Override
    	public boolean isAccountNonExpired() { 
    		return true;
    	}
    
    	@JsonIgnore
    	@Override
    	public boolean isAccountNonLocked() { 
    		return true;
    	}
    
    	@JsonIgnore
    	@Override
    	public boolean isCredentialsNonExpired() { 
    		return true;
    	}
    
    	@JsonIgnore
    	@Override
    	public String getPassword() { 
    		return password;
    	}
    
    	@Override
    	public Collection<? extends GrantedAuthority> getAuthorities() { 
    		return authorities;
    	}
    
    	@Override
    	public boolean isEnabled() { 
    		return true;
    	}
    
    	@Override
    	public String toString() { 
    		return "JwtUser [username=" + username + ", password=" + password + ", authorities=" + authorities + "]";
    	}
    
    }

### security 模块 ###

// @description : jwt的token认证过滤器
    public class JwtAuthenticationTokenFilter extends UsernamePasswordAuthenticationFilter { 
    
        @Autowired
        private UserDetailsService userDetailsService;
    
        @Autowired
        private JwtTokenUtil jwtTokenUtil;
    
        private final String tokenHeader = "token";
    
        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { 
    
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            String authToken = httpRequest.getHeader(tokenHeader);
            String username = jwtTokenUtil.getUsernameFromToken(authToken);
    
            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) { 
                UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
                if(jwtTokenUtil.validateToken(authToken, userDetails)){ 
                    UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                    auth.setDetails(new WebAuthenticationDetailsSource().buildDetails(httpRequest));
                    SecurityContextHolder.getContext().setAuthentication(auth);
                }
            }
    
            chain.doFilter(request, response);
        }
    }

#### JWT 工具类 ####

//jwt 生成token的方式 ，和 验证 token
    
    @Component
    public class JwtTokenUtil implements Serializable { 
    
        private static final long serialVersionUID = -8652360919584431721L;
    
        private static final String CLAIM_KEY_USERNAME = "sub";
        private static final String CLAIM_KEY_AUDIENCE = "audience";
        private static final String CLAIM_KEY_CREATED = "created";
    
        private static final String AUDIENCE_UNKNOWN = "unknown";
        private static final String AUDIENCE_WEB = "web";
    
        private Key secret = MacProvider.generateKey();
        private Long expiration = (long) 120; // 2 minutes
    
        /** * 生成token * @param userDetails * @return */
        public String generateToken(JwtUser userDetails) { 
            Map<String, Object> claims = new HashMap<>();
            claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
            claims.put(CLAIM_KEY_AUDIENCE, AUDIENCE_WEB);
            claims.put(CLAIM_KEY_CREATED, new Date().getTime() / 1000);
    
            return generateToken(claims);
        }
    
        /** * jwt 实际生成token * @param claims * @return */
        private String generateToken(Map<String, Object> claims) { 
            return Jwts.builder().setClaims(claims).setExpiration(generateExpirationDate())
                    .signWith(SignatureAlgorithm.HS512, secret).compact();
        }
    
        private Date generateExpirationDate() { 
            return new Date(System.currentTimeMillis() + expiration * 1000);
        }
    
        public String getUsernameFromToken(String token) { 
            if (token == null) { 
                return null;
            }
    
            String username;
            try { 
                final Claims claims = getClaimsFromToken(token);
                username = claims.getSubject();
            } catch (Exception e) { 
                username = null;
            }
    
            return username;
        }
    
        private Claims getClaimsFromToken(String token) { 
            Claims claims;
    
            final String tokenClean = token.substring(7); // remove "Bearer:"
            try { 
                claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(tokenClean).getBody();
            } catch (Exception e) { 
                claims = null;
            }
    
            return claims;
        }
    
        /** * 校验token的合法性 * @param token * @param userDetails * @return */
        public Boolean validateToken(String token, UserDetails userDetails) { 
            JwtUser user = (JwtUser) userDetails;
            final String username = getUsernameFromToken(token);
    
            return (username.equals(user.getUsername()) && !isTokenExpired(token));
        }
    
        private Boolean isTokenExpired(String token) { 
            final Date expiration = getExpirationDateFromToken(token);
            return expiration.before(new Date());
        }
    
        public Date getExpirationDateFromToken(String token) { 
            Date expiration;
            try { 
                final Claims claims = getClaimsFromToken(token);
                expiration = claims.getExpiration();
            } catch (Exception e) { 
                expiration = null;
            }
            return expiration;
        }
    
    }

#### jwt认证端点 ####

@Component
    public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint, Serializable { 
    
        private static final long serialVersionUID = 3671302053846319657L;
    
        @Override
        public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException { 
    
            // 没有认证通过将添加401
            httpServletResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Unauthorized");
        }
    }

#### 认证账号的验证类 ####

@Service("userDetailsService")
    public class MemberServiceImpl implements UserDetailsService { 
    
        private static final PasswordEncoder BCRYPT = new BCryptPasswordEncoder();
    
        // 这里的用户名和密码读者可以从数据库中获取
        @Value("${spring.security.user.name}")
        private String hardcodedUser;
    
        @Value("${spring.security.user.password}")
        private String password;
    
        @Override
        public JwtUser loadUserByUsername(String username) throws UsernameNotFoundException { 
    
            // 对密码进行加密
            String hardcodedPassword = BCRYPT.encode(password);
            if (username.equals(hardcodedUser) == false) { 
                throw new UsernameNotFoundException(String.format("No user found with username '%s'.", username));
            }else{ 
    
                SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority("ROLE_USER");
                List<GrantedAuthority> grantedAuthorityList = new ArrayList<GrantedAuthority>();
                grantedAuthorityList.add(simpleGrantedAuthority);
                return new JwtUser(hardcodedUser, hardcodedPassword, grantedAuthorityList);
            }
        }
    }

#### 创建封装对象 ####

/*将传递过来的对象数据封装到JwtAuthenticationRequest里面 */
    @Component
    public class WebAuthenticationDetailsSourceImpl implements AuthenticationDetailsSource<HttpServletRequest, JwtAuthenticationRequest> { 
    
        @Override
        public JwtAuthenticationRequest buildDetails(HttpServletRequest request) { 
    
             Gson gson = new Gson();
            String json = new String();
            String output = new String();
            BufferedReader br;
            StringBuffer buffer = new StringBuffer(16384);
            JwtAuthenticationRequest jwtAuthenticationRequest = new JwtAuthenticationRequest();
            try { 
                br = new BufferedReader(new InputStreamReader(request.getInputStream()));
                while ((output = br.readLine()) != null){ 
                    buffer.append(output);
                }
    
                json = buffer.toString();
                jwtAuthenticationRequest = gson.fromJson(json, JwtAuthenticationRequest.class);
            } catch (IOException e) { 
                e.printStackTrace();
            }
    
            return jwtAuthenticationRequest;
        }
    }

*  将数据 封装成 json 格式后 返回到 客户端

### control ###

@RestController
    public class AuthenticationRestController { 
    
        @Autowired
        private AuthenticationManager authenticationManager;
    
        @Autowired
        private JwtTokenUtil jwtTokenUtil;
    
        @Autowired
        private MemberServiceImpl userDetailsService;
    
        @Autowired
        private WebAuthenticationDetailsSourceImpl webAuthenticationDetailsSource;
    
        @RequestMapping(value = "/auth", method = RequestMethod.POST)
        public ResponseEntity<?> createAuthenticationToken(HttpServletRequest request){ 
    
            JwtAuthenticationRequest jwtAuthenticationRequest = webAuthenticationDetailsSource.buildDetails(request);
            UsernamePasswordAuthenticationToken authToken = new UsernamePasswordAuthenticationToken(jwtAuthenticationRequest.getUsername(), jwtAuthenticationRequest.getPassword());
            authToken.setDetails(jwtAuthenticationRequest);
            Authentication authenticate = authenticationManager.authenticate(authToken);
            SecurityContextHolder.getContext().setAuthentication(authenticate);
    
    
            JwtUser userDetails = userDetailsService.loadUserByUsername(jwtAuthenticationRequest.getUsername());
            final String token = jwtTokenUtil.generateToken(userDetails);
    
            return ResponseEntity.ok(new JwtAuthenticationResponse(token));
        }
    }

### config 模块 ###

#### securityConfig自动配置类 ####

@Configuration
    @EnableWebSecurity
    @EnableGlobalMethodSecurity(prePostEnabled = true)
    public class SecurityConfig extends WebSecurityConfigurerAdapter { 
    
        @Autowired
        private JwtAuthenticationEntryPoint unAuthorizedHandler;
    
        @Autowired
        private WebAuthenticationDetailsSourceImpl webAuthenticationDetailsSource;
    
    
        @Bean
        @ConditionalOnMissingBean(AuthenticationManager.class)
        public UsernamePasswordAuthenticationFilter usernamePasswordAuthenticationFilter(AuthenticationManager authenticationManager)throws Exception{ 
    
            UsernamePasswordAuthenticationFilter u = new UsernamePasswordAuthenticationFilter();
            u.setAuthenticationManager(authenticationManager);
            u.setAuthenticationDetailsSource(webAuthenticationDetailsSource);
            return u;
        }
    
        @Bean
        public PasswordEncoder passwordEncoder(){ 
            return new BCryptPasswordEncoder();
        }
    
        @Bean
        @Override
        public AuthenticationManager authenticationManagerBean() throws Exception { 
            return super.authenticationManagerBean();
        }
    
        @Bean
        public JwtAuthenticationTokenFilter authenticationTokenFilter() throws Exception{ 
    
            JwtAuthenticationTokenFilter j = new JwtAuthenticationTokenFilter();
            j.setAuthenticationManager(authenticationManager());
            j.setAuthenticationDetailsSource(webAuthenticationDetailsSource);
            return j;
        }
    
        @Override
        protected void configure(HttpSecurity httpSecurity) throws Exception { 
    
            httpSecurity
                    .csrf().disable()
                    .exceptionHandling().authenticationEntryPoint(unAuthorizedHandler)
                    .and()
                    .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                    .and()
                    .authorizeRequests()
                    .antMatchers(HttpMethod.GET, "/").permitAll()
                    .antMatchers("/auth/**").permitAll()
                    .anyRequest().authenticated().and().formLogin()
                    .authenticationDetailsSource(webAuthenticationDetailsSource)
                    .permitAll();
    
            // 添加自定义的jwt 安全过滤的filter
            httpSecurity.addFilterBefore(authenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
            httpSecurity.headers().cacheControl();
        }
    }

### 配置文件 ###

application.yml
    
    spring:
      cloud:
        config:
          server:
            git:
              uri: https://gitee.com/zhongzunfa/spring-cloud-config.git
              search-paths: SC-BOOK-CONFIG
              force-pull: true
      application:
        name: ch12-7-config-server-auth-jwt
    
      security:
        user:
          #name: root
          password: 1234
          name: root
    
    server:
        port: 9090

*  http://localhost:9014/configConsumer/getConfigInfo
 *  随便改 服务器和 客户端的密码，无法启动连接上
    
        org.springframework.web.client.HttpClientErrorException: 401 null

# 配置中心高可用（腻害） #

*  生产环境 、 高可用 必不可少
 *  客户端回退，是一种方式

## 客户端高可用(自动配置项目) ##

*  降低 客户端对配置中心的依赖程度
 *  先加载远程 配置文件，加载成功后 进行本地备份
 *  加载失败，会加载本地文件

### 自动加载属性配置类 ###

@Component
    @ConfigurationProperties(prefix = ConfigSupportProperties.CONFIG_PREFIX)
    public class ConfigSupportProperties { 
        //读取配置
        public static final String CONFIG_PREFIX = "spring.cloud.config.backup";
    
        private final String DEFAULT_FILE_NAME = "fallback.properties";
    
        //enable字段 get set
        private boolean enable = false;
        public boolean isEnable() { 
            return enable;
        }
        public void setEnable(boolean enable) { 
            this.enable = enable;
        }
    
        private String fallbackLocation;
        public String getFallbackLocation() { 
            return fallbackLocation;
        }
    
        //参数为 本地地址
        public void setFallbackLocation(String fallbackLocation) { 
            // 如果只是填写路径， 就其添加上一个默认的文件名
            if(fallbackLocation.indexOf(".") == -1){ 
                this.fallbackLocation = fallbackLocation + DEFAULT_FILE_NAME;
                return;
            }
            this.fallbackLocation = fallbackLocation;
        }
    }

### 创建configuration配置类 ###

@Configuration
    @EnableConfigurationProperties(ConfigSupportProperties.class)
    public class ConfigSupportConfiguration implements ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered { 
    
        private final Logger LOGGER = LoggerFactory.getLogger(ConfigSupportConfiguration.class);
        private final Integer orderNum = Ordered.HIGHEST_PRECEDENCE + 11;
    
        @Autowired(required = false)
        private List<PropertySourceLocator> propertySourceLocators = Collections.EMPTY_LIST;
    
        @Autowired
        private ConfigSupportProperties configSupportProperties;
    
    
        @Override
        public void initialize(ConfigurableApplicationContext configurableApplicationContext) { 
    
            if (!isHasCloudConfigLocator(this.propertySourceLocators)) { 
                LOGGER.info("未启用Config Server管理配置");
                return;
            }
    
    
            LOGGER.info("检查Config Service配置资源");
            ConfigurableEnvironment environment = configurableApplicationContext.getEnvironment();
            MutablePropertySources propertySources = environment.getPropertySources();
            LOGGER.info("加载PropertySources源：" + propertySources.size() + "个");
    
            if (!configSupportProperties.isEnable()) { 
                LOGGER.warn("未启用配置备份功能，可使用{}.enable打开", ConfigSupportProperties.CONFIG_PREFIX);
                return;
            }
    
    
            if (isCloudConfigLoaded(propertySources)) { 
                PropertySource cloudConfigSource = getLoadedCloudPropertySource(propertySources);
                LOGGER.info("成功获取ConfigService配置资源");
                //备份
                Map<String, Object> backupPropertyMap = makeBackupPropertyMap(cloudConfigSource);
                doBackup(backupPropertyMap, configSupportProperties.getFallbackLocation());
    
            } else { 
    
                LOGGER.error("获取ConfigService配置资源失败");
                Properties backupProperty = loadBackupProperty(configSupportProperties.getFallbackLocation());
                if (backupProperty != null) { 
                    HashMap backupSourceMap = new HashMap<>(backupProperty);
    
                    PropertySource backupSource = new MapPropertySource("backupSource", backupSourceMap);
                    propertySources.addFirst(backupSource);
                    LOGGER.warn("使用备份的配置启动：{}", configSupportProperties.getFallbackLocation());
                }
            }
    
        }
    
        @Override
        public int getOrder() { 
            return orderNum;
        }
    
        /** * 是否启用了Spring Cloud Config获取配置资源 * * @param propertySourceLocators * @return */
        private boolean isHasCloudConfigLocator(List<PropertySourceLocator> propertySourceLocators) { 
            for (PropertySourceLocator sourceLocator : propertySourceLocators) { 
                if (sourceLocator instanceof ConfigServicePropertySourceLocator) { 
                    return true;
                }
            }
            return false;
        }
    
        /** * 是否启用Cloud Config * * @param propertySources * @return */
        private boolean isCloudConfigLoaded(MutablePropertySources propertySources) { 
            if (getLoadedCloudPropertySource(propertySources) == null) { 
                return false;
            }
            return true;
        }
    
        /** * 获取加载的Cloud Config 配置项 * * @param propertySources * @return */
        private PropertySource getLoadedCloudPropertySource(MutablePropertySources propertySources) { 
            if (!propertySources.contains(PropertySourceBootstrapConfiguration.BOOTSTRAP_PROPERTY_SOURCE_NAME)) { 
                return null;
            }
    
            PropertySource propertySource = propertySources.get(PropertySourceBootstrapConfiguration.BOOTSTRAP_PROPERTY_SOURCE_NAME);
            if (propertySource instanceof CompositePropertySource) { 
                for (PropertySource<?> source : ((CompositePropertySource) propertySource).getPropertySources()) { 
                    if (source.getName().equals("configService")) { 
                        return source;
                    }
                }
            }
            
            return null;
        }
    
    
        /** * 生成备份的配置数据 * * @param propertySource * @return */
        private Map<String, Object> makeBackupPropertyMap(PropertySource propertySource) { 
    
            Map<String, Object> backupSourceMap = new HashMap<>();
            if (propertySource instanceof CompositePropertySource) { 
                CompositePropertySource composite = (CompositePropertySource) propertySource;
                for (PropertySource<?> source : composite.getPropertySources()) { 
                    if (source instanceof MapPropertySource) { 
                        MapPropertySource mapSource = (MapPropertySource) source;
                        for (String propertyName : mapSource.getPropertyNames()) { 
                            // 前面的配置覆盖后面的配置
                            if (!backupSourceMap.containsKey(propertyName)) { 
                                backupSourceMap.put(propertyName, mapSource.getProperty(propertyName));
                            }
                        }
                    }
                }
            }
            return backupSourceMap;
        }
    
        /** * 生成备份文件 * @param backupPropertyMap * @param filePath */
        private void doBackup(Map<String, Object> backupPropertyMap, String filePath) { 
            FileSystemResource fileSystemResource = new FileSystemResource(filePath);
            File backupFile = fileSystemResource.getFile();
            try { 
                if (!backupFile.exists()) { 
                    backupFile.createNewFile();
                }
                if (!backupFile.canWrite()) { 
                    LOGGER.error("无法读写文件：{}", fileSystemResource.getPath());
                }
    
                Properties properties = new Properties();
                Iterator<String> keyIterator = backupPropertyMap.keySet().iterator();
                while (keyIterator.hasNext()) { 
                    String key = keyIterator.next();
                    properties.setProperty(key, String.valueOf(backupPropertyMap.get(key)));
                }
    
                FileOutputStream fos = new FileOutputStream(fileSystemResource.getFile());
                properties.store(fos, "Backup Cloud Config");
            } catch (IOException e) { 
                LOGGER.error("文件操作失败：{}", fileSystemResource.getPath());
                e.printStackTrace();
            }
        }
    
        /** * 加载本地文件 * @param filePath * @return */
        private Properties loadBackupProperty(String filePath) { 
            PropertiesFactoryBean propertiesFactory = new PropertiesFactoryBean();
            Properties props = new Properties();
            try { 
                FileSystemResource fileSystemResource = new FileSystemResource(filePath);
                propertiesFactory.setLocation(fileSystemResource);
    
                propertiesFactory.afterPropertiesSet();
                props = propertiesFactory.getObject();
    
            } catch (IOException e) { 
                e.printStackTrace();
                return null;
            }
    
            return props;
        }
    }
    
    //判断远程 加载信息是否可用，如果不可用 读取本地配置
    //orderNum 只要加一个整数比其大 即可

### spring.factories ###

src/main/resources/META-INF/spring.factories
    org.springframework.cloud.bootstrap.BootstrapConfiguration=\
    cn.springcloud.book.config.configuration.ConfigSupportConfiguration

### config-client项目 ###

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-config-client</artifactId>
            </dependency>
    
            <dependency>
                <groupId>cn.springcloud.book</groupId>
                <artifactId>ch12-8-config-client-high-availability-autoconfig</artifactId>
                <version>1.0-SNAPSHOT</version>
            </dependency>

#### bootstrap.yml ####

spring:
        cloud:
            config:
                label: master
                uri: http://localhost:9090
                name: config-info
                profile: dev
                backup:
                    enable: true
                    fallbackLocation: D:\\application_dev\\idea_workspace\\sc-book-local-config-test\\fallback.properties
    
    # 对应父类：spring.cloud.config.backup 的 fallbackLocation属性

enable: true #是否启用 加载到远程配置信息进行本地备份
    
    对应代码：
    		if (!configSupportProperties.isEnable()) { 
                LOGGER.warn("未启用配置备份功能，可使用{}.enable打开", ConfigSupportProperties.CONFIG_PREFIX);
                return;
            }

*  http://localhost:9015/configConsumer/getConfigInfo
 *  D盘创建 对应的目录，就会进行备份
 *  如果只启动客户端，也会启动成功，会打印
    
        获取ConfigService配置资源失败
        .ConfigSupportConfiguration     : 使用备份的配置启动：D:\\application_dev\\idea_workspace\\sc-book-local-config-test\\fallback.properties

# 服务端 高可用 #

*  结合eureka 搭建 config server
 *  通过ribbo 的 负载均衡 选择 一个 config server进行

## eureka-server ##

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            </dependency>

@EnableEurekaServer

application.yml

server:
      port: 8761
    
    eureka:
      instance:
        hostname: localhost
      client:
        registerWithEureka: false #不注册到其他eureka
        fetchRegistry: false #不拉去其他的仓库
        serviceUrl:
          defaultZone: http://${ eureka.instance.hostname}:${ server.port}/eureka/ #注册地址
      server:
          waitTime InMs When Sync Empty: 0 #服务端 等待时间 当 异步为空
          enable Self Preservation: false #开启 自己保护 为 false

## config-server ##

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-config-server</artifactId>
            </dependency>
    
        <build>
            <finalName>ch12-9-config-server-high-availability</finalName>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>

@EnableConfigServer
    @EnableDiscoveryClient

application.yml

spring:
      cloud:
        config:
          server:
            git:
              uri: https://gitee.com/zhongzunfa/spring-cloud-config.git
              search-paths: SC-BOOK-CONFIG
      application:
        name: ch12-9-config-server-high-availability
    server:
        port: 9090
    
    eureka:
      client:
        serviceUrl:
          defaultZone: http://localhost:8761/eureka/

## config-client ##

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-config-client</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>

appliation.yml

server:
      port: 9016
    
    spring:
      application:
        name: ch12-9-config-client

bootstrap.yml

spring:
        cloud:
            config:
                label: master
                name: config-info
                profile: dev
                discovery:
                        enabled: true
                        service-id: ch12-9-config-server-high-availability #服务名字
                #uri 不用这个配置
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/

启动：

服务端和客户端 各启动两个

java -jar XXX.jar --server.port=9091

http://localhost:9016/configConsumer/getConfigInfo

# cloud 与 apollo #

*  携程 阿波罗
 *  具有 规范的权限，流程治理
 *  支持4个维度管理：key-value 格式的配置：
    
     *  application 应用
     *  environment 环境
     *  cluster 集群
     *  namespace 命名空间

apollo具备功能

*  管理 不同的环境，不同集群的配置
 *  实时生效 热发布
 *  版本发布管理
 *  灰度发布
 *  权限管理 发布审核 操作审计
 *  信息监控
 *  java 原生客户端
 *  开放平台api
 *  部署简单

## apollo总体架构模块 ##

config service

*  配置的 读取 推送，服务对象是 apollo客户端

admin service

*  配置的 修改 发布，服务对象是 apollo portal 管理界面
 *  config 和 admin 将自己注册到 eureka并保持心跳
 *  eureka 架了一层 Meta Server 用于封装 eureka的服务发现接口
 *  client 通过域名访问 Meta Server获取 config service 服务列表 （IP+PORT）
 *  直接通过 ip+port 访问服务，client侧会进行 load balance，错误重试。

## 客户端设计 ##

*  客户端和服务端保持 一个长连接
 *  客户端定时 从 apollo 配置中心 服务端 拉取 应用的 最新配置
    
     *  是一个 fallback机制，为了防止推送失效
     *  一般情况下，服务器都是返回304 not motified
     *  默认为5分钟后，使用apollo.refreshInterval 覆盖。

## 运行环境 ##

*  java -Denv=your-环境 -jar xxx.jar
 *  注意：key为全小写
 *  mac/linux为：/opt/settings/server.properties
 *  windows： c:\\opt\\settings\\server.properties

# cloud 和 apollo 实战 #

服务端： jak1.8+

客户端：jdk1.7+

mysql环境5.6.5+

## 基础数据导入 ##

### 下载： ###

*  https://github.com/ctripcorp/apollo/releases/tag/v1.0.0
 *  [apollo-adminservice-1.0.0-github.zip][]
 *  [apollo-configservice-1.0.0-github.zip][]
 *  [apollo-portal-1.0.0-github.zip][]
 *  最新的为1.7.1 ，访问：https://github.com/ctripcorp/apollo/releases
 *  [Apollo v1.7.1 release][]

### 修改配置启动 ###

*  修改三个项目的数据库配置信息：application-github.properties
 *  修改日志的打印目录：apollo-adminservice.conf （好像没啥用）
    
     *  真正的日志在：startup.sh 里面配置
 *  注意：这三个项目，别放在 中文目录下
 *  数据库里导入这两个文件：apolloconfigdb.sql 和 apolloportaldb.sql
 *  对应数据库的名字为：ApolloConfigDB (admin和config都连接) 和 ApolloPortalDB
 *  注意：要更改数据库里，app 表的配置中心：http://localhost:8761/eureka/
 *  注意：要更改 portal项目，apollo-env.properties 的连接为localhost

### 访问： ###

*  http://localhost:8070/
 *  用户名： apollo ，密码：admin
 *  点击创建项目
 *  点击创建配置，然后发布配置，即可。

## 创建config-client-apollo ##

<apollo-client-version>1.0.0</apollo-client-version>    
    	<dependencies>
    
            <dependency>
                <groupId>com.ctrip.framework.apollo</groupId>
                <artifactId>apollo-client</artifactId>
                <version>${apollo-client-version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
        </dependencies>

### 配置类 ###

@Configuration
    @EnableApolloConfig(value = "application", order = 10)
    public class AppConfig { 
    }

### controller ###

@RestController
    @RequestMapping("configConsumer")
    @RefreshScope
    public class ConfigClientController { 
    
        @Value("${config_info}")
        private String config;
    
        @RequestMapping("/getConfigInfo")
        public String getConfigInfo(){ 
            return config;
        }
    }

### application.yml ###

server:
      port: 9018
    
    spring:
      application:
        name: ch12-10-config-client-apollo
    
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/
    
    apollo:
      bootstrap:
        enabled: true
        namespaces: application
      meta: http://localhost:8080

### apollo配置 ###

src/main/resources/META-INF/app.properties
    
    app.id=123456789

访问：http://localhost:9018/configConsumer/getConfigInfo

修改apollo配置后，点击发布，数据会时时改变。

或者不用application的配置，在 VM options 设置：-Denv=dev -Ddev\_meta=http://localhost:8080

## gateway-zuul-apollo ##

*  apollo界面上，在上个项目里添加，添加 Namespace **TEST1.zuul-config**

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
    
    
            <dependency>
                <groupId>com.ctrip.framework.apollo</groupId>
                <artifactId>apollo-client</artifactId>
                <version>${apollo-client-version}</version>
            </dependency>

@EnableApolloConfig //开启apollo
    @SpringBootApplication//boot主类
    @EnableDiscoveryClient//服务发现
    @EnableZuulProxy//开启 zuul
    public class ZuulServerApplication { 
    
    }

### route刷新 ###

@Component
    public class ZuulPropertiesRefresher implements ApplicationContextAware { 
    
      private static final Logger logger = LoggerFactory.getLogger(ZuulPropertiesRefresher.class);
    
      //注入应用上下文
      private ApplicationContext applicationContext;
    
      @Autowired
      private RouteLocator routeLocator;//路由加载器
    
      //监听的位置是
      @ApolloConfigChangeListener(value = "TEST1.zuul-config")
      public void onChange(ConfigChangeEvent changeEvent) { 
        boolean zuulPropertiesChanged = false;
        for (String changedKey : changeEvent.changedKeys()) { 
          //如果改变的key是zuul开头的
          if (changedKey.startsWith("zuul.")) { 
            zuulPropertiesChanged = true;
            break;
          }
        }
        //就刷新属性
        if (zuulPropertiesChanged) { 
          refreshZuulProperties(changeEvent);
        }
      }
    
      private void refreshZuulProperties(ConfigChangeEvent changeEvent) { 
        logger.info("Refreshing zuul properties!");
    
        /** * rebind configuration beans, e.g. ZuulProperties * @see org.springframework.cloud.context.properties.ConfigurationPropertiesRebinder#onApplicationEvent *///发布事件，环境改变时间
        this.applicationContext.publishEvent(new EnvironmentChangeEvent(changeEvent.changedKeys()));
    
        /** * refresh routes * @see org.springframework.cloud.netflix.zuul.ZuulServerAutoConfiguration.ZuulRefreshListener#onApplicationEvent *///发布事件，路由刷新事件
        this.applicationContext.publishEvent(new RoutesRefreshedEvent(routeLocator));
    
        logger.info("Zuul properties refreshed!");
      }
    
      @Override
      public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { 
        this.applicationContext = applicationContext;
      }
    }

### application.yml ###

spring:
      application:
        name: ch12-10-gateway-zuul-apollo
    server:
      port: 9019
    eureka:
      client:
        serviceUrl:
          defaultZone: http://${ eureka.host:127.0.0.1}:${ eureka.port:8761}/eureka/
    
    zuul:
      routes:
        client-apollo:
          path: /client/**
          serviceId: ch12-10-config-client-apollo
    
    apollo:
      bootstrap:
        enabled: true
        namespaces: TEST1.zuul-config
      meta: http://localhost:8080

app.properties同样
    
    app.id=123456789

## config-client-apollo2 ##

controller改变

@RestController
    @RequestMapping("configConsumer")
    @RefreshScope
    public class ConfigClientController {
    
        @Value("${config_info_new}")
        private String config;
    
        @RequestMapping("/getConfigInfo")
        public String getConfigInfo(){
            return config;
        }
    }

*  这里只需要 把上面的controller放在 zuu项目就行了
 *  http://localhost:9019/configConsumer/getConfigInfo 访问成功

### apollo增加配置 ###

*  这里是想通过网关 访问其他两个项目，但是我不会

zuul.routes.client-apollo-new.path
    值为：
    /client_new/**

http://localhost:9019/client_new/configConsumer/getConfigInfo

增加配置：
    zuul.routes.client-apollo-new.serviceId
    值为：
    ch12-10-config-client-apollo2
    
    就算是这样：这个项目依然无法启动啊，因为读取不到配置。

[apollo-adminservice-1.0.0-github.zip]: https://github.com/ctripcorp/apollo/releases/download/v1.0.0/apollo-adminservice-1.0.0-github.zip
[apollo-configservice-1.0.0-github.zip]: https://github.com/ctripcorp/apollo/releases/download/v1.0.0/apollo-configservice-1.0.0-github.zip
[apollo-portal-1.0.0-github.zip]: https://github.com/ctripcorp/apollo/releases/download/v1.0.0/apollo-portal-1.0.0-github.zip
[Apollo v1.7.1 release]: https://github.com/ctripcorp/apollo/releases/tag/v1.7.1