延迟消息实现

最新推荐文章于 2024-05-28 22:45:07 发布
最新推荐文章于 2024-05-28 22:45:07 发布
阅读量437 收藏 7
点赞数 11
分类专栏： rabbitmq 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68935893/article/details/135476900
版权 
package com.java1234.producer.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class RabbitMQConfig {


    /**
     * direct交换机名称
     */
    public static final String DIRECT_EXCHANGE="directExchange";


    /**
     * delayedDirect交换机名称
     */
    public static final String DELAYED_DIRECT_EXCHANGE="delayedDirectExchange";


    /**
     * TTL_direct交换机名称
     */
    public static final String TTL_DIRECT_EXCHANGE="ttldirectExchange";

    /**
     * dlx_direct交换机名称
     */
    public static final String DLX_DIRECT_EXCHANGE="dlxldirectExchange";

    /**
     * direct交换机名称1
     */
    public static final String DIRECT_EXCHANGE1="directExchange1";


    /**
     * fanout交换机名称
     */
    public static final String FANOUT_EXCHANGE="fanoutExchange";

    /**
     * direct队列名称
     */
    public static final String DIRECT_QUEUE="directQueue";

    /**
     * delayed direct队列名称
     */
    public static final String DELAYED_DIRECT_QUEUE="delayedDirectQueue";

    /**
     * ttl_direct队列名称
     */
    public static final String TTL_DIRECT_QUEUE="ttldirectQueue";

    /**
     * dlx_direct队列名称
     */
    public static final String DLX_DIRECT_QUEUE="dlxdirectQueue";

    /**
     * direct1队列名称
     */
    public static final String DIRECT_QUEUE1="directQueue1";

    /**
     * direct2队列名称
     */
    public static final String DIRECT_QUEUE2="directQueue2";

    /**
     * 订阅队列1名称
     */
    public static final String SUB_QUEUE1="subQueue1";
    /**
     * 订阅队列2名称
     */
    public static final String SUB_QUEUE2="subQueue2";

    /**
     * direct路由Key
     */
    public static final String DIRECT_ROUTINGKEY="directRoutingKey";

    /**
     * ttl_direct路由Key
     */
    public static final String TTL_DIRECT_ROUTINGKEY="ttl_directRoutingKey";

    /**
     * dlx_direct路由Key
     */
    public static final String DLX_DIRECT_ROUTINGKEY="dlx_directRoutingKey";

    /**
     * delayed_direct路由Key
     */
    public static final String DELAYED_DIRECT_ROUTINGKEY="delayed_directRoutingKey";

    /**
     * topic队列名称1
     *
     */
    public static final String TOPIC_QUEUE1="topicQueue1";

    /**
     * topic队列名称2
     *
     */
    public static final String TOPIC_QUEUE2="topicQueue2";


    /**
     * direct交换机名称
     */
    public static final String TOPIC_EXCHANGE="topicExchange";

    /**
     * 定义一个direct交换机
     * @return
     */
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange(DIRECT_EXCHANGE);
    }


    /**
     * 定义一个TTL direct交换机
     * @return
     */
    @Bean
    public DirectExchange ttlDirectExchange(){
        return new DirectExchange(TTL_DIRECT_EXCHANGE);
    }


    /**
     * 定义一个delayed direct交换机
     * @return
     */
    @Bean
    public CustomExchange delayedDirectExchange(){
        Map<String, Object> args = new HashMap<>();

        args.put("x-delayed-type", "direct");

        return new CustomExchange(DELAYED_DIRECT_EXCHANGE,"x-delayed-message", true, false, args);
    }


    /**
     * 定义一个DLX direct交换机
     * @return
     */
    @Bean
    public DirectExchange dlxDirectExchange(){
        return new DirectExchange(DLX_DIRECT_EXCHANGE);
    }


    /**
     * 定义一个direct交换机1
     * @return
     */
    @Bean
    public DirectExchange directExchange1(){
        return new DirectExchange(DIRECT_EXCHANGE1);
    }


    /**
     * 定义一个fanout交换机
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange(FANOUT_EXCHANGE);
    }

    /**
     * 定义一个TTL direct队列
     * @return
     */
    @Bean
    public Queue ttlDirectQueue(){
        Map<String,Object> map=new HashMap<>();
        map.put("x-message-ttl",1000000);
        map.put("x-dead-letter-exchange",DLX_DIRECT_EXCHANGE);
        map.put("x-dead-letter-routing-key",DLX_DIRECT_ROUTINGKEY);
        map.put("x-max-length",10);
        return new Queue(TTL_DIRECT_QUEUE,true,false,false,map);
    }

    /**
     * 定义一个DELAYED direct队列
     * @return
     */
    @Bean
    public Queue delayedDirectQueue(){
        return new Queue(DELAYED_DIRECT_QUEUE);
    }

    /**
     * 定义一个DLX direct队列
     * @return
     */
    @Bean
    public Queue dlxDirectQueue(){
        return new Queue(DLX_DIRECT_QUEUE);
    }

    /**
     * 定义一个direct队列
     * @return
     */
    @Bean
    public Queue directQueue(){
        return new Queue(DIRECT_QUEUE);
    }




    /**
     * 定义一个direct1队列
     * @return
     */
    @Bean
    public Queue directQueue1(){
        return new Queue(DIRECT_QUEUE1);
    }


    /**
     * 定义一个direct2队列
     * @return
     */
    @Bean
    public Queue directQueue2(){
        return new Queue(DIRECT_QUEUE2);
    }

    /**
     * 定义一个订阅队列1
     * @return
     */
    @Bean
    public Queue subQueue1(){
        return new Queue(SUB_QUEUE1);
    }

    /**
     * 定义一个订阅队列2
     * @return
     */
    @Bean
    public Queue subQueue2(){
        return new Queue(SUB_QUEUE2);
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
     public Binding directBinding(){
        return BindingBuilder.bind(directQueue()).to(directExchange()).with(DIRECT_ROUTINGKEY);
     }



    /**
     * TTL定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding ttlDirectBinding(){
        return BindingBuilder.bind(ttlDirectQueue()).to(ttlDirectExchange()).with(TTL_DIRECT_ROUTINGKEY);
    }



    /**
     * dlx定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding dlxDirectBinding(){
        return BindingBuilder.bind(dlxDirectQueue()).to(dlxDirectExchange()).with(DLX_DIRECT_ROUTINGKEY);
    }


    /**
     * dlx定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding delayedDirectBinding(){
        return BindingBuilder.bind(delayedDirectQueue()).to(delayedDirectExchange()).with(DLX_DIRECT_ROUTINGKEY).noargs();
    }



    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding fanoutBinding1(){
        return BindingBuilder.bind(subQueue1()).to(fanoutExchange());
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding fanoutBinding2(){
        return BindingBuilder.bind(subQueue2()).to(fanoutExchange());
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding1(){
        return BindingBuilder.bind(directQueue1()).to(directExchange1()).with("error");
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding2(){
        return BindingBuilder.bind(directQueue2()).to(directExchange1()).with("info");
    }

    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding3(){
        return BindingBuilder.bind(directQueue2()).to(directExchange1()).with("error");
    }
    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding directBinding4(){
        return BindingBuilder.bind(directQueue2()).to(directExchange1()).with("warning");
    }

    /**
     * 定义一个topic队列1
     */
    @Bean
    public Queue topicQueue1(){
        return new Queue(TOPIC_QUEUE1);
    }

    /**
     * 定义一个topic队列2
     */
    @Bean
    public Queue topicQueue2(){
        return new Queue(TOPIC_QUEUE2);
    }


    /**
     * 定义一个direct交换机
     * @return
     */
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(TOPIC_EXCHANGE);
    }


    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding topicBinding1(){
        return BindingBuilder.bind(topicQueue1()).to(topicExchange()).with("*.orange.*");
    }



    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding topicBinding2(){
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("*.*.rabbit");
    }


    /**
     * 定义一个队列和交换机的绑定
     * @return
     */
    @Bean
    public Binding topicBinding3(){
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with("lazy.#");
    }
}


package com.java1234.consumer.service.impl;

import com.java1234.consumer.service.RabbitMqService;
import com.java1234.producer.config.RabbitMQConfig;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.Date;

import org.springframework.context.annotation.Bean;

@Service("rabbitmqService")
public class RabbitMqServiceImpl implements RabbitMqService {

    @Autowired
    private AmqpTemplate amqpTemplate;

    @Autowired
    CachingConnectionFactory cachingConnectionFactory;

    @Bean(name="limitContainerFactory")
    public SimpleRabbitListenerContainerFactory simpleRabbitListenerContainerFactory(){
        SimpleRabbitListenerContainerFactory factory=new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(cachingConnectionFactory);
        factory.setPrefetchCount(3);
        return factory;
    }

    @Override
    @RabbitListener(queues = {RabbitMQConfig.TTL_DIRECT_QUEUE})
    public void receiveMessage(String message, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag) {
        try{
            System.out.println(System.currentTimeMillis()+"接受到的mq消息："+message);
            //处理业务
            System.out.println("处理业务"+1/0);
            System.out.println("deliveryTag="+deliveryTag);
            channel.basicAck(deliveryTag,true);
//            if(deliveryTag==5){
//                channel.basicAck(deliveryTag,true);
//            }
        }catch (Exception e){
            e.printStackTrace();
            try {
                channel.basicNack(deliveryTag,false,false);
//                channel.basicReject(deliveryTag,true);
//                Thread.sleep(1000);
            }catch (Exception e1){
                e1.printStackTrace();
            }

        }

    }


//    @Override
//    @RabbitListener(queues = {RabbitMQConfig.DIRECT_QUEUE},containerFactory = "limitContainerFactory")
//    public void receiveMessage(String message, Channel channel, @Header(AmqpHeaders.DELIVERY_TAG) long deliveryTag) {
//        try{
//            System.out.println("接受到的mq消息："+message);
//            //处理业务
//            System.out.println("处理业务");
//            System.out.println("deliveryTag="+deliveryTag);
//            if(deliveryTag==5){
//                channel.basicAck(deliveryTag,true);
//            }
//        }catch (Exception e){
//            e.printStackTrace();
//            try {
//                channel.basicNack(deliveryTag,false,true);
                channel.basicReject(deliveryTag,true);
                Thread.sleep(1000);
//            }catch (Exception e1){
//                e1.printStackTrace();
//            }
//
//        }
//
//    }


    @Override
    @RabbitListener(queues = {RabbitMQConfig.DELAYED_DIRECT_QUEUE})
    public void receiveMessage2(String message) {
//        System.out.println("消费者1：接收到的mq消息："+message);
                System.out.println("队列1接收日志消息："+message+":"+new Date().toString());
    }


    @Override
    @RabbitListener(queues = {RabbitMQConfig.TOPIC_QUEUE2})
    public void receiveMessage3(String message) {
//        System.out.println("消费者2：接收到的mq消息："+message);
                System.out.println("队列2接收日志消息："+message);

    }

    @Override
    @RabbitListener(queues = {RabbitMQConfig.SUB_QUEUE1})
    public void receiveSubMessage1(String message) {
        System.out.println("订阅者1：接收到的mq消息："+message);
    }

    @Override
    @RabbitListener(queues = {RabbitMQConfig.SUB_QUEUE2})
    public void receiveSubMessage2(String message) {
        System.out.println("订阅者2：接收到的mq消息："+message);
    }

}


package com.java1234.consumer.service;


import com.rabbitmq.client.Channel;

public interface RabbitMqService {

    /**
     * 接受消息
     */
    public void receiveMessage(String message, Channel channel, long deliveryTag);

    /**
     * 接受消息
     */
    public void receiveMessage2(String message);

    /**
     * 接受消息
     */
    public void receiveMessage3(String message);


    /**
     * 接受订阅消息1
     */
    public void receiveSubMessage1(String message);
    /**
     * 接受订阅消息2
     */
    public void receiveSubMessage2(String message);
}


package com.java1234.consumer;

import com.java1234.consumer.service.RabbitMqService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class ConsumerApplication {

    public static void main(String[] args) {
       ApplicationContext ac = SpringApplication.run(ConsumerApplication.class,args);
//        RabbitMqService rabbitMqService=(RabbitMqService) ac.getBean("rabbitmqService");
//        rabbitMqService.receiveMessage();
    }
}


server:
  port: 81
spring:
  rabbitmq:
    host: 192.168.30.113
    port: 5672
    username: pzy
    password: 123456
    virtual-host: /



package com.java1234.producer.service.impl;

import com.java1234.producer.config.RabbitMQConfig;
import com.java1234.producer.service.RabbitMqService;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;

@Service("rabbitmqService")
public class RabbitMqServiceImpl implements RabbitMqService, RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnCallback {

    @Autowired
    private AmqpTemplate amqpTemplate;

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void init(){
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnCallback(this);
    }
    /**
     * String exchange 交换机名称
     * String routingKey 路由Key
     * Object object 具体发送的消息
     * @param message
     */
    @Override
    public void sendMessage(String message) {
//        amqpTemplate.convertAndSend(RabbitMQConfig.DIRECT_EXCHANGE,RabbitMQConfig.DIRECT_ROUTINGKEY,message);
        CorrelationData correlationData=new CorrelationData("3453");

//        rabbitTemplate.convertAndSend(RabbitMQConfig.DIRECT_EXCHANGE,RabbitMQConfig.DIRECT_ROUTINGKEY,message,correlationData);
        rabbitTemplate.convertAndSend(RabbitMQConfig.DIRECT_EXCHANGE,RabbitMQConfig.DIRECT_ROUTINGKEY,message,correlationData);

    }

    @Override
    public void sendTTLMessage(String message) {
//        MessageProperties messageProperties=new MessageProperties();
//        messageProperties.setExpiration("20000");//设置过期时间 20秒
//        Message msg=new Message(message.getBytes(),messageProperties);
        rabbitTemplate.convertAndSend(RabbitMQConfig.TTL_DIRECT_EXCHANGE,RabbitMQConfig.TTL_DIRECT_ROUTINGKEY,message);
    }

    @Override
    public void sendFanoutMessage(String message) {
        amqpTemplate.convertAndSend(RabbitMQConfig.FANOUT_EXCHANGE,"",message);
    }

    @Override
    public void sendRoutingMessage() {
        amqpTemplate.convertAndSend(RabbitMQConfig.DIRECT_EXCHANGE1,"warning2","发送warning2级别的消息");
    }

    @Override
    public void sendTopicMessage() {
//        amqpTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE,"quick.orange.rabbit","飞快的橘色兔子");
//                amqpTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE,"lazy.orange.elephant","慢腾腾的橘色大象");
//        amqpTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE,"quick.orange.fox","quick.orange.fox");
//        amqpTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE,"lazy.brown.fox","lazy.brown.fox");
        amqpTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE,"quick.brown.fox","quick.brown.fox");
    }

    @Override
    public void sendDelayedMessage(String message, Integer delayTime) {
        amqpTemplate.convertAndSend(RabbitMQConfig.DELAYED_DIRECT_EXCHANGE,RabbitMQConfig.DELAYED_DIRECT_ROUTINGKEY,message,a->{
            a.getMessageProperties().setDelay(delayTime);
            return a;
        });
    }

    /**
     *
     * @param correlationData 消息唯一标识
     * @param ack 交换机是否成功收到消息 true成功 false失败
     * @param cause 失败原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {

        System.out.println("confirm方法被执行了..."+correlationData);
        if(ack){
            System.out.println("交换机，消息接收成功"+cause);
        }else{
            System.out.println("交换机，消息接收失败"+cause);
            //我们这里要做一些消息补发的措施
            System.out.println("id="+correlationData.getId());
        }
    }

    /**
     *
     * @param message 消息主体
     * @param replyCode 返回code
     * @param replyText 返回信息
     * @param exchange 交换机
     * @param routingKey 路由key
     */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        System.out.println("return方法被执行...");
        System.out.println("消息主体："+new String(message.getBody()));
        System.out.println("replyCode："+replyCode);
        System.out.println("replyText："+replyText);
        System.out.println("exchange："+exchange);
        System.out.println("routingKey："+routingKey);
    }
}


package com.java1234.producer.service;

public interface RabbitMqService {

    /**
     * 发送消息
     * @param message
     */
    public void sendMessage(String message);


    /**
     * 发送TTL消息
     * @param message
     */
    public void sendTTLMessage(String message);

    /**
     * 发送消息
     * @param message
     */
    public void sendFanoutMessage(String message);


    /**
     * 发送路由模式消息
     */
    public void sendRoutingMessage();

    /**
     * 发送Topic模式消息
     */
    public void sendTopicMessage();

    /**
     * 发送延迟消息
     * @param message
     * @param delayTime
     */
    public void sendDelayedMessage(String message,Integer delayTime);
}


package com.java1234.producer;

import com.java1234.producer.service.RabbitMqService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class ProducerApplication {

    public static void main(String[] args) {
        ApplicationContext ac = SpringApplication.run(ProducerApplication.class, args);
        RabbitMqService rabbitMqService=(RabbitMqService) ac.getBean("rabbitmqService");
//        rabbitMqService.sendTTLMessage("测试消息TTL");
        rabbitMqService.sendDelayedMessage("测试延迟消息10秒",10000);
        rabbitMqService.sendDelayedMessage("测试延迟消息20秒",20000);
//        rabbitMqService.sendRoutingMessage();
//        rabbitMqService.sendTopicMessage();
//        rabbitMqService.sendMessage("confirm确认测试消息");
//                for(int i=0;i < 20;i++){
                     rabbitMqService.sendMessage("测试消息"+i);
//                    rabbitMqService.sendTTLMessage("测试消息TTL"+i);
//            rabbitMqService.sendMessage("RabbitMQ大爷你好！！！"+i);
             rabbitMqService.sendFanoutMessage(i+"用户欠费了");
//        }

    }
}


server:
  port: 80


spring:
  rabbitmq:
    host: 192.168.30.113
    port: 5672
    username: pzy
    password: 123456
    virtual-host: /
    publisher-confirm-type: correlated
    publisher-returns: true
九品印相
关注
  • 11
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot RabbitMQ 延迟消息实现完整版
09-10
Spring Boot 已经对RabbitMQ Client API进行了包装，使用起来简洁很多，下面详细介绍一下如何利用rabbitmq_delayed_message_exchange 插件和Spring Boot来实现延迟消息。
Spring Boot RabbitMQ 延迟消息实现完整版示例
08-27
本篇文章主要介绍了Spring Boot RabbitMQ 延迟消息实现完整版示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
redis实现延迟消息队列
03-29
redis实现延迟消息队列 需求背景 最近在做一个排队取号的系统 在用户预约时间到达前XX分钟发短信通知 在用户预约时间结束时要判断用户是否去取号了，不然就记录为爽约 在用户取号后开始，等待XX分钟后要发短信...
详解Spring Cloud Stream使用延迟消息实现定时任务(RabbitMQ)
08-26
主要介绍了详解Spring Cloud Stream使用延迟消息实现定时任务(RabbitMQ),小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
使用RabbitMQ死信实现延迟消息
05-24
spring boot 配置， Rabbitmq集成, 利用死信 实现延时消息队列实现
java学习和项目总结
2301_79390585的博客
05-24 609
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
Java高级面试精粹：问题与解答集锦（一）
Layla_c的博客
05-23 1347
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
数据访问与Spring Data JPA
无远弗届
05-25 467
假设我们要处理一个用户表（users），可以创建一个User@Entity // 标识这是一个实体类 public class User {@Id // 标识这是主键字段 @GeneratedValue(strategy = GenerationType . AUTO) // 主键生成策略 private Long id;// Getter 和 Setter ... }@Entity // 标识这是一个实体类 public class User {
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 573
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
深入理解Java的垃圾回收机制（GC）实现原理
微笑听雨
05-25 1768
GC是Java虚拟机的重要组成部分，通过自动内存管理，GC提高了Java程序的稳定性和安全性。理解GC的工作原理和不同收集器的特点，有助于选择合适的GC策略，优化应用性能。通过合理配置JVM参数，可以提高GC效率，减少应用停顿时间，提升系统的整体性能。
【进程信号】可重入函数&&volatile关键字
稻草人敲代码的博客
05-22 638
虽然执行了myhandler,也成功修改了flag的值，但是由于编译器优化，早就将flag的值拷贝到寄存器中了，CPU只会在寄存器中读取flag的值。标准情况下，键入 CTRL-C ,2号信号被捕捉，执行自定义动作，修改 flag＝1 ， while。意思就是说，可重入函数里面的数据都是临时变量，随着函数栈帧的销毁而销毁，编译器在优化代码的时候，会大概推断出哪些变量在特定的范围内不会改变。保持内存的可见性，告知编译器，被该关键字修饰的变量，，对该变量的任何操作，都必须在真实的内存中进行操作。
微信小程序uniapp+django洗脚按摩足浴城消费系统springboot
QQ1304979694的博客
05-24 718
Python语言官方规范访问数据库的统一接口规范(Python DB-API)，防止在使用不同数据库时，由于底层数据库技术不同造成接口程序紊乱的问题。（3）项目初期开发，美工设计，前端实现，开发信息系统的用户功能的实现，完善界面排版，实现信息提取发送等一系列功能。项目系统最后阶段的修改及最终测试运行。当然，在研究过程中也可以直接调查，对调查搜集到的资料进行综合分析、比较，调查法是科学研究中普遍的研究方法。（5）系统测试：对设计好的程序进行最终调试，通过调试发现存在的问题并解决，从而达到完善系统的目的。
ssm139选课排课系统的设计与开发+vue
hjjshua的博客
05-25 1111
互联网的普及，改变了人们正常的生活学习及消费习惯，而且也大大的节省了人们的时间，由于各种管理系统都再不断的增加，更方便了用户，也改良了很多的用户习惯。对于选课排课系统查询方面缺乏系统的管理方式，为提高选课排课系统效率，特开发了本选课排课系统。 选课排课系统的设计主要是对系统所要实现的功能进行详细考虑，确定所要实现的功能后进行界面的设计，在这中间还要考虑如何可以更好的将功能及页面进行很好的结合，方便用户可以很轻松明了的找到自己所需要的信息，还有系统平台后期的可操作性，通过对信息内容的详细了解进行技术的开发。
小小字符串竟然如此嚣张 —— 聊聊 Java 的 String
Gary_Tam的博客
05-25 390
大家好，我是徒手敲代码。今天来分享几个 String 在面试当中，比较常见的问题。这个东西用得最多，而且底层的原理，面试也经常问。
实现复杂树结构返回(不含子树), 并且结点间建立关联
qq_43476358的博客
05-24 622
如图因为硬件设备的限制, 在数据采集及通过MQ到库中时数据是一个传感器对应一个深度对应一个该传感器的采集值, 我们要做的是列出所有传感器, 以时间为索引, 时间和传感器对应上一个值数据字段返回(简单以json格式展示)析:这样就对应上标题了tableData有多组, 但是每一组的数值还和日期时间树的结点能对应上, 可以变向理解为tabledata中含有子树(截图比较抽象)
一个用Java编写的屏幕测距工具，包括游戏地图测量功能
学习学习学习
05-22 468
该程序提供了一个简单便捷的方式，在屏幕上测量距离，包括游戏地图分析在内。它允许用户准确确定屏幕上两点之间的距离，帮助游戏过程中的战略规划、资源管理和决策制定。注意：确保应用程序窗口覆盖屏幕上感兴趣的区域，以进行准确的测量。对于游戏地图，请调整缩放级别或分辨率，以匹配游戏内的设置，从而进行精确测量。
Java面向数据编程1.1版本
极道Jdon的技术博客
05-28 234
虽然将所有这些方法都集中在 Item 上似乎是合理的，因为它们都与购买流程交互，但增加了 predictLowStock（与基于机器学习的预购系统交互）、registerForRecommendations（另一个 ML 系统，这次是物品建议）和 reportPurchase（登记潜在危险物品的购买），让我们怀疑所有这些操作是否真的属于同一个接口。：这是不同上下文场景的方式，放在Item一个类或接口中肯定不对，如同学生借书，将借书这个动作建模在学生这个类或接口一样，借书时一种具体场景。
java多线程创建方式
最新发布
weixin_57763462的博客
05-28 781
这种方式是通过创建一个实现了Runnable接口的类，并实现run()方法来创建线程。然后将这个类的对象作为参数传递给Thread类的构造器，并调用Thread对象的start()方法来启动线程。这种方式是通过创建一个实现了Callable接口的类，实现call()方法，并使用FutureTask或者ExecutorService来创建线程。这种方式的优点在于，由于Java不支持多重继承，如果你的类需要继承其他类，那么实现Runnable接口将是唯一的选择。// 在这里定义线程的执行逻辑。
java的对象内存图
jiayu123321的博客
05-24 206
程序最刚刚开始的时候加载main方法，先把改class包的字节码文件加载到方法区再存储main（）方法，然后main（）方法进栈。在堆里面开辟一个空间，堆给予这个空间一个地址值，并把把s类里面的变量以及方法地址放到这个空间里面。是指在new的时候有没有想类传入实参，有的话就执行构造方法。在main里面生成一个Student类型的s的对象。如果在Student类中有赋值就会把值给相对的变量。给空间里面的变量给予默认初始化(就是给默认值)7. 将堆里面的地址值赋值给左边的局部变量。1.加载方法的class。
rabbitmq延迟消息实现定时任务会阻塞吗
06-10
在 RabbitMQ 中，延迟消息是通过在消息头中设置 x-delay 属性来实现的，而不是通过线程等待的方式。因此，当发送延迟消息后，程序会立即返回，不会阻塞当前线程。当延迟时间到达后，消息会被发送到指定的队列中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值