java复制代码@FeignClient(name = "foo-service",fallback = FooClient.Fallback.class)
public interface FooClient {
    @GetMapping("/foo/bar")
    Rest<Map<String, String>> bar();

    @Component
    class Fallback implements FooClient {
        @Override
        public Rest<Map<String, String>> bar() {
            return RestBody.fallback();
        }
    }
}

java复制代码/**
 * 需要注入Spring IoC
 **/
static class BearerTokenRequestInterceptor implements RequestInterceptor {
        @Override
        public void apply(RequestTemplate template) {
            final String authorization = HttpHeaders.AUTHORIZATION;
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            
            if (authentication instanceof JwtAuthenticationToken){
                JwtAuthenticationToken jwtAuthenticationToken = (JwtAuthenticationToken) authentication;
                String tokenValue = jwtAuthenticationToken.getToken().getTokenValue();
                template.header(authorization,"Bearer "+tokenValue);
            }
        }
    }

java复制代码	Supplier<Future<T>> futureSupplier = () -> executorService.submit(toRun::get);

java复制代码private Supplier<Object> asSupplier(final Method method, final Object[] args) {
		final RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
		return () -> {
			try {
				RequestContextHolder.setRequestAttributes(requestAttributes);
				return this.dispatch.get(method).invoke(args);
			}
			catch (RuntimeException throwable) {
				throw throwable;
			}
			catch (Throwable throwable) {
				throw new RuntimeException(throwable);
			}
			finally {
				RequestContextHolder.resetRequestAttributes();
			}
		};
	}

java复制代码		final RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();

java复制代码	RequestContextHolder.setRequestAttributes(requestAttributes);

java复制代码public abstract class RequestContextHolder  {
 
	private static final ThreadLocal<RequestAttributes> requestAttributesHolder =
			new NamedThreadLocal<>("Request attributes");

	private static final ThreadLocal<RequestAttributes> inheritableRequestAttributesHolder =
			new NamedInheritableThreadLocal<>("Request context");
// 省略
}

java复制代码    /**
     * 令牌中继
     */
    static class BearerTokenRequestInterceptor implements RequestInterceptor {
        private static final Pattern BEARER_TOKEN_HEADER_PATTERN = Pattern.compile("^Bearer (?<token>[a-zA-Z0-9-._~+/]+=*)$",
                Pattern.CASE_INSENSITIVE);

        @Override
        public void apply(RequestTemplate template) {
            final String authorization = HttpHeaders.AUTHORIZATION;
            ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            if (Objects.nonNull(requestAttributes)) {
                String authorizationHeader = requestAttributes.getRequest().getHeader(HttpHeaders.AUTHORIZATION);
                Matcher matcher = BEARER_TOKEN_HEADER_PATTERN.matcher(authorizationHeader);
                if (matcher.matches()) {
                    // 清除token头 避免传染
                    template.header(authorization);
                    template.header(authorization, authorizationHeader);
                }
            }
        }
    }

java复制代码 String blankStr = "    ";
 // true
 boolean trueVal = blankStr.isBlank();

java复制代码         String newStr = "Hello Java 11 \n felord.cn \r 2021-09-28";
 ​
         Stream<String> lines = newStr.lines();
         lines.forEach(System.out::println);
 //        Hello Java 11
 //        felord.cn
 //        2021-09-28

java复制代码 String str = "HELLO\u3000";
 // str = 6
 System.out.println("str = " + str.length());
 // trim = 6
 System.out.println("trim = " + str.trim().length());
 // strip = 5
 System.out.println("strip = " + str.strip().length());

java复制代码 String str = "HELLO";
 // 空字符
 String empty = str.repeat(0);
 // HELLO
 String repeatOne = str.repeat(1);
 // HELLOHELLO
 String repeatTwo = str.repeat(2);

java复制代码         List<String> sampleList = Arrays.asList("felord.cn", "java 11");
         // array = {"felord.cn", "java 11"};
         String[] array = sampleList.toArray(String[]::new);

java复制代码         List<String> sampleList = Arrays.asList("felord.cn", "java 11","jack");
         // [jack]
         List<String> result = sampleList.stream()
                 // 过滤以j开头的字符串
                 .filter(s -> s.startsWith("j"))
                 // 同时不包含11的字符串
                 .filter(Predicate.not(s -> s.contains("11")))
                 .collect(Collectors.toList());

scss复制代码   default Predicate<T> negate() {
         return (t) -> !test(t);
     }

java复制代码         List<String> result = sampleList.stream()
                 // 过滤以j开头的字符串
                 .filter((@NotNull var s) -> s.startsWith("j"))
                 // 同时不包含11的字符串
                 .filter(Predicate.not((@NotNull var s) -> s.contains("11")))
                 .collect(Collectors.toList());

java复制代码String dir= "C://yourDir";
// 写入文件
Path path = Files.writeString(Files.createTempFile(dir, "hello", ".txt"), "hello java 11");
// 读取文件
String fileContent = Files.readString(path);

java复制代码public class Outer {
    private int outerInt;

     class Inner {
       public void printOuterField() {
         System.out.println("Outer field = " + outerInt);
       }
    }
}

xml复制代码<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.kafka</groupId>
        <artifactId>spring-kafka</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

yaml复制代码# 应用端口号
server:
  port: 28099
# Kafka配置
spring:
  kafka:
    # 指定kafka 代理地址，可以多个
    bootstrap-servers: 127.0.0.1:9092

    producer:
      retries: 0
      # 每次批量发送消息的数量
      batch-size: 16384
      # 缓存容量
      buffer-memory: 33554432
      # 指定消息key和消息体的编解码方式
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer:
      # 指定默认消费者group id
      group-id: consumer-tutorial
      auto-commit-interval: 100
      auto-offset-reset: earliest
      enable-auto-commit: true
      # 指定消息key和消息体的编解码方式
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
    # 指定listener 容器中的线程数，用于提高并发量
    listener:
      missing-topics-fatal: false
      concurrency: 3

typescript复制代码package com.xuegao.kafkaproject.config;

import org.apache.kafka.clients.admin.NewTopic;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.config.TopicBuilder;
import org.springframework.kafka.core.*;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * @author xg
 * @Date: 2021/10/21 19:22
 */
@Configuration
@EnableKafka
public class KafkaConfig {

    @Bean
    ConcurrentKafkaListenerContainerFactory<Integer, String>
    kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<Integer, String> factory =
                new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        return factory;
    }

    @Bean
    public ConsumerFactory<Integer, String> consumerFactory() {
        return new DefaultKafkaConsumerFactory<>(consumerConfigs());
    }

    @Bean
    public Map<String, Object> consumerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "127.0.0.1:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "default-topic-group");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        return props;
    }


    @Bean
    public ProducerFactory<String, Object> producerFactory() {
        return new DefaultKafkaProducerFactory<>(producerConfigs());
    }

    @Bean
    public Map<String, Object> producerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "127.0.0.1:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return props;
    }

    @Bean
    public KafkaTemplate<String, Object> kafkaTemplate() {
        return new KafkaTemplate<String, Object>(producerFactory());
    }


    @Bean
    public NewTopic initialSendMsgTopic() {
        return new NewTopic("kafka.topic",8, (short) 2 );
    }

    @Bean
    public NewTopic topic1() {
        return TopicBuilder.name("my-topic")
                .partitions(10)
                .replicas(3)
                .compact()
                .build();
    }
}

typescript复制代码@Resource
private KafkaTemplate<String, Object> kafkaTemplate;

/**
 * kafka 发送消息
 *
 * @param obj 消息对象
 */
public void send(T obj) {
    String jsonObj = JSON.toJSONString(obj);
    logger.info("------------ message = {}", jsonObj);

    //发送消息
    ListenableFuture<SendResult<String, Object>> future = kafkaTemplate.send("kafka.topic", jsonObj);
    future.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {
        @Override
        public void onFailure(Throwable throwable) {
            logger.info("Produce: The message failed to be sent:" + throwable.getMessage());
        }

        @Override
        public void onSuccess(SendResult<String, Object> stringObjectSendResult) {
            //TODO 业务处理
            logger.info("Produce: The message was sent successfully:");
            logger.info("Produce: _+_+_+_+_+_+_+ result: " + stringObjectSendResult.toString());
        }
    });
}

less复制代码/**
 * 监听kafka.tut 的topic，不做其他业务
 *
 * @param record
 * @param topic  topic
 */
@KafkaListener(id = "tutest", topics = "kafka.topic")
public void listen(ConsumerRecord<?, ?> record, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) {
    Optional<?> kafkaMessage = Optional.ofNullable(record.value());

    if (kafkaMessage.isPresent()) {
        Object message = kafkaMessage.get();

        logger.info("Receive： +++++++++++++++ Topic:" + topic);
        logger.info("Receive： +++++++++++++++ Record:" + record);
        logger.info("Receive： +++++++++++++++ Message:" + message);
    }
}

arduino复制代码输入：
	candies = [2,3,5,1,3], extraCandies = 3
输出：
	[true,true,true,false,true] 
解释：
	孩子 1 有 2 个糖果，如果他得到所有额外的糖果（3个），那么他总共有 5 个糖果，他将成为拥有最多糖果的孩子。
	孩子 2 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。
	孩子 3 有 5 个糖果，他已经是拥有最多糖果的孩子。
	孩子 4 有 1 个糖果，即使他得到所有额外的糖果，他也只有 4 个糖果，无法成为拥有糖果最多的孩子。
	孩子 5 有 3 个糖果，如果他得到至少 2 个额外糖果，那么他将成为拥有最多糖果的孩子。

arduino复制代码输入：
	candies = [4,2,1,1,2], extraCandies = 1
输出：
	[true,false,false,false,false] 
解释：
	只有 1 个额外糖果，所以不管额外糖果给谁，只有孩子 1 可以成为拥有糖果最多的孩子。

arduino复制代码输入：
	candies = [12,1,12], extraCandies = 10
输出：
	[true,false,true]

java复制代码class Solution {
    public List<Boolean> kidsWithCandies(int[] candies, int extraCandies) {
        // 查找最多有多少糖果
        int max = 0;
        for (int c : candies) {
            max = Math.max(max, c);
        }
        
        // 假设额外的糖果都给他
        List<Boolean> ans = new ArrayList<>(candies.length);
        for (int c : candies) {
            ans.add(c + extraCandies >= max);
        }
        
        return ans;
    }
}

c复制代码/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
bool* kidsWithCandies(int* candies, int candiesSize, int extraCandies, int* returnSize){
    // 查找最多有多少糖果
    *returnSize = candiesSize;
    int max = 0;
    for (int i = 0; i < candiesSize; ++i) {
        if (candies[i] > max) {
            max = candies[i];
        }
    }

    // 假设额外的糖果都给他
    bool *ans = (bool *) malloc(sizeof(bool) * candiesSize);
    for (int i = 0; i < candiesSize; ++i) {
        ans[i] = candies[i] + extraCandies >= max;
    }

    return ans;
}

cpp复制代码class Solution {
public:
    vector<bool> kidsWithCandies(vector<int>& candies, int extraCandies) {
        // 查找最多有多少糖果
        int max = *max_element(candies.begin(), candies.end());

        // 假设额外的糖果都给他
        vector<bool> ans;
        for (auto c : candies) {
            ans.push_back(c + extraCandies >= max);
        }
        
        return ans;
    }
};

python复制代码class Solution:
    def kidsWithCandies(self, candies: List[int], extraCandies: int) -> List[bool]:
        # 查找最多有多少糖果
        maxCandies = max(candies)
        # 假设额外的糖果都给他
        ans = [c + extraCandies >= maxCandies for c in candies]
        return ans

go复制代码func kidsWithCandies(candies []int, extraCandies int) []bool {
    // 查找最多有多少糖果
	max := 0
	for _, c := range candies {
		if c > max {
			max = c
		}
	}

	// 假设额外的糖果都给他
	ans := make([]bool, len(candies))
	for i, c := range candies {
		ans[i] = c+extraCandies >= max
	}

	return ans
}

rust复制代码impl Solution {
    pub fn kids_with_candies(candies: Vec<i32>, extra_candies: i32) -> Vec<bool> {
        // 查找最多有多少糖果
        let max = candies.iter().max().unwrap();
        // 假设额外的糖果都给他
        candies.iter().map(|c| {
            c + extra_candies >= *max
        }).collect()
    }
}

java复制代码public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

//这里主要就是获取AtomicInteger类value这个这个字段在地址的偏
//移量，也就是地址，这个value字段是使用的volatile 进行修饰的，保证了字段的可见性
    static {
        try {
//获取value值的内存偏移量
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
    private volatile int value;
 //AtomicInteger初始化就是对value进行赋值
 public AtomicInteger(int initialValue) {
        value = initialValue;
    }

arduino复制代码//实际对数据操作的是unsafe的类的getAndAddInt方法
public final int getAndAdd(int delta) {
    return unsafe.getAndAddInt(this, valueOffset, delta);
}

// 提供自增易用的方法，返回增加1后的值
public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

// 额外提供的compareAndSet方法
public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

// Unsafe类的提供的方法
public final int getAndAddInt (Object o,long offset, int delta){
    int v;
    do {
           v = getIntVolatile(o, offset);
    } while (!weakCompareAndSetInt(o, offset, v, v + delta));
    return v;
}

arduino复制代码//CAS自旋，通过getIntVolatile方法通过内存偏移量获取对象最新的值，再调用cas方法，如果失败了就不断的重
//试获取对象新值然后CAS,直到成功
public final int getAndAddInt(Object var1, long var2, int var4) {
     int var5;
     do {
     //先去内存中获取内存地址所指向的值，这个将这个内存值赋值给var5，这个方法是native方法
     //var5是预期值
     var5 = this.getIntVolatile(var1, var2);
//在修改前先比较一次内存的值还是否是预期值var5，将偏移量var2、对应的unsafe对象var1
//和var5带进compareAndSwapInt去获取此时内存中偏移量所指向的数值然后
//和预期值var5进行比较，如果是相等的就将偏移量var2指向的主内存地址中的值修改为
//var5 + var4，失败就进行重试,每次重试都会去内存中重新获取值赋值给var5,然后修改时再比较一下
       } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

       return var5;
    }

csharp复制代码// Unsafe实例
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

static {
    try {
        // 获得value在AtomicInteger中的偏移量
        valueOffset = unsafe.objectFieldOffset
        (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}
// 实际变量的值
private volatile int value;

sql复制代码public final int getAndSet(int newValue) {
        for (;;) {
            int current = get();
            if (compareAndSet(current, newValue))
                return current;
        }
}

arduino复制代码protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

java复制代码Elasticsearch is the distributed search and analytics engine at the heart of the Elastic Stack.
Elasticsearch provides near real-time search and analytics for all types of data.

java复制代码1,9,15,45,68,323,457

java复制代码8,6,30,23,255,134

java复制代码1000,62101,131385,132052,191173,196658

properties复制代码key=value

java复制代码@RestController
public class EnvironementController {

    @Autowired
    Environment environment;

    @GetMapping("/env")
    public String env(){
        return environment.getProperty("key");
    }
}

java复制代码@RestController
public class EnvironementController {

    @Value("${env}")
    private String env;

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

java复制代码public class CusEnvironmentPostProcessor implements EnvironmentPostProcessor {
    private final Properties properties=new Properties();
    private String propertiesFile="custom.properties";

    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        Resource resource=new ClassPathResource(propertiesFile);
        environment.getPropertySources().addLast(loadProperties(resource));
    }

    private PropertySource<?> loadProperties(Resource resource){
        if(!resource.exists()){
            throw new IllegalArgumentException("file:{"+resource+"} not exist");
        }
        try {
            properties.load(resource.getInputStream());
            return new PropertiesPropertySource(resource.getFilename(),properties);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

properties复制代码name=mic
age=18

properties复制代码org.springframework.boot.env.EnvironmentPostProcessor=\
  com.example.springbootzookeeper.CusEnvironmentPostProcessor

java复制代码@RestController
public class TestController {

    @Value("${name}")
    public String val;

    @GetMapping("/")
    public String say(){
        return val;
    }
}

java复制代码public class ZookeeperApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext>{
    //PropertySourceLocator接口支持扩展自定义配置加载到spring Environment中。
    private final List<PropertySourceLocator> propertySourceLocators;

    public ZookeeperApplicationContextInitializer(){
        //基于SPI机制加载所有的外部化属性扩展点
        ClassLoader classLoader=ClassUtils.getDefaultClassLoader();
        //这部分的代码是SPI机制
        propertySourceLocators=new ArrayList<>(SpringFactoriesLoader.loadFactories(PropertySourceLocator.class,classLoader));
    }
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        //获取运行的环境上下文
        ConfigurableEnvironment environment=applicationContext.getEnvironment();
        //MutablePropertySources它包含了一个CopyOnWriteArrayList集合，用来包含多个PropertySource。
        MutablePropertySources mutablePropertySources = environment.getPropertySources();
        for (PropertySourceLocator locator : this.propertySourceLocators) {
            //回调所有实现PropertySourceLocator接口实例的locate方法，收集所有扩展属性配置保存到Environment中
            Collection<PropertySource<?>> source = locator.locateCollection(environment,applicationContext);
            if (source == null || source.size() == 0) {
                continue;
            }
            //把PropertySource属性源添加到environment中。
            for (PropertySource<?> p : source) {
                //addFirst或者Last决定了配置的优先级
                mutablePropertySources.addFirst(p);
            }
        }
    }
}

properties复制代码org.springframework.context.ApplicationContextInitializer=\
  com.gupaoedu.example.zookeepercuratordemo.config.ZookeeperApplicationContextInitializer

java复制代码public interface PropertySourceLocator {

    PropertySource<?> locate(Environment environment,ConfigurableApplicationContext applicationContext);
	//Environment表示环境变量信息
    //applicationContext表示应用上下文
    default Collection<PropertySource<?>> locateCollection(Environment environment, ConfigurableApplicationContext applicationContext) {
        return locateCollection(this, environment,applicationContext);
    }

    static Collection<PropertySource<?>> locateCollection(PropertySourceLocator locator,
                                                          Environment environment,ConfigurableApplicationContext applicationContext) {
        PropertySource<?> propertySource = locator.locate(environment,applicationContext);
        if (propertySource == null) {
            return Collections.emptyList();
        }
        return Arrays.asList(propertySource);
    }
}

java复制代码public class ZookeeperPropertySourceLocator implements PropertySourceLocator{

    private final CuratorFramework curatorFramework;

    private final String DATA_NODE="/data";  //仅仅为了演示，所以写死目标数据节点

    public ZookeeperPropertySourceLocator() {
        curatorFramework= CuratorFrameworkFactory.builder()
                .connectString("192.168.221.128:2181")
                .sessionTimeoutMs(20000).connectionTimeoutMs(20000)
                .retryPolicy(new ExponentialBackoffRetry(1000,3))
                .namespace("config").build();
        curatorFramework.start();
    }

    @Override
    public PropertySource<?> locate(Environment environment, ConfigurableApplicationContext applicationContext) {
        System.out.println("开始加载远程配置到Environment中");
        CompositePropertySource composite = new CompositePropertySource("configService");
        try {
            Map<String,Object> dataMap=getRemoteEnvironment();
            //基于Map结构的属性源
            MapPropertySource mapPropertySource=new MapPropertySource("configService",dataMap);
            composite.addPropertySource(mapPropertySource);
            addListener(environment,applicationContext);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return composite;
    }

    private Map<String,Object> getRemoteEnvironment() throws Exception {
        String data=new String(curatorFramework.getData().forPath(DATA_NODE));
        //暂时支持json格式
        ObjectMapper objectMapper=new ObjectMapper();
        Map<String,Object> map=objectMapper.readValue(data, Map.class);
        return map;
    }
    //添加节点变更事件
    private void addListener(Environment environment, ConfigurableApplicationContext applicationContext){
        NodeDataCuratorCacheListener curatorCacheListener=new NodeDataCuratorCacheListener(environment,applicationContext);
        CuratorCache curatorCache=CuratorCache.build(curatorFramework,DATA_NODE,CuratorCache.Options.SINGLE_NODE_CACHE);
        CuratorCacheListener listener=CuratorCacheListener
                .builder()
                .forChanges(curatorCacheListener).build();
        curatorCache.listenable().addListener(listener);
        curatorCache.start();
    }
}

properties复制代码com.gupaoedu.example.zookeepercuratordemo.config.PropertySourceLocator=\
  com.gupaoedu.example.zookeepercuratordemo.config.ZookeeperPropertySourceLocator

java复制代码public class NodeDataCuratorCacheListener implements CuratorCacheListenerBuilder.ChangeListener {
    private Environment environment;
    private ConfigurableApplicationContext applicationContext;
    public NodeDataCuratorCacheListener(Environment environment, ConfigurableApplicationContext applicationContext) {
        this.environment = environment;
        this.applicationContext=applicationContext;
    }
    @Override
    public void event(ChildData oldNode, ChildData node) {
        System.out.println("数据发生变更");
        String resultData=new String(node.getData());
        ObjectMapper objectMapper=new ObjectMapper();
        try {
            Map<String,Object> map=objectMapper.readValue(resultData, Map.class);
            ConfigurableEnvironment cfe=(ConfigurableEnvironment)environment;
            MapPropertySource mapPropertySource=new MapPropertySource("configService",map);
            cfe.getPropertySources().replace("configService",mapPropertySource);
            //发布事件，用来更新@Value注解对应的值（事件机制可以分两步演示）
            applicationContext.publishEvent(new EnvironmentChangeEvent(this));
            System.out.println("数据更新完成");
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }
}

java复制代码public class EnvironmentChangeEvent extends ApplicationEvent {
    
    public EnvironmentChangeEvent(Object source) {
        super(source);
    }
}

java复制代码@Component
public class ConfigurationPropertiesRebinder implements ApplicationListener<EnvironmentChangeEvent> {
    private ConfigurationPropertiesBeans beans;
    private Environment environment;
    public ConfigurationPropertiesRebinder(ConfigurationPropertiesBeans beans,Environment environment) {
        this.beans = beans;
        this.environment=environment;
    }

    @Override
    public void onApplicationEvent(EnvironmentChangeEvent event) {
        rebind();
    }
    public void rebind(){
        this.beans.getFieldMapper().forEach((k,v)->{
            v.forEach(f->f.resetValue(environment));
        });
    }
}

java复制代码@Component
public class ConfigurationPropertiesBeans implements BeanPostProcessor {

    private Map<String,List<FieldPair>> fieldMapper=new HashMap<>();

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
        throws BeansException {
        Class clz=bean.getClass();
        if(clz.isAnnotationPresent(RefreshScope.class)){ //如果某个bean声明了RefreshScope注解，说明需要进行动态更新
            for(Field field:clz.getDeclaredFields()){
                Value value=field.getAnnotation(Value.class);
                List<String> keyList=getPropertyKey(value.value(),0);
                for(String key:keyList){
                    //使用List<FieldPair>存储的目的是，如果在多个bean中存在相同的key，则全部进行替换
                    fieldMapper.computeIfAbsent(key,(k)->new ArrayList()).add(new FieldPair(bean,field,value.value()));
                }
            }
        }
        return bean;
    }
    //获取key信息，也就是${value}中解析出value这个属性
    private List<String> getPropertyKey(String value,int begin){
        int start=value.indexOf("${",begin)+2;
        if(start<2){
            return new ArrayList<>();
        }
        int middle=value.indexOf(":",start);
        int end=value.indexOf("}",start);
        String key;
        if(middle>0&&middle<end){
            key=value.substring(start,middle);
        }else{
            key=value.substring(start,end);
        }
        //如果是这种用法，就需要递归，@Value("${swagger2.host:127.0.0.1:${server.port:8080}}")
        List<String> keys=getPropertyKey(value,end);
        keys.add(key);
        return keys;
    }

    public Map<String, List<FieldPair>> getFieldMapper() {
        return fieldMapper;
    }
}

java复制代码@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RefreshScope {

}

java复制代码public class FieldPair {
    private static PropertyPlaceholderHelper propertyPlaceholderHelper=new PropertyPlaceholderHelper("${","}",":",true);
    private Object bean;
    private Field field;
    private String value;

    public FieldPair(Object bean, Field field, String value) {
        this.bean = bean;
        this.field = field;
        this.value = value;
    }

    public void resetValue(Environment environment){
        boolean access=field.isAccessible();
        if(!access){
            field.setAccessible(true);
        }
        //从新从environment中将占位符替换为新的值
        String resetValue=propertyPlaceholderHelper.replacePlaceholders(value,((ConfigurableEnvironment) environment)::getProperty);
        try {
           //通过反射更新
            field.set(bean,resetValue);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

java复制代码@RefreshScope
@RestController
public class ConfigController {

    @Value("${name}")
    private String name;

    @Value("${job}")
    private String job;

    @GetMapping
    public String get(){
        return name+":"+job;
    }
}

java复制代码public class CustomPropertySourceLocator implements PropertySourceLocator{

    @Override
    public PropertySource<?> locate(Environment environment, ConfigurableApplicationContext applicationContext) {
        Map<String, Object> source = new HashMap<>();
        source.put("age","18");
        MapPropertySource propertiesPropertySource = new MapPropertySource("configCenter",source);
        return propertiesPropertySource;
    }
}

properties复制代码com.gupaoedu.example.zookeepercuratordemo.config.PropertySourceLocator=\
  com.gupaoedu.example.zookeepercuratordemo.config.ZookeeperPropertySourceLocator,\
  com.gupaoedu.example.zookeepercuratordemo.config.CustomPropertySourceLocator

java复制代码@RefreshScope
@RestController
public class ConfigController {

    @Value("${name}")
    private String name;

    @Value("${job}")
    private String job;

    @Value("${age}")
    private String age;

    @GetMapping
    public String get(){
        return name+":"+job+":"+age;
    }
}

c复制代码php artisan horizon:terminate

复制代码php artisan horizon

kotlin复制代码php artisan horizon:pause

php artisan horizon:continue

c复制代码php artisan horizon:terminate

ini复制代码[program:horizon]
process_name=%(program_name)s
command=php /home/forge/app.com/artisan horizon
autostart=true
autorestart=true
user=forge
redirect_stderr=true
stdout_logfile=/home/forge/app.com/horizon.log

php复制代码<?php

namespace App\Jobs;

use App\Video;
use Illuminate\Bus\Queueable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;

class RenderVideo implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    /**
     * video 实例
     *
     * @var \App\Video
     */
    public $video;

    /**
     * 创建工作实例
     *
     * @param  \App\Video  $video
     * @return void
     */
    public function __construct(Video $video)
    {
        $this->video = $video;
    }

    /**
     * 执行任务
     *
     * @return void
     */
    public function handle()
    {
        //
    }
}

css复制代码$video = App\Video::find(1);

App\Jobs\RenderVideo::dispatch($video);

php复制代码class RenderVideo implements ShouldQueue
{
    /**
     * 获取分配给这个任务的标签
     *
     * @return array
     */
    public function tags()
    {
        return ['render', 'video:'.$this->video->id];
    }
}

css复制代码Horizon::routeMailNotificationsTo('example@example.com');

//这个不常用，起码我没用过。
Horizon::routeSlackNotificationsTo('slack-webhook-url', '#channel');

Horizon::routeSmsNotificationsTo('138xxxxxxxx');

dart复制代码'waits' => [
    'redis:default' => 60, //单位秒
],

php复制代码/**
 * 定义应用程序的任务调度
 *
 * @param  \Illuminate\Console\Scheduling\Schedule  $schedule
 * @return void
 */
protected function schedule(Schedule $schedule)
{
    $schedule->command('horizon:snapshot')->everyFiveMinutes();
}

java复制代码for (int i = 0; i < list.size(); i++) {
 System.out.println(list.get(i));
}

java复制代码int m = list.size();
for (int i = 0; i < m; i++) {
   System.out.println(list.get(i));
}

java复制代码for (int i = 0, n = list.size(); i < n; i++) {
    System.out.println(list.get(i));
}

java复制代码for (int i = list.size() - 1; i >= 0; i--) {
    System.out.println(list.get(i));
}

java复制代码for (Iterator<String> it = list.iterator(); it.hasNext();) {
    System.out.println(it.next());
}

java复制代码for (Object o : list) {
     System.out.println(o);
}

java复制代码list.forEach(i-> System.out.println(i));

java复制代码for (int i = 0; i < 10; i++) {
   for (int j = 0; j < 10000; j++) {
     // 逻辑处理
   }
}

java复制代码//前：
 int a = 10, b = 11;
  for (int i = 0; i < 10; i++) {
      i = i * a * b;
  } 
 
 //后：
 int c = a * b;
 for (int i = 0; i < 10; i++) {
     i = i * c;
  }

java复制代码for (int i = 0; i < 10; i++) {
     try {
 
     } catch (Exception e) {
 
     }
}

java复制代码try {
   for (int i = 0; i < 10; i++) {
   }
} catch (Exception e) {
 
}