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容器先于自定义的缓存监听器初始化,在缓存监听器加载的时候就能使用依赖注入的实例.

概述
本篇将介绍如下几个方面：
完成运营商后台广告类型管理与广告管理、完成前台工程广告轮播图的展示、使用SpringDataRedis操作字符串、set、List、hash等类型缓存、使用SpringDataRedis实现广告数据的缓存。

广告管理
1.后台管理
1.1搭建广告工程
基于高内聚低耦合的原则，我们需要单独搭建广告服务工程。
具体操作和创建pinyougou-sellergoods服务工程差不多，这里给出几点注意事项：
1、我们目前有两个服务工程，当两个工程同时启动时会发生端口冲突，因为连接dubbox注册中心的端口默认是20880。所以我们需要配置一下pinyougou-content-service工程的dubbox端口
2、由于需要用到上传服务，还需要添加common工具包的依赖
1.2广告图片上传
将pinyougou-shop-web有关服务上传的资源拷贝到pinyougou-manager-web
在pinyougou-manager-web 的springmvc.xml中添加配置
<!-- 配置多媒体解析器 -->
<bean id="multipartResolver"
      class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="defaultEncoding" value="UTF-8"></property>
    <!-- 设定文件上传的最大值 5MB，5*1024*1024 -->
    <property name="maxUploadSize" value="5242880"></property>
</bean>

在contentController.js编写代码(注意引入uploadService)
//上传广告图
$scope.uploadFile=function(){
    uploadService.uploadFile().success(
        function(response){
            if(response.success){
                $scope.entity.pic=response.message;					
            }else{
                alert("上传失败！");
            }
        }
    ).error(
        function(){
            alert("上传出错！");
        }
    );		
}

修改content.html实现上传功能
<tr>            
    <td>图片</td>
    <td>
        <input type="file" id="file">
        <button ng-click="uploadFile()">上传</button>	                             
        <img alt="" src="{{entity.pic}}" height="100px" width="200px">
    </td>
</tr>

1.3广告类目选择
在contentController.js中添加代码
//加载广告分类列表
$scope.findContentCategoryList=function(){
    contentCategoryService.findAll().success(
        function(response){
            $scope.contentCategoryList=response;				
        }
    );
}

在content.html 初始化调用此方法，将广告分类改为下拉列表
<select  class="form-control" ng-model="entity.categoryId" ng-options="item.id as item.name  for item in contentCategoryList"></select>  

1.4广告状态
修改content.html
<input  type="checkbox" ng-model="entity.status" ng-true-value="1" ng-false-value="0">

修改contentController.js
$scope.status=["无效","有效"];

2.前台展示
修改首页，当其轮播广告图根据后台设置的广告列表动态产生。
2.1搭建门面工程
创建war模块pinyougou-portal-web ，此工程为网站前台的入口，参照其它war模块编写配置文件。不需要添加SpringSecurity框架
pom.xml中配置tomcat启动端口为9103
2.2后端实现
在pinyougou-content-interface工程ContentService接口增加方法定义
/**
	 * 根据广告类型ID查询列表
	 * @param key
	 * @return
	 */
public List<TbContent> findByCategoryId(Long categoryId);

在pinyougou-content-service工程ContentServiceImpl类增加方法
@Override
public List<TbContent> findByCategoryId(Long categoryId) {
    TbContentExample example = new TbContentExample();
    Criteria criteria = example.createCriteria();
    criteria.andCategoryIdEqualTo(categoryId);
    criteria.andStatusEqualTo("1");//条件：有效
    example.setOrderByClause("sort_order");//排序
    return contentMapper.selectByExample(example);
}

在pinyougou-portal-web创建控制器类 ContentController
@RestController
@RequestMapping("/content")
public class ContentController {

	@Reference
	private ContentService contentService;
	/**
	 * 根据广告分类ID查询广告列表
	 * @param categoryId
	 * @return
	 */
	@RequestMapping("/findByCategoryId")
	public List<TbContent> findByCategoryId(Long categoryId) {
		return contentService.findByCategoryId(categoryId);
	}

}

2.3前端代码
在pinyougou-portal-web工程创建contentService.js
app.service("contentService",function($http){
	//根据分类ID查询广告列表
	this.findByCategoryId=function(categoryId){
		return $http.get("content/findByCategoryId.do?categoryId="+categoryId);
	}	
});

在pinyougou-portal-web创建contentController.js
//广告控制层（运营商后台）
app.controller("contentController",function($scope,contentService){	
	$scope.contentList=[];//广告集合	
	$scope.findByCategoryId=function(categoryId){
		contentService.findByCategoryId(categoryId).success(
			function(response){
				$scope.contentList[categoryId]=response;
			}
		);		
	}		
});

在body上添加指令
<body ng-app="pinyougou" ng-controller="contentController" ng-init="findByCategoryId(1)">

修改首页轮播图
<div class="yui3-u Center banerArea">
    <!--banner轮播-->
    <div id="myCarousel" data-ride="carousel" data-interval="4000" class="sui-carousel slide">
        <ol class="carousel-indicators">
            <li data-target="#myCarousel" data-slide-to="{{$index}}" class="{{$index==0?'active':''}}" ng-repeat="item in contentList[1]"></li>
        </ol>
        <div class="carousel-inner">
            <div class="{{$index==0?'active':''}} item" ng-repeat="item in contentList[1]">
                <a href="{{item.url}}">
                    <img src="{{item.pic}}"  />
                </a>
            </div>

这里首个循环需要增加class=“active”，效果是直接显示，否则可能页面会先出现一段空白，极不美观。
效果：

缓存解决方案
首页每天有大量的人访问，对数据库造成很大的访问压力，甚至是瘫痪。我们通常的做法有两种：一种是数据缓存、一种是网页静态化。我们今天讨论第一种解决方案。
1.SpringDataRedis简介
1.1演变过程
1、redis是一款开源的Key-Value数据库，运行在内存中，由ANSI C编写。企业开发通常采用Redis来实现缓存。同类的产品还有memcache 、memcached 、MongoDB等。
2、Jedis是Redis官方推出的一款面向Java的客户端，提供了很多接口供Java语言调用。可以在Redis官网下载，当然还有一些开源爱好者提供的客户端，如Jredis、SRP等等，推荐使用Jedis。
3、Spring-data-redis是spring大家族的一部分，提供了在srping应用中通过简单的配置访问redis服务，对reids底层开发包(Jedis,  JRedis, and RJC)进行了高度封装，RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅，并对spring 3.1 cache进行了实现。
spring-data-redis针对jedis提供了如下功能：

1.连接池自动管理，提供了一个高度封装的“RedisTemplate”类

2.针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口

ValueOperations：简单K-V操作

SetOperations：set类型数据操作

ZSetOperations：zset类型数据操作

HashOperations：针对map类型的数据操作

ListOperations：针对list类型的数据操作
1.2配置
pom.xml需要引入Jedis和SpringDataRedis依赖
<!-- 缓存 -->
<dependency> 
		  <groupId>redis.clients</groupId> 
		  <artifactId>jedis</artifactId> 
		  <version>2.8.1</version> 
</dependency> 
<dependency> 
		  <groupId>org.springframework.data</groupId> 
		  <artifactId>spring-data-redis</artifactId> 
		  <version>1.7.2.RELEASE</version> 
</dependency>	

resources下创建properties文件夹，建立redis-config.properties
redis.host=127.0.0.1 
redis.port=6379 
redis.pass= 
redis.database=0 
redis.maxIdle=300 
redis.maxWait=3000 
redis.testOnBorrow=true 

maxIdle ：最大空闲数
maxWaitMillis:连接时的最大等待毫秒数
testOnBorrow：在提取一个jedis实例时，是否提前进行验证操作；如果为true，则得到的jedis实例均是可用的；
resources下创建spring文件夹 ，创建applicationContext-redis.xml
<context:property-placeholder location="classpath*:properties/*.properties" />   
<!-- redis 相关配置 --> 
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
    <property name="maxIdle" value="${redis.maxIdle}" />   
    <property name="maxWaitMillis" value="${redis.maxWait}" />  
    <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
</bean>  
<bean id="JedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" 
      p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:pool-config-ref="poolConfig"/>  

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">  
    <property name="connectionFactory" ref="JedisConnectionFactory" />  
</bean>  

1.3Value类型操作
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:spring/applicationContext-redis.xml")
public class TestValue {
	@Autowired
	private RedisTemplate redisTemplate;	
	@Test
	public void setValue(){
		redisTemplate.boundValueOps("name").set("itcast");		
	}	
	@Test
	public void getValue(){
		String str = (String) redisTemplate.boundValueOps("name").get();
		System.out.println(str);
	}	
	@Test
	public void deleteValue(){
		redisTemplate.delete("name");;
	}	
}

1.4Set类型操作
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:spring/applicationContext-redis.xml")
public class TestSet {
	
	@Autowired
	private RedisTemplate redisTemplate;
	
	/**
	 * 存入值
	 */
	@Test
	public void setValue(){
		redisTemplate.boundSetOps("nameset").add("曹操");		
		redisTemplate.boundSetOps("nameset").add("刘备");	
		redisTemplate.boundSetOps("nameset").add("孙权");
	}
	
	/**
	 * 提取值
	 */
	@Test
	public void getValue(){
		Set members = redisTemplate.boundSetOps("nameset").members();
		System.out.println(members);
	}
	
	/**
	 * 删除集合中的某一个值
	 */
	@Test
	public void deleteValue(){
		redisTemplate.boundSetOps("nameset").remove("孙权");
	}
	
	/**
	 * 删除整个集合
	 */
	@Test
	public void deleteAllValue(){
		redisTemplate.delete("nameset");
	}
}

1.5List类型操作
（1）右压栈
/**
	 * 右压栈：后添加的对象排在后边
	 */
@Test
public void testSetValue1(){		
    redisTemplate.boundListOps("namelist1").rightPush("刘备");
    redisTemplate.boundListOps("namelist1").rightPush("关羽");
    redisTemplate.boundListOps("namelist1").rightPush("张飞");		
}

/**
	 * 显示右压栈集合
	 */
@Test
public void testGetValue1(){
    List list = redisTemplate.boundListOps("namelist1").range(0, 10);/*起始位置，最后位置*/
    System.out.println(list);
}

（2）左压栈
/**
	 * 左压栈：后添加的对象排在前边
	 */
@Test
public void testSetValue2(){		
    redisTemplate.boundListOps("namelist2").leftPush("刘备");
    redisTemplate.boundListOps("namelist2").leftPush("关羽");
    redisTemplate.boundListOps("namelist2").leftPush("张飞");		
}

/**
	 * 显示左压栈集合
	 */
@Test
public void testGetValue2(){
    List list = redisTemplate.boundListOps("namelist2").range(0, 10);
    System.out.println(list);
}

（3）根据索引查询元素
/**
	 * 查询集合某个元素
	 */
@Test
public void testSearchByIndex(){
    String s = (String) redisTemplate.boundListOps("namelist1").index(1);
    System.out.println(s);
}

（4）移除某个元素的值
/**
	 * 移除集合某个元素
	 */
@Test
public void testRemoveByIndex(){
    redisTemplate.boundListOps("namelist1").remove(1, "关羽");
}

1.6Hash类型操作
（1）存入值
@Test
public void testSetValue(){
    redisTemplate.boundHashOps("namehash").put("a", "唐僧");
    redisTemplate.boundHashOps("namehash").put("b", "悟空");
    redisTemplate.boundHashOps("namehash").put("c", "八戒");
    redisTemplate.boundHashOps("namehash").put("d", "沙僧");
}

（2）提取所有的KEY
@Test
public void testGetKeys(){
    Set s = redisTemplate.boundHashOps("namehash").keys();		
    System.out.println(s);		
}

运行结果：[a, b, c, d]
（3）提取所有的值
@Test
public void testGetValues(){
    List values = redisTemplate.boundHashOps("namehash").values();
    System.out.println(values);		
}

运行结果：[唐僧, 悟空, 八戒, 沙僧]
（4）根据KEY提取值
@Test
public void testGetValueByKey(){
    Object object = redisTemplate.boundHashOps("namehash").get("b");
    System.out.println(object);
}

（5）根据KEY移除值
@Test
public void testRemoveValueByKey(){
    redisTemplate.boundHashOps("namehash").delete("c");
}

2.缓存广告数据
现在我们首页的广告每次都是从数据库读取，这样当网站访问量达到高峰时段，对数据库压力很大，并且影响执行效率。我们需要将这部分广告数据缓存起来。
2.1读取缓存
因为缓存对于我们整个的系统来说是通用功能。广告需要用，其它数据可能也会用到，所以我们将配置放在公共组件层（pinyougou-common）中较为合理。
配置可参照上文，配好后让pinyougou-content-service依赖pinyougou-common
修改 pinyougou-content-service的ContentServiceImpl
@Autowired 
private RedisTemplate redisTemplate;

@Override
public List<TbContent> findByCategoryId(Long categoryId) {
    List<TbContent> list = (List<TbContent>) redisTemplate.boundHashOps("content").get(categoryId);
    if(list==null) {
        System.out.println("从数据库读取数据放入缓存");
        TbContentExample example = new TbContentExample();
        Criteria criteria = example.createCriteria();
        criteria.andCategoryIdEqualTo(categoryId);
        criteria.andStatusEqualTo("1");//条件：有效
        example.setOrderByClause("sort_order");//排序
        list=contentMapper.selectByExample(example);
        redisTemplate.boundHashOps("content").put(categoryId, list);//存入缓存
    }else {
        System.out.println("从缓存读取数据");
    }
    return list;
}


2.2更新缓存
当广告数据发生变更时，需要将缓存数据清除，这样再次查询才能获取最新的数据
修改pinyougou-content-service工程ContentServiceImpl.java 的add方法
/**
	 * 增加
	 */
@Override
public void add(TbContent content) {
    contentMapper.insert(content);	
    //清除缓存
    redisTemplate.boundHashOps("content").delete(content.getCategoryId());
}

考虑到用户可能会修改广告的分类，这样需要把原分类的缓存和新分类的缓存都清除掉。
/**
	 * 修改
	 */
@Override
public void update(TbContent content){
    //查询修改前的分类Id
    Long categoryId = contentMapper.selectByPrimaryKey(content.getId()).getCategoryId();
    redisTemplate.boundHashOps("content").delete(categoryId);
    contentMapper.updateByPrimaryKey(content);
    //如果分类ID发生了修改,清除修改后的分类ID的缓存
    if(categoryId.longValue()!=content.getCategoryId().longValue()){
        redisTemplate.boundHashOps("content").delete(content.getCategoryId());
    }	
}	

删除广告后清除缓存
    /**
 * 批量删除
 */
    @Override
    public void delete(Long[] ids) {
    for(Long id:ids){
        //清除缓存
        Long categoryId = contentMapper.selectByPrimaryKey(id).getCategoryId();//广告分类ID
        redisTemplate.boundHashOps("content").delete(categoryId);
        contentMapper.deleteByPrimaryKey(id);
    }		
}

结语
对比数模学品优购真的是一种享受🤔
👴不想回建模了，拜拜了您嘞

我的博客原文链接
前言
通常的我们的项目开发中，经常会遇到那种在服务一启动就需要自动执行一些业务代码的情况。比如将数据库中的配置信息或者数据字典之类的缓存到redis，或者在服务启动的时候将一些配置化的定时任务开起来。关于spring mvc或者springboot如何在项目启动的时候就执行一些代码，方法其实有很多，我这边介绍一下我使用过的三种。
  
1、@PostConstruct 注解
从Java EE5规范开始，Servlet中增加了两个影响Servlet生命周期的注解，@PostConstruct和@PreDestroy，这两个注解被用来修饰一个非静态的void（）方法。@PostConstruct会在所在类的构造函数执行之后执行，在init()方法执行之前执行。(@PreDestroy注解的方法会在这个类的destory()方法执行之后执行。)

使用示例：在Spring容器加载之后，我需要启动定时任务去做任务的处理（我的定时任务采用的是读取数据库配置的方式）。在这里我使用@PostConstruct 指定了需要启动的方法。

@Component // 注意 这里必须有
public class StartAllJobInit {

    protected Logger logger = LoggerFactory.getLogger(getClass().getName());
    @Autowired
    JobInfoService jobInfoService;

    @Autowired
    JobTaskUtil jobTaskUtil;

    @PostConstruct // 构造函数之后执行
    public void init(){
        System.out.println("容器启动后执行");
        startJob();
    }

    public void startJob() {
        List<JobInfoBO> list = jobInfoService.findList();
        for (JobInfoBO jobinfo :list) {
            try {
                if("0".equals(jobinfo.getStartWithrun())){
                    logger.info("任务{}未设置自动启动。", jobinfo.getJobName());
                    jobInfoService.updateJobStatus(jobinfo.getId(), BasicsConstantManual.BASICS_SYS_JOB_STATUS_STOP);
                }else{
                    logger.info("任务{}设置了自动启动。", jobinfo.getJobName());
                    jobTaskUtil.addOrUpdateJob(jobinfo);
                    jobInfoService.updateJobStatus(jobinfo.getId(), BasicsConstantManual.BASICS_SYS_JOB_STATUS_STARTING);
                }
            } catch (SchedulerException e) {
                logger.error("执行定时任务出错，任务名称 {} ", jobinfo.getJobName());
            }
        }
    }
}

2、实现CommandLineRunner接口并重写run()方法
CommandLineRunner接口文档描述如下：
/**
 * Interface used to indicate that a bean should <em>run</em> when it is contained within
 * a {@link SpringApplication}. Multiple {@link CommandLineRunner} beans can be defined
 * within the same application context and can be ordered using the {@link Ordered}
 * interface or {@link Order @Order} annotation.
 * <p>
 * If you need access to {@link ApplicationArguments} instead of the raw String array
 * consider using {@link ApplicationRunner}.
 *
 * @author Dave Syer
 * @see ApplicationRunner
 */
public interface CommandLineRunner {

	/**
	 * Callback used to run the bean.
	 * @param args incoming main method arguments
	 * @throws Exception on error
	 */
	void run(String... args) throws Exception;

}

如上所说：接口被用作加入Spring容器中时执行run(String… args)方法，通过命令行传递参数。SpringBoot在项目启动后会遍历所有实现CommandLineRunner的实体类并执行run方法，多个实现类可以并存并且根据order注解排序顺序执行。这边还有个ApplicationRunner接口，但是接收参数是使用的ApplicationArguments。这边不再赘述。
同样是启动时执行定时任务，使用这种方式我的写法如下：
@Component // 注意 这里必须有
//@Order(2) 如果有多个类需要启动后执行 order注解中的值为启动的顺序
public class StartAllJobInit implements CommandLineRunner {

    protected Logger logger = LoggerFactory.getLogger(getClass().getName());
    @Autowired
    JobInfoService jobInfoService;

    @Autowired
    JobTaskUtil jobTaskUtil;

    @Override
    public void run(String... args) {
        List<JobInfoBO> list = jobInfoService.findList();
        for (JobInfoBO jobinfo :list) {
            try {
                if("0".equals(jobinfo.getStartWithrun())){
                    logger.info("任务{}未设置自动启动。", jobinfo.getJobName());
                    jobInfoService.updateJobStatus(jobinfo.getId(), BasicsConstantManual.BASICS_SYS_JOB_STATUS_STOP);
                }else{
                    logger.info("任务{}设置了自动启动。", jobinfo.getJobName());
                    jobTaskUtil.addOrUpdateJob(jobinfo);
                    jobInfoService.updateJobStatus(jobinfo.getId(), BasicsConstantManual.BASICS_SYS_JOB_STATUS_STARTING);
                }
            } catch (SchedulerException e) {
                logger.error("执行定时任务出错，任务名称 {} ", jobinfo.getJobName());
            }
        }
    }
}

3、使用ContextRefreshedEvent事件(上下文件刷新事件)

ContextRefreshedEvent 官方在接口上的doc说明


Event raised when an {@code ApplicationContext} gets initialized or refreshed.

ContextRefreshedEvent是Spring的ApplicationContextEvent一个实现，ContextRefreshedEvent 事件会在Spring容器初始化完成后以及刷新时触发。
在这里我需要在springboot程序启动之后加载配置信息和字典信息到Redis缓存中去，我可以这样写：
@Component // 注意 这个也是必须有的注解 三种都需要 使spring扫描到这个类并交给它管理
public class InitRedisCache implements ApplicationListener<ContextRefreshedEvent> {
    static final Logger logger = LoggerFactory
            .getLogger(InitRedisCache.class);

    @Autowired
    private SysConfigService sysConfigService;

    @Autowired
    private SysDictService sysDictService;


    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        logger.info("-------加载配置信息 start-------");
        sysConfigService.loadConfigIntoRedis();
        logger.info("-------加载配置信息 end-------");

        logger.info("-------加载字典信息 start-------");
        sysDictService.loadDictIntoRedis();
        logger.info("-------加载字典信息 end-------");
    }
}

注意：这种方式在springmvc-spring的项目中使用的时候会出现执行两次的情况。这种是因为在加载spring和springmvc的时候会创建两个容器，都会触发这个事件的执行。这时候只需要在onApplicationEvent方法中判断是否有父容器即可。
@Override  
  public void onApplicationEvent(ContextRefreshedEvent event) {  
      if(event.getApplicationContext().getParent() == null){//root application context 没有parent，他就是老大.  
           //需要执行的逻辑代码，当spring容器初始化完成后就会执行该方法。  
      }  
  }  

总结
以上，就是我在实际开发中常用的三种，在项目启动时执行代码的方式，开发者可以根据不同的使用情况选择合适的方法去执行自己的业务逻辑。