NotGeek

小马哥 vip 中期回顾

Fri, 29 May 2020 00:00:00 +0000

小马哥 VPI 中期回顾

回顾

Spring Boot Logger
Spring Boot Actuator 联想到 JMX
- 为生产而准备的特性。
- JMX，管控，就是控制它，单机的时候怎么办？集群的时候怎么办？
- Endpoint 的 /restart
  - JMX restart operation 操作

讨论范畴

Spring Boot
Spring Framework 设计模式
Spring Security

Spring Boot 还有命令行的创建方式。

某次事件

解决问题需要有具体的方式。

为什么不用 ftp 把文件下载下来去看呢？

有很多网站上的文章，网上并不是很正确

不患无位，患所以立

Profile

Spring Cloud config Service
- provider 当 Profile 一样的时候，会进行更新配置。

自己多种实现

找到方便的实现

对周围人的接受程度怎么样

Spring Boot 三大特性

自动装配（可以实现）

嵌入式容器（可以实现）

为生产准备（可以相关协议来实现）

干什么

怎么做

怎么应用的更好

安全

HealthEndpoint
- sensitive 不敏感的 false
RestartEndpoint
- sensitive 敏感的 true

前端开始面向对象

规模扩大，必须统一认知

没有统一的认知，造成代码比较乱

方法和技术如何学习

实施

协调

Spring Framwork

重复的发明轮子

Tomcat
- Embed 版本

Spring

EmbeddedServletContainFactory
- org.springframework.boot.web.embedded.tomcat.TomcatEmbeddedContext
- org.springframework.boot.web.embedded.jetty.JettyEmbeddedWebAppContext

你都可以进行实现不同的注入。

理解 Filter

PipeLine

value -> value -> value

Filter

filter -> filter -> filter

HandlerInterceptor handlerInterceptor ;

@Controller
public String index() {
    
}

void begin();
void do();
void after();

AfterReturnAdvide
MethodBeforeAdvice

设计模式的理解在于

看了多少代码

写了多少代码

Spring Boot 的内置的 Tomcat

有一个 AbstractEmbeddedServletContainerFactory 的入口，

EmbeddedServletContainerFactory

Spring Boot 有几种嵌入式容器，进入了不同的 classPath ，然后进行加载不同的容器，在进入自动装配。里边有一个条件装配，有一个顺序， Tomcat，Jetty，Undertow

Spring MVC 怎么学习？

@RestController

@RestController
 -  @ResponseBody
 -   @Controller

我们可以通过 MedieType 来指定自描述消息。这样子可以实现一套自定义的自描述消息。

@RequestMapping

produces
consume 是 Content-Type 就是我们的 Accept

HttpMessageConverter 可以进行解析。

可以转化来，转化去。

老罗说：

学习不能躺着学

单词不背，是考不上雅思的。。。。

每个程序员都有擅长的地方，不擅长的地方。

诚实

诚信

REST

JSP 性能比较好，XML，纯的 HTML，都可以进行支持
thymeleaf 可能不是特别的适用于线上，设计起来不是特别好，性能不怎么样

教育能够改变一个人的人生观，财富观，世界观。可能对人的一生造成很大的影响。

评估技术的时候要理性的评估，不要头脑发热

Spring Boot 易学难精
- 问题不容易找到解决的方式，需要自己有经验，社交方式发生了改变。
application/html
- 介质 / 格式 / 限制

Properties 也可以是 XML

java.util.Properties#loadFromXML

Spring Cloud

Spring Cloud config

                          +-------------+         +-------------+
                          | Application |         |   Config    |
                   +----> |      A 1    | ----->  |             |-----+  
                   |      +-------------+         +-------------+     |
                   |                                                  |
+-------------+    |     +-------------+          +-------------+     |        +-------------+
| Application |----+---->| Application |          |   Config    |-----+----->  |     Git     |
|      A      |    |     |      A2     | ----->   |             |     |        |             |
+-------------+    |     +-------------+          +-------------+     |        +-------------+
                   |                                                  |
                   |      +-------------+         +-------------+     |
                   |      | Application |         |   Config    |     |
                   +----> |      A 3    | ----->  |             | ----+
                          +-------------+         +-------------+

config-server

                                                                         
+-------------+                                 +-------------+              +-------------+
|   config    |----+                            |   Config    |-----+----->  |     Git     |
|   client    |    |                      +-->  |    Server   |     |        |             |
+-------------+    |                      |     +-------------+     |        +-------------+
                   |                      |                         |
                   |                      |                         |                           ....
                   |                      |                         |
+-------------+    |     +-------------+  |      +-------------+    |        +-------------+
|    config   |----+---->| Application |  |      |   Config    |----+----->  |     Git     |
|    client   |    |     |      A2     | -+--->  |   Server    |    |        |             |
+-------------+    |     +-------------+  |      +-------------+    |        +-------------+
                   |                      |                         |
                   |                      |                         |                           ....
                   |                      |                         |
+-------------+    |                      |      +-------------+    |        +-------------+
|    config   |----+                      +----> |   Config    |----+----->  |     Git     |
|    client   |                                  |   Server    |             |             |
+-------------+                                  +-------------+             +-------------+

Apollo

+-----------+      +--------+                                              +--------------+
|  config   |----->|  WEB   |                                   +--Push--- |  Web Console |
|  client   |      |        | ----pull---> +-------------+      |          +--------------+ 
+-----------+      +--------+              |   Config    | <----+               
                                           |   Server    |                     
                                           +-------------+                             
                                                |            
                                                |                     +-------------+
                                                +---------------------|     Mysql   |
                                                                      |             |
                                                                      +-------------+

断路保护器

服务端，有保护器
客户端，也需要保护器

Spring Cloud config client

发布订阅模式

Observer / ` Observable`

事件监听模式

Event / EventListener

我们可以注册事件监听器，然后

我们可以发布事件，进行响应。

我们的

ConfigFileApplicationListener 配置服务器监听事件
- 我们可以配置很多个应用，意味着，我们可以有多个服务

META-INF/spring.factories

ApplicationListener=\
xxxListener,\
XXXListener
\xxx

BootstrapApplicationListener

优先于 ConfigFileApplicationListener 进行加载

EnvironmentEndpoint

关联多个带名称的 PropertySource

MutablePropertySources

关联然后进行修改。

Eureka

XML RPC
WebService -> SOAP
REST -> JSON/XML

高可用架构

URI
URL
Nginx
xxx

Eureka 客户端

Eureka 服务端

自我注册
- 快速失败
- 容错

高可用

Eureka 客户端的高可用
- 多个服务端
- 还可以替换掉健康检查的端口
服务端高可用
- 相互注册

Ribbon

IRule
- 各种规则

需要从整体的去把控，看到整个系统的全貌。

随机分配可能不太确定，所以还是轮询更加稳定一点。

Hystrix

整合 Turbine

聚合 Hystrix
- 把相同的应用的状态给集中起来。
- 配置集群的配置

Spring Cloud Demo ，不太完整。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-boot-starter-turbine</artifactId>
</dependency>

# 服务端口
sever.port=8080

# server port
management.port=8081

问答

Ribbon 是用来做什么，只能做负载均衡吗？

答：主要用户客户端均衡
Kafka 与 Active MQ

答：
- Active MQ 相对完善，
- Kafka 在能力上比较灵活放弃不少约束，性能相对较好
Java 基础的提高书籍

答：《Java 编程思想》、《Effect Java》………
{@link} ？？

答：Java Doc 一部分，
- {@link xxx} 引用到某个类
- @since 开始版本
- @version 当前版本
- @author 作者
- <code></code> 嵌入代码

Spring cloud config 配置，获取到 git 中的 properties 文件属性（my.name）嵌套在 Spring xml 中使用

答：利用注解 @ImportResource("abc.xml")

abc.xml

<bean id="person" class="com.darian.Person">
    <property name="name" value="${my.name}"/>
</bean>

启动类 Main.java

@ImportReource("abc.xml")
@SpringBootApplication
public class MainApplication {
   
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }
}

将实时数据放在 Redis，Stom 去消费号码？

答：Stom 对数据持久好一点，Redis 比 DB 逊色一点。

new SpringApplicationBuilder().sources(Appconfig.class) 方式启动，AppliConfig 和配置文件哪个先加载？

答：

Appconfig 是一个 @Configuration 的 class，配置文件是一个外部资源，不会相互影响，
- 如果 Appconfig 配置了 @PropertySource 或者 @PropertySources 的话，会优先加载 @PropertySource 中的配置资源。

@PropertySources(
    {
        @PropertySource(value = "config.properties",
                        encoding = "UTF-8"),
        @PropertySource(value = "config-3.config",
                        encoding = "GBK")
    }
)
@SpringBootApplication
public class Java9CoreApplication {
    //..........
    ////

Java 8 以后支持了 @Repeatable 可以同时标记多个。

人的依赖性不太好，要自己多多思考问题，再去和别人讨论。

Java9 新特性之核心库

Thu, 28 May 2020 00:00:00 +0000

Java 9 新特性之核心库（上）

主要议题

Java 9 新特性简介
Java 9 核心库
问答互动

新特性简介

重要新特性

模块化
核心库
安全
部署
JVM
调优

详情

http://docs.oracle.com/javase/9/whatsnew/toc.htm

Java 9 的模块化，最大的更新

jshell 的东西

在 Java 6 的时候，有 javascript on JVM

还有 Java 8 jcmd 可以调节参数

同一个类可以在不同的 jar 包用不同的版本。

`PropertyPermission`

在设置 #setProperties 的时候，就需要权限。

jdeps 分析数

Java doc 需要很好写

`javac` 就是 java compile

Source
Compile

`invokedynamic`

动态生成字节码指令

`JVM.logger`

统一的 Java 日志，要知道生产的状态，

GI 默认的垃圾回收

CMS 淘汰掉了

G1 - 越来越偏向与服务器，提升吞吐量

CMS 托管了，让大家取维护。

讨论范围

集合工厂方法（Factory Method of Collections）
进程（Process）
统一日志 API（Platform Logging API）
堆栈 API （Stack-Walking API）
变量处理（Variable Handles）
自旋等待提示（Spin-Wait Hints）
压缩字符串（Compact String）

GitHub 资源： https://github.com/mercyblitz

集合工厂方法（Factory Method of Collections）

Guava

Lists.newArrayList()

Apache common lang

StringUtils

Java

Objects

进程（Process）

`ProcessHandleDemo`

public class ProcessHandleDemo {
    public static void main(String[] args) {
        echoOnExit();
        echoAllProcessors();
    }

    private static void echeCurrentProcessonExit() {
        Runtime.getRuntime()
                .addShutdownHook(new Thread(() -> {
                    RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
                    String value = runtimeMXBean.getName(); // value=pid@xxx

                    String pid = value.substring(0, value.indexOf("@"));

                    
                    System.out.println("Current [" + ProcessHandle.current().pid()
                            + "]Process while on Exit! ");
                }));
    }

    private static void echoOnExit() {
        ProcessHandle.current()
                .onExit()
                .thenAccept(System.out::println);
    }

    private static void echoAllProcessors() {
        ProcessHandle.allProcesses().forEach(System.out::println);
    }
}

`ProcessHandle`

public interface ProcessHandle extends Comparable<ProcessHandle> {

    long pid();

    public static Optional<ProcessHandle> of(long pid) {
        return ProcessHandleImpl.get(pid);
    }

    // 所有的子、孙进程
    Stream<ProcessHandle> descendants();

    // 子进程
    static Stream<ProcessHandle> children(long pid) {
        //。。。
    }


    //    。。。。
}

https://github.com/mercyblitz/confucius-commons

https://github.com/mercyblitz/confucius-commons

package org.confucius.commons.lang.process;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.concurrent.TimeoutException;

/**
 * {@link Process} Executor
 *
 * @author <a href="mailto:mercyblitz@gmail.com">Mercy<a/>
 * @version 1.0.0
 * @see ProcessExecutor
 * @since 1.0.0
 */
public class ProcessExecutor {

    private static final long waitForTimeInSecond = Long.getLong("process.executor.wait.for", 1);
    private final String command;
    private final String arguments;
    private final Runtime runtime = Runtime.getRuntime();
    private final ProcessManager processManager = ProcessManager.INSTANCE;
    private boolean finished;

    /**
     * Constructor
     *
     * @param processName
     *         command
     * @param arguments
     *         process arguments
     */
    public ProcessExecutor(String processName, String... arguments) {
        StringBuilder argumentsBuilder = new StringBuilder();
        if (arguments != null) {
            for (String argument : arguments) {
                argumentsBuilder.append(" ").append(argument);
            }
        }
        this.arguments = argumentsBuilder.toString();
        this.command = processName + this.arguments;
    }

    /**
     * Execute current process.
     * <p/>
     * //     * @param inputStream  input stream keeps output stream from process
     *
     * @param outputStream
     *         output stream for process normal or error input stream.
     * @throws IOException
     *         if process execution is failed.
     */
    public void execute(OutputStream outputStream) throws IOException {
        try {
            this.execute(outputStream, Long.MAX_VALUE);
        } catch (TimeoutException e) {
        }
    }

    /**
     * Execute current process.
     * <p/>
     * //     * @param inputStream  input stream keeps output stream from process
     *
     * @param outputStream
     *         output stream for process normal or error input stream.
     * @param timeoutInMilliseconds
     *         milliseconds timeout
     * @throws IOException
     *         if process execution is failed.
     * @throws TimeoutException
     *         if the execution is timeout over specified <code>timeoutInMilliseconds</code>
     */
    public void execute(OutputStream outputStream, long timeoutInMilliseconds) throws IOException, TimeoutException {
        Process process = runtime.exec(command);
        long startTime = System.currentTimeMillis();
        long endTime = -1L;
        InputStream processInputStream = process.getInputStream();
        InputStream processErrorInputStream = process.getErrorStream();
//        OutputStream processOutputStream = process.getOutputStream();
        int exitValue = -1;
        while (!finished) {
            long costTime = endTime - startTime;
            if (costTime > timeoutInMilliseconds) {
                finished = true;
                process.destroy();
                String message = String.format("Execution is timeout[%d ms]!", timeoutInMilliseconds);
                throw new TimeoutException(message);
            }
            try {
                processManager.addUnfinishedProcess(process, arguments);
                while (processInputStream.available() > 0) {
                    outputStream.write(processInputStream.read());
                }
                while (processErrorInputStream.available() > 0) {
                    outputStream.write(processErrorInputStream.read());
                }
                exitValue = process.exitValue();
                if (exitValue != 0) {
                    throw new IOException();
                }
                finished = true;
            } catch (IllegalThreadStateException e) {
                // Process is not finished yet;
                // Sleep a little to save on CPU cycles
                waitFor(waitForTimeInSecond);
                endTime = System.currentTimeMillis();
            } finally {
                processManager.removeUnfinishedProcess(process, arguments);
            }
        }
    }

    /**
     * Wait for specified seconds
     *
     * @param seconds
     *         specified seconds
     */
    private void waitFor(long seconds) {
        try {
            Thread.sleep(seconds * 1000);
        } catch (InterruptedException e) {
            Thread.interrupted();
        }
    }

    /**
     * Check current process finish or not.
     *
     * @return <code>true</code> if current process finished
     */
    public boolean isFinished() {
        return finished;
    }
}

堆栈 API （Stack-Walking API）

java.lang.StackWalker
- java.lang.StackWalker.StackFrame

XXFrame 在 Java 里边是 帧 的意思。

package org.confucius.commons.lang.reflect;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.apache.commons.lang3.ClassUtils;
import org.apache.commons.lang3.reflect.ConstructorUtils;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.apache.commons.lang3.reflect.MethodUtils;

import javax.annotation.Nonnull;
import java.lang.reflect.*;
import java.util.List;
import java.util.Map;

/**
 * Reflection Utility class , generic methods are defined from {@link FieldUtils} , {@link MethodUtils} , {@link
 * ConstructorUtils}
 *
 * @author <a href="mailto:mercyblitz@gmail.com">Mercy</a>
 * @version 1.0.0
 * @see Method
 * @see Field
 * @see Constructor
 * @see Array
 * @see MethodUtils
 * @see FieldUtils
 * @see ConstructorUtils
 * @since 1.0.0
 */
public abstract class ReflectionUtils {

    /**
     * Sun JDK 实现类：sun.reflect.Reflection全名称
     */
    public static final String SUN_REFLECT_REFLECTION_CLASS_NAME = "sun.reflect.Reflection";

    /**
     * Current Type
     */
    private static final Class<?> TYPE = ReflectionUtils.class;
    /**
     * sun.reflect.Reflection方法名称
     */
    private static final String getCallerClassMethodName = "getCallerClass";
    /**
     * sun.reflect.Reflection invocation frame
     */
    private static final int sunReflectReflectionInvocationFrame;
    /**
     * {@link StackTraceElement} invocation frame
     */
    private static final int stackTraceElementInvocationFrame;
    /**
     * Is Supported sun.reflect.Reflection ?
     */
    private static final boolean supportedSunReflectReflection;
    /**
     * sun.reflect.Reflection#getCallerClass(int) method
     */
    private static final Method getCallerClassMethod;

    // Initialize sun.reflect.Reflection
    static {
        Method method = null;
        boolean supported = false;
        int invocationFrame = 0;
        try {
            // Use sun.reflect.Reflection to calculate frame
            Class<?> type = Class.forName(SUN_REFLECT_REFLECTION_CLASS_NAME);
            method = type.getMethod(getCallerClassMethodName, int.class);
            method.setAccessible(true);
            // Adapt SUN JDK ,The value of invocation frame in JDK 6/7/8 may be different
            for (int i = 0; i < 9; i++) {
                Class<?> callerClass = (Class<?>) method.invoke(null, i);
                if (TYPE.equals(callerClass)) {
                    invocationFrame = i;
                    break;
                }
            }
            supported = true;
        } catch (Exception e) {
            method = null;
            supported = false;
        }
        // set method info
        getCallerClassMethod = method;
        supportedSunReflectReflection = supported;
        // getCallerClass() -> getCallerClass(int)
        // Plugs 1 , because Invocation getCallerClass() method was considered as increment invocation frame
        // Plugs 1 , because Invocation getCallerClass(int) method was considered as increment invocation frame
        sunReflectReflectionInvocationFrame = invocationFrame + 2;
    }

    // Initialize StackTraceElement
    static {
        int invocationFrame = 0;
        // Use java.lang.StackTraceElement to calculate frame
        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
        for (StackTraceElement stackTraceElement : stackTraceElements) {
            String className = stackTraceElement.getClassName();
            if (TYPE.getName().equals(className)) {
                break;
            }
            invocationFrame++;
        }
        // getCallerClass() -> getCallerClass(int)
        // Plugs 1 , because Invocation getCallerClass() method was considered as increment invocation frame
        // Plugs 1 , because Invocation getCallerClass(int) method was considered as increment invocation frame
        stackTraceElementInvocationFrame = invocationFrame + 2;
    }

    /**
     * Get Caller class
     *
     * @return 获取调用该方法的Class name
     * @version 1.0.0
     * @since 1.0.0
     */
    @Nonnull
    public static String getCallerClassName() {
        return getCallerClassName(sunReflectReflectionInvocationFrame);
    }

    /**
     * Get Caller Class name
     *
     * @param invocationFrame
     *         invocation frame
     * @return Class name under specified invocation frame
     * @throws IndexOutOfBoundsException
     *         当<code>invocationFrame</code>数值为负数或者超出实际的层次
     * @version 1.0.0
     * @see Thread#getStackTrace()
     * @since 1.0.0
     */
    @Nonnull
    protected static String getCallerClassName(int invocationFrame) throws IndexOutOfBoundsException {
        if (supportedSunReflectReflection) {
            Class<?> callerClass = getCallerClassInSunJVM(invocationFrame + 1);
            if (callerClass != null)
                return callerClass.getName();
        }
        return getCallerClassNameInGeneralJVM(invocationFrame + 1);
    }

    /**
     * 通用实现方式，获取调用类名
     *
     * @return 调用类名
     * @version 1.0.0
     * @see #getCallerClassNameInGeneralJVM(int)
     * @since 1.0.0 2012-3-15 下午03:09:28
     */
    static String getCallerClassNameInGeneralJVM() {
        return getCallerClassNameInGeneralJVM(stackTraceElementInvocationFrame);
    }

    /**
     * 通用实现方式，通过指定调用层次数值，获取调用类名
     *
     * @param invocationFrame
     *         invocation frame
     * @return specified invocation frame 类
     * @throws IndexOutOfBoundsException
     *         当<code>invocationFrame</code>数值为负数或者超出实际的层次
     * @version 1.0.0
     * @see
     * @since 1.0.0 2012-3-15 下午02:43:47
     */
    static String getCallerClassNameInGeneralJVM(int invocationFrame) throws IndexOutOfBoundsException {
        StackTraceElement[] elements = Thread.currentThread().getStackTrace();
        StackTraceElement targetStackTraceElement = elements[invocationFrame];
        return targetStackTraceElement.getClassName();
    }

    static Class<?> getCallerClassInSunJVM(int realFramesToSkip) throws UnsupportedOperationException {
        if (!supportedSunReflectReflection) {
            throw new UnsupportedOperationException("需要SUN的JVM！");
        }
        Class<?> callerClass = null;
        if (getCallerClassMethod != null) {
            try {
                callerClass = (Class<?>) getCallerClassMethod.invoke(null, realFramesToSkip);
            } catch (Exception ignored) {
            }
        }
        if (callerClass != null) {
        }
        return callerClass;
    }

    /**
     * Get caller class in General JVM
     *
     * @param invocationFrame
     *         invocation frame
     * @return caller class
     * @version 1.0.0
     * @see #getCallerClassNameInGeneralJVM(int)
     * @since 1.0.0
     */
    static Class<?> getCallerClassInGeneralJVM(int invocationFrame) {
        String className = getCallerClassNameInGeneralJVM(invocationFrame + 1);
        Class<?> targetClass = null;
        try {
            targetClass = Class.forName(className);
        } catch (ClassNotFoundException impossibleException) {
            throw new IllegalStateException("How can?");
        }
        return targetClass;
    }

    /**
     * Get caller class
     * <p/>
     * For instance,
     * <pre>
     *     package com.acme;
     *     import ...;
     *     class Foo {
     *         public void bar(){
     *
     *         }
     *     }
     * </pre>
     *
     * @return Get caller class
     * @throws IllegalStateException
     *         无法找到调用类时
     * @version 1.0.0
     * @since 1.0.0 2012-2-28 下午07:42:26
     */
    @Nonnull
    public static Class<?> getCallerClass() throws IllegalStateException {
        return getCallerClass(sunReflectReflectionInvocationFrame);
    }

    /**
     * Get caller class In SUN HotSpot JVM
     *
     * @return Caller Class
     * @throws UnsupportedOperationException
     *         If JRE is not a SUN HotSpot JVM
     * @version 1.0.0
     * @see #getCallerClassInSunJVM(int)
     * @since 1.0.0
     */
    static Class<?> getCallerClassInSunJVM() throws UnsupportedOperationException {
        return getCallerClassInSunJVM(sunReflectReflectionInvocationFrame);
    }

    /**
     * Get caller class name In SUN HotSpot JVM
     *
     * @return Caller Class
     * @throws UnsupportedOperationException
     *         If JRE is not a SUN HotSpot JVM
     * @version 1.0.0
     * @see #getCallerClassInSunJVM(int)
     * @since 1.0.0
     */
    static String getCallerClassNameInSunJVM() throws UnsupportedOperationException {
        Class<?> callerClass = getCallerClassInSunJVM(sunReflectReflectionInvocationFrame);
        return callerClass.getName();
    }

    /**
     * @param invocationFrame
     *         invocation frame
     * @return
     * @version 1.0.0
     * @see
     * @since 1.0.0
     */
    static Class<?> getCallerClass(int invocationFrame) {
        if (supportedSunReflectReflection) {
            Class<?> callerClass = getCallerClassInSunJVM(invocationFrame + 1);
            if (callerClass != null)
                return callerClass;
        }
        return getCallerClassInGeneralJVM(invocationFrame + 1);
    }

    /**
     * Get caller class in General JVM
     *
     * @return Caller Class
     * @version 1.0.0
     * @see #getCallerClassInGeneralJVM(int)
     * @since 1.0.0 2012-3-15 下午03:11:16
     */
    static Class<?> getCallerClassInGeneralJVM() {
        return getCallerClassInGeneralJVM(stackTraceElementInvocationFrame);
    }

    /**
     * Get caller class's {@link Package}
     *
     * @return caller class's {@link Package}
     * @throws IllegalStateException
     *         see {@link #getCallerClass()}
     * @version 1.0.0
     * @see #getCallerClass()
     * @since 1.0.0
     */
    public static Package getCallerPackage() throws IllegalStateException {
        return getCallerClass().getPackage();
    }

    /**
     * Assert array index
     *
     * @param array
     *         Array object
     * @param index
     *         index
     * @throws IllegalArgumentException
     *         see {@link ReflectionUtils#assertArrayType(Object)}
     * @throws ArrayIndexOutOfBoundsException
     *         If <code>index</code> is less than 0 or equals or greater than length of array
     */
    public static void assertArrayIndex(Object array, int index) throws IllegalArgumentException {
        if (index < 0) {
            String message = String.format("The index argument must be positive , actual is %s", index);
            throw new ArrayIndexOutOfBoundsException(message);
        }
        ReflectionUtils.assertArrayType(array);
        int length = Array.getLength(array);
        if (index > length - 1) {
            String message = String.format("The index must be less than %s , actual is %s", length, index);
            throw new ArrayIndexOutOfBoundsException(message);
        }
    }

    /**
     * Assert the object is array or not
     *
     * @param array
     *         asserted object
     * @throws IllegalArgumentException
     *         if the object is not a array
     */
    public static void assertArrayType(Object array) throws IllegalArgumentException {
        Class<?> type = array.getClass();
        if (!type.isArray()) {
            String message = String.format("The argument is not an array object, its type is %s", type.getName());
            throw new IllegalArgumentException(message);
        }
    }

    /**
     * Assert Field type match
     *
     * @param object
     *         Object
     * @param fieldName
     *         field name
     * @param expectedType
     *         expected type
     * @throws IllegalArgumentException
     *         if type is not matched
     */
    public static void assertFieldMatchType(Object object, String fieldName, Class<?> expectedType) throws IllegalArgumentException {
        Class<?> type = object.getClass();
        Field field = FieldUtils.getDeclaredField(type, fieldName, true);
        Class<?> fieldType = field.getType();
        if (!expectedType.isAssignableFrom(fieldType)) {
            String message = String.format("The type[%s] of field[%s] in Class[%s] can't match expected type[%s]", fieldType.getName(), fieldName, type.getName(), expectedType.getName());
            throw new IllegalArgumentException(message);
        }
    }


    /**
     * Convert {@link Array} object to {@link List}
     *
     * @param array
     *         array object
     * @return {@link List}
     * @throws IllegalArgumentException
     *         if the object argument is not an array
     */
    @Nonnull
    public static <T> List<T> toList(Object array) throws IllegalArgumentException {
        int length = Array.getLength(array);
        List<T> list = Lists.newArrayListWithCapacity(length);
        for (int i = 0; i < length; i++) {
            Object element = Array.get(array, i);
            list.add((T) toObject(element));
        }
        return list;
    }

    private static Object toObject(Object object) {
        if (object == null) {
            return object;
        }
        Class<?> type = object.getClass();
        if (type.isArray()) {
            return toList(object);
        } else {
            return object;
        }
    }


    /**
     * Read fields value as {@link Map}
     *
     * @param object
     *         object to be read
     * @return fields value as {@link Map}
     */
    @Nonnull
    public static Map<String, Object> readFieldsAsMap(Object object) {
        Map<String, Object> fieldsAsMap = Maps.newLinkedHashMap();
        Class<?> type = object.getClass();
        Field[] fields = type.getDeclaredFields();
        for (Field field : fields) {

            if (Modifier.isStatic(field.getModifiers())) { // To filter static fields
                continue;
            }

            field.setAccessible(true);

            try {
                String fieldName = field.getName();
                Object fieldValue = field.get(object);
                if (fieldValue != null) {
                    Class<?> fieldValueType = fieldValue.getClass();
                    if (ClassUtils.isPrimitiveOrWrapper(fieldValueType)) {
                    } else if (fieldValueType.isArray()) {
                        fieldValue = toList(fieldValue);
                    } else if ("java.lang".equals(fieldValueType.getPackage().getName())) {

                    } else {
                        fieldValue = readFieldsAsMap(fieldValue);
                    }
                }
                fieldsAsMap.put(fieldName, fieldValue);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return fieldsAsMap;
    }


}

public class ReflectionUtilsTest extends AbstractTestCase {

    //。。。。。。

    @Test
    public void testGetCallerClassNamePerformance() {

        for (int i = 0; i < 6; i++) {
            int times = (int) Math.pow(10 + .0, i + .0);
            testGetCallerClassNameInSunJVMPerformance(times);
            testGetCallerClassNameInGeneralJVMPerformance(times);
            System.out.println();
        }
    }

    private void testGetCallerClassNameInSunJVMPerformance(int times) {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < times; i++) {
            ReflectionUtils.getCallerClassNameInSunJVM();
        }
        long costTime = System.currentTimeMillis() - startTime;
        System.out.printf("It's cost to execute ReflectionUtils.getCallerClassNameInSunJVM() %d times : %d ms！\n", times, costTime);
    }

    private void testGetCallerClassNameInGeneralJVMPerformance(int times) {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < times; i++) {
            ReflectionUtils.getCallerClassNameInGeneralJVM();
        }
        long costTime = System.currentTimeMillis() - startTime;
        System.out.printf("It's cost to execute ReflectionUtils.getCallerClassNameInGeneralJVM() %d times : %d ms！\n", times, costTime);
    }

    // 。。。。
}

//,......
It's cost to execute ReflectionUtils.getCallerClassNameInSunJVM() 100000 times : 34 ms！
It's cost to execute ReflectionUtils.getCallerClassNameInGeneralJVM() 100000 times : 4016 ms！

区别

sun.reflect.Reflection 内部的 #getCallerClass 方法

为什么异常会特别的费时间。

主要是在

Throwable#fillInStackTrace

private native Throwable fillInstackTrace(int dummy);

`sun.misc.Unsafe` -> `VariableHandle`

计算偏移量

@ForceInline
public void putObject(Object o, long offset, Object x) {
    theInternalUnsafe.putObject(o, offset, x);
}

稍有不慎，JVM 就可能挂掉了。

`VarHandle` 用法

private static void testVarHandle() throws NoSuchFieldException, IllegalAccessException {
    A a = new A();

    VarHandle varHandle;

    varHandle = MethodHandles.lookup()
        .in(A.class)
        .findVarHandle(A.class, "value", String.class);


    // CAS = 首先比较对等性，然后才能设置
    varHandle.compareAndSet(a, "Hellxx", "World");
    System.out.println(a.value);

    varHandle.compareAndSet(a, "Hello", "World");
    System.out.println(a.value);
}

统一日志 API （Platform Logging API）

Apache commons-logging : facade API for Java Logging And Log4j
Slf-api : java logging + log4j + logback
Java 9 : System.Logger 它想把其他的给统一掉，还想模块化。

Slf-api 没有把 Log4j2 搞进去

Spring Framework < 5.0 : Commons-logging
Spring Framework >- 5.0 : Slf4j-api
Spring Framework > 6 : Java 9 Logger 可能，猜测的。

自旋等待提示（Spin-Wait Hints）

As a practical example and use case, current x86 processors support a PAUSE instruction that can be used to indicate spinning behavior. Using a PAUSE instruction demonstrably reduces thread-to-thread round trips. Due to its benefits and widely recommended use, the x86 PAUSE instruction is commonly used in kernel spinlocks, in POSIX libraries that perform heuristic spins prior to blocking, and even by the JVM itself. However, due to the inability to hint that a Java loop is spinning, its benefits are not available to regular Java code.

作为一个实际示例和用例，当前 x86 处理器支持一个 PAUSE 指令，该指令可用于指示旋转行为。使用 PAUSE 指令可明显减少线程到线程的往返行程。由于其优点和广泛推荐的用途，x86 PAUSE 指令通常用于内核自旋锁、在阻止前执行启发式旋转的 POSIX 库中，甚至由 JVM 本身使用。但是，由于无法提示 Java 循环正在旋转，因此常规 Java 代码无法使用其优点。

An empty method would be a valid implementation of the java.lang.Thread.onSpinWait() method, but an intrinsic implementation is the obvious goal for hardware platforms that can benefit from it. We intend to produce an intrinsic x86 implementation for the JDK as part of this JEP. A prototype implementation already exists and results from initial testing show promise. Refer to JBS bug JDK-8147844 for pointers to webrevs with the proposed changes in class libraries and JVM.

空方法是 java 的有效实现。朗。线程。onSpinWait（）方法，但内在实现是硬件平台的明显目标，可以从中获益。作为 JEP 的一部分，我们打算为 JDK 生成一个内部 x86 实现。原型实现已经存在，初始测试的结果显示出希望。有关类库和 JVM 中建议的更改指向 Webrev 的指针，请参阅 JBS bug JDK-81478444。

java.lang.Thread#onSpinWait

    @HotSpotIntrinsicCandidate
    public static void onSpinWait() {}

就是，你调用一下，JVM 就知道了你要用 自旋锁了

压缩字符串（Compact String）

http://openjdk.java.net/jeps/254

在 Java 6 版本已经

Java6 里边都有了 -XX:+UserCompressedStrings 都已经做掉了，可以占用更少的内存

Java9 模块化

Wed, 27 May 2020 00:00:00 +0000

JAVA 9 的模块化

模块化前时代

Ant 时代（时代比较老）
Maven 时代（Gradle）
OSGI 时代（ ~~没用过~~ ）

Ant

javac 命令，Java 早就有了，

<!--... -->
<target>
    <delete dir="${file}"/>
</target>
<!--... -->

主要进行了文件操作。

Maven

文件管理 <resource>
版本管理 <dependency> ， GAV 帮我们确定一个版本。
- dependencyManagement

缺点

编译时进行处理的，运行时加载的一些类，

OSGI

http://enroute.osgi.org

运行时操作的

OSGI 并不比模块化特别差。

Eclipse 就是基于 OSGI 来构建的。

Spring 也支持过 OSGI，动态模块化，OSGI 反而把问题搞复杂了，间接依赖很难去把控

加载的时候，文件系统不一定加载具体某个版本。

       
    +--------------+                     +--------------+
    |  ObjectUtils |                     |  StringUtils |
    +--------------+                     +--------------+ 
           |                                   |
           |                                   |
           +-----------------+-----------------+
                             |
    +------------------------+------------------------------+   文件系统
    |                        |                              |
    |        +-------------—-+----------+                   |
    |        |                          |                   |
    |   +------------------+      +------------------+      |
    |   | commons-lang 2.4 |      | commons-lang 2.6 |      |
    |   +------------------+      +------------------+      |
    |                                                       |
    +-------------------------------------------------------+
    

文件系统加载的不确定性，#list(File) 加载的不确定性。

                         +--------------+         
                         |    Tomcat    |         
                         +--------------+ 
                               |
                             Tomcat/lib
                               |
                         +---------------+         
                         |  ClassLoader  |
                         |    Commons    |       
                         +---------------+ 
                                |
            +-------------------+---------------------+
            |                                         |
      +-------------+                          +-------------+
      |    App1     |                          |   App1      |
      +-------------+                          +-------------+
           |                                           |
         WEB-INF/lib                                WEB-INF/lib
           |                                           |
      +---------------+                        +---------------+  
      | ClassLoader1  |                        | ClassLoader1  |   
      +---------------+                        +---------------+ 
           |                                          |
           |                                          |
      +---------------+                        +---------------+  
      | ClassLoader1  |                        | ClassLoader1  |   
      +---------------+                        +---------------+ 
      
      ~app1/WEB-INF/                           ~app1/WEB-INF/
      lib/commons-lang-2.4.jar                  lib/commons-lang-2.5.jar

Tomcat 有自己的 Commons

我们启动程序有一个 -classpath 环境变量，会导致另一个事情，没有办法区分。

在本地环境可以，在线上部署的时候不可以的时候，

ClassLoader
Tomcat 有一个 WebAppClassLoader extends URLClassLoader

在 -classpath 里边的时候就是先来先服务，主要就是一位内 URLClassLoader 的 addURL 方法。

URLClassLoader#findClass

就是 getResource 的方法，先来先服务。通过类文件去寻找。
- return defineClass(className)

如果可以清楚的知道我 jar 包的版本

NoSuchMethodException

模块化

模块声明
- module com.darian{}
- 依赖
  - requires
- 导出
  - exports

D:\anzhuanga\Java\jdk-11.0.1\bin\java.exe "-javaagent:D:\anzhuang\IntelliJ IDEA 2020.1\lib\idea_rt.jar=6529:D:\anzhuang\IntelliJ IDEA 2020.1\bin" -Dfile.encoding=UTF-8 -p D:\GitHub_Repositories\mercyblitz-gp-public\java9-modular-demo\out\production\java9-modular-demo -m com.darian/helloworld.com.darian.java9.helloWorld.HelloWorldMain
Hello, World

-m -p

- module-path 没有了 classpath，一直跟到了 module-info 路径下边，

问题

模块不是想要什么就有什么。

如果把 module 删了的化，还是想用啥用啥。

module com.darian {
    requires java.logging;
    requires java.management;
}

/***
 *
 *
 * @author <a href="mailto:1934849492@qq.com">Darian</a> 
 * @date 2020/5/28  9:16
 */
public class HelloWorldMain {
    public static void main(String[] args) {
        Logger logger = Logger.getLogger(HelloWorldMain.class.getName());
        logger.info("xxx");
        System.out.println("Hello, World");

        RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
        System.out.println(runtimeMXBean.getUptime());
    }
}

优点

就是我们按需引入就好了

缺点

就是我们不许知道在类在哪里。

运行时，只需要运行我的 jar 包就更小了，就会容量变得更加的小。

它还可以显示的帮我做隔离，

另一个目录下可以引入另一个模块。

Java 的另一个程序支持，引入就可以

定义模块

模块结构
模块描述文件
- - module-info.class
Java 平台模块

在模块化里边，并没有了 public 的类。

必须显示的 exports ，支队本模块来可读性

启动的时候，会更加的小。

Maven 的使用就发生了变化。

使用模块

模块路径
模块解析
模块可读性
模块访问性
隐形可读性

变化

-module-path 取代了 class-path

module user.domain {
    exports com.darian.domain;
    // 不需要依赖其他模块
}

module user.service {

    // transitive 传递依赖
    requires transitive user.domain;
    requires java.logging;

    // 导出
    // 1. 本模块的 public class 需要显示的 exports
    // 2. exports 不支持子包传递
    exports com.darian.service;
    exports com.darian.service.impl;
}

module bootstrap {

    requires  user.service;
}

你可以传递依赖过来。

传递依赖会特别麻烦。
没有增加复杂度，只是增加了透明度。

高端玩家的游戏

JAVA 9 是 -claspath 和 -module-path 混用。

工具整合

Maven
IDE
- Idea

兼容性

非命名模块
自动模块

D:\anzhuanga\Java\jdk-11.0.1\bin\java.exe "-javaagent:D:\anzhuang\IntelliJ IDEA 2020.1\lib\idea_rt.jar=8021:D:\anzhuang\IntelliJ IDEA 2020.1\bin" -Dfile.encoding=UTF-8 -p D:\GitHub_Repositories\mercyblitz-gp-public\java9-module-demo\bootstrap\target\classes;D:\GitHub_Repositories\mercyblitz-gp-public\java9-module-demo\user-service\target\classes;D:\GitHub_Repositories\mercyblitz-gp-public\java9-module-demo\user\target\classes;

...

Java 9 以后通过，-p 引入

就是 module-path 和 class-path 类似，

它即使可以帮你把这个东西搞进来，但是它还是无法预判你用到了哪些东西

你看不出来一个很明显的提升

https://openjdk.java.net/projects/jigsaw/spec/sotms

使用场景

当你场景受限，需要直系依赖的时候就有用了。

Spring 的使用

spring.io 工程。
- https://spring.io/projects/platform#learn
  - spring-io-platform 帮你做到了版本管理，
  - 而我们用模块化的时候，当工具做的更好的时候，可能使用的更加顺手

$ java --list-modules
java.base@11.0.1
java.compiler@11.0.1
java.datatransfer@11.0.1
java.desktop@11.0.1
java.instrument@11.0.1
java.logging@11.0.1
java.management@11.0.1
java.management.rmi@11.0.1
java.naming@11.0.1
java.net.http@11.0.1
java.prefs@11.0.1
java.rmi@11.0.1
java.scripting@11.0.1

微服务网关新选择 spring cloud gateway

Tue, 26 May 2020 00:00:00 +0000

微服务网关新选择 Spring Cloud Gateway

本次目标

项目总览

spring-cloud-zuul-demo : http://localhost:9090/rest-api/helloWorld
路由：
熔断：100ms，增加等待时间，随机 0-199ms
- rest-service-provider-demo : http://localhost:8080/helloWorld
spring-cloud-gateway-demo
- http://localhost:7070/rest-api/helloWorld
- http://localhost:7070/rest-service/helloWorld
  - 都可以调用到 http://localhost:8080/helloWorld

zuul 的第一次会比较慢。

回顾 Spring Cloud Zuul

掌握 Spring Cloud Gateway 基本使用

This project provides an API Gateway built on top of the Spring Ecosystem, including: Spring 5, Spring Boot 2 and Project Reactor. Spring Cloud Gateway aims to provide a simple, yet effective way to route to APIs and provide cross cutting concerns to them such as: security, monitoring/metrics, and resiliency.

Spring Cloud Gateway requires the Netty runtime provided by Spring Boot and Spring Webflux. It does not work in a traditional Servlet Container or when built as a WAR.

2. Glossary

Route: The basic building block of the gateway. It is defined by an ID, a destination URI, a collection of predicates, and a collection of filters. A route is matched if the aggregate predicate is true.

Predicate: This is a Java 8 Function Predicate. The input type is a Spring Framework ServerWebExchange. This lets you match on anything from the HTTP request, such as headers or parameters.

Filter: These are instances of Spring Framework GatewayFilter that have been constructed with a specific factory. Here, you can modify requests and responses before or after sending the downstream request.

他以 Spring 5 ,Spring Boot 2.0 为基础，做的 API，快速的构建。

基于 Netty，然后不是在 Servlet 应用中。

术语

路由
判断
过滤器

整合 Spring WebFlux

网关选型

Spring Cloud Zuul

Servlet API

Spring Cloud GateWay

Netty
Reactor- > netty

Netfliz Zuul2

netty

Sevlet

Nginx

Kong

c
http proxy

Envoy

httpProxy

OpenResty 可以自己去链接数据库，自己去做，一些事情。重要的是转发。

技术支持

Reactive Route 写法

函数式比声明式的优势在哪里？

在 Java 中，语言规范规定，注解里边的只能用常量，不能用非常量。这个值一旦定义好以后，就不能改了。
所以 Route 的写法弹性就很大，

package com.darian.restserviceproviderdemo.reactive.web;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;

import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;

/***
 *
 *
 * @author <a href="mailto:1934849492@qq.com">Darian</a>
 * @date 2020/5/27  10:13
 */
@Configuration
public class ReactiveWebEndpointConfiguration {

    @GetMapping("/helloWorld_1")
    @ResponseBody
    public String helloWorld() {
        return "hello, world!";
    }

    /**
     * Response
     * -- status = "200"
     * -- body = "hello, world";
     * HTTP Method = GET
     * HTTP URI = /helloWorld
     * Q: 这比传统 Controller 优势在哪里
     * --
     * return ServerResponse
     * Reactor
     * Publish -> Mono(0,1) | Flux(0,n)
     */
    @Bean
    public RouterFunction<ServerResponse> helloWorldRouteFunction() {
        return route(GET("/helloWorld"),
                request -> ServerResponse.ok() // 200
                        .body(Mono.just("Hello, world"), String.class));
    }

}

Spring Cloud-Gateway 代码

server.port=7070
spring.cloud.gateway.routes[0].id=gateway
spring.cloud.gateway.routes[0].uri=http://127.0.0.1:8080
spring.cloud.gateway.routes[0].predicates[0]=Path=/rest-api/helloWorld
#spring.cloud.gateway.routes[0].predicates[0].args=
# 姐去掉一段， /rest-api/ 去掉
spring.cloud.gateway.routes[0].filters[0]=StripPrefix=1
spring.cloud.gateway.routes[0].filters[1].name=Hystrix
spring.cloud.gateway.routes[0].filters[1].args.name=rest
spring.cloud.gateway.routes[0].filters[1].args.fallbackUri=forward:/fallback

# 配置熔断, 100 ms
hystrix.command.rest.execution.isolation.thread.timeoutInMilliseconds=100
logging.level.root = debug

package com.darian.springcloudgatewaydemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

import java.net.URI;
import java.util.Optional;
import java.util.function.Function;

import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;

@SpringBootApplication
//@RestController
public class SpringCloudGatewayDemoApplication {

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

    //@GetMapping("/fallback")
    //public String fallback() {
    //    return "fallback...";
    //}

    // webFlux: Function Endpoint
    @Bean
    public RouterFunction<ServerResponse> helloWorldRouteFunction() {
        return route(GET("/fallback"),
                request -> {
                    return ServerResponse.ok() // 200
                            .body(Mono.just("fallback...."), String.class);
                });
    }

    // Gateway Function Endpoint
    @Bean
    public RouteLocator routeLocator(RouteLocatorBuilder builder) {

        return builder.routes()
                .route("rest-api",// id
                        r -> r.path("/rest-service/helloWorld")
                                .uri("http://localhost:8080/helloWorld"))
                .build();  // 返回 RouteLocator
    }
}

测试，两个链接，一个是配置的，一个是手动的

http://localhost:7070/rest-service/helloWorld
http://localhost:7070/rest-api/helloWorld

微服务网关整合

Mon, 25 May 2020 00:00:00 +0000

微服务网关整合

整体架构图

Kong 的使用

Spring Cloud Zuul

proxyServlet -> localhost:8080
http://localhost:9090/proxy-servlet/
- http://localhost:8080/

网关架构

方案一 : Nginx + Lua

方案二： Nginx + Lua = Openresty

方案三： Nginx + Lua + DB = Kong

Kong 的使用（Windows）

kong 的安装文档：https://konghq.com/install/
kong 的 Docker 安装文档：https://docs.konghq.com/install/docker/

安装 Docker

下载 Docker Toolbox

windows 10 一下的版本：https://docs.docker.com/toolbox/overview/
Docker Image + Oracle Virtual VM

$ docker container ls -all

$ docker rm xxxx

Docker 安装 Kong

$

创建网络

docker network create kong-net

启动数据库

docker run -d --name kong-database \
               --network=kong-net \
               -p 5432:5432 \
               -e "POSTGRES_USER=kong" \
               -e "POSTGRES_DB=kong" \
               -e "POSTGRES_PASSWORD=kong" \
               postgres:9.6

准备数据库

docker run --rm \
     --network=kong-net \
     -e "KONG_DATABASE=postgres" \
     -e "KONG_PG_HOST=kong-database" \
     -e "KONG_PG_PASSWORD=kong" \
     -e "KONG_CASSANDRA_CONTACT_POINTS=kong-database" \
     kong:latest kong migrations bootstrap

启动 Kong

docker run -d --name kong \
     --network=kong-net \
     -e "KONG_DATABASE=postgres" \
     -e "KONG_PG_HOST=kong-database" \
     -e "KONG_PG_PASSWORD=kong" \
     -e "KONG_CASSANDRA_CONTACT_POINTS=kong-database" \
     -e "KONG_PROXY_ACCESS_LOG=/dev/stdout" \
     -e "KONG_ADMIN_ACCESS_LOG=/dev/stdout" \
     -e "KONG_PROXY_ERROR_LOG=/dev/stderr" \
     -e "KONG_ADMIN_ERROR_LOG=/dev/stderr" \
     -e "KONG_ADMIN_LISTEN=0.0.0.0:8001, 0.0.0.0:8444 ssl" \
     -p 8000:8000 \
     -p 8443:8443 \
     -p 127.0.0.1:8001:8001 \
     -p 127.0.0.1:8444:8444 \
     kong:latest

docker run -d --name kong      --network=kong-net      -e "KONG_DATABASE=postgres"      -e "KONG_PG_HOST=kong-database"      -e "KONG_PG_PASSWORD=kong"      -e "KONG_CASSANDRA_CONTACT_POINTS=kong-database"      -e "KONG_PROXY_ACCESS_LOG=/dev/stdout"      -e "KONG_ADMIN_ACCESS_LOG=/dev/stdout"      -e "KONG_PROXY_ERROR_LOG=/dev/stderr"      -e "KONG_ADMIN_ERROR_LOG=/dev/stderr"      -e "KONG_ADMIN_LISTEN=0.0.0.0:8001, 0.0.0.0:8444 ssl"      -p 8000:8000      -p 8443:8443      -p 127.0.0.1:8001:8001      -p 127.0.0.1:8444:8444      kong:latest

Kong 网关服务

https://docs.konghq.com/0.13.x/getting-started/configuring-a-service/

注册服务

curl -i -X POST \
  --url http://localhost:8001/services/ \
  --data 'name=example-service' \
  --data 'url=http://mockbin.org'

添加服务路由

curl -i -X POST \
  --url http://localhost:8001/services/example-service/routes \
  --data 'hosts[]=example.com'

添加服务实例

https://docs.konghq.com/0.13.x/loadbalancing/#blue-green-deployments

curl -X POST http://192.168.0.1:8001/upstreams \
    --data "name=test-service"

curl -X POST http://192.168.0.1:8001/upstreams/test-service/targets \
    --data "target=192.168.0.1:80"
    --data "weight=100"

curl -X POST http://192.168.0.1:8001/services/ \
    --data "name=test-service" \
    --data "host=test-service" \
    --data "path=/address"

curl -X POST http://192.168.0.1:8001/services/ \
    --data "name=test-service" \
    --data "url=http://192.168.0.1:8080"

curl -X POST http://192.168.0.1:8001/services/test-service/routes/ \
    --data "paths[]=/test1"

网页输入：转发成功

192.168.0.1:8000/test1

Eureka

Eureka 的注册是被动的，

Kong 是主动的。

Eureka 是 Java，必须重新拉取，还有是内存型的，需要全部的拉取。容易 hang 住。

当你不想用 Eureka 来做注册中心的时候，Kong 是另一个方案。

微服务网关设计

Sun, 24 May 2020 00:00:00 +0000

微服务网关设计

网关整体设计架构图

Spring Cloud 官网：

Zuul

Authentication 认证

Insights

Stress Testing 压力测试

Canary Testing 金丝雀发布

Dynamic Routing 动态路由

Service Migration 服务整合

Load Shedding 负载保护

Security 安全

Static Response handling 静态输出

Active/Active traffic management 活动管理

不全是这些

Kong 的方案

有一个 DNS 的方案，比较偷懒的方案

操作日志保存在哪里

操作日志要看重要程度与否，一般来说，可以存在数据库，也可以存在其他地方。

大多数都存在宽表，NoSQL，HBase 数据库中，或者时序数据库中，因为你需要 memery reduce，因为，你需要记录你登陆多少次，在数据库中是很难做的，你可以 Count ，但是不会这么做，

软负载和硬负载

硬负载
软负载
- DNS 的负载
- Ring 环网的负载

策略

各种策略都可以自定义，

最小访问次数等等

Kong 的 API，

负载均衡是一个算法，

但是反向代理是一个程序

手写网关

代码

package com.darian.proxydemo.controller;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StreamUtils;
import org.springframework.web.client.RestTemplate;

import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletOutputStream;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.*;

/***
 *
 *
 * @author <a href="mailto:1934849492@qq.com">Darian</a>
 * @date 2020/5/27  3:57
 */
@WebServlet(name = "proxy", urlPatterns = "/proxy/*")
public class ProyServlet extends HttpServlet {

    // Proxy -> POST GET
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 请求头，请求体
        // header、Body

        // Client(Header + Body proxy forward => IP.PORT)
        // X-forwarded-For如果请求套存在，使用该值
        //Client 127.0.0.1 ->Proxy(168.0.0.)
        // httpServletRequest -> HttpClient > 192.0.0.1

        // 转发客户端
        RestTemplate restTemplate = new RestTemplate();

        // 执行请求到目标服务器(支持https)
        // 当前端口 8080
        // 目标服务器
        String RootURL = "http://www.baidu.com";
        RootURL = "http://localhost:8080";

        // Accept:  Request -> http://localhost:8080/abc -> RequestURI + "/abc"
        // target URL  => http://localhost:9090/abc
        String targetURL = RootURL + request.getRequestURI().substring("/proxy".length());
        // 构造 Request 实体
        RequestEntity requestEntity = null;
        try {
            requestEntity = createRequestEntity(request, targetURL);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }


        ResponseEntity<byte[]> responseEntity = restTemplate
                .exchange(requestEntity, byte[].class);

        wirteHeaders(responseEntity, response);
        writeBody(responseEntity, response);


    }

    private RequestEntity<byte[]> createRequestEntity(
            HttpServletRequest request, String url) throws URISyntaxException, IOException {
        String method = request.getMethod();
        HttpMethod httpMethod = HttpMethod.resolve(method);
        byte[] body = createRequestEntity(request);
        MultiValueMap<String, String> headers = createRequestHeaders(request);
        RequestEntity<byte[]> requestEntity = new RequestEntity(body, headers, httpMethod, new URI(url));

        return requestEntity;
    }


    private MultiValueMap<String, String> createRequestHeaders(HttpServletRequest request) {
        HttpHeaders headers = new HttpHeaders();

        ArrayList<String> headerNames = Collections.list(request.getHeaderNames());
        for (String headerName : headerNames) {
            ArrayList<String> headerValues = Collections.list(request.getHeaders(headerName));

            for (String headerValue : headerValues) {
                headers.add(headerName, headerValue);
            }
        }
        return headers;
    }

    private byte[] createRequestEntity(HttpServletRequest request) throws IOException {
        ServletInputStream inputStream = request.getInputStream();
        return StreamUtils.copyToByteArray(inputStream);
    }


    private void preparedHeaders(HttpServletRequest request,
                                 RequestEntity<byte[]> requestEntity) {
        // 准备请求头
        HttpHeaders headers = requestEntity.getHeaders();

        List<String> headerNames = Collections.list(request.getHeaderNames());

        for (String headerName : headerNames) {
            List<String> headerValues = Collections.list(request.getHeaders(headerName));
            for (String headValue : headerValues) {
                headers.add(headerName, headValue);
            }
        }
    }


    /**
     * 输出 Body 部分
     *
     * @param responseEntity
     * @param response
     * @throws IOException
     */
    private void writeBody(ResponseEntity<byte[]> responseEntity,
                           HttpServletResponse response) throws IOException {
        if (responseEntity.hasBody()) {
            byte[] body = responseEntity.getBody();
            // 输出二进制值
            ServletOutputStream servletOutputStream = response.getOutputStream();
            // 输出 ServletOutputStream
            servletOutputStream.write(body);
            servletOutputStream.flush();

        }
    }

    private void wirteHeaders(ResponseEntity<byte[]> responseEntity,
                              HttpServletResponse httpServletResponse) {
        // 获取响应的头
        HttpHeaders httpHeaders = responseEntity.getHeaders();
        // 输出转发 Response 头
        for (Map.Entry<String, List<String>> entry : httpHeaders.entrySet()) {
            String headerName = entry.getKey();
            List<String> headerValues = entry.getValue();

            for (String headerValue : headerValues) {
                httpServletResponse.addHeader(headerName, headerValue);
            }
        }

    }

    public static void main(String[] args) throws Exception {
        // 创建转发客户端
        RestTemplate restTemplate = new RestTemplate();
        RequestEntity requestEntity = new RequestEntity(HttpMethod.GET, new URI("http://www.baidu.com"));
        ResponseEntity<byte[]> responseEntity = restTemplate.exchange("http://www.baidu.com",
                HttpMethod.GET,
                requestEntity,
                byte[].class);

        System.err.println("responseEntity : \n" + responseEntity);
        System.err.println("responseEntity.getBody() : \n" + new String(responseEntity.getBody()));

    }
}

结果

http://localhost:8080/proxy/abc

-> 转发到   http://localhost:8080/abc

两个的结果都是

{
  status: "OK",
  msg: "成功",
  url: "/abc"
}

http://localhost:8080/proxy/

-> 转发到   http://localhost:8080/

两个的结果都是

{
  status: "OK",
  msg: "成功",
  url: "/"
}

Zuul 原理

可以通过我的应用名称反向的寻找我的服务列表
- 需要借助于 Eureka

Zuul

com.netflix.zuul.filters.ZuulServletFilter

com.netflix.zuul.filters.ZuulServletFilter#doFilter

this#preRouting

this#routing

  void routing() throws ZuulException {
   this.zuulRunner.route();
  }

com.netflix.zuul.ZuulRunner#route
- com.netflix.zuul.FilterProcessor#route
  - List<ZuulFilter> list = FilterLoader.getInstance().getFiltersByType(sType);

this#postRouting

`Servlet30WrapperFilter`

public class Servlet30WrapperFilter extends ZuulFilter {
    //...
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        if (request instanceof HttpServletRequestWrapper) {
            request = (HttpServletRequest)ReflectionUtils.getField(this.requestField, request);
            ctx.setRequest(new Servlet30RequestWrapper(request));
        } else if (RequestUtils.isDispatcherServletRequest()) {
            ctx.setRequest(new Servlet30RequestWrapper(request));
        }

        return null;
    }
    //  ..
}

`RibbonRoutingFilter`

public class RibbonRoutingFilter extends ZuulFilter {
//...
    public Object run() {
        RequestContext context = RequestContext.getCurrentContext();
        this.helper.addIgnoredHeaders(new String[0]);

        try {
            RibbonCommandContext commandContext = this.buildCommandContext(context);
            ClientHttpResponse response = this.forward(commandContext);
            this.setResponse(response);
            return response;
        } catch (ZuulException var4) {
            throw new ZuulRuntimeException(var4);
        } catch (Exception var5) {
            throw new ZuulRuntimeException(var5);
        }
    }
//...
        protected ClientHttpResponse forward(RibbonCommandContext context) throws Exception {
        Map<String, Object> info = this.helper.debug(context.getMethod(), context.getUri(), context.getHeaders(), context.getParams(), context.getRequestEntity());
        RibbonCommand command = this.ribbonCommandFactory.create(context);

        try {
            ClientHttpResponse response = (ClientHttpResponse)command.execute();
            this.helper.appendDebug(info, response.getRawStatusCode(), response.getHeaders());
            return response;
        } catch (HystrixRuntimeException var5) {
            return this.handleException(info, var5);
        }
    }
    //...
    
}

`HttpClientRibbonCommandFactory`

public class HttpClientRibbonCommandFactory extends AbstractRibbonCommandFactory {
    ///...
    
public HttpClientRibbonCommand create(final RibbonCommandContext context) {
        ZuulFallbackProvider zuulFallbackProvider = this.getFallbackProvider(context.getServiceId());
        String serviceId = context.getServiceId();
        RibbonLoadBalancingHttpClient client = (RibbonLoadBalancingHttpClient)this.clientFactory.getClient(serviceId, RibbonLoadBalancingHttpClient.class);
        client.setLoadBalancer(this.clientFactory.getLoadBalancer(serviceId));
        return new HttpClientRibbonCommand(serviceId, client, context, this.zuulProperties, zuulFallbackProvider, this.clientFactory.getClientConfig(serviceId));
    }
    
    ///....
    
}

`RibbonLoadBalancingHttpClient`

public class RibbonLoadBalancingHttpClient extends AbstractLoadBalancingClient<RibbonApacheHttpRequest, RibbonApacheHttpResponse, CloseableHttpClient> {

    //....
    public RibbonApacheHttpResponse execute(RibbonApacheHttpRequest request, final IClientConfig configOverride) throws Exception {
        Builder builder = RequestConfig.custom();
        IClientConfig config = configOverride != null ? configOverride : this.config;
        builder.setConnectTimeout((Integer)config.get(CommonClientConfigKey.ConnectTimeout, this.connectTimeout));
        builder.setSocketTimeout((Integer)config.get(CommonClientConfigKey.ReadTimeout, this.readTimeout));
        builder.setRedirectsEnabled((Boolean)config.get(CommonClientConfigKey.FollowRedirects, this.followRedirects));
        RequestConfig requestConfig = builder.build();
        request = this.getSecureRequest(request, configOverride);
        HttpUriRequest httpUriRequest = request.toRequest(requestConfig);
        HttpResponse httpResponse = ((CloseableHttpClient)this.delegate).execute(httpUriRequest);
        return new RibbonApacheHttpResponse(httpResponse, httpUriRequest.getURI());
    }

    //....
}

总结

网关都是找，应用，应用找 IP，然后把 RequestHeaders ，RequestBody 写进去，

转发，

最后把 ReponseHeader ，ResponseBody 写出来。

Spring cloud 分布式事件驱动编程

Sat, 23 May 2020 00:00:00 +0000

Spring Cloud 分布式事件驱动编程

课件

本期议题

Java 标准事件
Spring 标准事件
Spring Cloud 分布式事件

架构图

本地事件

远程事件

本次事件

Java 标准事件

标准事件
- java.util.EventObject
标准监听器
- java.util.EventListener

Java 的 MourseEvent 事件， Java 标准的方式

在 MQ 中，事件的载体运用了消息。

HTTP，是同步的事件，Request，Response

Spring 标准事件

标准事件
- org.springframework.context.ApplicationEvent
标准监听器
- org.springframework.context.ApplicationListener
事件发布器
- org.springframework.context.ApplicationEventPublisher

ApplicationFailEvent

本地的事件

ApplicationEvent

ApplicationContextEvent

ContextRefreshedEvent

import org.springframework.context.PayloadApplicationEvent;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/***
 * XML 形式的 Application Demo
 *
 * @author <a href="mailto:1934849492@qq.com">Darian</a> 
 * @date 2020/5/26  3:14
 */
public class XmlApplicationContextDemo {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext xmlApplicationContext = new ClassPathXmlApplicationContext();

        xmlApplicationContext.addApplicationListener(event -> {
            if (event instanceof PayloadApplicationEvent) {
                PayloadApplicationEvent payloadApplicationEvent = PayloadApplicationEvent.class.cast(event);
                System.err.println(payloadApplicationEvent.getPayload());
            } else {
                System.err.println(event);
            }
        });

        xmlApplicationContext.refresh();
        // Spring 萨汗国那下文是一个 事件发布器，非 ApplicationEvent, 是 PayLoadApplicationEvent
        xmlApplicationContext.publishEvent("Hello, World!");
        xmlApplicationContext.publishEvent(156456);

    }
}

org.springframework.context.event.ContextRefreshedEvent[source=org.springframework.context.support.ClassPathXmlApplicationContext@52525845: startup date [Tue May 26 03:31:09 CST 2020]; root of context hierarchy]
03:31:09.370 [main] DEBUG org.springframework.core.env.PropertySourcesPropertyResolver - Could not find key 'spring.liveBeansView.mbeanDomain' in any property source
Hello, World!
156456

Spring Cloud 分布式事件

分布式事件
- org.springframework.cloud.bus.event.RemoteApplicationEvent 实现类
  - org.springframework.cloud.bus.event.EnvironmentChangeRemoteApplicationEvent
  - org.springframework.cloud.bus.event.**RefreshRemoteApplicationEvent

从谁发给谁？，是同步还是异步？

public abstract class RemoteApplicationEvent extends ApplicationEvent {
    private static final Object TRANSIENT_SOURCE = new Object();
    private final String originService;
    private final String destinationService;
    private final String id;

Spring Cloud Bus

Spring Cloud Bus links the nodes of a distributed system with a lightweight message broker. This broker can then be used to broadcast state changes (such as configuration changes) or other management instructions. A key idea is that the bus is like a distributed actuator for a Spring Boot application that is scaled out. However, it can also be used as a communication channel between apps. This project provides starters for either an AMQP broker or Kafka as the transport.

…

…

…

The bus currently supports sending messages to all nodes listening or all nodes for a particular service (as defined by Eureka). The /bus/* actuator namespace has some HTTP endpoints. Currently, two are implemented. The first, /bus/env, sends key/value pairs to update each node’s Spring Environment. The second, /bus/refresh, reloads each application’s configuration, as though they had all been pinged on their /refresh endpoint.

Spring Cloud Bus 通过轻量级的 message broker ，来进行实现应用之间的通信。

Bus 只是告诉了你一个端口，没有告诉你往哪里走，

“/bus/refresh?destination=customers.**”

提供者的发送端口，事件源在哪里，没有告诉你 IP，所以必须进行依赖于服务发现

+------------------------+         +-------+        +------------------------+
|                        |  JSON   |       |  JSON  |                        |
| RemoteApplicationEvent | ------> | Kafka |  ----> | RemoteApplicationEvent |
|            A           |         |       |        |          B             |
+------------------------+         +-------+        +------------------------+

EventObject （JDK）

ApplicationEvent （Spring）
- RemoteApplicationEvent （Spring-cloud）
  - MessageRemoteApplicationEvent （Customized）

Kafka 和 zookeeper 版本最好对应

http://localhost:8080/send/sync/event?message=ss&destinationService=localhost:8081

curl

丰富 spring cloud stream 生态

Fri, 22 May 2020 00:00:00 +0000

丰富 Spring Cloud Stream 生态

Spring Cloud

spring Cloud Stream

轻量级的通信，没有说一定要用消息，内部的实现用的消息。

事件驱动编程

预备条件

消息中间件：
- RabbitMQ ( Message Broker )
- RocketMQ ( 自定义 )
注册中心：
- Zookeeper ( 注册中心 2181)
客户端应用：
- spring-cloud-client-application ( 8888 )
服务端应用：
- spring-cloud-server-application ( 9090 )
Stream Cloud Stream Binder :
- RabbitMQ
- RocketMQ
- HTTP Binder

我们通过 Spring Cloud Stream 来进行通信

可以一个发送，然后多个可以监听到。

Binder 实现步骤

A typical binder implementation consists of the following:

A class that implements the Binder interface; （实现 Binder 接口）
A Spring @Configuration class that creates a bean of type Binder along with the middleware connection infrastructure.（Binder 实现类上标注 @Configuration 注解）
A META-INF/spring.binders file found on the classpath containing one or more binder definitions, as shown in the following example:（META-INF/spring.binders 配置 Binder 名称和 Binder 实现自动装配类映射）

HTTP Binder 的实现架构图

细节

RabbitMQ 和 Kafka 都是根据 ExtendedBindingProperties 来进行扩展的。
public class RabbitExtendedBindingProperties implements ExtendedBindingProperties<RabbitConsumerProperties, RabbitProducerProperties> {

步骤

利用 DiscoveryClient 获取实例列表，可以拿到一堆列表。discoveryClient.getInstances(serviceName);
- 随机负载均衡算法，然后再去，拿到队以ing的 URL
Target URL = rootURL + Endpoint URI -> http://localhost:9090/mesage/receive
- String targetURI = rootURL + MessageReceiverController.ENDPOINT_URI;
我的 HTTP Binder 既有 RestTemplate HTTP 请求，还有 @Controller HTTP 消费端。
REST 发送消息
- ` byte[] messageBody = (byte[]) message.getPayload();` 请求内容
- RestTemplate.exchange 发送请求
接受消息
- MessageReceiverController 包含 InputChannel
  - inputChannel.send(new GenericMessage(requestBody))
绑定 InputChannel
- HttpMessageChannelBinder#bindConsumer 内部调用 MessageReceiverController#setInputChannel 给 controller 注入 MessageChannel
自动装配 MessageReceiverController 、 HttpMessageChannelBinder
META-INF/spring.binders
- http:\xxxxx.xxx.xxx.http.HttpMessageChannelBinderConfiguration
application.properties 客户端和服务端都需要配置
- spring.cloud.stream.bindings.test-http.binder = http 配置 channel 名称
@StreamListener("test-http") 添加监听的 channel
@Input("test-http") 配置输入的 channel

spring.factories 自动装配

  org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.gupao.micro.services.spring.cloud.stream.binder.http.HttpMessageChannelWebAutoConfiguration

小技巧

@RestController
public class MessageReceiverController implements Controller {

自动装配

Eureka 2.0 闭源后，spring cloud 应该何去何从

Thu, 21 May 2020 00:00:00 +0000

Eureka 2.0 闭源后，Spring Cloud 该何去何从？

Spring Cloud 的特性？

1. Features

Spring Cloud focuses on providing good out of box experience for typical use cases and extensibility mechanism to cover others.

Distributed/versioned configuration

Service registration and discovery

Routing

Service-to-service calls

Load balancing

Circuit Breakers

Distributed messaging

Cloud Native Applications

就是一个开发的范式

Cloud Native

根上下文： Bootstrap Application
配置
- 子上下文： Spring Boot ApplicationContext
  - 配置
  - Beans 是多层的
  - 多层的事件管理
  - 多层 Message 管理

类似于双亲委派来进行多层次的加载

Spring ApplicationContext / BeanFactory

BeanFactory 和 FactoryBean 的区别

BeanFactory 管理 Bean 以及塔的生命周期，Spirng Bean 容器
ApplicationContext
- 子接口
  - ConfigurableApplicationContext
- BeanFactory
  - ListableBeanFactory
  - HierachicalBeanFactory 层次性的
    - parent： 5 beans
    - current: 3 Beans
- 事件/监听（ApplicationEventPublisher）
- 资源管理（ResourceLoader ）

bootstrap.yml

Application Context Hierarchies

多层次上下文的描述，Spring Cloud 官网

@SpringBootApplication
public class EurekaClosedSourceApplication {

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

}

public class ApplicationContextDemo {

    public static void main(String[] args) {
        // 设置 父上下文
        AnnotationConfigApplicationContext parentContext = new AnnotationConfigApplicationContext(SuperUser.class);

        // 构建一个注解驱动的应用上下文
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.setParent(parentContext);
        // 注册 UserConfiguration -》 User
        context.register(UserConfiguration.class);

        // 启动 Spring 应用上下文
        context.refresh();

        System.err.println(context.getBean(UserConfiguration.class));
        System.err.println(context.getBean(User.class));
        // 当前上下文 -> 找不到 -> parent 上下文
        // Spring MVC -> ContextLoaderListener -> Root WebApplicatin
        // Spring MVC -> DispatcherServlet -> Servlet WebApplication -> Parent == Root WebApplication
        // <context-param>  -> XML 文件，娶不到 dispatcher-servlet.xml
        // 父获取子的，自然取不到。
        // Bootstrap ClassLoader 完全无法感知 子 ClassLoader
        System.err.println(context.getBean(SuperUser.class));

        // 关闭 Spring 应用上下文
        context.close();
    }


    @Configuration
    public static class UserConfiguration {
        @Bean
        public User user() {
            return new User();
        }
    }
}

Changing the Location of Bootstrap Properties

上下文的配置，进行 merge

自定义

配置

外部化

调整层次性

META-INF/spring.factories

Environment Changes

Environment 抽象， Spring Boot 里边

Spring 总是喜欢用 Rest 的方式来做。不一定是 config 的 Spirng Boot 服务，

Encryption And Decryption

加密和解密

Endpoints

Spring Cloud Commons : Common Abstractions

可以完全的自定义。

服务可以自动的注册。

Spring RestTemplate LoadBlance 可以负载均衡

@Configuration
public class MyConfiguration {
    @LoadBalance
    @Bean
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

没有负载均衡怎么办？

重试策略也可以来做，就是最大次数怎么来做。？就相当于拦截？

RestTemplate 在 Spring Cloud 类似于泛化调用？

/{application}/{profile}/{label}

Spring Cloud 莫名的会出现类名找不到。

Spring Cloud Config Server

Environment Repository

{application} 应用
{profile} 配置化条件
{label}

应用/区域/配置化条件/

Git Backend

Docker 是一个不变的镜像，那么 Git 放上去，到底是变还是不变？变得化，存在哪里？

Authentication

认证，Git 配置中心的认证

镜像要是做映射管理，还是特别麻烦的。

Health Indicator

是一个健康检查，

特性：

粗粒度： OK
细粒度：JDBC，配置中心怎么杨

application.yml

passowrd: '{cipher}DASFASDFASDFA' 

Enabedding the Config Server

内置化的 Config Service

Push Notifications and Spring Cloud Bus

配置中心的推送以及分布式消息的推送

假如说

Config 出现改变的时候，
- Config Server 感知到了。
  - 每个子服务 Config Client 需要轮询，感知
    - 应用多的化，会把服务给搞崩了
  - Cloud Bus 推送消息过来，然后

成千上万的服务会直接 hang 掉。

拆分可以解决并发的问题，不可以解决内存的问题。进行全量列表的拉取问题。

ZooKeeper 可以用 Master/Slave 进行读写分离，

可以设置多长时间感知一下，但是时间设置太短，会对机器造成损耗。

如果要做网关的化，是否需要把 Eureka 的所有的注册列表全部拉过来？

@EnableEurekaClient

可以用 @EnableDiscoverClient 代替

Spring Cloud 的 Commons API 比较好。

Zuul 为什么不好用？

就是一个 Servlet ，Filter

ZuulProxy
ZuulServer

zuul 比较麻烦，只能做一半，ssl 在 Tomcat 里边配置证书。

zuul 效率比较低，依赖于链接数多少个，没有实现异步化。

Zuul 的配置没有办法再次重新加载
nginx 可以修改。

zuul 尽量是走回头路。

zuul 是对外的。

Zuul 有 Grovy 的方式。还有很多问题。

Nginx 采用了多工的方式

nginx 可以进行重启

nginx 可以配合内部的 IP 来做的。

KONG 的方式

DNS 的方式
IP 的方式

携程的方式

java 会公用 ThreadLocal

具体问题具体分析。

程序员必学英语目录

Fri, 23 Aug 2019 00:00:00 +0000

NotGeek

小马哥 vip 中期回顾

小马哥 VPI 中期回顾

TOC

回顾

讨论范畴

Profile

安全

Spring Framwork

理解 Filter

Spring Boot 的内置的 Tomcat

Spring MVC 怎么学习？

REST

Properties 也可以是 XML

Spring Cloud

Spring Cloud config

config-server

Apollo

断路保护器

Spring Cloud config client

发布订阅模式

事件监听模式

EnvironmentEndpoint

Eureka

高可用架构

Eureka 客户端

Eureka 服务端

高可用

Ribbon

Hystrix

整合 Turbine

问答

Java9 新特性之核心库

Java 9 新特性之核心库（上）

TOC

主要议题

新特性简介

详情

PropertyPermission

javac 就是 java compile

invokedynamic

JVM.logger

GI 默认的垃圾回收

CMS 淘汰掉了

CMS 托管了，让大家取维护。

讨论范围

集合工厂方法（Factory Method of Collections）

Guava

Apache common lang

Java

进程（Process）

ProcessHandleDemo

ProcessHandle

堆栈 API （Stack-Walking API）

区别

sun.misc.Unsafe -> VariableHandle

VarHandle 用法

统一日志 API （Platform Logging API）

自旋等待提示（Spin-Wait Hints）

压缩字符串（Compact String）

Java9 模块化

JAVA 9 的模块化

TOC

模块化前时代

Ant

Maven

缺点

OSGI

模块化

优点

缺点

定义模块

使用模块

变化

工具整合

兼容性

使用场景

Spring 的使用

微服务网关新选择 spring cloud gateway

微服务网关新选择 Spring Cloud Gateway

`PropertyPermission`

`javac` 就是 java compile

`invokedynamic`

`JVM.logger`

`ProcessHandleDemo`

`ProcessHandle`

`sun.misc.Unsafe` -> `VariableHandle`

`VarHandle` 用法

测试，两个链接，一个是配置的，一个是手动的

`Servlet30WrapperFilter`

`RibbonRoutingFilter`

`HttpClientRibbonCommandFactory`

`RibbonLoadBalancingHttpClient`