悠然予夏
悠然予夏

kafka重试队列

        kafka没有重试机制不支持消息重试，也没有死信队列，因此使用kafka做消息队列时，需要自己实现消息重试的功能。

实现

创建新的kafka主题作为重试队列：

  1. 创建一个topic作为重试topic，用于接收等待重试的消息。
  2. 普通topic消费者设置待重试消息的下一个重试topic。
  3. 从重试topic获取待重试消息储存到redis的zset中，并以下一次消费时间排序
  4. 定时任务从redis获取到达消费事件的消息，并把消息发送到对应的topic
  5. 同一个消息重试次数过多则不再重试

代码实现

1、新建springboot项目



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.2.8.RELEASE
         
    
    com.lagou.kafka.demo
    demo-retryqueue
    0.0.1-SNAPSHOT
    demo-retryqueue
    Demo project for Spring Boot

    
        1.8
    

    
        
            org.springframework.boot
            spring-boot-starter-data-redis
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.kafka
            spring-kafka
        
        
            com.alibaba
            fastjson
            1.2.73
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
            
                
                    org.junit.vintage
                    junit-vintage-engine
                
            
        
        
            io.projectreactor
            reactor-test
            test
        
        
            org.springframework.kafka
            spring-kafka-test
            test
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

2、添加application.properties

# bootstrap.servers
spring.kafka.bootstrap-servers=node1:9092
# key序列化器
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
# value序列化器
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer

# 消费组id：group.id
spring.kafka.consumer.group-id=retryGroup
# key反序列化器
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
# value反序列化器
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer

# redis数据库编号
spring.redis.database=0
# redis主机地址
spring.redis.host=node1
# redis端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=20
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=1000

# Kafka主题名称，业务主题
spring.kafka.topics.test=tp_demo_retry_01
# 重试队列，重试主题
spring.kafka.topics.retry=tp_demo_retry_02

3、RetryqueueApplication

package com.lagou.kafka.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RetryqueueApplication {

    public static void main(String[] args) {
        SpringApplication.run(RetryqueueApplication.class, args);
    }

}

4、AppConfig

package com.lagou.kafka.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
public class AppConfig {
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);

        return template;
    }

}

5、RetryController

package com.lagou.kafka.demo.controller;

import com.lagou.kafka.demo.service.KafkaService;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.ExecutionException;

@RestController
public class RetryController {

    @Autowired
    private KafkaService kafkaService;

    @Value("${spring.kafka.topics.test}")
    private String topic;

    @RequestMapping("/send/{message}")
    public String sendMessage(@PathVariable String message) throws ExecutionException, InterruptedException {

        ProducerRecord record = new ProducerRecord<>(
                topic,
                message
        );

        // 向业务主题发送消息
        String result = kafkaService.sendMessage(record);

        return result;
    }

}

6、KafkaService

package com.lagou.kafka.demo.service;

import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Service;

import java.util.concurrent.ExecutionException;

@Service
public class KafkaService {

    private Logger log = LoggerFactory.getLogger(KafkaService.class);

    @Autowired
    private KafkaTemplate kafkaTemplate;

    public String sendMessage(ProducerRecord record) throws ExecutionException, InterruptedException {

        SendResult result = this.kafkaTemplate.send(record).get();
        RecordMetadata metadata = result.getRecordMetadata();
        String returnResult = metadata.topic() + "\t" + metadata.partition() + "\t" + metadata.offset();
        log.info("发送消息成功：" + returnResult);

        return returnResult;
    }

}

7、RetryService

package com.lagou.kafka.demo.service;

import com.alibaba.fastjson.JSON;
import com.lagou.kafka.demo.entity.RetryRecord;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.common.header.Header;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

import java.nio.ByteBuffer;
import java.util.Calendar;
import java.util.Date;

@Service
public class RetryService {
    private static final Logger log = LoggerFactory.getLogger(RetryService.class);

    /**
     * 消息消费失败后下一次消费的延迟时间(秒)
     * 第一次重试延迟10秒;第	二次延迟30秒,第三次延迟1分钟...
     */
    private static final int[] RETRY_INTERVAL_SECONDS = {10, 30, 1*60, 2*60, 5*60, 10*60, 30*60, 1*60*60, 2*60*60};

    /**
     * 重试topic
     */
    @Value("${spring.kafka.topics.retry}")
    private String retryTopic;

    @Autowired
    private KafkaTemplate kafkaTemplate;

    public void consumerLater(ConsumerRecord record){
        // 获取消息的已重试次数
        int retryTimes = getRetryTimes(record);
        Date nextConsumerTime = getNextConsumerTime(retryTimes);
        // 如果达到重试次数，则不再重试
        if(nextConsumerTime == null) {
            return;
        }

        // 组织消息
        RetryRecord retryRecord = new RetryRecord();
        retryRecord.setNextTime(nextConsumerTime.getTime());
        retryRecord.setTopic(record.topic());
        retryRecord.setRetryTimes(retryTimes);
        retryRecord.setKey(record.key());
        retryRecord.setValue(record.value());

        // 转换为字符串
        String value = JSON.toJSONString(retryRecord);
        // 发送到重试队列
        kafkaTemplate.send(retryTopic, null, value);
    }

    /**
     * 获取消息的已重试次数
     */
    private int getRetryTimes(ConsumerRecord record){
        int retryTimes = -1;
        for(Header header : record.headers()){
            if(RetryRecord.KEY_RETRY_TIMES.equals(header.key())){
                ByteBuffer buffer = ByteBuffer.wrap(header.value());
                retryTimes = buffer.getInt();
            }
        }
        retryTimes++;
        return retryTimes;
    }

    /**
     * 获取待重试消息的下一次消费时间
     */
    private Date getNextConsumerTime(int retryTimes){
        // 重试次数超过上限,不再重试
        if(RETRY_INTERVAL_SECONDS.length < retryTimes) {
            return null;
        }

        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND, RETRY_INTERVAL_SECONDS[retryTimes]);
        return calendar.getTime();
    }
}

8、ConsumerListener

package com.lagou.kafka.demo.listener;

import com.lagou.kafka.demo.service.RetryService;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

@Component
public class ConsumerListener {

    private static final Logger log = LoggerFactory.getLogger(ConsumerListener.class);

    @Autowired
    private RetryService kafkaRetryService;

    private static int index = 0;

    @KafkaListener(topics = "${spring.kafka.topics.test}", groupId = "${spring.kafka.consumer.group-id}")
    public void consume(ConsumerRecord record) {
        try {
            // 业务处理
            log.info("消费的消息：" + record);
            index++;
            if (index % 2 == 0) {
                throw new Exception("该重发了");
            }
        } catch (Exception e) {
            log.error(e.getMessage());
            // 消息重试，实际上先将消息放到redis
            kafkaRetryService.consumerLater(record);
        }
    }

}

9、RetryListener

package com.lagou.kafka.demo.listener;

import com.alibaba.fastjson.JSON;
import com.lagou.kafka.demo.entity.RetryRecord;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Set;
import java.util.UUID;

@Component
@EnableScheduling
public class RetryListener {

    private Logger log = LoggerFactory.getLogger(RetryListener.class);

    private static final String RETRY_KEY_ZSET = "_retry_key";
    private static final String RETRY_VALUE_MAP = "_retry_value";
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private KafkaTemplate kafkaTemplate;

    @Value("${spring.kafka.topics.test}")
    private String bizTopic;

    @KafkaListener(topics = "${spring.kafka.topics.retry}")
//    public void consume(List> list) {
//        for(ConsumerRecord record : list){
    public void consume(ConsumerRecord record) {

        System.out.println("需要重试的消息：" + record);
        RetryRecord retryRecord = JSON.parseObject(record.value(), RetryRecord.class);

        /**
         * 防止待重试消息太多撑爆redis,可以将待重试消息按下一次重试时间分开存储放到不同介质
         * 例如下一次重试时间在半小时以后的消息储存到mysql,并定时从mysql读取即将重试的消息储储存到redis
         */

        // 通过redis的zset进行时间排序
        String key = UUID.randomUUID().toString();
        redisTemplate.opsForHash().put(RETRY_VALUE_MAP, key, record.value());
        redisTemplate.opsForZSet().add(RETRY_KEY_ZSET, key, retryRecord.getNextTime());
    }
//    }

    /**
     * 定时任务从redis读取到达重试时间的消息,发送到对应的topic
     */
//    @Scheduled(cron="2 * * * * *")
    @Scheduled(fixedDelay = 2000)
    public void retryFromRedis() {
        log.warn("retryFromRedis----begin");
        long currentTime = System.currentTimeMillis();
        // 根据时间倒序获取
        Set> typedTuples =
                redisTemplate.opsForZSet().reverseRangeByScoreWithScores(RETRY_KEY_ZSET, 0, currentTime);
        // 移除取出的消息
        redisTemplate.opsForZSet().removeRangeByScore(RETRY_KEY_ZSET, 0, currentTime);
        for(ZSetOperations.TypedTuple tuple : typedTuples){
            String key = tuple.getValue().toString();
            String value = redisTemplate.opsForHash().get(RETRY_VALUE_MAP, key).toString();
            redisTemplate.opsForHash().delete(RETRY_VALUE_MAP, key);
            RetryRecord retryRecord = JSON.parseObject(value, RetryRecord.class);
            ProducerRecord record = retryRecord.parse();

            ProducerRecord recordReal = new ProducerRecord(
                    bizTopic,
                    record.partition(),
                    record.timestamp(),
                    record.key(),
                    record.value(),
                    record.headers()
            );

            kafkaTemplate.send(recordReal);
        }
        // todo 发生异常将发送失败的消息重新发送到redis
    }
} 
  
10、RetryRecord
 
  
package com.lagou.kafka.demo.entity;

import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.header.Header;
import org.apache.kafka.common.header.internals.RecordHeader;

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

public class RetryRecord {

    public static final String KEY_RETRY_TIMES = "retryTimes";

    private String key;
    private String value;

    private Integer retryTimes;
    private String topic;
    private Long nextTime;

    public RetryRecord() {
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public Integer getRetryTimes() {
        return retryTimes;
    }

    public void setRetryTimes(Integer retryTimes) {
        this.retryTimes = retryTimes;
    }

    public String getTopic() {
        return topic;
    }

    public void setTopic(String topic) {
        this.topic = topic;
    }

    public Long getNextTime() {
        return nextTime;
    }

    public void setNextTime(Long nextTime) {
        this.nextTime = nextTime;
    }

    public ProducerRecord parse() {
        Integer partition = null;
        Long timestamp = System.currentTimeMillis();
        List
 headers = new ArrayList<>();
        ByteBuffer retryTimesBuffer = ByteBuffer.allocate(4);
        retryTimesBuffer.putInt(retryTimes);
        retryTimesBuffer.flip();
        headers.add(new RecordHeader(RetryRecord.KEY_RETRY_TIMES, retryTimesBuffer));

        ProducerRecord sendRecord = new ProducerRecord(
                topic, partition, timestamp, key, value, headers);
        return sendRecord;
    }
}
 
  
启动，访问浏览器，进行测试
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(消息队列,kafka,java,分布式)

        

            

                
    
                    
  • Spark Sql 简单校验的实现
                        小小小小小小小小小小码农
sparksqljava
                        
    在网上参考了很多资料，都是要依赖Sparksession，这个需要spark环境，非常不友好，jdk版本也不好控制。不使用Sparksession获取上下文，利用spark和antlr的静态方法使用java实现简单的sparksql的语法以及内置函数的校验。1.spark版本3.2.0org.apache.sparkspark-sql_2.123.2.0org.antlrantlr4-runtim
    
                    
    • 
                    
  • Spring(6）——Spring、Spring Boot 与 Spring MVC 的关系与区别
                        南山不太冷
Springspringspringbootmvc
                        
    Spring、SpringBoot与SpringMVC的关系与区别1.核心定位Spring定位：基础框架，提供IoC（控制反转）和DI（依赖注入）核心功能，管理对象生命周期及依赖关系。功能：支持事务管理、AOP（面向切面编程）、数据访问等，适用于所有Java应用（不限于Web）。SpringMVC定位：Spring的子框架，专注于Web层开发，基于MVC（Model-View-Controller
    
                    
    • 
                    
  • sequelize + Nodejs + MySQL 的简单用法
                        小公鸡卡哇伊呀~
mysql数据库
                        
    HowtoUseSequelizeORMinNodeJS-Tutorial1Sequlize简介Sequelize是最流行的可以与Nodejs一起使用的一种关系数据库ORM(Object-relationalmapping对象关系映射)，Mongoose是MongoDB的ORM.Sequelize的作用，简单地说，就是避免在代码里写原生SQL语句，而是将这种语句改成JavaScript：不必再写类
    
                    
    • 
                    
  • InfluxDB写入测试
                        PascalMing
编程influxdbjava读写测试
                        
    早几年测试时序库时，采集数据到kafka，然后用不同数据进行存储验证。Influxdb是花时间比较多的，它的数据建模方法、读写方法都需要使用特殊的API。时间久了自己也经常忘记，把当时的测试关键代码记录下来，也方便日后查找。代码基于java编写。1、接口数据定义，clientid+tag组合必须唯一publicclassKafkaInfo{//客户端idpublicStringclientid;/
    
                    
    • 
                    
  • JavaScript 的 requestAnimationFrame
                        小华0000
javascript开发语言ecmascript
                        
    在现代Web开发中，用户体验至关重要。动画作为用户交互的重要组成部分，如果处理不当，很容易出现卡顿、掉帧等问题，严重影响用户体验。幸运的是，JavaScript提供了一个强大的API：requestAnimationFrame（简称rAF），它为我们创建平滑、高效的动画提供了坚实的基础。本文将深入探讨requestAnimationFrame的原理、使用、高级技巧以及在实际项目中的应用，帮助你掌握
    
                    
    • 
                    
  • Cesium在三维模型中的应用
                        IT邦少
前端贴图
                        
    Cesium在三维模型中的应用Cesium简介Cesium介绍Cesium是一个跨平台,跨浏览器的展示三维地球和地图的javascript库Cesium使用WebGL来进行硬件加速图形,使用时不需要任何插件支持,但是浏览器必须支持WebGLCesium是基于Apache2.0许可的开源程序,它可以免费的用于商业和非商业用途Cesium特点支持2D,2.5D,3D形式的地图展示可以绘制各种几何图形,
    
                    
    • 
                    
  • 2025前端面试题超全面解析（附答案与深度扩展）
                        北辰alk
前端前端
                        
    文章目录一、HTML篇（扩展版）1.**HTML5语义化标签的实际应用场景**2.**WebComponents实战：如何封装一个自定义按钮组件？**3.**WebWorker的用途与限制**二、CSS篇（扩展版）1.**CSS盒模型详解：border-boxvscontent-box**2.**CSS动画性能优化技巧**3.**CSS预处理器（Sass/Less）核心功能对比**三、JavaSc
    
                    
    • 
                    
  • Cesium-三维地球可视化应用
                        程序员_三木
Web3dwebglThree.js
                        
    什么是CesiumJS？CesiumJS是一个强大的开源JavaScript库，用于构建高性能的3D地图和地球可视化应用。无论你是从事地理信息系统（GIS）开发、数据可视化，还是需要展示空间数据，CesiumJS都能提供灵活的解决方案。它以WebGL为核心，专注于大规模地理空间数据的实时渲染。CesiumJS是Cesium平台的核心部分，与Cesiumion等服务无缝集成，支持从数据管理到可视化的
    
                    
    • 
                    
  • 深度探索 Java 代码审计：筑牢安全防线的关键之路
                        阿贾克斯的黎明
javajava安全开发语言
                        
    在当今高度数字化的时代，软件安全成为了至关重要的议题。对于众多使用Java语言进行开发的程序员而言，深入掌握Java代码审计技能，无疑是守护软件安全的核心手段。本文将围绕一本涵盖Java代码审计丰富知识的书籍目录，全面剖析Java代码审计的各个关键环节以及其在CTFAWD比赛中的重要应用。一、学习经验：开启Java代码审计的智慧之门Java代码审计之路并非坦途，需要有系统的学习方法和实践经验。书籍
    
                    
    • 
                    
  • 前端初学者，该如何开始学习？
                        四六的六
前端学习个人开发
                        
    前端初学者，该如何开始学习？嗨，作为一个曾经的前端小白，现在也算是入门了，我特别理解刚开始学习前端时的迷茫，所以很愿意和你分享一下我的学习经验。刚开始的时候，得先搞清楚前端技术到底是啥。简单来说，前端就是咱们平常在浏览器里看到的网页那些东西。它主要由HTML、CSS和JavaScript三个部分组成。HTML（超文本标记语言）：作为构建网页内容的基石，HTML以其独特的标签体系定义了网页的基本架构
    
                    
    • 
                    
  • Spring Boot中使用RabbitMQ实现简单的消息发送与接收
                        Takumilovexu
MQjava-rabbitmqrabbitmqspringboot
                        
    文章目录环境准备1.RabbitMQ的基础配置2.实现消息发送功能3.实现消息接收功能4.总结在微服务架构和分布式系统中，消息队列是实现异步通信和解耦的重要工具。RabbitMQ作为一种常见的消息中间件，广泛应用于消息传递、任务分发等场景。本文将带你一步步实现如何在SpringBoot应用中使用RabbitMQ进行消息的发送和接收。我们将构建一个消息发送者（Publisher）和一个消息接收者（C
    
                    
    • 
                    
  • Cesium实时建筑物三维可视化与地理信息系统（GIS）
                        OvzStream
GIS
                        
    近年来，随着科技的不断发展，地理信息系统（GIS）和三维可视化技术在城市规划、建筑设计和地理空间分析中扮演着越来越重要的角色。在这篇文章中，我们将探讨如何利用Cesium库实现实时建筑物的三维可视化与GIS集成，为读者展示如何通过编写代码来实现这一功能。首先，我们需要了解Cesium是什么。Cesium是一个开源的JavaScript库，专门用于创建基于Web的地理信息系统应用程序。它提供了强大的
    
                    
    • 
                    
  • JavaWeb学习——登录校验
                        灰太狼想上班
JavaWeb基础学习springtomcatservlet后端
                        
    JavaWeb学习——登录校验一、功能实现只需要接受请求参数username和password，然后调用接口在数据库表中查询键值匹配的数据项即可二、登录校验登录校验通常分为两步，一是登录标记，二是统一拦截1、会话跟踪会话：用户打开浏览器，访问web服务器的资源，会话建立，知道有一方断开连接，会话结束。在一次会话中可以包含多次请求和响应会话跟踪：一种维护浏览器的方法，服务器要识别多次请求是否来自于同
    
                    
    • 
                    
  • Java面试精选（1）:Spring，SpringMVC，SpringBoot，SpringCloud有什么区别和联系？
                        Java面试精选
springjavaspringbootvue编程语言
                        
    简单介绍Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。Spring使你能够编写更干净、更可管理、并且更易于测试的代码。SpringMVC是Spring的一个模块，一个web框架。通过DispatcherServlet,ModelAndView和ViewResolver，开发web应用变得很容易。主要针对的是网站应用程序或者服务开发——URL路由、Session、模板引
    
                    
    • 
                    
  • Kotlin知识体系(一) : Kotlin的五大基础语法特性
                        氦客
知识体系-Kotlin基础kotlin开发语言android基础语法特性知识体系
                        
    前言在Android开发领域，Kotlin凭借其简洁性和安全性已成为官方推荐语言。本文将通过Kotlin的五大基础语法特性，结合实际应用场景展示它们在Android开发中的独特价值。一、变量声明：val与var的哲学1.1不可变优先原则Kotlin的val关键字用于声明不可变变量（相当于Java的final），这是构建可靠Android应用的基石：valPI=3.14159//类型推断为Doubl
    
                    
    • 
                    
  • 用Java爬虫轻松获取微店店铺所有商品信息
                        数据小爬虫@
java爬虫开发语言
                        
    在当今电商蓬勃发展的时代，微店作为一个轻量级且功能强大的电商平台，吸引了众多商家和消费者。无论是进行市场调研、数据分析，还是寻找热门商品，获取微店店铺的所有商品信息都是一项极具价值的任务。然而，手动浏览和整理这些信息显然是低效且容易出错的。幸运的是，通过编写Java爬虫程序，我们可以高效地完成这一任务。本文将详细介绍如何利用Java爬虫获取微店店铺的所有商品信息。一、为什么选择Java爬虫？Jav
    
                    
    • 
                    
  • 前端初学者，有哪些适合的学习网站？
                        四六的六
前端学习个人开发
                        
    对于前端初学者而言，选择合适的学习网站至关重要，以下是一些我知道的优质学习平台，在这里分享给大家：菜鸟教程：该网站以其简洁明了的界面设计和通俗易懂的教程内容而受到广大初学者的欢迎。其前端教程体系涵盖了前端开发的大量入门知识，包括HTML、CSS、JavaScript等基础技术，以及当前主流的前端框架和工具的使用方法，如Vue.js、React、Webpack等。教程内容的讲解方式深入浅出，注重从基
    
                    
    • 
                    
  • HarmonyNext实战：基于ArkTS的分布式任务调度系统开发
                        
harmonyos-next
                        
    HarmonyNext实战：基于ArkTS的分布式任务调度系统开发引言在HarmonyNext生态系统中，分布式任务调度是一个核心且复杂的技术领域。随着设备互联的普及，如何在多设备间高效、可靠地分配和执行任务成为开发者面临的重要挑战。本文将深入探讨如何利用ArkTS语言构建一个高性能的分布式任务调度系统，涵盖从架构设计到代码实现的完整过程。分布式任务调度系统概述分布式任务调度系统的核心目标是将任务
    
                    
    • 
                    
  • HarmonyNext实战：基于ArkTS的跨设备分布式计算应用开发
                        
harmonyos-next
                        
    HarmonyNext实战：基于ArkTS的跨设备分布式计算应用开发引言随着分布式计算技术的快速发展，跨设备协同计算已成为提升应用性能的重要手段。HarmonyNext作为新一代操作系统，提供了强大的分布式能力，而ArkTS作为其开发语言，能够帮助开发者高效实现跨设备分布式计算。本文将详细讲解如何在HarmonyNext平台上使用ArkTS开发一个跨设备分布式计算应用。我们将从分布式计算的基本原理
    
                    
    • 
                    
  • Uncaught (in promise)
                        weixin_42601702
javascript前端vue.jsjson开发语言
                        
    "Uncaught(inpromise)"的意思是"未捕获(在承诺中)"，通常出现在使用JavaScript中的Promise对象时。它表示在一个Promise对象中发生了错误，但是没有被处理，也就是没有被"捕获"。这通常是由于没有正确处理Promise链中的异常而导致的。要解决此问题，可以在Promise链中使用catch()方法来捕获错误，并采取适当的措施来处理它们。另外，也可以使用try-c
    
                    
    • 
                    
  • 为什么很多人喷 Java 开发者离了 spring 框架就不会写代码了
                        getapi
javaspring开发语言
                        
    很多人批评Java开发者离开Spring框架后难以独立开发的原因可从技术特性与开发者习惯两方面分析：Java语言的历史设计局限Java的泛型实现存在缺陷，其原始值包装类（如Integer与int）的自动装拆箱机制出现较晚（Java5引入），且编译器无法彻底解决原始值与包装类的隐式转换问题[[1]][[2]]。这种设计导致开发者在处理基础类型与对象时需要额外关注类型转换，而Spring框架通过封装（
    
                    
    • 
                    
  • 如何在GitHub上Clone项目：一步步指南
                        Fanstay985
github
                        
    GitHub作为全球最大的代码托管平台，汇聚了无数开发者的智慧结晶。对于初学者和资深开发者来说，学会如何从GitHub上克隆（Clone）项目是一项基本且重要的技能。本文将详细介绍如何在GitHub上克隆项目的步骤，帮助你轻松将他人的代码库下载到本地进行学习和开发。一、准备工作在开始之前，请确保你已经安装了Git。Git是一个分布式版本控制系统，用于代码的版本管理。如果你还没有安装Git，可以从G
    
                    
    • 
                    
  • 面试中必会的Java基础(一）
                        每次的天空
面试java学习
                        
    Java是面向对象编程所以第一就是面向对象编程的特点是什么？面向对象编程类与对象：掌握类的定义、成员变量和成员方法的声明与使用，以及如何通过类创建对象。理解对象的生命周期，包括创建、使用和销毁。封装：明白封装的概念，即把数据和操作数据的方法封装在一个类中，通过访问修饰符（public、private、protected等）来控制对类成员的访问。继承：理解继承的概念和作用，掌握通过extends关键
    
                    
    • 
                    
  • Spring Boot 核心知识点精讲：助你快速上手与深度理解
                        无眠_
springboot运维后端
                        
    SpringBoot核心知识点精讲：助你快速上手与深度理解摘要：SpringBoot以其约定优于配置、快速开发、易部署等特性，成为Java微服务开发的首选框架。本文将深入浅出地介绍SpringBoot的核心知识点，包括自动配置、起步依赖、依赖注入、外部化配置等，帮助读者快速上手SpringBoot并深入理解其运行机制，为高效开发SpringBoot应用打下坚实基础。关键词：SpringBoot,自
    
                    
    • 
                    
  • Python常用数据结构
                        我真的不会做啊
python数据结构开发语言
                        
    背景：最近在学习自动化测试，发现基本是用python写的脚本就顺带好好学一学python，准备以后也深入学习一下今天简单的介绍一下python里面常用的数据结构吧Python数据结构原生数据结构原生数据结构元组Tuple()tup1=('Python','Java',1,2)tup2=(9527,)注意：1、使用()、tuple()创建元组，元组可以为空且元素类型可以不同；2、若元组中仅包含一个数
    
                    
    • 
                    
  • .NET c#知识点小补充
                        豆皮没有豆
.Net基础-c#c#基础.net
                        
    1.面向对象：（1)对象：在程序中我们可以把任何事物来映射显示生活中的万事万物，那么我们把这些事物称之为对象。对象：属性、方法(主动）、事件（被动）。（2)面向对象：使用这种语言通过描述属性以及行为进行构造一个对象。（3)集成开发环境：具有代码的编辑、编译、检测、运行。a.所有的文件（.cs/.java/.py/.html。。。。）只是装载代码的一个载体文件。b.其承载的代码若要实现其具有的功能，
    
                    
    • 
                    
  • 初见SpringCloud ing
                        Camellia0212
重生之我要做开发springspringcloud
                        
    Consul服务注册与发现服务注册与发现服务注册：微服务在启动时，会将自己的信息（如IP地址、端口、服务名称等）注册到Consul。服务发现：其他微服务可以通过Consul查询到已注册的服务，并通过这些信息进行通信。分布式配置管理Consul可以作为配置中心，管理分布式系统的配置。SpringCloudConsul可以将配置信息存储在Consul中，并在应用启动时或者运行时动态获取和更新这些配置信
    
                    
    • 
                    
  • （简单易懂口语化）对象的继承 - 2 成员变量 与 构造方法 的继承
                        奕口汤圆
Java学习java开发语言考研学习方法改行学it学习
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档成员变量与构造方法的继承规则内容概述一、成员变量的继承1，成员变量继承的本质2，访问的特点3，代码示例二、构造方法的继承1，构造方法的访问特点1.1父类的构造方法不会被子类继承。1.2子类中所有的构造方法默认先访问父类中的无参构造，再执行自己。1.3如何调用父类构造方法？总结内容概述（全文为Java描述）具体讲解成员变量与构造方法的继
    
                    
    • 
                    
  • javaweb中@Component和@Mapper和@Service和@RestController这几个注解要加在哪?为什么?
                        瑞金彭于晏
mavenjavaspringbootspring
                        
    在JavaWeb开发中特别是在使用Spring框架（包括SpringBoot）时，@Component、@Mapper、@Service、@RestController这些注解扮演着非常重要的角色，它们用于定义组件的类型，并帮助Spring框架进行自动装配和依赖注入。下面分别解释这些注解应该加在哪里以及为什么：1.@Component加在哪里：@Component可以加在任何类上，表示这个类是一个
    
                    
    • 
                    
  • Java Stream 去重的多种方法
                        坎布里奇
javajavapython开发语言
                        
    在JavaStream中实现去重有多种方法，具体取决于需求和场景。以下是常见的几种方法及示例：1.使用distinct()方法适用于对象已正确实现equals()和hashCode()，基于对象整体去重并保留顺序：ListuniquePersons=persons.stream().distinct().collect(Collectors.toList());2.根据对象的属性去重方法一：使用C
    
                    
    • 
                                
  • 算法 单链的创建与删除
                                    换个号韩国红果果
c算法
                                    
    
先创建结构体
struct student {
	int data;
	//int tag;//标记这是第几个
	struct student *next;
};
//  addone 用于将一个数插入已从小到大排好序的链中
struct student *addone(struct student *h,int x){
		if(h==NULL)  //??????
			
    
                                
    • 
                                
  • 《大型网站系统与Java中间件实践》第2章读后感
                                    白糖_
java中间件
                                    
           断断续续花了两天时间试读了《大型网站系统与Java中间件实践》的第2章，这章总述了从一个小型单机构建的网站发展到大型网站的演化过程---整个过程会遇到很多困难，但每一个屏障都会有解决方案，最终就是依靠这些个解决方案汇聚到一起组成了一个健壮稳定高效的大型系统。 
  
       看完整章内容，
    
                                
    • 
                                
  • zeus持久层spring事务单元测试
                                    deng520159
javaDAOspringjdbc
                                    
    今天把zeus事务单元测试放出来,让大家指出他的毛病, 
1.ZeusTransactionTest.java 单元测试 
  
package com.dengliang.zeus.webdemo.test;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;
import 
    
                                
    • 
                                
  • Rss 订阅 开发
                                    周凡杨
htmlxml订阅rss规范
                                    
      
              RSS是 Really Simple Syndication的缩写（对rss2.0而言，是这三个词的缩写，对rss1.0而言则是RDF Site Summary的缩写，1.0与2.0走的是两个体系）。 
  
RSS
    
                                
    • 
                                
  • 分页查询实现
                                    g21121
分页查询
                                    
    在查询列表时我们常常会用到分页，分页的好处就是减少数据交换，每次查询一定数量减少数据库压力等等。 
按实现形式分前台分页和服务器分页： 
前台分页就是一次查询出所有记录，在页面中用js进行虚拟分页，这种形式在数据量较小时优势比较明显，一次加载就不必再访问服务器了，但当数据量较大时会对页面造成压力，传输速度也会大幅下降。 
服务器分页就是每次请求相同数量记录，按一定规则排序，每次取一定序号直接的数据
    
                                
    • 
                                
  • spring jms异步消息处理
                                    510888780
jms
                                    
    spring JMS对于异步消息处理基本上只需配置下就能进行高效的处理。其核心就是消息侦听器容器，常用的类就是DefaultMessageListenerContainer。该容器可配置侦听器的并发数量，以及配合MessageListenerAdapter使用消息驱动POJO进行消息处理。且消息驱动POJO是放入TaskExecutor中进行处理，进一步提高性能，减少侦听器的阻塞。具体配置如下： 
    
                                
    • 
                                
  • highCharts柱状图
                                    布衣凌宇
hightCharts柱图
                                    
    第一步：导入 exporting.js,grid.js,highcharts.js;第二步：写controller 
  
@Controller@RequestMapping(value="${adminPath}/statistick")public class StatistickController {  private UserServi
    
                                
    • 
                                
  • 我的spring学习笔记2-IoC（反向控制 依赖注入）
                                    aijuans
springmvcSpring 教程spring3 教程Spring 入门
                                    
    IoC（反向控制 依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 
IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明： 
如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
    
                                
    • 
                                
  • TLS java简单实现
                                    antlove
javasslkeystoretlssecure
                                    
      
1. SSLServer.java 
package ssl;

import java.io.FileInputStream;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.KeyStore;
import 
    
                                
    • 
                                
  • Zip解压压缩文件
                                    百合不是茶
Zip格式解压Zip流的使用文件解压
                                    
      
 ZIP文件的解压缩实质上就是从输入流中读取数据。Java.util.zip包提供了类ZipInputStream来读取ZIP文件,下面的代码段创建了一个输入流来读取ZIP格式的文件; 
ZipInputStream in = new ZipInputStream(new FileInputStream(zipFileName)); 
  
  
&n
    
                                
    • 
                                
  • underscore.js 学习（一）
                                    bijian1013
JavaScriptunderscore
                                    
            工作中需要用到underscore.js，发现这是一个包括了很多基本功能函数的js库，里面有很多实用的函数。而且它没有扩展 javascript的原生对象。主要涉及对Collection、Object、Array、Function的操作。       学
    
                                
    • 
                                
  • java jvm常用命令工具——jstatd命令(Java Statistics Monitoring Daemon)
                                    bijian1013
javajvmjstatd
                                    
    1.介绍 
        jstatd是一个基于RMI（Remove Method Invocation）的服务程序，它用于监控基于HotSpot的JVM中资源的创建及销毁，并且提供了一个远程接口允许远程的监控工具连接到本地的JVM执行命令。 
        jstatd是基于RMI的，所以在运行jstatd的服务
    
                                
    • 
                                
  • 【Spring框架三】Spring常用注解之Transactional
                                    bit1129
transactional
                                    
    Spring可以通过注解@Transactional来为业务逻辑层的方法(调用DAO完成持久化动作)添加事务能力，如下是@Transactional注解的定义： 
  
/*
 * Copyright 2002-2010 the original author or authors.
 *
 * Licensed under the Apache License, Version 
    
                                
    • 
                                
  • 我(程序员)的前进方向
                                    bitray
程序员
                                    
    作为一个普通的程序员,我一直游走在java语言中,java也确实让我有了很多的体会.不过随着学习的深入,java语言的新技术产生的越来越多,从最初期的javase,我逐渐开始转变到ssh,ssi,这种主流的码农,.过了几天为了解决新问题,webservice的大旗也被我祭出来了,又过了些日子jms架构的activemq也开始必须学习了.再后来开始了一系列技术学习,osgi,restful.....
    
                                
    • 
                                
  • nginx lua开发经验总结
                                    ronin47

                                    
    使用nginx lua已经两三个月了，项目接开发完毕了，这几天准备上线并且跟高德地图对接。回顾下来lua在项目中占得必中还是比较大的，跟PHP的占比差不多持平了，因此在开发中遇到一些问题备忘一下  1：content_by_lua中代码容量有限制，一般不要写太多代码，正常编写代码一般在100行左右（具体容量没有细心测哈哈，在4kb左右），如果超出了则重启nginx的时候会报 too long pa
    
                                
    • 
                                
  • java-66-用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。颠倒之后的栈为{5,4,3,2,1}，5处在栈顶
                                    bylijinnan
java
                                    
    
import java.util.Stack;

public class ReverseStackRecursive {

	/**
	 * Q 66.颠倒栈。
	 * 题目：用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。
	 * 颠倒之后的栈为{5,4,3,2,1}，5处在栈顶。
	 *1. Pop the top element
	 *2. Revers
    
                                
    • 
                                
  • 正确理解Linux内存占用过高的问题
                                    cfyme
linux
                                    
    Linux开机后，使用top命令查看，4G物理内存发现已使用的多大3.2G，占用率高达80%以上： 
Mem:   3889836k total,  3341868k used,   547968k free,   286044k buffers 
Swap:  6127608k total,&nb
    
                                
    • 
                                
  • [JWFD开源工作流]当前流程引擎设计的一个急需解决的问题
                                    comsci
工作流
                                    
     
 
     当我们的流程引擎进入IRC阶段的时候，当循环反馈模型出现之后，每次循环都会导致一大堆节点内存数据残留在系统内存中，循环的次数越多，这些残留数据将导致系统内存溢出，并使得引擎崩溃。。。。。。 
 
      而解决办法就是利用汇编语言或者其它系统编程语言，在引擎运行时，把这些残留数据清除掉。
    
                                
    • 
                                
  • 自定义类的equals函数
                                    dai_lm
equals
                                    
    仅作笔记使用 
 

public class VectorQueue {

	private final Vector<VectorItem> queue;

	private class VectorItem {
		private final Object item;
		private final int quantity;

		public VectorI
    
                                
    • 
                                
  • Linux下安装R语言
                                    datageek
R语言 linux
                                    
    命令如下：sudo gedit  /etc/apt/sources.list1、deb http://mirrors.ustc.edu.cn/CRAN/bin/linux/ubuntu/ precise/ 2、deb http://dk.archive.ubuntu.com/ubuntu hardy universesudo apt-key adv --keyserver ke
    
                                
    • 
                                
  • 如何修改mysql 并发数(连接数)最大值
                                    dcj3sjt126com
mysql
                                    
    MySQL的连接数最大值跟MySQL没关系，主要看系统和业务逻辑了 
  
方法一：进入MYSQL安装目录 打开MYSQL配置文件 my.ini 或 my.cnf查找 max_connections=100 修改为 max_connections=1000 服务里重起MYSQL即可 
　　方法二：MySQL的最大连接数默认是100客户端登录：mysql -uusername -ppass
    
                                
    • 
                                
  • 单一功能原则
                                    dcj3sjt126com
面向对象的程序设计软件设计编程原则
                                    
    单一功能原则[
编辑]            
SOLID    原则    
 
 单一功能原则 
 开闭原则 
 Liskov代换原则 
 接口隔离原则 
 依赖反转原则 
      
 
 查   
 论   
 编 
      
在面向对象编程领域中，单一功能原则（Single responsibility principle）规定每个类都应该有
    
                                
    • 
                                
  • POJO、VO和JavaBean区别和联系
                                    fanmingxing
VOPOJOjavabean
                                    
    POJO和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Plain Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比POJO复杂很多，JavaBean是一种组件技术，就好像你做了一个扳子，而这个扳子会在很多地方被
    
                                
    • 
                                
  • SpringSecurity3.X--LDAP：AD配置
                                    hanqunfeng
SpringSecurity
                                    
    前面介绍过基于本地数据库验证的方式，参考http://hanqunfeng.iteye.com/blog/1155226，这里说一下如何修改为使用AD进行身份验证【只对用户名和密码进行验证，权限依旧存储在本地数据库中】。 
  
将配置文件中的如下部分删除： 
  <!-- 认证管理器，使用自定义的UserDetailsService，并对密码采用md5加密-->  
  
    
                                
    • 
                                
  • mac mysql 修改密码
                                    IXHONG
mysql
                                    
    $ sudo /usr/local/mysql/bin/mysqld_safe –user=root & //启动MySQL(也可以通过偏好设置面板来启动)$ sudo /usr/local/mysql/bin/mysqladmin -uroot password yourpassword //设置MySQL密码（注意，这是第一次MySQL密码为空的时候的设置命令，如果是修改密码，还需在-
    
                                
    • 
                                
  • 设计模式--抽象工厂模式
                                    kerryg
设计模式
                                    
    抽象工厂模式： 
 
    工厂模式有一个问题就是，类的创建依赖于工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则。我们采用抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。 
 
    总结：这个模式的好处就是，如果想增加一个功能，就需要做一个实现类，
    
                                
    • 
                                
  • 评"高中女生军训期跳楼”
                                    nannan408

                                    
       首先，先抛出我的观点，各位看官少点砖头。那就是，中国的差异化教育必须做起来。 
   孔圣人有云：有教无类。不同类型的人，都应该有对应的教育方法。目前中国的一体化教育，不知道已经扼杀了多少创造性人才。我们出不了爱迪生，出不了爱因斯坦，很大原因，是我们的培养思路错了，我们是第一要“顺从”。如果不顺从，我们的学校，就会用各种方法，罚站，罚写作业，各种罚。军
    
                                
    • 
                                
  • scala如何读取和写入文件内容？
                                    qindongliang1922
javajvmscala
                                    
    直接看如下代码： 
 
package file

import java.io.RandomAccessFile
import java.nio.charset.Charset

import scala.io.Source
import scala.reflect.io.{File, Path}

/**
 * Created by qindongliang on 2015/
    
                                
    • 
                                
  • C语言算法之百元买百鸡
                                    qiufeihu
c算法
                                    
    中国古代数学家张丘建在他的《算经》中提出了一个著名的“百钱买百鸡问题”，鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问翁，母，雏各几何？ 
代码如下： 
#include <stdio.h>
int main()
{
	int cock,hen,chick;                               /*定义变量为基本整型*/
	for(coc
    
                                
    • 
                                
  • Hadoop集群安全性：Hadoop中Namenode单点故障的解决方案及详细介绍AvatarNode
                                    wyz2009107220
NameNode
                                    
    正如大家所知，NameNode在Hadoop系统中存在单点故障问题，这个对于标榜高可用性的Hadoop来说一直是个软肋。本文讨论一下为了解决这个问题而存在的几个solution。 
1. Secondary NameNode 
原理：Secondary NN会定期的从NN中读取editlog，与自己存储的Image进行合并形成新的metadata image 
优点：Hadoop较早的版本都自带，
    
                                
    •