深入浅出boot2.0 第13章3 定时任务包含我的整理（非socket）

亦凉 2023-02-20 06:26 7阅读 0赞

redis缓存:
    引入：
    org.springframework.boot
    spring-boot-starter-data-redis
    并在此引用下排除：
    g:io.lettuce
    a:lettuce-core
    不使用异步客户端lettuce，自己在引用一个jedis客户端
    redis.clients
    jedis
    
    配置：		
    spring.redis.jedis.pool
    .min-idle=5
    .max-active=10
    .max-idle=10
    .max-wait=2000
    
    spring.redis
    .port=6379
    .host=192.168.1.1
    .password=123
    
    spring.cache
    .type=REDIS
    .cache-names=redisCache
    .redis.time-to-live=600000 （毫秒）
    
    使用：StringSerializer 解析key
    	@PostConstruct
    	public void initRedisTemplate() { 
    		RedisSerializer<String> strSerializer = redisTemplate.getStringSerializer();
    		redisTemplate.setKeySerializer(strSerializer);
    		redisTemplate.setHashKeySerializer(strSerializer);
    	}
    
    
    使用：
    	@Cacheable(value = "redisCache", key = "'redis_user_'+#userName")
    	@Transactional
    	public DatabaseUser getUserByName(String userName) { }
    
    	@Cacheable(value = "redisCache", key = "'redis_user_role_'+#userName")
    	public List<DatabaseRole> findRolesByUserName(String userName) { 
    
    StringRedisTemplate 这个类 继承 RedisTemplate
     rt.opsForValue().set("key1","我的测试ke1");
    rt.opsForHash().put("hash","field","hvalue");
    
    
    
    
    异步线程池：
    @Configuration
    @EnableAsync（1，开启）
    public class AsyncConfig implements AsyncConfigurer { 
        // 定义线程池
        @Override
        public Executor getAsyncExecutor() { 
            // 定义线程池 （ThreadPoolTaskExecutor）
            ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
            // A:核心线程数
            taskExecutor.setCorePoolSize(10);
            // B:线程池最大线程数
            taskExecutor.setMaxPoolSize(30);
            // C:线程队列最大线程数
            taskExecutor.setQueueCapacity(2000);
            // 初始化
            taskExecutor.initialize();
            return taskExecutor;
        }
    }
    
    2，在方法上用：    @Async // 声明使用异步调用
    
    
    
    active MQ
    
    引用：
    org.apache.activemq
    activemq-pool
    
    org.springframework.boot
    spring-boot-starter-activemq
    
    
    # ActiveMQ地址
    spring.activemq.broker-url=tcp://localhost:61616
    
    # 配置用户名和密码
    spring.activemq.user=
    .password=
    
    # 是否使用发布订阅模式，默认是为false，即是用的是点对点的模式
    spring.jms.pub-sub-domain=true
    
    # 是否启用连接池
    spring.activemq.pool.enabled=true
    
    # 连接池最大连接数配置
    spring.activemq.pool.max-connections=50
    
    #信任所有类（把类转用ActiveMQ传递）
    spring.activemq.packages.trust-all=true 
    
    # 默认发送目的地址（用默认也监控它）
    spring.jms.template.default-destination=activemq.default.destination
    
    使用（发送）：
    @Autowired
    private JmsTemplate jmsTemplate = null;
    
    jmsTemplate.convertAndSend(message);
    
    使用（监听）：
    @JmsListener(destination = "${spring.jms.template.default-destination}")
    public void receiveMsg(String message) { 
    }
    
    默认用的是：SimpleMessageConverter 如需要：Jackson2JsonMessageConverter，SerializerMessageConverter  需配置：JmsTemplate
    
    
    发送接收实体类：
    实体类：implements Serializable
    
      // 使用自定义地址发送对象
     jmsTemplate.convertAndSend("我的目的地", user);
    
        @JmsListener(destination = "我的地址")
        public void receiveUser(User user) { }
    
    
    
    RabbitMQ
    docker启动：
    docker pull rabbitmq:management
    docker run -d -p 5672:5672 -p 15672:15672 
    --name rabbitmq rabbitmq:management
    
    --name:指定容器名称
    账号密码guest，guest
    
    AMQP常用的消息协议
    引用：
    org.springframework.boot
    spring-boot-starter-amqp
    
    配置：
    
    spring.rabbitmq
    .host=localhost
    .port=5672
    .username=admin
    .password=123
    
    #是否确认发送的消息已经被消费。 发送消息方可监听 发送消息到消费端是否成功。
    成功 则会 根据设置 进行回调。
    .publisher-confirms=true
    
    创建队列：
    	@Bean
    	public Queue createQueueMsg() { 
    		// 创建字符串消息队列，boolean值代表是否持久化消息
    		return new Queue(msgQueueName, true);
    	}
    
    	@Bean
    	public Queue createQueueUser() { 
    		// 创建用户消息队列，boolean值代表是否持久化消息
    		return new Queue(userQueueName, true);
    	}
    
    使用(发送者和回调)：
    implements ConfirmCallback, RabbitMqService
    
        @Autowired
        private RabbitTemplate rabbitTemplate = null;
    
            // 设置回调
            rabbitTemplate.setConfirmCallback(this);
            // 发送消息，通过msgRouting确定队列
            rabbitTemplate.convertAndSend("字符串routing", msg);
    
            rabbitTemplate.convertAndSend("对象routing", user);
    
        // 回调确认方法
        @Override
        public void confirm(CorrelationData correlationData, 
                boolean ack, String cause) { 
            if (ack) { 
                消息成功
            } else { 
               消费失败: + cause
            }
        }
    
    使用(监听者)：
    @Component
    public class Receiver { 
    	// 定义监听字符串队列名称
    	@RabbitListener(queues = {  "字符串routing" })
    	public void receiveMsg(String msg) { 
     	收到消息: + msg
    	}
    	
        	// 定义监听用户队列名称
    	@RabbitListener(queues = {  "对象routing" })
    	public void receiveUser(User user) { 
    	收到用户 + user
    	}
    }
    、
    
    
    
    =========================================================
    
    定时任务。
    1.@EnableScheduling
    2.@Scheduled 去配置如何定时
    
    
        // 每隔1秒执行一次
        @Scheduled(fixedRate = 1000)
        @Async //异步执行
        public void job1() { }
    
    //IoC容器初始化后，第一次延迟3秒，每隔1秒执行一次
        @Scheduled(initialDelay = 3000, fixedRate = 1000)
    
        @Scheduled(cron = "0 * 11 * * ?") 秒0 分（任意） 时11  天（任意） 月（任意） 星期（不指定）。即：11:00到11:59点每一分钟执行一次
    
    Scheduled 属性：
        @Scheduled(cron = "", zone = "", 
                   fixedDelay = 0L, fixedDelayString = "", 
                   initialDelay = 300L,initialDelayString = "", 
                   fixedRate = 1L, fixedRateString = ""
        )
    cron 表达式
    zone 设定区域时间
    fixedDelay  上个任务完成，到下个任务开始的间隔
    +String  ，同上，并且支持SpEL
    
    fixedRate 从上个任务开始（并不是完成）到下一个任务开始的间隔
    
    initialDelay  ioc容器初始化后，首次任务执行延迟时间，单位毫秒
    
    
    cron学习 (秒 分 时 天 月 星期 年)
    
    *  任意值
    ？不指定，用来处理天 和 星期 冲突
    - 指定时间区域
    / 指定时间间隔执行
    L  最后的
    # 第几个
    ,  列举多个项
    
    
    
    - 秒 分 时 天 月 星期 年
    - 0 0 0 * * ？ 每天 00:00 触发。
    - 0 15 23 ？ * * 	23点15分0秒 
    - 0 15 0 * * ？      0:15触发
    - 0 15 10 * * ? *    10:15触发
    - 0 30 10 * * ？2018     2018年10:30分每天执行
    - 
    - 0 * 23 * * ？ 每天23点0秒 任意执行=23:00——23:59 1分钟触发一次
    - 0 0/3 23 * * ？ 23:00——23:59分， 每3分钟执行一次。3分钟1间隔 23点
    - 0 0/3 20,23 * * ？  比上面又多了一个 20点--21点
    - 0 0-5 21 * * ？ 21点 0 — 5 分钟的 0秒执行
    - 0 10,44 14 ？ 3 WED     3月的每周3 14:10或14点44触发
    - 0 0 23 ？ * MON-FRI     周一到周五23点执行 （国人认为的周一到周四）
    - 0 30 23 ? * 6L    17到20年 任意月的 最后一个周5 23点30分 
    - 0 15 22 ？ * 6#3    6数字，肯定代表周5了。每月第三周周五的22:15触发 （）

# 定时任务 #

*  月末，季末，年末，统计 表
 *  main 主类上加入： @EnableScheduling
 *  @Scheduled 去配置如何定时

## 简单测试定时任务 ##

@Service
    public class ScheduleServiceImpl { 
        // 计数器
        int count1 = 1;
        int count2 = 1;
        
        // 每隔1秒执行一次
        @Scheduled(fixedRate = 1000)
        // 使用异步执行
        @Async
        public void job1() { 
            System.out.println("【" +Thread.currentThread().getName()+"】"
                    + "【job1】每秒钟执行一次，执行第【" + count1 + "】次");
            count1 ++;
        }
        
        // 每隔1秒执行一次
        @Scheduled(fixedRate = 1000)
        // 使用异步执行
        @Async
        public void job2() { 
            System.out.println("【" +Thread.currentThread().getName()+"】"
                    + "【job2】每秒钟执行一次，执行第【" + count2 + "】次");
            count2 ++;
        }
        
        int count3 = 1;
        int count4 = 1;
        // Spring IoC容器初始化后，第一次延迟3秒，每隔1秒执行一次
        @Scheduled(initialDelay = 3000, fixedRate = 1000)
        @Async
        public void job3() { 
            System.out.println("【" + Thread.currentThread().getName() + "】" 
                + "【job3】每秒钟执行一次，执行第【" + count3 + "】次");
            count3++;
        }
    
        // 11:00到11:59点每一分钟执行一次
        @Scheduled(cron = "0 * 11 * * ?") 秒0 分（任意） 时11  天（任意） 月（任意） 星期（不指定）
        @Async
        public void job4() { 
            System.out.println("【" + Thread.currentThread().getName() 
                + "】【job4】每分钟执行一次，执行第【" + count4 + "】次");
            count4 ++;
        }
    }

## Scheduled 属性说明 ##

@Scheduled(cron = "", zone = "", 
                   fixedDelay = 0L, fixedDelayString = "", 
                   initialDelay = 300L,initialDelayString = "", 
                   fixedRate = 1L, fixedRateString = ""
        )

*  cron 表达式
 *  zone 设定区域时间
 *  fixedDelay 上个任务完成，到下个任务开始的间隔
 *  fixedDelayString 同上，使用的是字符串，可以使用SpEL来引入配置文件的配置
 *  
 *  initialDelay ioc容器初始化后，首次任务执行延迟时间，单位毫秒
 *  initialDelayString 同上，使用SpEL来引入配置文件的配置
 *  
 *  fixedRate 从上个任务开始（并不是完成）到下一个任务开始的间隔，单位为毫秒
 *  fixedRateString 同上，可以使用SpEL来引入配置文件的配置

## cron学习 (秒 分 时 天 月 星期 年) ##

*  可以通过表达式，更加灵活地配置运行的方式。
 *  秒 分 时 天 月 星期 年 （年可以不配置）
 *  
 *  0 0 0 ？\* WED
    
     *  秒分时 天 月 星期
     *  wednesday星期3
     *  每个星期3 中午 0点整
     *  ？ 和 \* ，天 和 星期 会产生定义上的冲突，会以 ? 表示
     *  \*表示 任意的月

<table> 
 <thead> 
  <tr> 
   <th align="center">通配符</th> 
   <th align="center">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">*</td> 
   <td align="center">任意值</td> 
  </tr> 
  <tr> 
   <td align="center">？</td> 
   <td align="center">不指定，用来处理天 和 星期 冲突</td> 
  </tr> 
  <tr> 
   <td align="center">-</td> 
   <td align="center">指定时间区域</td> 
  </tr> 
  <tr> 
   <td align="center">/</td> 
   <td align="center">指定时间间隔执行</td> 
  </tr> 
  <tr> 
   <td align="center">L</td> 
   <td align="center">最后的</td> 
  </tr> 
  <tr> 
   <td align="center">#</td> 
   <td align="center">第几个</td> 
  </tr> 
  <tr> 
   <td align="center">,</td> 
   <td align="center">列举多个项</td> 
  </tr> 
 </tbody> 
</table>

### cron表达式 举例 ###

*  秒 分 时 天 月 星期 年
 *  0 0 0 \* \* ？ 每天 00:00 触发。 0秒 0分 0时 任意天 任意月 星期不指定
 *  0 15 23 ？ \* \* 23点15分0秒 天不指定，月星期任意
 *  0 15 0 \* \* ？ 0秒15分0小时 任意天任意月 星期不指定 0:15触发
 *  0 15 10 \* \* ? \* 0秒15分10小时 任意天任意月 星期不指定 任意年 10:15触发
 *  0 30 10 \* \* ？2018 0秒30分10小时 天月任意星期不指定 2018年。2018年10:30分每天执行
 *  
 *  0 \* 23 \* \* ？ 0秒 分钟任意 23小时 天月任意 星期不指定。 每天23点0秒 分钟任意执行=23:00——23:59 1分钟触发一次
 *  0 0/3 23 \* \* ？ 23:00——23:59分， 每3分钟执行一次。0秒 3分钟1间隔 23点
 *  0 0/3 20,23 \* \* ？ 比上面又多了一个 8点–9点
 *  0 0-5 21 \* \* ？ 21点 0 — 5 分钟的 0秒执行
 *  0 10,44 14 ？ 3 WED 0秒10或44分钟 14点 天不指定 3 月 周3 。3月的每周3 14:10或14点44触发
 *  0 0 23 ？ \* MON-FRI 周一到周五 0秒0分钟23点 天不指定，年任意。周一到周五23点执行
 *  0 30 23 ? \* 6L 2017-2020 17到20年 任意月的 最后一个周5 23点30分
 *  0 15 22 ？ \* 6\#3 0秒15分钟22点 天不指定 月任意 ，星期是第三周周5 。每月第三周周五的22:15触发