精华内容
下载资源
问答
  • 1:启动项目时加载数据库数据到缓存中 ...5:页面配置要改变的数据,修改后刷新map中的值,动态更新缓存数据 2:具体实现的代码如下 注意:需要引入自己的mapper查询结果 import org.slf4j.Logger; impo...

    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());
        }
    }
    
    
    展开全文
  • 项目启动加载缓存

    千次阅读 2017-04-21 14:07:31
    Tomcat启动时加载数据缓存--Web.xml里listener的加载顺序,优先初始化Spring IOC容器 多个listener加载顺序  最近用到在Tomcat服务器启动时自动加载数据缓存,这就需要创建一个自定义的缓存监听器并...
    
    

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

     

    Xml代码  
    1. <listener>  
    2.         <listener-class>  
    3.             org.springframework.web.context.ContextLoaderListener  
    4.         </listener-class>  
    5. </listener>  
    6. <listener>  
    7.     <listener-class>  
    8.         com.wsjiang.test.listener.CacheListener  
    9.     </listener-class>  
    10. </listener>  

     

          上面的配置细细大意为,先配置spring监听器,启动spring,再配置一个缓存监听器,我希望他们是顺序执行的,因为在缓存监听器中需要 spring注入其他对象的实例,我期望在服务器加载缓存监听器前加载Spring的监听器,将其优先实例化。但是实际运行发现他们并不是按照配置的顺序 加载的。


          对上面的问题我查询了很多资料,找到了一种解决方案,希望能帮助遇到同类问题的朋友。
          思路就是,既然listener的顺序是不固定的,那么我们可以整合两个listener到一个类中,这样就可以让初始化的顺序固定了。我就重写了 org.springframework.web.context.ContextLoaderListener这个类的 contextInitialized方法.大致代码如下:

    Java代码  
    1. public class ContextLoaderListenerOverWrite extends ContextLoaderListener {  
    2.     private IStationService stationService;  
    3.     private IOSCache osCache;  
    4.     @Override  
    5.     /** 
    6.      * @description 重写ContextLoaderListener的contextInitialized方法 
    7.      */  
    8.     public void contextInitialized(ServletContextEvent event) {  
    9.         super.contextInitialized(event);  
    10.         ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(event.getServletContext());  
    11.         //获取bean  
    12.         stationService = (IStationService) applicationContext.getBean("stationService");   
    13.         osCache = (IOSCache) applicationContext.getBean("osCache");  
    14.         /* 
    15.          具体地业务代码 
    16.          */  
    17.     }  
    18. }  

     

          web.xml的配置就由两个listener变为一个:

    Xml代码  
    1. <listener>  
    2.     <listener-class>  
    3.                  com.wsjiang.test.listener.ContextLoaderListenerOverWrite  
    4.         </listener-class>  
    5. </listener>  

           这样就能保证Spring的IOC容器先于自定义的缓存监听器初始化,在缓存监听器加载的时候就能使用依赖注入的实例.

    展开全文
  • 完成运营商后台广告类型管理与广告管理、完成前台工程广告轮播图的展示、使用SpringDataRedis操作字符串、set、List、hash等类型缓存、使用SpringDataRedis实现广告数据缓存。 广告管理 1.后台管理 1.1搭建广告...

    83222944_p0

    概述

    本篇将介绍如下几个方面:

    完成运营商后台广告类型管理与广告管理、完成前台工程广告轮播图的展示、使用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”,效果是直接显示,否则可能页面会先出现一段空白,极不美观。

    效果:

    image-20200730121831269

    缓存解决方案

    首页每天有大量的人访问,对数据库造成很大的访问压力,甚至是瘫痪。我们通常的做法有两种:一种是数据缓存、一种是网页静态化。我们今天讨论第一种解决方案。

    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;
    }
    

    image-20200730170914785

    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);
        }		
    }
    

    结语

    对比数模学品优购真的是一种享受🤔

    👴不想回建模了,拜拜了您嘞

    展开全文
  • 我的博客原文链接 前言 通常的我们的项目开发中,经常会遇到...关于spring mvc或者springboot如何在项目启动的时候就执行一些代码,方法其实有很多,我这边介绍一下我使用过的三种。 1、@PostConstruct 注解 从J...

    我的博客原文链接

    前言

    通常的我们的项目开发中,经常会遇到那种在服务一启动就需要自动执行一些业务代码的情况。比如将数据库中的配置信息或者数据字典之类的缓存到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容器初始化完成后就会执行该方法。  
          }  
      }  
    

    总结

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

    展开全文
  • Java:数据缓存机制

    2020-03-13 14:11:19
    对于查看频繁的表记录,且表数据不会增删改操作,可以在项目启动的时候,直接相关的表中的数据加载到内存中。 数据缓存机制思路 1. WEB-INFO配置project-servlet.xml <bean id="cacheLoader" class=...
  • 项目现状:已有一web app将oracle数据库主键做了缓存。如果在web app启动的情况下,不能直接操作数据库,否则报主键冲突。 解决办法:启动web app时,后台新加一线程运行数据抓取代码。 1.在web.xml文件中新加一个...
  • 类似spring-boot-starter-web等功能,现在模拟一个redis缓存启动器,实现功能: 其他项目引入这个组件依赖,在配置文件中加上redis连接配置后 1.可以直接使用redis工具类操作redis存数据,不用在另外的项目中再弄...
  • /** 按code和登录名缓存的人员map数据 */ static Map, TSysStaff> usersMap; /** 同步的所有人员归属部门信息 */ static List<TSysStaffOrg> usersOrg; /** 按人员code缓存的人员归属部门map数据 */ static ...
  • tomcat 启动加载项目

    2011-01-30 13:06:05
    因为hibernate会自动缓存查询的内容,所以第一次查询会比较慢,但之后就会很快,通过在tomcat启动时候用hibernate进行一次查询,之后用户就能直接从缓存拿到数据Web.xml配置 hibernate.init....
  • 通常JavaWeb项目在第一次启动时我们需要做一些初始化工作,比如:初始化一个管理员的登录账户和密码,配置缓存、定时任务等,这些操作可以通过手工修改数据库完成,但是容易出错且繁琐,而且也很麻烦。如果这个java ...
  • 1.2.4 Android移动Web项目开发的三种解决方案:Native, Web和Hybrid优缺陷分析 4 1.2.5国内外应用现状 6 1.2.6 研究现状总结 7 1.3研究目标与内容 7 1.3.1多窗口浏览器模式的实现机制 7 1.3.2跨域交互即缓存处理方法...
  • /**完成步骤 1、创建关系型数据库mysql的Provice库,同时启动nosql系列的redis数据库 2、创建项目,导入相关的jar包 3、创建jedis/utils/domain/dao/service/web项目框架包 4、书写相关代码*///页面<!DOCTYPE ...
  • //这里一般指后端项目API的前缀,例如 /baidu/*/*/1.api /mi/*/*/2.api const BASE_API = "" export function axiosIntercept(Vue, router) { const axiosIntercept = axios.create({ ...
  • 项目为全栈工程师学习笔记,不求最深最好,开源技术搬运工 其他项目:Spring Cloud微服务学习笔记 Spring Boot项目实践 Java体系知识点汇总: : 网站资源链接 S3基本使用事件 数据库隔离等级验证 常用JVM命令...
  • 通常,在web项目启动时,各位可能有疑问“Java中如何让web服务器启动的时候自动运行web程序中的某些业务”,如何在web项目启动时,做一些准备工作,如1.查询数据,放入缓存;2.清理原有数据缓存;等一系列操作。在此...
  • mall-admin-web项目的安装及部署请参考:mall前端项目的安装与部署。 Docker环境部署 使用虚拟机安装CentOS7.6请参考:虚拟机安装及使用Linux,看这一篇就够了; Docker环境的安装请参考:开发者必备Docker命令; ...
  • SpringBoot使用缓存注解

    2020-09-28 20:07:48
    创建SpringBoot项目,仅导入web和cache的依赖2. 在启动类上加上@EnableCaching注解3.在方法上使用缓存注解演示效果,多次访问该方法二、整合mysql环境搭建1.基础sql2、引入mysql依赖3、数据库连接信息4、启动mapper...
  • # 启动爬取 职位数据 的 worker env/bin/celery_lg_jobs_data_worker # 启动爬取 职位数量 的 worker env/bin/celery_lg_jobs_count_worker env/bin 目录下其他可执行脚本 # 直接爬取职位数量 env/bin/crawl_lg_...
  • spring boot 项目代码,直接启动,第一部分 点睛Spring 4.x 第1 章 Spring 基础 ..........................................2 1.1 Spring 概述 ............................................. 2 1.2 Spring 项目...
  • 目前笔者在做一个Java开发的Web项目项目启动的时候需要将大量不变的平台数据放入缓存中,方便快速读取。一开始笔者很疑惑,Java是不能直接操作内存的,但是我们缓存却是要把数据放入内存中,那这是怎么实现的呢?...
  • Weblogic8缓存清理

    千次阅读 2012-02-10 14:24:39
    在Weblogic8上部署完新的应用之后总是无法显示最新的页面,...删除/CH2/usr/ppap_web/wtcDomain/single/wtcDomain/2222Server/.wlnotdelete/extract路径下关于本项目数据,重新启动Weblgic8就可以显示最新界面了。
  • 缓存(三)实操

    2019-07-13 14:07:00
    1.创建一个spring初始化项目,jdk1.8 2.核心模块选中cache 3.引入web模块 4.数据库选mySQL和MyBatis 5.编写实体类,不用加注解。 6.配置数据源 7.编写Mapper接口,并在启动类上加@...
  • JSON构建前端form表单不能缓存数据问题修复; HIVE JSON构建增加头尾选项参数; 备注: 2.1.1版本不建议升级,数据源信息加密方式变更会导致之前已加密的数据源解密失败,任务运行失败。 如果需要升级请重建数据源,...
  • 这将安装并启动内存缓存缓存)和闪亮的(Web加速器)。 假设您已经安装了docker。 docker run -p 11211:11211 -d memcached memcached -I 30m go get github.com/bilbof/shiny cd $GOPATH/src/github....
  • soul-bootstrap启动的时候soul-web会发起一个http请求,从soul-admin拿到全量的数据,然后更新到缓存。 soul-bootstrap启动之后会定时的发起http长轮询到soul-admin,如果有数据修改,把全量数据返回,然后更新到...
  • 方式一:项目中 添加了redis作为一个缓存, webservlet 异步启动线程,线程中加一个轮询查redis ,如果redis有需要的值,则返回, 设置timeout 在规定时间内没有查到值,则返回超时.. 这个流程在实际做起来,会存在一定的...
  • 研究项目笔记

    2010-06-23 11:53:00
    1.入口函数:AdminWeb:启动,停止web服务器RunService(argc,argv,NULL,SZSERVICEDISPLAYNAME,SZDEPENDENCIES);2.解析后的东西都去哪里了?缓存到什么数据结构了?
  • 在进行 Web 项目开发的过程中,可能会存在一些需要经常访问的静态数据,针对这种在程序运行过程中可能几乎不会发生变化的数据,我们可以尝试在程序运行前写入到缓存中,这样在系统后续使用时就可以直接从缓存中进行...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 182
精华内容 72
关键字:

web项目启动缓存数据