1：启动项目时加载数据库数据到缓存中
 
大体思路：
 1：自定义类实现InitializingBean接口
 2：并追加注解@Component
 3：set方法注入mapper
 4：从数据库查出的数据放入map中
 5：页面配置要改变的数据，修改后刷新map中的值，动态更新缓存数据
 
2:具体实现的代码如下
 
注意：需要引入自己的mapper查询结果
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @description: TestPropertiesInit 属性数据初始化:
 * 实现InitializingBean接口，重写方法afterPropertiesSet()方法，可以在项目启动时进行加载
 * @author: 
 * @create: 2020.2.25
 */
@Component("TestPropertiesInit")
public class TestPropertiesInit implements InitializingBean {

    private static Logger logger = LoggerFactory.getLogger(TestPropertiesInit.class);
    //项目启动加载数据存入map中
    public static Map<String, String> map = new HashMap<String, String>();

    public static Map<String, String> getMap() {
        return map;
    }


    public static void setMap(Map<String, String> map) {
        TestPropertiesInit.map = map;
    }

    private ConstantMapper constantMapper;

    public ConstantMapper getConstantMapper() {
        return constantMapper;
    }

    //采用set方式获取对象，不能采用autowire,项目启动时未初始化完成spring对象
    @Resource
    public void setConstantMapper(ConstantMapper constantMapper) {
        this.constantMapper = constantMapper;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        logger.info("----初始化系统参数开始---------------start");

        List<Constant> constants = this.constantMapper.queryAllCode();
        for (Constant c : constants) {
            map.put(c.getCode(), c.getValue());
            //System.out.println("map====="+map.toString());
        }
        //System.out.println(map);
        logger.info("----初始化系统参数结束--------success-------end" + map.toString());
    }
}

 
 
 Tomcat启动时加载数据到缓存--Web.xml里listener的加载顺序，优先初始化Spring IOC容器
 
 

  多个listener加载顺序 
 
 
 
 
 
 
  
 最近用到在Tomcat服务器启动时自动加载数据到缓存，这就需要创建一个自定义的缓存监听器并实现ServletContextListener接口，并且在此自定义监听器中需要用到Spring的依赖注入功能.在web.xml文件中监听器配置如下:
 
  
  
 
  
 
   
 
    

      Xml代码  
    
 
   
 
   
 <listener>  
         <listener-class>  
             org.springframework.web.context.ContextLoaderListener  
         </listener-class>  
 </listener>  
 <listener>  
     <listener-class>  
         com.wsjiang.test.listener.CacheListener  
     </listener-class>  
 </listener>  
 
  
 
  
  
 
  
       上面的配置细细大意为，先配置spring监听器，启动spring，再配置一个缓存监听器，我希望他们是顺序执行的，因为在缓存监听器中需要 spring注入其他对象的实例,我期望在服务器加载缓存监听器前加载Spring的监听器,将其优先实例化。但是实际运行发现他们并不是按照配置的顺序 加载的。
 
  
 
       对上面的问题我查询了很多资料，找到了一种解决方案,希望能帮助遇到同类问题的朋友。
       思路就是，既然listener的顺序是不固定的，那么我们可以整合两个listener到一个类中，这样就可以让初始化的顺序固定了。我就重写了 org.springframework.web.context.ContextLoaderListener这个类的 contextInitialized方法.大致代码如下:
 
  
 
   
 
    

      Java代码  
    
 
   
 
   
 public class ContextLoaderListenerOverWrite extends ContextLoaderListener {  
     private IStationService stationService;  
     private IOSCache osCache;  
     @Override  
     /** 
      * @description 重写ContextLoaderListener的contextInitialized方法 
      */  
     public void contextInitialized(ServletContextEvent event) {  
         super.contextInitialized(event);  
         ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(event.getServletContext());  
         //获取bean  
         stationService = (IStationService) applicationContext.getBean("stationService");   
         osCache = (IOSCache) applicationContext.getBean("osCache");  
         /* 
          具体地业务代码 
          */  
     }  
 }  
 
  
 
  
  
 
  
       web.xml的配置就由两个listener变为一个:
 
  
 
   
 
    

      Xml代码  
    
 
   
 
   
 <listener>  
     <listener-class>  
                  com.wsjiang.test.listener.ContextLoaderListenerOverWrite  
         </listener-class>  
 </listener>  
 
  
 
  
        这样就能保证Spring的IOC容器先于自定义的缓存监听器初始化,在缓存监听器加载的时候就能使用依赖注入的实例.
 
 
 

redis 是什么？这个应该是你做一下工作的前提，不明白的可以百科一下。如果你大概明白了redis的工作原理。那么请继续往下看：
 
一。首先你需要明白，为什么要在你的项目中使用redis缓存？
 
现在很多应用程序要存储结构简单更新频繁的数据，在我看来，字典表里的数据就是存储结构简单且更新频繁的数据，因此，需要读取字典表里的数据时，可以考虑使用redis了。
 
 
这只是其中之一的例子。
 
二。如何在web项目添加redis？
 
 
 在java项目中，redis提供了很多客户端库，我用的jedis，它封装了对redis数据库的所有操作。
 
 　　一般web应用中，我们还会用到spring，方便的地方在于spring本身也提供了对redis的支持--spring-data-redis，可以到官网查看文档，并有实例。
 
 　　具体步骤：
 
 　　1.引入pom依赖（如果没用maven的话，自行引入jar包吧）
 
 
 
<dependencies>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>1.5.0.RELEASE</version>
    </dependency>
</dependencies>
 
 
 　　同时将jedis也依赖上，因为spring-data-redis底层就是用的jedis：
 
 
 
　　　　　<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.6.0</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
 
 
  
 
 　　2.在容器中配置RedisTemplate实例
 
 
 
<bean id="jedisConnFactory" 
    class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" 
    p:use-pool="true"/>

<!-- redis template definition -->
<bean id="redisTemplate" 
    class="org.springframework.data.redis.core.RedisTemplate" 
    p:connection-factory-ref="jedisConnFactory"/>
 
 
 　　注意：这是官网直接复制过来的，我这样直接放在xml中，会报错，即使是引入p的命名空间。然后我就尝试将p属性写成property后，就没有报错了，但是在后面用的时候会key和value会出现类似"\xac\xed\x00\x05t\x00\tb "这样的情况，查询得知这是因为spring-data-redis需要将数据存储到jedis中，这中间需要序列化，再由jedis存储到数据库，问题就出在序列化上了，它会将key和value的类型信息也序列化后带上，这显然不是我们想要的结果。
 
 　　所以RedisTemplate提供了对key和value序列化类，于是我打算这样：
 
 
 
<bean id="redisTemplate"
          class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="jedisConnFactory"/>
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.GenericToStringSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.GenericToStringSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
    </bean>
 
 
 　　可是中间两个序列化类还是报错，没有无参构造器，所以就准备采用构造器注入的方式，但是要求注入的参数是一个Object.class类型，我也不知道怎么注入这种类型的，搞来搞去还是干脆就不要xml了，直接写配置类：
 
 
 
@Configuration
public class RedisConfig {
    @Bean
    JedisConnectionFactory jedisConnectionFactory() {
        return new JedisConnectionFactory();
    }

    @Bean
    RedisTemplate<String, Object> redisTemplate() {
        final RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory());
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new GenericToStringSerializer<>(Object.class));
        template.setValueSerializer(new GenericToStringSerializer<>(Object.class));
        return template;
    }
}
 
 
 　　这下可算可以了（当然要注意扫描包）。
 
 　　有了RedisTemplate之后，就可以写具体的实现业务类了，RedisTemplate基本支持所有redis操作，比如：
 
 
 
@Component
public class SpringRedisClientImpl implements SpringRedisClient {
    @Autowired
    private RedisTemplate<String, Object> template;
    @Autowired
    private JedisConnectionFactory jedisConnectionFactory;

    @Override
    public void setKey(String key, String value) {
        template.opsForValue().set(key, value);
    }

    @Override
    public Object getKey(String key) {
        return template.opsForValue().get(key);
    }

    @Override
    public void incr(String key) {
        template.opsForValue().increment(key, 1);
    }

    @Override
    public void lPush(String key, String value) {
        template.opsForList().leftPush(key, value);
    }

    @Override
    public boolean checkKey(String key) {
        return template.hasKey(key);
    }

    @Override
    public Object lIndex(String key) {
        return template.opsForList().index(key, 0);
    }

    @Override
    public Long llength(String key) {
        return template.opsForList().size(key);
    }

    @Override
    public String lpop(String key) {

        return (String) template.opsForList().leftPop(key);
    }

    @Override
    public Set<String> getKeys(String pattern) {
        return template.keys(pattern);
    }

    @Override
    public void flushAll() {
        Jedis jedis = jedisConnectionFactory.getShardInfo().createResource();
        jedis.flushAll();
        jedis.close();
    }
}
 
 
 　　最后，启动redis-server.exe就可以了（这里要注意要先启动这个，再启动web项目，否则启动不了，原因未知），如果对redis比较熟悉的，可以自行配置redis.windows.conf文件。其实我也不太熟悉conf文件里面的配置，尤其是持久化到磁盘那个。所以在我的项目里，我是将数据以每天为单位保存到mysql中，并清空redis。
 

最近用到在Tomcat服务器启动时自动加载数据到缓存，这就需要创建一个自定义的缓存监听器并实现ServletContextListener接口，并且在此自定义监听器中需要用到Spring的依赖注入功能.在web.xml文件中监听器配置如下:
 
 <listener>  
            <listener-class>  
                org.springframework.web.context.ContextLoaderListener  
            </listener-class>  
    </listener>  
    <listener>  
        <listener-class>  
            com.wsjiang.test.listener.CacheListener  
        </listener-class>  
    </listener>  

    <listener>  
            <listener-class>  
                org.springframework.web.context.ContextLoaderListener  
            </listener-class>  
    </listener>  
    <listener>  
        <listener-class>  
            com.wsjiang.test.listener.CacheListener  
        </listener-class>  
    </listener>  
 
   上面的配置细细大意为，先配置spring监听器，启动spring，再配置一个缓存监听器，我希望他们是顺序执行的，因为在缓存监听器中需要 spring注入其他对象的实例,我期望在服务器加载缓存监听器前加载Spring的监听器,将其优先实例化。但是实际运行发现他们并不是按照配置的顺序加载的。
 对上面的问题我查询了很多资料，找到了一种解决方案,希望能帮助遇到同类问题的朋友。
  思路就是，既然listener的顺序是不固定的，那么我们可以整合两个listener到一个类中，这样就可以让初始化的顺序固定了。我就重写了org.springframework.web.context.ContextLoaderListener这个类的contextInitialized方法.大致代码如下:
 
 public class ContextLoaderListenerOverWrite extends ContextLoaderListener {  
        private IStationService stationService;  
        private IOSCache osCache;  
        @Override  
        /** 
         * @description 重写ContextLoaderListener的contextInitialized方法 
         */  
        public void contextInitialized(ServletContextEvent event) {  
            super.contextInitialized(event);  
            ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(event.getServletContext());  
            //获取bean  
            stationService = (IStationService) applicationContext.getBean("stationService");   
            osCache = (IOSCache) applicationContext.getBean("osCache");  
            /* 
             具体地业务代码 
             */  
        }  
    }  
 
  web.xml的配置就由两个listener变为一个:
 
<listener>  
        <listener-class>  
                     com.wsjiang.test.listener.ContextLoaderListenerOverWrite  
            </listener-class>  
    </listener>  

    <listener>  
        <listener-class>  
                     com.wsjiang.test.listener.ContextLoaderListenerOverWrite  
            </listener-class>  
    </listener>  
 
   这样就能保证Spring的IOC容器先于自定义的缓存监听器初始化,在缓存监听器加载的时候就能使用依赖注入的实例.