【分布式消息服务】——Kafka——SpringBoot操作

最新推荐文章于 2023-04-25 14:50:12 发布
最新推荐文章于 2023-04-25 14:50:12 发布
阅读量292 收藏 3
点赞数
分类专栏： 互联网解决方案 文章标签： kafka java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44275259/article/details/107060343
版权

Kafka——API——SpringBoot环境搭建

maven核心引入：

     <!-- kafka应用-->
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>

其他maven引入（方便测试）：

    <!--Spring Boot 测试组件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.0.9.RELEASE</version>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>com.vaadin.external.google</groupId>
                    <artifactId>android-json</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
      <!-- 测试应用-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- swagger应用-->
       <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.7.0</version>
        </dependency>
        <!-- mvc应用-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- lombok应用-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- 测试应用-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

配置swaggerUI：

注意RequestHandlerSelectors.basePackage(“com.xdoc.template.module”)，将这个包名改成自己的

@Configuration
@EnableSwagger2
public class SwaggerConfig extends WebMvcConfigurerAdapter {
    private boolean enableSwagger=true;

    @Autowired
    private ApplicationContext applicationContext;


    @PostConstruct
    public void setObjectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();
        SimpleModule module = new SimpleModule();
        objectMapper.registerModule(module);

        JacksonAnnotationIntrospector jacksonAnnotationIntrospector=  new JacksonAnnotationIntrospector();

        objectMapper.setAnnotationIntrospector(new JacksonAnnotationIntrospector() {

            @Override
            public boolean isAnnotationBundle(Annotation ann) {
                if (ann.annotationType() == JSONField.class) {
                    return true;
                }
                return super.isAnnotationBundle(ann);
            }

            @Override
            public PropertyName findNameForSerialization(Annotated a) {
                PropertyName nameForSerialization = super.findNameForSerialization(a);
                if (nameForSerialization == null || nameForSerialization == PropertyName.USE_DEFAULT) {
                    JSONField jsonField = _findAnnotation(a, JSONField.class);
                    if (jsonField != null) {
                        return PropertyName.construct(jsonField.name());
                    }
                }
                return nameForSerialization;
            }

            @Override
            public PropertyName findNameForDeserialization(Annotated a) {
                PropertyName nameForDeserialization = super.findNameForDeserialization(a);
                if (nameForDeserialization == null || nameForDeserialization == PropertyName.USE_DEFAULT) {
                    JSONField jsonField = _findAnnotation(a, JSONField.class);
                    if (jsonField != null) {
                        return PropertyName.construct(jsonField.name());
                    }
                }
                return nameForDeserialization;
            }
        });

        ObjectMapperConfigured objectMapperConfigured = new ObjectMapperConfigured(applicationContext, objectMapper);
        applicationContext.publishEvent(objectMapperConfigured);
    }


    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2).groupName("framework").enable(enableSwagger)
                .genericModelSubstitutes(DeferredResult.class).useDefaultResponseMessages(false)
                .forCodeGeneration(false).pathMapping("/").apiInfo(apiInfo()).select()
                .apis(RequestHandlerSelectors.basePackage("com.xdoc.template.module")).build()
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder().title("kafka测试").description("测试文档").termsOfServiceUrl("")
                .contact("dragon").version("1.0").build();
    }


}

application.yml

spring:
  kafka:
    bootstrap-servers: 112.126.57.37:9092,112.126.57.37:9093
    producer:
      # 生产者————序列化机制配置
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-deserializer: org.apache.kafka.common.serialization.StringSerializer
      # 生产者————消息缓存配置
      batch-size: 65536
      buffer-memory: 524288
    listener:
      concurrency: 1
      type: batch
    consumer:
      # 消费者————标识/事务配置
      group-id: tencent-trip
      max-poll-records: 20
      auto-commit-interval: 100
      enable-auto-commit: true
      # 消费者————序列化器配置
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

Kafka——API——简单DEMO

我们首先演示一个简单的发布订阅模式，就是消费者利用监听模式获取消费信息；
消费者配置类

@Component
@Slf4j
public class KafkaConsumerConfig {
    @Value("${spring.kafka.bootstrap-servers}")
    private String bootstrapServers;
    @Value("${spring.kafka.consumer.group-id}")
    private String groupId;
    @Value("${spring.kafka.consumer.key-deserializer}")
    private String consumerKeyDeserializer;
    @Value("${spring.kafka.consumer.value-deserializer}")
    private String consumerValueDeserializer;
    @Value("${spring.kafka.consumer.max-poll-records}")
    private String maxPollRecords;

    @Value("${spring.kafka.consumer.auto-commit-interval}")
    private String autoCommitIntervalMs;
    @Value("${spring.kafka.consumer.enable-auto-commit}")
    private String enableAutoCommit;
    @Value("${spring.kafka.listener.concurrency}")
    private Integer concurrency;

    /**
     * 消费者—poll配置的时候会用到
     */
    @Bean
    public KafkaConsumer  kafkaConsumer(){
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<>(consumerConfigs());
        kafkaConsumer.subscribe(Collections.singletonList("test1"));
        return kafkaConsumer;
    }
    /**
     * 消费者——监听器整体配置
     * @return
     */
    @Bean
    public ConcurrentKafkaListenerContainerFactory ContainerFactory() {
        ConcurrentKafkaListenerContainerFactory container = new ConcurrentKafkaListenerContainerFactory();
        container.setConsumerFactory(new DefaultKafkaConsumerFactory<>(consumerConfigs()));
        //禁止自动启动
        container.setAutoStartup(false);
        container.setBatchListener(true);
        container.setConcurrency(concurrency);
        return container;
    }
    /**
     * 消费者配置生成
     * @return
     */
    private Map<String, Object> consumerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);//连接地址
        props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);//组标识
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, consumerKeyDeserializer);//序列化配置
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, consumerValueDeserializer);//序列化配置
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, maxPollRecords);//每一批拉取的数量，监听时
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, enableAutoCommit);//是否自动提交消费位移
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitIntervalMs);//消费位移自动提交时间间隔
        return props;
    }
}

生产者配置类

@Component
@Slf4j
public class KafkaProducerConfig {
    @Value("${spring.kafka.bootstrap-servers}")
    private String bootstrapServers;
    @Value("${spring.kafka.producer.key-serializer}")
    private String producerKeyDeserializer;
    @Value("${spring.kafka.producer.value-deserializer}")
    private String producerValueDeserializer;


    /**
     * 生产者——kafkaTemplate配置
     * @return
     */
    @DependsOn("producerFactory")
    @Bean
    public KafkaTemplate<Integer, String> kafkaTemplate(KafkaGlobalHandler kafkaGlobalHandler,ProducerFactory producerFactory) {
        KafkaTemplate template = new KafkaTemplate<String, String>(producerFactory);
        template.setDefaultTopic("defalutTopic");
        template.setProducerListener(kafkaGlobalHandler);
        return template;
    }
    /**
     * 生产者配置工厂
     * @return
     */
    @Bean
    public ProducerFactory<Integer, String> producerFactory() {
        DefaultKafkaProducerFactory factory = new DefaultKafkaProducerFactory<>(producerConfigs());
        return factory;
    }
    /**
     * 生产者者配置生成
     * @return
     */
    private Map<String, Object> producerConfigs() {
        Map<String, Object> producerConfigs = new HashMap<>();
        producerConfigs.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        producerConfigs.put(ProducerConfig.RETRIES_CONFIG, 1);// 重试，0为不启用重试机制
        producerConfigs.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384); // 批量发送，延迟为1毫秒，启用该功能能有效减少生产者发送消息次数，从而提高并发量
        producerConfigs.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 1024000); // 生产者可以使用的总内存字节来缓冲等待发送到服务器的记录
        producerConfigs.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, producerKeyDeserializer);
        producerConfigs.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,producerValueDeserializer);
        return producerConfigs;
    }
}

创建生产者的api接口

@Api(tags = "kafka——Api测试")
@RestController
public class KafkaProducerController {
    @Autowired
    KafkaTemplate kafkaTemplate;
    @PostMapping("/kafkaTest/sendMessage")
    public ResponseVO sendMessage(String message){
        kafkaTemplate.send("test1", message);
        return ApiResult.success("成功");
    }
}

创建监听者的处理接口

@Component
public class KafkaComuserListener {
    @KafkaListener(topics = "testTopic")
    public void receiveMessage(String message){
        System.out.println("testTopic:"+message);
    }
}

测试
输入swaggerUI地址：http://localhost:30002/swagger-ui.html#
发送消息：
在这里插入图片描述
观察控制台:

Kafka——API——KafkaTemplate演示

/**
 * @send方法api汇总
 * topic：这里填写的是Topic的名字
 * partition：这里填写的是分区的id，其实也是就第几个分区，id从0开始。表示指定发送到该分区中
 * timestamp：时间戳，一般默认当前时间戳
 * key：消息的键
 * data：消息的数据
 * ProducerRecord：消息对应的封装类，包含上述字段
 * Message<?>：Spring自带的Message封装类，包含消息及消息头
 */
@Api(tags = "kafka——Api测试")
@RestController
public class KafkaProducerController {
    @Autowired
    KafkaTemplate kafkaTemplate;
    /**
     * @需指定topic发送
     * ListenableFuture<SendResult<K, V>> send(String topic, V data);
     * ListenableFuture<SendResult<K, V>> send(String topic, K key, V data);
     * ListenableFuture<SendResult<K, V>> send(String topic, Integer partition, K key, V data);
     * ListenableFuture<SendResult<K, V>> send(String topic, Integer partition, Long timestamp, K key, V data);
     */
    @PostMapping("/kafkaTest/sendMessage")
    public ResponseVO sendMessage(String message){
        kafkaTemplate.send("test1", message);
        return ApiResult.success("成功");
    }
    @PostMapping("/kafkaTest/sendProducerRecord")
    public ResponseVO sendProducerRecord(String message){
        kafkaTemplate.send(new ProducerRecord("testTopic",message));
        return ApiResult.success("成功");
    }
    /**
     * @template配置的默认topic
     * ListenableFuture<SendResult<K, V>> sendDefault(V data);
     * ListenableFuture<SendResult<K, V>> sendDefault(V data);
     * ListenableFuture<SendResult<K, V>> sendDefault(K key, V data);
     * ListenableFuture<SendResult<K, V>> sendDefault(Integer partition, K key, V data);
     * ListenableFuture<SendResult<K, V>> sendDefault(Integer partition, Long timestamp, K key, V data);
     */
    @PostMapping("/kafkaTest/sendDefault")
    public ResponseVO sendDefault(String message){
        kafkaTemplate.sendDefault("defalutTopic", message);
        return ApiResult.success("成功");
    }
    /**
     * @同步回调
     * 回调是复杂编程中，根据需要去设计，一般就是可靠性的验证
     */
    @PostMapping("/kafkaTest/sendCallBack1")
    public ResponseVO sendCallBack1(String message) throws Exception{
        ListenableFuture future = kafkaTemplate.send("testTopic", message);
        /**
         * @获取future状态
         */
        future.isCancelled();
        future.isDone();
        future.get();//会阻塞
        future.get(1000, TimeUnit.SECONDS);//超时自动抛异常
        return ApiResult.success("成功");
    }
    /**
     * @异步回调
     * 回调是复杂编程中，根据需要去设计，一般就是可靠性的验证
     */
    @PostMapping("/kafkaTest/sendCallBack2")
    public ResponseVO sendCallBack2(String message) throws Exception{
        ListenableFuture future = kafkaTemplate.send("testTopic", message);
        future.addCallback(new ListenableFutureCallback<SendResult>() {
            @Override
            public void onFailure(Throwable throwable) {
            }
            @Override
            public void onSuccess(SendResult result) {
            }
        });
        return ApiResult.success("成功");
    }
}

默认主题可以添加这个测试，但注意默认消费者要在template中配置好topic

  @KafkaListener(topics = "defalutTopic")
    public void receiveDefalutTopicMessage(String message){
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
        System.out.println("defalutTopic: " + message);
    }

Kafka——API——KafkaConsumer演示（消费位移管理）

手动提交

kafka将消费位移交给消费者自己去管理那么，如何设置手动提交呢？

首先关闭消费者的自动提交功能

spring:
  kafka:
    ……
    consumer:
      ……
      auto-commit-interval: 100
      enable-auto-commit: false
      ……

我们利用junit测试类去测试
在这里插入图片描述

@RunWith(SpringRunner.class)
@SpringBootTest
class DemoApplicationTests {
    @Autowired
    KafkaTemplate KafkaConsumer;
    @Test
    void contextLoads() {
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records)
                System.out.printf("offset = %d, key = %s, value = %s\n", record.offset(), record.key(), record.value());
            if(records.count()!=0){
                consumer.commitSync();
            }
        }
    }
}

发送消息
在这里插入图片描述
所有api

consumer.commitSync();//同步提交位移
consumer.commitAsync();//异步提交位移
consumer.wakeup();//其他线程调用一次wakeup可以中断while Ture循环
consumer.close();//被中断的线程需要调用关闭按钮让出连接权，让另外一个consumer建立连接
consumer.seek(new TopicPartition("test1",2),2);//更改consumer的拉取位置，seek()只是指定了poll()拉取的开始位移，这并不影响在Kafka中保存的提交位移
 /**
* 获取某个主题的分区信息
 */
List<PartitionInfo> partitionInfoList = consumer.partitionsFor("topic1");
/**
 * 让消费者固定分区和指定消费
 * 可以遍历分区信息区绑定
*/
partitionInfoList.forEach(partitionInfo->{
   consumer.assign(Collections.singletonList(new TopicPartition(partitionInfo.topic(),partitionInfo.partition())));
});
//重平衡监听
consumer.subscribe(Arrays.asList("test1"), new ConsumerRebalanceListener() {
   public void onPartitionsAssigned(Collection<TopicPartition> partitions) { //均衡之前
   }
   public void onPartitionsRevoked(Collection<TopicPartition> partitions) {//均衡之后
   }
});

重平衡监听

 /**
* @消费者重平衡监听器
*/
consumer.subscribe(Arrays.asList("test1"), new ConsumerRebalanceListener() {
            @Override
            public void onPartitionsAssigned(Collection<TopicPartition> partitions) { //均衡之前
                /**
                 * 业务还没处理完，先提交位移然后保存数据库
                 */
            }
            @Override
            public void onPartitionsRevoked(Collection<TopicPartition> partitions) {//均衡之后
                /**
                 * 从数据库拿出未处理的消息，接着处理
                 */
            }
        });

Kafka——API——事务管理

Kafka——网络IO原理

NetworkClient是SpringBoot中作为消费者向kafak服务器发送的网络关键类，利用这个类我们可以看到提交前的数据，重而排查一些问题；
然后Fetcher是作为拉取者最核心的部分，我们关注一下这个方法就行；

 public synchronized int sendFetches() {
        // Update metrics in case there was an assignment change
        sensors.maybeUpdateAssignment(subscriptions);

        Map<Node, FetchSessionHandler.FetchRequestData> fetchRequestMap = prepareFetchRequests();
        for (Map.Entry<Node, FetchSessionHandler.FetchRequestData> entry : fetchRequestMap.entrySet()) {
            final Node fetchTarget = entry.getKey();
            final FetchSessionHandler.FetchRequestData data = entry.getValue();
            final FetchRequest.Builder request = FetchRequest.Builder
                    .forConsumer(this.maxWaitMs, this.minBytes, data.toSend())
                    .isolationLevel(isolationLevel)
                    .setMaxBytes(this.maxBytes)
                    .metadata(data.metadata())
                    .toForget(data.toForget())
                    .rackId(clientRackId);

            if (log.isDebugEnabled()) {
                log.debug("Sending {} {} to broker {}", isolationLevel, data.toString(), fetchTarget);
            }
            RequestFuture<ClientResponse> future = client.send(fetchTarget, request);
            // We add the node to the set of nodes with pending fetch requests before adding the
            // listener because the future may have been fulfilled on another thread (e.g. during a
            // disconnection being handled by the heartbeat thread) which will mean the listener
            // will be invoked synchronously.
            this.nodesWithPendingFetchRequests.add(entry.getKey().id());
            future.addListener(new RequestFutureListener<ClientResponse>() {
                @Override
                public void onSuccess(ClientResponse resp) {
                    synchronized (Fetcher.this) {
                        try {
                            @SuppressWarnings("unchecked")
                            FetchResponse<Records> response = (FetchResponse<Records>) resp.responseBody();
                            FetchSessionHandler handler = sessionHandler(fetchTarget.id());
                            if (handler == null) {
                                log.error("Unable to find FetchSessionHandler for node {}. Ignoring fetch response.",
                                        fetchTarget.id());
                                return;
                            }
                            if (!handler.handleResponse(response)) {
                                return;
                            }

                            Set<TopicPartition> partitions = new HashSet<>(response.responseData().keySet());
                            FetchResponseMetricAggregator metricAggregator = new FetchResponseMetricAggregator(sensors, partitions);

                            for (Map.Entry<TopicPartition, FetchResponse.PartitionData<Records>> entry : response.responseData().entrySet()) {
                                TopicPartition partition = entry.getKey();
                                FetchRequest.PartitionData requestData = data.sessionPartitions().get(partition);
                                if (requestData == null) {
                                    String message;
                                    if (data.metadata().isFull()) {
                                        message = MessageFormatter.arrayFormat(
                                                "Response for missing full request partition: partition={}; metadata={}",
                                                new Object[]{partition, data.metadata()}).getMessage();
                                    } else {
                                        message = MessageFormatter.arrayFormat(
                                                "Response for missing session request partition: partition={}; metadata={}; toSend={}; toForget={}",
                                                new Object[]{partition, data.metadata(), data.toSend(), data.toForget()}).getMessage();
                                    }

                                    // Received fetch response for missing session partition
                                    throw new IllegalStateException(message);
                                } else {
                                    long fetchOffset = requestData.fetchOffset;
                                    FetchResponse.PartitionData<Records> partitionData = entry.getValue();

                                    log.debug("Fetch {} at offset {} for partition {} returned fetch data {}",
                                            isolationLevel, fetchOffset, partition, partitionData);

                                    Iterator<? extends RecordBatch> batches = partitionData.records.batches().iterator();
                                    short responseVersion = resp.requestHeader().apiVersion();

                                    completedFetches.add(new CompletedFetch(partition, partitionData,
                                            metricAggregator, batches, fetchOffset, responseVersion));
                                }
                            }

                            sensors.fetchLatency.record(resp.requestLatencyMs());
                        } finally {
                            nodesWithPendingFetchRequests.remove(fetchTarget.id());
                        }
                    }
                }

                @Override
                public void onFailure(RuntimeException e) {
                    synchronized (Fetcher.this) {
                        try {
                            FetchSessionHandler handler = sessionHandler(fetchTarget.id());
                            if (handler != null) {
                                handler.handleError(e);
                            }
                        } finally {
                            nodesWithPendingFetchRequests.remove(fetchTarget.id());
                        }
                    }
                }
            });

        }
        return fetchRequestMap.size();
    }
骆子无悔
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot应用kafka实现分布式队列服务
holmes369的博客
03-20 304
pom.xml文件内容 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.0.RELEAS...
Kafka在SpringBoot中的应用
12-25
kafka is a distributed, partitiononed,replicated commited logservice. kafka是一个分布式的、易扩展的、安全性高的消息服务系统。kafka提供了类似于JMS的特性，但在设计实现上又完全不同，它并不是基于JMS规范实现的（kafka的实现不包含事务特性性）。kafka对消息的保存时以Topic进行归类的，向Topic发送消息的称谓Producer,从Topic接受消息的称谓Consumer
SpringBoot Kafka 整合使用
kevin
06-26 585
前提 假设你了解过 SpringBoot 和 Kafka。 1、SpringBoot 如果对 SpringBoot 不了解的话，建议去看看 DD 大佬 和 纯洁的微笑 的系列博客。 2、Kafka Kafka 的话可以看看我前两天写的博客 ： Kafka 安装及快速入门 学习的话自己开台虚拟机自己手动搭建环境吧，有条件的买服务器。 注意：一定要亲自自己安装实践，接下来我们将这两个进行整...
SpringBoot整合kafka
06-14
SpringBoot整合kafka代码，两个工程 一个消费者 一个生产者，利用定时任务。很简洁代码。欢迎大家下载哦。可参考这篇文章代码哦。https://blog.csdn.net/weixin_39984161/article/details/91986809
springboot+dubbo分布式架构，提供分布式缓存、分布式锁、分布式Session、读写分离
05-15
数据库：Druid数据库连接池，监控数据库访问性能，统计SQL的执行性能。 持久层：mybatis持久化，使用MyBatis-Plus优化，减少sql开发量；aop切换数据库实现读写分离。Transtraction注解事务。 MVC： 基于spring mvc注解,Rest风格Controller。Exception统一管理。 缓存和Session：注解redis缓存数据，Spring-session和redis实现分布式session同步，重启服务会话不丢失。 数据同步：基于redis的分布式锁。 Web安全：实现XSS过滤和CSR过滤。 多系统交互：Dubbo,ActiveMQ多系统交互。 前后端分离：前端使用ajax访问后端的rest服务，后端返回json格式数据。页面用nginx反向代理访问。 支付功能：实现微信和支付宝支付客户端。 日志：Logback打印日志，默认打印Web和Service简要日志。 工具类：字符串处理，类型转换，日期处理，IO和文件，Excel读写，加密解密，HTTP客户端，XML处理，转码，各种Util等等。 代码生成器：根据数据库表结构生成简单的增删改查功能代码，包括model、mapper、service、controller。
springboot-kafka_springboot_kafka_
09-29
**SpringBoot集成Kafka——构建消息队列系统** 在现代微服务架构中，消息队列（Message Queue）作为异步处理和解耦组件起着至关重要的作用。SpringBoot以其轻量级、快速启动和易于配置的特点，成为开发Java应用的...
使用KafkaStreams和SpringBoot实现微服务Saga分布式事务-Piotr.pdf
06-30
通过这种方式，Kafka Streams和Spring Boot的组合为微服务架构提供了灵活且可靠的分布式事务解决方案，允许在保持服务独立性的同时保证数据一致性。然而，这种模式也需要注意并发控制、错误处理和回滚策略的复杂性，...
SpringBoot项目集成kafka
06-08
这与我们的主题——SpringBoot集成Kafka和Swagger的讨论不太相关，但如果你需要对这些文件进行处理，你可能需要使用Apache POI库来解析Word文档内容。 总之，SpringBoot与Kafka的集成使得开发人员可以轻松地构建...
java面试——SpringBoot面试专题.zip
09-26
- **RabbitMQ** / **Kafka**：消息队列，实现异步处理和解耦。 - **Docker**：Spring Boot应用可以通过Docker打包成容器，方便部署。 10. **微服务** - **Spring Cloud**：基于Spring Boot构建大型分布式系统的...
webapp.zip（使用地点是springboot——跨服务器文件上传）
09-28
Spring Boot可以通过RabbitMQ、Kafka等消息中间件，或者使用HTTP/HTTPS协议调用其他服务器上的API来实现。例如，使用Feign客户端（需添加`spring-cloud-starter-openfeign`依赖）可以方便地实现服务间的调用： ```...
kafka 简单设计和springboot集成
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
02-04 264
1.引入maven 依赖： public class MsgProducer { public static void main(String[] args) throws InterruptedException, ExecutionException { Properties props = new Properties(); props.put(P...
搭建大型分布式服务（十三）SpringBoot整合kafka
hanyi_的专栏
03-21 430
一、本文要点 接上文，我们已经把SpringBoot整合mybatis+Hikari+es+redis了，并且通过docker搭建好了kafka环境，本文将介绍SpringBoot如何整合kafka，利用MQ技术，做到削峰填谷，模块解耦。系列文章完整目录 kafkalistener 测试 消息解耦 消息分区时序性 springboot整合kafka springboot + mybatis + Hikari + elasticsearch + redis + kafka 二、开发环境
Jackson-AnnotationIntrospector + @AliasFor 实现自定义注解 + JSON序列化的一种场景
最新发布
weixin_43558927的博客
04-25 1464
需求: 动态表头(相对来说)目前只是控制列宽列名,排序,显隐等简单操作, 没有现成的, 如何新设计一个动态表单模版领域又十分复杂, 耗时. 考虑直接使用注解配置的方式将一个包含表头字段的对象的每个配置字段映射为一个动态表头配置的集合返给前端, 存储json即可.由于前端动态渲染时, 列头的prop属性和列表数据序列化json时的key是要相同的, 本次实现将自定义注解和Jackson的注解组合使用来达到目的.
java 日期注解 xml_Spring Boot 四 利用注解自定义日期格式化
weixin_32955207的博客
03-07 563
在日期的格式化过程中，我们有时候需要将日期格式化到秒或者微妙，有时候又仅仅需要将日期格式化到日期，所以定义全局的日期格式化肯定难以满足需求，这时就需要一种更灵活的方法。在Spring Boot对JSON的处理类中，定义了annotationIntrospector属性，专用于处理注解，因此自定义日期格式化的步骤分为四步，如下：1. 定义日期格式化注解，用于盛放格式化样式；2. 定义日期JSON串行...
一：Kafka快速实战与基本原理
Xx__WangQi的博客
04-19 1993
目录 一、Kafka的使用场景 二、Kafka基本概念 三、kafka基本使用 3.1 安装前的环境准备 3.1.1 下载安装包 3.1.2 修改配置 3.1.3 启动服务 3.1.4 创建主题 3.1.5 发送消息 3.1.6 消费消息 3.2 主题Topic和消息日志Log 四、kafka集群实战 4.1 集群配置 4.2 集群消费 4.3 Java客户端访问Kafka 4.4 Spring Boot整合Kafka Kafka是最初由Linkedin公司开发，是一个
SpringBoot实战(十四)之整合KafKa
weixin_30245867的博客
01-03 247
本人今天上午参考了不少博文，发现不少博文不是特别好，不是因为依赖冲突问题就是因为版本问题。 于是我结合相关的博文和案例，自己改写了下并参考了下，于是就有了这篇文章。希望能够给大家帮助，少走一些弯路。 一、KafKa的介绍 1.主要功能 根据官网的介绍，ApacheKafka®是一个分布式流媒体平台，它主要有3种功能： 　　a.发布和订阅消息流，这个功能类似于消息队列，这也是kaf...
Spring Boot 2.x实战94 - 事件驱动3 - Kafka与Kafka Streams
汪云飞记录本
07-14 1699
3.Kafka Apache Kafka以Topic为导向，提供消息中间件的功能。一个类型的数据称之为一个Topic。 3.1 安装Kafka 使用docker compose安装Apache Kafka。 stack.yml version: '3.1' services: zookeeper: image: wurstmeister/zookeeper restart: always kafka: image: wurstmeister/kafka port
RabbitMQ 系列之分布式事务处理-最终一致性-SpringBoot实现
人人都是程序员
06-05 8271
目录 分布式事务应用场景： 如何使用RabbitMQ 解决分布式事务-最终一致性： 实现场景：用户下单service - 扣减用户积分 service 结合Springboot 处理分布式事务-为减少篇幅，只列出主要几块代码，详见文末源码链接： maven-parent . pom.xml 以下是Maven-module.orderProducer 生产者模块内容 mav...
Kafka：分布式消息技术详解与关键应用
本文档深入浅出地探讨了分布式消息技术中的重要组件——Kafka。Kafka是由LinkedIn公司最早开发的，随后捐赠给了Apache基金会，成为了一个备受瞩目的开源项目。Kafka的核心特性包括其分布式、分区的、多副本设计，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值