SpringBoot整合

最新推荐文章于 2023-07-15 20:00:03 发布

爱敲代码的小楚

最新推荐文章于 2023-07-15 20:00:03 发布

阅读量128

点赞数

本文链接：https://blog.csdn.net/qq_47075878/article/details/130594904

版权

Java 同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

SpringBoot

1 篇文章 0 订阅

订阅专栏

SpringBoot整合

MyBatis在SpringBoot中使用

依赖加入

<!--mybatis-plus-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.3.1</version>
</dependency>
  <!--逆向工程-->  
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-generator</artifactId>
</dependency>

配置文件（application.yml）

@MapperScan("com.atguigu.yygh.mapper")

spring:
  profiles:
    active: dev # 环境设置
  application:
    name: service-edu # 不用_下划线兼容会好些
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/db_01_guli_edu?serverTimezone=GMT%2B8&characterEncoding=utf8
    driver-class-name: com.mysql.cj.jdbc.Driver
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # MyBaits日志
  mapper-locations: classpath:com/atguigu/guli/service/edu/mapper/xml/*.xml

public interface UserMapper extends BaseMapper<User> {
}

public interface HospitalSetService extends IService<HospitalSet> {
}

@service
public class HospitalSetServiceImpl extends ServiceImpl<HospitalSetMapper,HospitalSet> implements HospitalSetService {
}

自动填充时间

属性加上

@TableField(fill = FieldFill.INSERT)
private Date createTime;
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;

配置：

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    // mp执行添加操作，这个方法执行
    @Override
    public void insertFill(MetaObject metaObject) {
        setFieldValByName("createTime",new Date(),metaObject);
        setFieldValByName("updateTime",new Date(),metaObject);
    }

    // 执行修改操作，这个方法执行
    @Override
    public void updateFill(MetaObject metaObject) {
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

乐观锁配置

数据库中要有个version字段

类的字段配置

@Version
private Integer version;

乐观锁配置

@Configuration
public class MpConf {

    /**
     * 乐观锁插件
     * @return
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor(){
        return new OptimisticLockerInterceptor();
    }
}

分页需要做的

@EnableTransactionManagement
@Configuration
@MapperScan("com.atguigu.guli.service.*.mapper")
public class MybatisPlusConfig {

    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

示例

@Test
public void test2(){

    Page<User> userPage1 = new Page<>(1, 4);
    Page<User> userPage = userMapper.selectPage(userPage1, null);
    List<User> records = userPage.getRecords();
    records.forEach(System.out::println);
}

逻辑删除

添加 deleted字段

ALTERTABLE `user` ADD COLUMN `deleted` boolean DEFAULT false

添加deleted 字段，并加上 @TableLogic 注解

@TableLogic
private Integer deleted;

配置（可选）

application.properties 加入以下配置，此为默认值，如果你的默认值和mp默认的一样,该配置可无

mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

SpringBoot和MongoDB整合

启动mongoDB 失败是服务没启动 命令mongod --dbpath /data/db --bind_ip 0.0.0.0

spring-data-mongodb提供了MongoTemplate与MongoRepository两种方式访问
mongodb，MongoRepository操作简单，MongoTemplate操作灵活，
我们在项目中可以灵活适用这两种方式操作mongodb，MongoRepository的缺点是不够灵活，MongoTemplate正好可以弥补不足。

第一步：依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
		<!--日期的工具-->
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.10.1</version>
    </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>
</dependencies>

第二步：配置文件

spring.data.mongodb.uri=mongodb://192.168.179.200:27017/test

第三步：创建对应的类

@Data
@Document("User")
public class User {

 @Id
 private String id;
 private String name;
 private Integer age;
 private String email;
 private String createDate;
}

MongoTemplate

@SpringBootTest
class DemomogoApplicationTests {

    @Autowired
    private MongoTemplate mongoTemplate;

    //添加
    @Test
    public void createUser() {
        User user = new User();
        user.setAge(20);
        user.setName("test");
        user.setEmail("4932200@qq.com");
        User user1 = mongoTemplate.insert(user);
        System.out.println(user1);
    }

    //查询所有
    @Test
    public void findUser() {
        List<User> userList = mongoTemplate.findAll(User.class);
        System.out.println(userList);
    }

    //根据id查询
    @Test
    public void getById() {
        User user = 
mongoTemplate.findById("5ffbfa2ac290f356edf9b5aa", User.class);
        System.out.println(user);
    }

    //条件查询
    @Test
    public void findUserList() {
        Query query = new Query(Criteria
                .where("name").is("test")
                .and("age").is(20));
        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList);
    }

    //模糊查询
    @Test
    public void findUsersLikeName() {
        String name = "est";
        String regex = String.format("%s%s%s", "^.*", name, ".*$");
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Query query = new Query(Criteria.where("name").regex(pattern));
        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList);
    }

    //分页查询
    @Test
    public void findUsersPage() {
        String name = "est";
        int pageNo = 1;
        int pageSize = 10;

        Query query = new Query();
        String regex = String.format("%s%s%s", "^.*", name, ".*$");
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        query.addCriteria(Criteria.where("name").regex(pattern));
        int totalCount = (int) mongoTemplate.count(query, User.class);
        List<User> userList = mongoTemplate.find(query.skip((pageNo - 1) * pageSize).limit(pageSize), User.class);

        Map<String, Object> pageMap = new HashMap<>();
        pageMap.put("list", userList);
        pageMap.put("totalCount",totalCount);
        System.out.println(pageMap);
    }

    //修改
    @Test
    public void updateUser() {
        User user = mongoTemplate.findById("5ffbfa2ac290f356edf9b5aa", User.class);
        user.setName("test_1");
        user.setAge(25);
        user.setEmail("493220990@qq.com");
        Query query = new Query(Criteria.where("_id").is(user.getId()));
        Update update = new Update();
        update.set("name", user.getName());
        update.set("age", user.getAge());
        update.set("email", user.getEmail());
        UpdateResult result = mongoTemplate.upsert(query, update, User.class);
        long count = result.getModifiedCount();
        System.out.println(count);
    }

    //删除操作
    @Test
    public void delete() {
        Query query = 
new Query(Criteria.where("_id").is("5ffbfa2ac290f356edf9b5aa"));
        DeleteResult result = mongoTemplate.remove(query, User.class);
        long count = result.getDeletedCount();
        System.out.println(count);
    }
}

MongoRepository （可以使用命名方式来查询）

public interface UserRepository extends MongoRepository<User, String> {
}

@SpringBootTest
class DemomogoApplicationTests1 {

    @Autowired
    private UserRepository userRepository;

    //添加
    @Test
    public void createUser() {
        User user = new User();
        user.setAge(20);
        user.setName("张三");
        user.setEmail("3332200@qq.com");
        User user1 = userRepository.save(user);
    }

    //查询所有
    @Test
    public void findUser() {
        List<User> userList = userRepository.findAll();
        System.out.println(userList);
    }

    //id查询
    @Test
    public void getById() {
        User user = userRepository.findById("5ffbfe8197f24a07007bd6ce").get();
        System.out.println(user);
    }

    //条件查询
    @Test
    public void findUserList() {
        User user = new User();
        user.setName("张三");
        user.setAge(20);
        Example<User> userExample = Example.of(user);
        List<User> userList = userRepository.findAll(userExample);
        System.out.println(userList);
    }
    
	//模糊查询
    @Override
    public List<Hospital> findByHosname(String hosname) {
        return hospitalRepository.findHospitalByHosnameLike(hosname);
    }

    
    //模糊查询
    @Test
    public void findUsersLikeName() {
        //创建匹配器，即如何使用查询条件
        ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
                .withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写
        User user = new User();
        user.setName("三");
        Example<User> userExample = Example.of(user, matcher);
        List<User> userList = userRepository.findAll(userExample);
        System.out.println(userList);
    }

    //分页查询
    @Test
    public void findUsersPage() {
        Sort sort = Sort.by(Sort.Direction.DESC, "age");
//0为第一页
        Pageable pageable = PageRequest.of(0, 10, sort);
//创建匹配器，即如何使用查询条件
        ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
                .withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写
        User user = new User();
        user.setName("三");
        Example<User> userExample = Example.of(user, matcher);
//创建实例
        Example<User> example = Example.of(user, matcher);
        Page<User> pages = userRepository.findAll(example, pageable);
        System.out.println(pages);
    }

    //修改
    @Test
    public void updateUser() {
        User user = userRepository.findById("5ffbfe8197f24a07007bd6ce").get();
        user.setName("张三_1");
        user.setAge(25);
        user.setEmail("883220990@qq.com");
        User save = userRepository.save(user);
        System.out.println(save);
    }

    //删除
    @Test
    public void delete() {
        userRepository.deleteById("5ffbfe8197f24a07007bd6ce");
    }
}

RabbitMq和SpringBoot整合

记得相关的配置项可以写在一个微服务中，在使用的项目中依赖注入就行

第一步：先注入依赖

<!--rabbitmq消息队列-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!--rabbitmq 协议-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>

第二步： RabbitMq的相关配置

这写配置是关于Mq的消息成功（confirm）或失败（returnedMessage）的相关配置

/**
 * @Description 消息发送确认
 * @author: JC
 * @date: 2021/11/10 18:46
 * <p>
 * ConfirmCallback  只确认消息是否正确到达 Exchange 中
 * ReturnCallback   消息没有正确到达队列时触发回调，如果正确到达队列不执行
 * <p>
 * 1. 如果消息没有到exchange,则confirm回调,ack=false
 * 2. 如果消息到达exchange,则confirm回调,ack=true
 * 3. exchange到queue成功,则不回调return
 * 4. exchange到queue失败,则回调return
 *
 */
@Slf4j
@Component
public class MQProducerAckConfig implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnCallback{


    @Autowired
    private RabbitTemplate rabbitTemplate;

    // 修饰一个非静态的void（）方法,在服务器加载Servlet的时候运行，
    // 并且只会被服务器执行一次在构造函数之后执行，init（）方法之前执行。
    @PostConstruct
    public void init(){
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnCallback(this);
    }

    /**
     * @param correlationData
     * @param ack 消息是否发送成功
     * @param cause 消息发送失败原因
     * 修饰一个非静态的void（）方法,在服务器加载Servlet的时候运行，
     * 并且只会被服务器执行一次在构造函数之后执行，init（）方法之前执行。
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {

        if(ack){
            // 消息成功发送到了交换机
            System.out.println("消息发送成功");
        }else{
            // 消息发送失败
            System.out.println("消息发送失败");
        }
    }


    /**
     * 表示消息没有发送成功 ，才会执行改方法
     * @param message 应答码
     * @param replyCode 应答码
     * @param replyText 应答码对应的文本
     * @param exchange 交换机
     * @param routingKey 消息使用的路由键 routing
     */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        // 反序列化对象输出
        System.out.println("消息主体: " + new String(message.getBody()));
        System.out.println("应答码: " + replyCode);
        System.out.println("描述：" + replyText);
        System.out.println("消息使用的交换器 exchange : " + exchange);
        System.out.println("消息使用的路由键 routing : " + routingKey);

    }
}

第三步：在需要使用的项目中配置yaml

spring:
  rabbitmq:
    host: 192.168.179.128
    port: 5672
    username: guest
    password: guest
    publisher-confirms: true
    publisher-returns: true
    listener:
      simple:
        acknowledge-mode: manual #默认情况下消息消费者是自动确认消息的，如果要手动确认消息则需要修改确认模式为manual
        prefetch: 1 # 消费者每次从队列获取的消息数量。此属性当不设置时为：轮询分发，设置为1为：公平分发

第四步：记得最好设置一个关于Rabbit的常量类（constant类似的的包）

public class MqConst {
    /**
     * 消息补偿
     */
    public static final String MQ_KEY_PREFIX = "mq:list";
    public static final int RETRY_COUNT = 3;
    /**
     * 商品上下架
     */
    public static final String EXCHANGE_DIRECT_GOODS = "exchange.direct.goods";
    public static final String ROUTING_GOODS_UPPER = "goods.upper";
    public static final String ROUTING_GOODS_LOWER = "goods.lower";
    //队列
    public static final String QUEUE_GOODS_UPPER  = "queue.goods.upper";
    public static final String QUEUE_GOODS_LOWER  = "queue.goods.lower";
    /**
     * 取消订单，发送延迟队列
     */
    public static final String EXCHANGE_DIRECT_ORDER_CANCEL = "exchange.direct.order.cancel";//"exchange.direct.order.create" test_exchange;
    public static final String ROUTING_ORDER_CANCEL = "order.create";
    //延迟取消订单队列
    public static final String QUEUE_ORDER_CANCEL  = "queue.order.cancel";
    //取消订单 延迟时间 单位：秒 真实业务
    public static final int DELAY_TIME  = 24*60*60;

    /**
     * 订单支付
     */
    public static final String EXCHANGE_DIRECT_PAYMENT_PAY = "exchange.direct.payment.pay";
    public static final String ROUTING_PAYMENT_PAY = "payment.pay";
    //队列
    public static final String QUEUE_PAYMENT_PAY  = "queue.payment.pay";

    /**
     * 减库存
     */
    public static final String EXCHANGE_DIRECT_WARE_STOCK = "exchange.direct.ware.stock";
    public static final String ROUTING_WARE_STOCK = "ware.stock";
    //队列
    public static final String QUEUE_WARE_STOCK  = "queue.ware.stock";
    /**
     * 减库存成功，更新订单状态
     */
    public static final String EXCHANGE_DIRECT_WARE_ORDER = "exchange.direct.ware.order";
    public static final String ROUTING_WARE_ORDER = "ware.order";
    //队列
    public static final String QUEUE_WARE_ORDER  = "queue.ware.order";

    /**
     * 关闭交易
     */
    public static final String EXCHANGE_DIRECT_PAYMENT_CLOSE = "exchange.direct.payment.close";
    public static final String ROUTING_PAYMENT_CLOSE = "payment.close";
    //队列
    public static final String QUEUE_PAYMENT_CLOSE  = "queue.payment.close";
    /**
     * 定时任务
     */
    public static final String EXCHANGE_DIRECT_TASK = "exchange.direct.task";
    public static final String ROUTING_TASK_1 = "seckill.task.1";
    //队列
    public static final String QUEUE_TASK_1  = "queue.task.1";
    /**
     * 秒杀
     */
    public static final String EXCHANGE_DIRECT_SECKILL_USER = "exchange.direct.seckill.user";
    public static final String ROUTING_SECKILL_USER = "seckill.user";
    //队列
    public static final String QUEUE_SECKILL_USER  = "queue.seckill.user";

    /**
     * 定时任务
     */

    public static final String ROUTING_TASK_18 = "seckill.task.18";
    //队列
    public static final String QUEUE_TASK_18  = "queue.task.18";


}

第五步:创建service 调用进行发送（有延迟消息和非延迟消息的区别）延迟还需要配置

@Service
public class RabbitService {

    // 消息发送的方法
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 表示成功发送消息
     * @param exchange
     * @param routingKey
     * @param message
     * @return
     */
    public boolean sendMessage(String exchange, String  routingKey, Object message){
        // 发送消息！
        rabbitTemplate.convertAndSend(exchange,routingKey,message);
        return true;
    }

    /**
     * 发送延迟消息
     * @param exchange 交换机
     * @param routingKey 路由键
     * @param message 消息
     * @param delayTime 单位：秒
     */
    public boolean sendDelayMessage(String exchange, String routingKey, Object message, int delayTime) {

        this.rabbitTemplate.convertAndSend(exchange, routingKey, message, msg ->{
            msg.getMessageProperties().setDelay(delayTime*1000);
                return msg;
        });
        return true;
    }

}

第六步使用延迟消息的配置（死信交换机）

消息延迟就是当超过多少时间就执行

本质就是用两条交换机（或说队列）当主的TTL（存活时间过了）就让其执行第二个队列

然后不消费第一个队列的消息等其过期，我们监控第二个队列执行就行

消息延迟相关配置 (记得放config包中)

@Configuration
public class DeadLetterMqconfig {

    // 定义变量：
    public static final String EXCHANGE_DEAD = "exchange.dead";
    public static final String ROUTING_DEAD_1 = "routing.dead.1";
    public static final String ROUTING_DEAD_2 = "routing.dead.2";
    public static final String QUEUE_DEAD_1 = "queue.dead.1";
    public static final String QUEUE_DEAD_2 = "queue.dead.2";

    // 定义交换机
    @Bean
    public DirectExchange exchange(){
        return new DirectExchange(EXCHANGE_DEAD,true,false,null);
    }

    @Bean
    public Queue queue1(){

        // 设置如果队列一 出现问题，则通过参数转到exchange_dead，routing_dead_2 上！
        HashMap<String, Object> map = new HashMap<>();
        // 参数绑定 此处的key 固定值，不能随意写
        map.put("x-dead-letter-exchange",EXCHANGE_DEAD);
        map.put("x-dead-letter-routing-key",ROUTING_DEAD_2);
        // 设置延迟时间
        map.put("x-message-ttl", 10 * 1000);
        // 队列名称，是否持久化，是否独享、排外的【true:只可以在本次连接中访问】，是否自动删除，队列的其他属性参数
        return new Queue(QUEUE_DEAD_1,true,false,false,map);
    }

    @Bean
    public Binding binding(){
        // 将队列一 通过routing_dead_1 key 绑定到exchange_dead 交换机上
        return BindingBuilder.bind(queue1()).to(exchange()).with(ROUTING_DEAD_1);
    }

    // 这个队列二就是一个普通队列
    @Bean
    public Queue queue2(){
        return new Queue(QUEUE_DEAD_2,true,false,false,null);
    }

    // 设置队列二的绑定规则
    @Bean
    public Binding binding2(){
        // 将队列二通过routing_dead_2 key 绑定到exchange_dead交换机上！
        return BindingBuilder.bind(queue2()).to(exchange()).with(ROUTING_DEAD_2);
    }

}

// 监听获取消息！ 需要设置绑定参数
// @RabbitListener()
@RabbitListener(bindings = @QueueBinding(
                value = @Queue(value = "queue.confirm",durable = "true", autoDelete = "false"),
                exchange = @Exchange(value = "exchange.confirm",durable = "true", autoDelete = "false"),
                key= {"routing.confirm"}
                ))
@SneakyThrows
public void getMsg(String msg, Message message, Channel channel){
    long deliveryTag = 0;
    try {
        System.out.println("获取的消息："+msg);
        System.out.println("获取的消息(Message)："+new String(message.getBody()));
        // 手动确认 ： ack
        deliveryTag = message.getMessageProperties().getDeliveryTag();
        // false: 表示一个一个来确认消息 ，true表示批量确认消息！
        channel.basicAck(deliveryTag,false);
    } catch (IOException e) {
        log.info("rabbitMq监听失败原因:"+e.getMessage());
        // 第三个参数：是否重回队列
        channel.basicNack(deliveryTag,false,true);

    } finally {

    }

}

第七步：监听rabbitMq进行消费

非消息延迟的监听

@Component
public class ListReceiver {

    @Autowired
    private SearchService searchService;

    /**
     * 实现商品上架（es 中上架）
     * @param skuId
     * @param message
     * @param channel
     */
    @RabbitListener(
        bindings = @QueueBinding(
                value = @Queue(value = MqConst.QUEUE_GOODS_UPPER,durable = "true",autoDelete = "false"),
                exchange = @Exchange(value = MqConst.EXCHANGE_DIRECT_GOODS,durable = "true", autoDelete = "false"),
                key = MqConst.ROUTING_GOODS_UPPER
        )
    )
    @SneakyThrows
    public void upperGoodsListener(Long skuId, Message message, Channel channel){

        // 有消息
        if(skuId != null){
            // 实现上架
            searchService.upperGoods(skuId);
        }
        // 消息确认
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        // false: 表示一个一个来确认消息 ，true表示批量确认消息！
        channel.basicAck(deliveryTag,false);

        // 第三个参数：是否重回队列
    }


    /**
     * 实现商品上架（es 中下架）
     * @param skuId
     * @param message
     * @param channel
     */
    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(value = MqConst.QUEUE_GOODS_UPPER,durable = "true",autoDelete = "false"),
                    exchange = @Exchange(value = MqConst.EXCHANGE_DIRECT_GOODS,durable = "true", autoDelete = "false"),
                    key = MqConst.ROUTING_GOODS_LOWER
            )
    )
    @SneakyThrows
    public void lowerGoodsListener(Long skuId, Message message, Channel channel){

        // 有消息
        if(skuId != null){
            // 实现上架
            searchService.lowerGoods(skuId);
        }
        // 消息确认
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        // false: 表示一个一个来确认消息 ，true表示批量确认消息！
        channel.basicAck(deliveryTag,false);

    }
}

消息延迟的监听(监听方法的第一个参数根据对应传入值的类)

@Component
public class OrderReceiver {

    @Autowired
    private OrderService orderService;

//  监听的消息
    @SneakyThrows
    @RabbitListener(queues = MqConst.QUEUE_ORDER_CANCEL)
    public void cancelOrder(Long orderId , Message message, Channel channel){
        //  判断当前订单Id 不能为空
        try {
            if (orderId!=null){
                //  发过来的是订单Id，那么你就需要判断一下当前的订单是否已经支付了。
                //  未支付的情况下：关闭订单
                //  根据订单Id 查询orderInfo select * from order_info where id = orderId
                //  利用这个接口IService  实现类ServiceImpl 完成根据订单Id 查询订单信息 ServiceImpl 类底层还是使用的mapper
                OrderInfo orderInfo = orderService.getById(orderId);
                //  判断支付状态,进度状态
                if (orderInfo!=null && "UNPAID".equals(orderInfo.getOrderStatus())
                        && "UNPAID".equals(orderInfo.getProcessStatus())){
                    //  关闭订单
                    //  int i = 1/0;
                    orderService.execExpiredOrder(orderId);
                }
            }
        } catch (Exception e) {
            //  消息没有正常被消费者处理：
            //  第一个参数就是long 标识， 第二个参数表示 是否批量确认 ，第三个参数是否重回队列
            channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,true);
            //  发短信的形式通知我们的管理员，立刻查看并解决问题 类似于消息的积压！
            //  如果线上真的出现了这种问题，你能停止这个微服务改代码? 跟我刚刚的操作类似，启动一个其他的程序消费这个消息！
            e.printStackTrace();
        }
        //  手动确认消息 如果不确认，有可能会到消息残留。
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
    }
}