xml复制代码<Connector port="8080" protocol="HTTP/1.1"
          connectionTimeout="20000"
          maxThreads="150"
          redirectPort="8443" />

xml复制代码http {
    limit_req_zone $binary_remote_addr zone=myRateLimit:10m rate=10r/s;
}

xml复制代码server {
    location / {
        limit_req zone=myRateLimit;
        proxy_pass http://my_upstream;
    }
}

xml复制代码limit_conn_zone $binary_remote_addr zone=perip:10m;
limit_conn_zone $server_name zone=perserver:10m;

server {
    ...
    limit_conn perip 10;
    limit_conn perserver 100;
}

java复制代码// 每秒2个的速率提交任务
final RateLimiter rateLimiter = RateLimiter.create(2.0);
void submitTasks(List tasks, Executor executor) {
    for (Runnable task : tasks) {
        rateLimiter.acquire(); // may wait
        executor.execute(task);
    }
}

lua复制代码-- 获取调用脚本时传入的第一个key值（用作限流的 key）
local key = KEYS[1]
-- 获取调用脚本时传入的第一个参数值（限流大小）
local limit = tonumber(ARGV[1])

-- 获取当前流量大小
local curentLimit = tonumber(redis.call('get', key) or "0")

-- 是否超出限流
if curentLimit + 1 > limit then
-- 返回(拒绝)
return 0
else
-- 没有超出 value + 1
redis.call("INCRBY", key, 1)
-- 设置过期时间
redis.call("EXPIRE", key, 2)
-- 返回(放行)
return 1
end

java复制代码
示例 1：

    输入：nums1 = [1,3], nums2 = [2]
    输出：2.00000
    解释：合并数组 = [1,2,3] ，中位数 2
    
示例 2：

    输入：nums1 = [1,2], nums2 = [3,4]
    输出：2.50000
    解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
    
示例 3：

    输入：nums1 = [0,0], nums2 = [0,0]
    输出：0.00000
    
示例 4：

    输入：nums1 = [], nums2 = [1]
    输出：1.00000
    
示例 5：

    输入：nums1 = [2], nums2 = []
    输出：2.00000

提示：
	
	nums1.length == m
    nums2.length == n
    0 <= m <= 1000
    0 <= n <= 1000
    1 <= m + n <= 2000
    -106 <= nums1[i], nums2[i] <= 106

java复制代码
/**
     * 
     * 方式一：时间复杂度和空间复杂度都为O(m+n)
     *
     * @param nums1
     * @param nums2
     * @return
     */
    public static double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int numLength = nums1.length + nums2.length;
        // 定义合并后的集合
        List<Integer> list = new ArrayList();
		// 使用for循环将元素添加到新的数组(方式一)
        //for (int i : nums1) {
        //    list.add(i);
        //}
        //for (int i : nums2) {
        //    list.add(i);
        //}
        // 使用lambda表达式将数组合并到集合中(方式二)
        list.addAll(Arrays.stream(nums1).boxed().collect(Collectors.toList()));
        list.addAll(Arrays.stream(nums2).boxed().collect(Collectors.toList()));
        // 使用结合工具类的排序方式对存放了两个数组的集合进行排序(sort底层的排序方式是：)
        Collections.sort(list);
        int middle = list.size() / 2;
        // 两数组元素之和为偶数
        if (numLength % 2 == 0) {
            int leftMiddle = middle - 1;
            double middleValue = (Double.valueOf(list.get(leftMiddle)) + Double.valueOf(list.get(middle))) / 2;
            return middleValue;
        } else {
            return Double.valueOf(list.get(middle));
        }
    }

ini复制代码    public static double findMedianSortedArrays2(int[] nums1, int[] nums2) {
        int num1Length = nums1.length;
        int num2Length = nums2.length;
        int sumLength = num1Length + num2Length;
        // 第一个中位数指针
        int preItem = 0;
        // 第二个中位数指针(如果两个数组总长度为奇数，则直接返回该值即可)
        int curItem = 0;
        // 遍历的数组1的元素下标
        int num1Index = 0;
         // 遍历的数组2的元素下标
        int num2Index = 0;
        // 需要遍历的次数(查询中位数，并不需要将两个数组元素都遍历完)
        int foreachTime = sumLength / 2;
        for (int i = 0; i <= foreachTime; i++) {
            // 保证preItem总是在curItem前面
            preItem = curItem;
            // num2Index >= num2Length需要放在nums1[num1Index] < nums2[num2Index]前面，否则会出现下标越界
            // nums1[num1Index] < nums2[num2Index]的目的就是为了按照模拟从小到大的顺序循环两个数组的元素
            if (num1Index < num1Length && (num2Index >= num2Length || nums1[num1Index] < nums2[num2Index])) {
                curItem = nums1[num1Index++];
            } else {
                curItem = nums2[num2Index++];
            }
        }
        // 如果是偶数，则取中间两个元素的平均值
        if (sumLength % 2 == 0) {
            return Double.valueOf(preItem + curItem) / 2;
        }
        return curItem;
    }

java复制代码 public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int m = nums2.length;
        //奇数时k值，除法是向下取整，因此需要+1
        int left = (n + m + 1) / 2;
     	// 偶数时取两个中间值的平均值做中位数
        int right = (n + m + 2) / 2;
        //将偶数和奇数的情况区分
        if((n + m) % 2 == 0){
        return (getMedian(nums1, 0, n - 1, nums2, 0, m - 1, left) + getMedian(nums1, 0, n - 1, nums2, 0, m - 1, right)) * 0.5;
        } else {
            return getMedian(nums1, 0, n - 1, nums2, 0, m - 1, left);
        }
    }

   public static double getMedian(int[] num1, int num1StartIndex, int num1EndIndex, int[] num2, int num2StartIndex, int num2EndIndex, int k) {
        // 获取需要遍历数组的长度(不能直接用num1.length获取，这样会导致数组的长度一致不会变动)
        int num1Length = num1EndIndex - num1StartIndex + 1;
        int num2Length = num2EndIndex - num2StartIndex + 1;
        // 总长度
        int totalLength = num1Length + num2Length;
        // 如果num1长度大于num2，则进行交换位置，保证num1数组为包含元素最少的数组
        if (num1Length > num2Length) {
            return getMedian(num2, num2StartIndex, num2EndIndex, num1, num1StartIndex, num1EndIndex, k);
        }
        // 如果最短的数组长度为0，则中位数获取剩下还有元素的数组
        if (num1Length == 0) {
            return num2[num2StartIndex + k - 1];
        }
        // 如果k为1(表示查询第一小的数值),表示数组第一个元素为中位数,则取两个数组中位数中最小的值
        if (k == 1) {
            return Math.min(num1[num1StartIndex], num2[num2StartIndex]);
        }
        // 计算两个数组起始下标的位置
        // 疑问：为什么比较的两个值需要添加num1StartIndex和num2StartIndex，原因是比较的是k/2的元素，但是每轮递归后
        // k需要减去上一轮排除的元素的个数
        // 减去1是因为前面计算的都是长度，但是offset对应的是数组下标
        // Math.min是为了防止数组长度比k/2长度小而导致数组越界的问题，使用它表示如果数组长度小于k/2时，则直接将数组坐标指到最后一个
        int num1CompareItem = num1StartIndex + Math.min(num1Length, k / 2) - 1;
        int num2CompareItem = num2StartIndex + Math.min(num2Length, k / 2) - 1;
        // 判断两个数组中位数的值
        if (num1[num1CompareItem] > num2[num2CompareItem]) {
            return getMedian(num1, num1StartIndex, num1EndIndex, num2, num2CompareItem + 1, num2EndIndex, k - (num2CompareItem - num2StartIndex+ 1));
        } else {
            return getMedian(num1, num1CompareItem + 1, num1EndIndex, num2, num2StartIndex, num2EndIndex, k - (num1CompareItem -num1StartIndex + 1));
        }
    }

yaml复制代码apiVersion: istio.alibabacloud.com/v1beta1
kind: TrafficLabel
metadata:
  name: default
spec:
  rules:
  - labels:
      - name: trafficLabel
        valueFrom:
        - $getContext(x-request-id)  //若使用aliyun arms,对应为x-b3-traceid
        - $(localLabel)
    attachTo:
    - opentracing
    # 表示生效的协议，空为都不生效，*为都生效
    protocols: "*"

yaml复制代码apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: myapp
spec:
  host: myapp/*
  subsets:
  - name: myproject            # 项目环境
    labels:
      env: abc
  - name: isolation            # 隔离环境
    labels:
      env: xxx                 # 机器分组
  - name: testing-trunk        # 主干环境
    labels:
      env: yyy
  - name: testing              # 日常环境
    labels:
      env: zzz
---
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: myapp
spec:
  hosts: 
        - myapp/*
  ports:
  - number: 12200
    name: http
    protocol: HTTP
    endpoints:
      - address: 0.0.0.0
        labels:
            env: abc
      - address: 1.1.1.1
        labels:
            env: xxx
      - address: 2.2.2.2
        labels:
            env: zzz
      - address: 3.3.3.3
        labels:
            env: yyy

yaml复制代码apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: default-route
spec:
  hosts:                     # 对所有应用生效
  - */*
  http:
  - name: default-route
    route:
    - destination:
        subset: $trafficLabel
      weight: 100
      fallback:
         case: noinstances
         target: testing-trunk
    - destination:
            host: */*
        subset: testing-trunk    # 主干环境
      weight: 0
      fallback:
        case: noavailabled
        target: testing
    - destination:
        subset: testing          # 日常环境
      weight: 0
      fallback:
        case: noavailabled
        target: mock
    - destination:
            host: */*
        subset: mock             # Mock中心
       weight: 0

yaml复制代码apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: dev-x-route
spec:
  hosts:                   # 对哪些应用生效（不支持多应用配置）
  - myapp/*
  http:
  - name: dev-x-route
    match:
      trafficLabel:
      - exact: testing-trunk # 主干环境标
      sourceLabels:
      - exact: dev-x  # 流量来自某个项目环境
    route:
    - destination:
            host: myapp/*
        subset: testing-trunk # 80%流量打向主干环境
      weight: 80
      fallback:
        case: noavailabled
        target: testing
    - destination：
            host: myapp/*
        subset: testing       # 20%流量打向日常环境
      weight: 20

js复制代码    //注解只会存在源代码中，将会被编译器丢弃
    SOURCE,
    //注解将会保留到class文件阶段，但是在加载如vm的时候会被抛弃
    CLASS,
    //注解不单会被保留到class文件阶段，而且也会被vm加载进虚拟机的时候保留
    RUNTIME

bash复制代码用于描述类、接口(包括注解类型) 或enum声明 Class, interface (including annotation type), or enum declaration 
    TYPE,

    用于描述域 Field declaration (includes enum constants)
    FIELD,
 
    用于描述方法 Method declaration
    METHOD,
 
    用于描述参数 Formal parameter declaration 
    PARAMETER,

    用于描述构造器 Constructor declaration
    CONSTRUCTOR,
 
    用于描述局部变量 Local variable declaration
    LOCAL_VARIABLE,
 
    Annotation type declaration
    ANNOTATION_TYPE,
 
    用于描述包 Package declaration
    PACKAGE,
 
    用来标注类型参数 Type parameter declaration
    TYPE_PARAMETER,
 
     *能标注任何类型名称 Use of a type
    TYPE_USE

js复制代码@Conditional(CustomOnPropertyCondition.class)意思为CustomOnPropertyCondition类中返回为true才会使用注解

package com.airboot.bootdemo.config;
import org.springframework.context.annotation.Conditional;
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@Documented
@Conditional(CustomPropertyCondition.class)
public @interface CustomProperty {
    
    //参数
    String name() default "";
        /**
         * havingValue数组，支持or匹配
         */

    //参数
    String[] havingValue() default {};

}

js复制代码public class CustomPropertyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        return false;
    }
}

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.Map;


public class CustomPropertyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
        //获取注解上的参数和配置值
        Map<String, Object> annotationAttributes = annotatedTypeMetadata.getAnnotationAttributes(RequestMapping.class.getName());
        //获取具体的参数值
        String propertyName = (String) annotationAttributes.get("name");
        String[] values = (String[]) annotationAttributes.get("havingValue");
        if (0 == values.length) {
            return false;
        }
        //从application.properties中获取配置
        String propertyValue = conditionContext.getEnvironment().getProperty(propertyName);
        // 有一个匹配上就ok
        for (String havingValue : values) {
            if (propertyValue.equalsIgnoreCase(havingValue)) {
                return true;
            }
        }
        return false;
    }
}

js复制代码Map<String, Object> annotationAttributes = annotatedTypeMetadata.getAnnotationAttributes(RequestMapping.class.getName()); 获取类中注解上的参数

String propertyValue = conditionContext.getEnvironment().getProperty(propertyName);获取application.properties上的配置。

js复制代码@RequestMapping(value ="/Demo")
@Controller
@ResponseBody
@Api("demo测试类")
@CustomProperty(name = "condition",havingValue = {"2"})
public class DemoController {

}

js复制代码package com.airboot.bootdemo.config;

import java.lang.annotation.*;


@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface UserCheck {

    //当前用户在request中的名字
    String value() default "userid";
}

js复制代码import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

public class UserCheckMethodArgumentResolver implements HandlerMethodArgumentResolver {
    @Override
    public boolean supportsParameter(MethodParameter methodParameter) {
        return false;
    }

    @Override
    public Object resolveArgument(MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer, NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory) throws Exception {
        return null;
    }
}

js复制代码import com.airboot.bootdemo.entity.DemoVO;
import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;

public class UserCheckMethodArgumentResolver implements HandlerMethodArgumentResolver {
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        if (parameter.getParameterType().isAssignableFrom(DemoVO.class) && parameter.hasParameterAnnotation(UserCheck.class)) {
            return true;
        }
        return false;
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        UserCheck currentUserAnnotation = parameter.getParameterAnnotation(UserCheck.class);
        //获取head中的
        String userId = webRequest.getHeader("userId");
        //组装入参 return后的参数 类型需要和controllor中的相同 
        DemoVO demoVO = new DemoVO();
        demoVO.setId(Long.valueOf(1));
        return demoVO;
    }
}

js复制代码    @GetMapping(value = "/selectDemoByVo")
    public List<DemoVO> selectDemoByVo(@RequestBody @UserCheck DemoVO demoVO) {
        return demoService.selectDemoVO(demoVO);
    }

bash复制代码1.JoinPoint  
* java.lang.Object[] getArgs()：获取连接点方法运行时的入参列表； 
* Signature getSignature() ：获取连接点的方法签名对象； 
* java.lang.Object getTarget() ：获取连接点所在的目标对象； 
* java.lang.Object getThis() ：获取代理对象本身； 

2.ProceedingJoinPoint  
* ProceedingJoinPoint继承JoinPoint子接口，它新增了两个用于执行连接点方法的方法： 
* java.lang.Object proceed() throws java.lang.Throwable：通过反射执行目标对象的连接点处的方法； 
* java.lang.Object proceed(java.lang.Object[] args) throws java.lang.Throwable：通过反射执行目标对象连接点处的方法，不过使用新的入参替换原来的入参。

js复制代码import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {

    int p0() default 0;
    String p1() default "";
    Class<?> clazz();

}

js复制代码import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Aspect
@Component
public class TestAspect {

    // 切入点签名
    @Pointcut("@annotation(com.airboot.bootdemo.config.TestAnnotation)")
    private void cut() {
    }

    // 前置通知
    @Before("cut()")
    public void BeforeCall() {
        log.info("====前置通知start");

        log.info("====前置通知end");
    }

    // 环绕通知
    @Around(value = "cut()")
    public Object AroundCall(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("====环绕通知start");

        // 注解所切的方法所在类的全类名
        String typeName = joinPoint.getTarget().getClass().getName();
        log.info("目标对象:[{}]", typeName);

        // 注解所切的方法名
        String methodName = joinPoint.getSignature().getName();
        log.info("所切方法名:[{}]", methodName);

        StringBuilder sb = new StringBuilder();
        // 获取参数
        Object[] arguments = joinPoint.getArgs();
        for (Object argument : arguments) {
            sb.append(argument.toString());
        }
        log.info("所切方法入参：[{}]", sb.toString());

        // 统计方法执行时间
        long start = System.currentTimeMillis();

        //执行目标方法，并获得对应方法的返回值
        Object result = joinPoint.proceed();
        log.info("返回结果:[{}]", result);

        long end = System.currentTimeMillis();
        log.info("====执行方法共用时：[{}]", (end - start));

        log.info("====环绕通知之结束");
        return result;
    }

    // 后置通知
    @After("cut()")
    public void AfterCall() {
        log.info("====后置通知start");

        log.info("====后置通知end");
    }

    // 最终通知
    @AfterReturning("cut()")
    public void AfterReturningCall() {
        log.info("====最终通知start");

        log.info("====最终通知end");
    }

    // 异常通知
    @AfterThrowing(value = "cut()", throwing = "ex")
    public void afterThrowing(Throwable ex) {
        throw new RuntimeException(ex);
    }

}

js复制代码    @RequestMapping(value = "/selectDemoByVo")
    @TestAnnotation(p0 = 123, p1 = "qaws",clazz = DemoVO.class)
    public List<DemoVO> selectDemoByVo(@RequestBody DemoVO demoVO) {
        return demoService.selectDemoVO(demoVO);
    }

bash复制代码import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface InterceptorAnnotation {


    String[] value() default {};

    String[] authorities() default {};

    String[] roles() default {};
}

js复制代码import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;

public class TestAnnotationInterceptor extends HandlerInterceptorAdapter {
    // 在调用方法之前执行拦截
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 将handler强转为HandlerMethod, 前面已经证实这个handler就是HandlerMethod
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        // 从方法处理器中获取出要调用的方法
        Method method = handlerMethod.getMethod();
        // 获取出方法上的自定义注解
        InterceptorAnnotation access = method.getAnnotation(InterceptorAnnotation.class);
        if (access == null) {
            // 如果注解为null,没有注解 不拦截
            return true;
        }
        //获取注解值
        if (access.authorities().length > 0) {
            // 如果权限配置不为空, 则取出配置值
            String[] authorities = access.authorities();
        }
        // 拦截之后应该返回公共结果, 这里没做处理
        return true;
    }
}

js复制代码import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class InterceptorConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TestAnnotationInterceptor()).addPathPatterns("/**");
    }
}

js复制代码    @RequestMapping(value = "/selectDemoByVo")
    @InterceptorAnnotation(authorities = {"admin"})
    public List<DemoVO> selectDemoByVo(@RequestBody DemoVO demoVO) {
        return demoService.selectDemoVO(demoVO);
    }

js复制代码import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;

@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(validatedBy = TestConstraintValidator.class)
public @interface TestConstraintAnnotation {

    String message() default "入参大小不合适";

    long min();

    long max();

    boolean required() default true;

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

}

js复制代码public class TestConstraintValidator implements ConstraintValidator<TestConstraintAnnotation, Object> {
    private long max = 1;
    private long min = 1;

    @Override
    public void initialize(TestConstraintAnnotation constraintAnnotation) {
        max = constraintAnnotation.max();
        min = constraintAnnotation.min();
    }

    @Override
    public boolean isValid(Object o, ConstraintValidatorContext constraintValidatorContext) {
        if(o == null){
            return true;
        }
        if(Long.valueOf(o.toString())>=min && Long.valueOf(o.toString())<=max){
            return true;
        }
        return false;
    }
}

bash复制代码    @RequestMapping(value = "/selectDemoByVo")
    public List<DemoVO> selectDemoByVo(@Valid @RequestBody DemoVO demoVO) {
        return demoService.selectDemoVO(demoVO);
    }

bash复制代码    @TestConstraintAnnotation(min = 1, max = 10)
    private Long id;

properties复制代码spring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id
spring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE

yaml复制代码spring:
  application:
    name: note
  shardingsphere:
    enabled: true
    sharding:
      tables:
        t_order:
          keyGenerator:
            column: id
            #生成算法 UUID SNOWFLAKE
            type: SNOWFLAKE
            #可选配置
            props:
              worker-id: 132

java复制代码/**
     * 添加对象所有字段
     *
     * @param order 插入字段对象(必须含ID）
     * @return int
     */
    @Insert("insert into t_order(id,user_id,order_sn,gmt_create,gmt_update) values(null,#{userId},#{orderSn},#{gmtCreate},#{gmtUpdate})")
    int insert(Order order);

java复制代码/**
     * 添加对象所有字段
     *
     * @param order 插入字段对象(必须含ID）
     * @return int
     */
    @Insert("insert into t_order(user_id,order_sn,gmt_create,gmt_update) values(#{userId},#{orderSn},#{gmtCreate},#{gmtUpdate})")
    int insert(Order order);

bash复制代码git clone https://github.com/apache/skywalking-kubernetes
cd skywalking-kubernetes/chart
helm repo add elastic https://helm.elastic.co
helm dep up skywalking
export SKYWALKING_RELEASE_NAME=skywalking  # 定义自己的名称
export SKYWALKING_RELEASE_NAMESPACE=default  # 定义自己的命名空间

yaml复制代码oap:
  image:
    tag: 8.1.0-es7      # Set the right tag according to the existing Elasticsearch version
  storageType: elasticsearch7

ui:
  image:
    tag: 8.1.0

elasticsearch:
  enabled: false
  config:               # For users of an existing elasticsearch cluster,takes effect when `elasticsearch.enabled` is false
    host: elasticsearch-client
    port:
      http: 9200
    user: "elastic"         # [optional]
    password: "admin@123"     # [optional]

bash复制代码helm install "${SKYWALKING_RELEASE_NAME}" skywalking -n "${SKYWALKING_RELEASE_NAMESPACE}" \
  -f ./skywalking/values-my-es.yaml

bash复制代码$ kubectl get deployment -n skywalking
NAME                READY   UP-TO-DATE   AVAILABLE   AGE
my-skywalking-oap   2/2     2            2           9m
my-skywalking-ui    1/1     1            1           9m

bash复制代码FROM alpine:3.8

LABEL maintainer="zuozewei@hotmail.com"

ENV SKYWALKING_VERSION=8.1.0

ADD http://mirrors.tuna.tsinghua.edu.cn/apache/skywalking/${SKYWALKING_VERSION}/apache-skywalking-apm-${SKYWALKING_VERSION}.tar.gz /

RUN tar -zxvf /apache-skywalking-apm-${SKYWALKING_VERSION}.tar.gz && \
    mv apache-skywalking-apm-bin skywalking && \
    mv /skywalking/agent/optional-plugins/apm-trace-ignore-plugin* /skywalking/agent/plugins/ && \
    echo -e "\n# Ignore Path" >> /skywalking/agent/config/agent.config && \
    echo "# see https://github.com/apache/skywalking/blob/v8.1.0/docs/en/setup/service-agent/java-agent/agent-optional-plugins/trace-ignore-plugin.md" >> /skywalking/agent/config/agent.config && \
    echo 'trace.ignore_path=${SW_IGNORE_PATH:/health}' >> /skywalking/agent/config/agent.config

bash复制代码docker build -t 172.16.106.237/monitor/skywalking-agent:8.1.0 .

yaml复制代码apiVersion: apps/v1
kind: Deployment
metadata:
  name: demo-skywalking
spec:
  replicas: 1
  selector:
    matchLabels:
      app: demo-skywalking
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: demo-skywalking
    spec:
      initContainers:
        - name: init-skywalking-agent
          image: 172.16.106.237/monitor/skywalking-agent:8.1.0
          command:
            - 'sh'
            - '-c'
            - 'set -ex;mkdir -p /vmskywalking/agent;cp -r /skywalking/agent/* /vmskywalking/agent;'
          volumeMounts:
            - mountPath: /vmskywalking/agent
              name: skywalking-agent
      containers:
        - image: nginx:1.7.9
          imagePullPolicy: Always
          name: nginx
          ports:
            - containerPort: 80
              protocol: TCP
          volumeMounts:
            - mountPath: /opt/skywalking/agent
              name: skywalking-agent
      volumes:
        - name: skywalking-agent
          emptyDir: {}

xml复制代码FROM insideo/centos7-java8-build
VOLUME /tmp
ADD mall-admin.jar app.jar
RUN bash -c 'touch /app.jar'
RUN ln -snf /usr/share/zoneinfo/Asia/Shanghai  /etc/localtime && echo Asia/Shanghai > /etc/timezone
ENTRYPOINT ["java","-Dapp.id=svc-mall-admin","-javaagent:/opt/skywalking/agent/skywalking-agent.jar","-Dskywalking.agent.service_name=svc-mall-admin","-Dskywalking.collector.backend_service=my-skywalking-oap.skywalking.svc.cluster.local:11800","-jar","-Dspring.profiles.active=prod","-Djava.security.egd=file:/dev/./urandom","/app.jar"]

yaml复制代码---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: svc-mall-admin
spec:
  replicas: 1
  selector:
    matchLabels:
      app: svc-mall-admin
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
    type: RollingUpdate
  template:
    metadata:
      labels:
        app: svc-mall-admin
    spec:
      initContainers:
        - name: init-skywalking-agent
          image: 172.16.106.237/monitor/skywalking-agent:8.1.0
          command:
            - 'sh'
            - '-c'
            - 'set -ex;mkdir -p /vmskywalking/agent;cp -r /skywalking/agent/* /vmskywalking/agent;'
          volumeMounts:
            - mountPath: /vmskywalking/agent
              name: skywalking-agent
      containers:
        - image: 172.16.106.237/mall_repo/mall-admin:1.0
          imagePullPolicy: Always
          name: mall-admin
          ports:
            - containerPort: 8180
              protocol: TCP
          volumeMounts:
            - mountPath: /opt/skywalking/agent
              name: skywalking-agent
      volumes:
        - name: skywalking-agent
          emptyDir: {}
---
apiVersion: v1
kind: Service
metadata:
  name: svc-mall-admin
spec:
  ports:
    - name: http
      port: 8180
      protocol: TCP
      targetPort: 8180
  selector:
    app: svc-mall-admin

复制代码递归是一个很强的描述工具，不是算法。唯一的作用就是辅助你的思维，比如有时候从递归的角度很
容易构造递推式。至于现有语言的语法上能否高效率的支持递归不是核心问题。
数据结构中的二叉树的很多接口都是用到递归思维

markdown复制代码    注意：递归不能无限递归下去，否则会造成死循环和栈溢出

scss复制代码//1.用递归的方式顺序打印一个数的每一位
当n为两位数时还要进行拆分，所以if判断条件为n>9
Print(1234)
Print(123)
Print(12)  
Print(1) 
//
 
 
void Print(int n)
{
	if (n > 9)
	{
		Print(n / 10);
	}
		printf("%d ", n % 10);
}
 
int main()
{
	int n = 0;
	//输入要打印的数
	scanf("%d", &n);
	Print(n);
	return 0;
}

arduino复制代码void Print(int n)
{
	if (n > 0)
	{
		printf("%d ", n % 10);
		n /= 10;
		//n%10：得到最后一位数字
		//n/10 ：除掉最后一位数字
		Print(n);
	}
	else
		return;
}
int main()
{
	int n = 0;
	//输入要打印的数
	scanf("%d", &n);
	Print(n);
	return 0;
}

yaml复制代码阶乘是基斯顿·卡曼（Christian Kramp，1760～1826）于 1808 年发明的运算符号，是数学术语。

一个正整数的阶乘（factorial）是所有小于及等于该数的正整数的积，并且0的阶乘为1。自然数n的阶乘写作n!。1808年，基斯顿·卡曼引进这个表示法。

arduino复制代码//用递归+非递归的方式求阶乘
// //注意：负数没有阶乘。
//阶乘是指从1到n的连续自然数相乘的积。符号为:n!
// 所以我人为规定，输入为负数时，输出1
//非递归

ini复制代码
int Fac1(int n)
{
	int i = 0;
	int sum = 1;//注意sum不可以初始化为0，因为0乘任何数都为0
	//i也不可以从0开始 0*任何数字都为0
	for (i = 1; i <= n; i++)
	{
		sum *= i;
	}
	return sum;
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = Fac1(n);
	printf("%d\n", ret);
	return 0;
}

arduino复制代码//递归方式
int Fac2(int  n)
{
	return n < 1 ? 1 : Fac2(n - 1) * n;
}
 
int main()
{
	int n = 0;
	scanf("%d", &n);
	int rett = Fac2(n);
	printf("%d\n", rett);
	return 0;
}

java复制代码class ImpCallable implements Callable<String> {
    // 核心线程数
    private static final int CORE_POOL_SIZE=2;
    // 最大线程数
    private static final int MAX_POOL_SIZE=4;
    // 线程数大于 corePoolSize 线程持续时间
    private static final int KEEP_ALIVE_TIME=1;
    // 阻塞队列的大小
    private static final int QUEUE_CAPACITY=5;
    private static final TimeUnit UNIT = TimeUnit.SECONDS;
    // 自定义线程名
    private static final String THREAD_NAME = "my-self-thread-pool-%d";

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                UNIT,
                new ArrayBlockingQueue<>(QUEUE_CAPACITY),
                new BasicThreadFactory.Builder().namingPattern(THREAD_NAME).build(),
                new ThreadPoolExecutor.CallerRunsPolicy());
        ImpCallable task = new ImpCallable();
        List<Future<String>> futureList = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            // 提交任务到线程池
            Future<String> future = executor.submit(task);
            // 任务结果 future 加入结果队列
            futureList.add(future);
        }

        for (Future<String> fut : futureList) {
            try {
                // 取出结果
                System.out.println(new Date() + "--" + fut.get());
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }

        executor.shutdown();

        try {
            executor.awaitTermination(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("All threads Finished");
    }

    @Override
    public String call() throws Exception {
        Thread.sleep(2000L);
        return Thread.currentThread().getName();
    }
}

arduino复制代码private static final int RUNNING = -536870912;
private static final int SHUTDOWN = 0;
private static final int STOP = 536870912;
private static final int TIDYING = 1073741824;
private static final int TERMINATED = 1610612736;

java复制代码/**
 * 计算 1 + 1/2! + 1/3! + 1/4! +  + 1/20! 的值
 */
public class question_06 {
    public static void main(String args[]) {
        double sum=0,a=1;
        int i=1;
        while(i<=20) {
            sum=sum+a;
            i=i+1;
            //关键点，动态规划思想
            a=a*(1.0/i);
        }
        System.out.println("sum="+sum);
    }
}