节假日配置初始化 redis缓存方案及@PostConstruct注解，Cache方案GuavaUtils.java工具类

节假日配置初始化 redis缓存方案及@PostConstruct注解，Cache方案GuavaUtils.java工具类

启动报错：本机，在jenkins上面没有报错？包括嵌套的注入Bean

java 静态代码块和spring @value等注解注入顺序
https://www.cnblogs.com/oktokeep/p/15530697.html

/**
* 节假日配置初始化 redis缓存，在项目启动运行时加载。
* 如果使用了StringRedisTemplate 在@PostConstruct在运行时启动会报错。
    解决方案：1.可以将该方法的注解@PostConstruct去掉。在程序实际运行中再初始化加载。不影响。
    2.或者更改缓存方案，可以使用本地化的com.google.common.cache.Cache来实现。 如：GuavaUtils.java工具类
**/
@Service
//@Component
public class HolidayInitService implements ApplicationContextAware {

    @Autowired
    private HolidayFeignApi holidayFeignApi;
    @Autowired
    private StringRedisTemplate redisTemplate;

    public static StringRedisTemplate stringRedisTemplate;

    private ApplicationContext applicationContext;
    

    /**
     * 运行时加载
     * @return
     */
    @PostConstruct
    public String getHolidaySettingByUrlNoCache() {
        //1.@Autowired注入方式
        System.out.println("stringRedisTemplate=" + redisTemplate);
        
        //2.静态类方式
        stringRedisTemplate = this.redisTemplate;
        System.out.println("stringRedisTemplate2=" + stringRedisTemplate);

        //3.applicationContext.getBean方式
        System.out.println("HolidayFeignApi=" + holidayFeignApi);
        HolidayFeignApi holidayFeignApi = applicationContext.getBean(HolidayFeignApi.class);
        System.out.println("HolidayFeignApi2=" + holidayFeignApi);
        
        //以上3种方式都可以正常的注入BEAN
        
        String json = null;
        //测试： HolidayFeignApi 这个类调用方法可以正常启动。   获取json
        //运行这一行启动会报错。
        stringRedisTemplate.opsForValue().set(holidayKey, json,1, TimeUnit.DAYS);
        
        return json;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

# 需要的jar包 guava-19.0.jar

package com.example.core.mydemo.cache;

import com.google.common.cache.CacheBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.StringUtils;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import java.util.concurrent.TimeUnit;

public class GuavaUtils {
    private final static Logger logger = LoggerFactory.getLogger(GuavaUtils.class);


    final static Cache<String, String> cache =
            CacheBuilder.newBuilder()
                    //设置cache的初始大小为10，要合理设置该值
                    .initialCapacity(10)
                    //设置并发数为5，即同一时间最多只能有5个线程往cache执行写入操作
                    .concurrencyLevel(5)
                    //设置cache中的数据在写入之后的存活时间为2个小时
                    .expireAfterWrite(2 * 60 * 60, TimeUnit.SECONDS)
                    //设置缓存的移除通知
                    .removalListener(notification -> {
                        logger.info("", "", notification.getKey() + " " + notification.getValue() + " 被移除,原因:" + notification.getCause());
                    }).build();

    public static void setKeyVal(String key, String value) {
        if (StringUtils.isEmpty(key) || StringUtils.isEmpty(value)) {
            return;
        }
        cache.put(key, value);
    }

    public static String getValByKey(String key) {
        if (StringUtils.isEmpty(key)) {
            return null;
        }
        String value = cache.getIfPresent(key);
        return value;
    }

    public static void delKey(String key) {
        if (StringUtils.isEmpty(key)) {
            return;
        }
        cache.invalidate(key);
    }

    public static void main(String[] args) {
        GuavaUtils.setKeyVal("myOrderKey","123456789");
        System.out.println("value=" + GuavaUtils.getValByKey("myOrderKey"));

        GuavaUtils.delKey("myOrderKey");
        System.out.println("value2=" + GuavaUtils.getValByKey("myOrderKey"));
    }
}

springboot用@Autowired和@PostConstruct注解把config配置读取到bean变成静态方法
public static Configs conf;

@Autowired
private Configs conf2;

@PostConstruct
public void initconf(){
conf = conf2;
}

原理剖析： spring不能注入static对象
静态变量、类变量不是对象的属性，而是一个类的属性，所以静态方法是属于类（class）的，普通方法才是属于实体对象（也就是New出来的对象）的，
spring注入是在容器中实例化对象，所以不能使用静态方法。

而使用静态变量、类变量扩大了静态方法的使用范围。静态方法在spring是不推荐使用的，依赖注入的主要目的,是让容器去产生一个对象的实例,然后在整个生命周期中使用他们，同时也让testing工作更加容易。

一旦你使用静态方法,就不再需要去产生这个类的实例,这会让testing变得更加困难，同时你也不能为一个给定的类，依靠注入方式去产生多个具有不同的依赖环境的实例，
这种static field是隐含共享的，并且是一种global全局状态，spring同样不推荐这样去做。