[黑马程序员SpringBoot2]——开发实用篇3

最新推荐文章于 2023-12-29 10:47:11 发布
最新推荐文章于 2023-12-29 10:47:11 发布
阅读量346 收藏 1
点赞数
分类专栏： # JavaEE 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56444564/article/details/134541284
版权

目录：

  1. jetcache远程缓存方案
  2. jetcache本地缓存方案
  3. jetcache方法缓存
  4. j2cache基本操作
  5. springboot整合quartz​​​​​​​
  6. springboot整合task
  7. 发送简单邮件
  8. 发送多部件邮件
  9. 消息简介
  10. 购物订单案例-发送短信
  11. ActiveMQ安装
  12. springboot整合ActiveMQ
  13. RabbitMQ安装
  14. springboot整合RabbitMQ(direct模式)
  15. springboot整合RabbitMQ(topic模式)
  16. RocketMQ安装
  17. springboot整合RockeMQ
  18. Kafka安装
  19. springboot整合Kafka
  20. 监控的意义
  21. SpringBootAdmin
  22. actuator
  23. info端点指标控制
  24. health端点指标控制
  25. metrics端点指标控制
  26. ​​​​​​​自定义端点

1.jetcache远程缓存方案

  • jetCache对SpningCache进行了封装，在原有功能基础上实现了多级缓存、缓存统计、自动刷新、异步调用、数据报表等功能
  • jetcache设定了本地缓存与远程缓存的多级缓存解决方案
  • 本地缓存(local)
    • LlinkedHashMap
    • Caffeine
  • 远程缓存(remote)
    • Redis
    • Tair

加入jetcache坐标

配置远程缓存必要属性

配置本地缓存必要属性

配置范例

配置属性说明

开启jetcache注解支持

声明缓存对象

操作缓存

代码示例：

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.example</groupId>
    <artifactId>sprintboot_20_jetcache</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>sprintboot_20_jetcache</name>
    <description>sprintboot_20_jetcache</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alicp.jetcache</groupId>
            <artifactId>jetcache-starter-redis</artifactId>
            <version>2.6.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <image>
                        <builder>paketobuildpacks/builder-jammy-base:latest</builder>
                    </image>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

server:
  port: 8080

mybatis-plus:
  global-config:
    db-config:
      table-prefix: tbl_
      id-type: auto
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl


spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3308/test_db
      username: root
      password: 666666

jetcache:
  remote:
    default:
      type: redis
      host: localhost
      port: 6379
      poolConfig:
        maxTotal: 50
    sms:
      type: redis
      host: localhost
      port: 6379
      poolConfig:
        maxTotal: 50

BookController.class

package com.example.springboot_20_jetcache.controller;

import com.example.springboot_20_jetcache.domain.Book;
import com.example.springboot_20_jetcache.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/books")
public class BookController {
    @Autowired
    private BookService bookService;

    @GetMapping("{id}")
    public Book getById(@PathVariable Integer id) {
        return bookService.getById(id);
    }

    @PostMapping
    public boolean save(@RequestBody Book book) {
        return bookService.save(book);
    }

    @PutMapping
    public boolean update(@RequestBody Book book) {
        return bookService.update(book);
    }

    @DeleteMapping("{id}")
    public boolean delete(@PathVariable Integer id) {
        return bookService.delete(id);
    }

    @GetMapping
    public List<Book> getAll() {
        return bookService.getAll();
    }
}

SMSCodeController.class

package com.example.springboot_20_jetcache.controller;

import com.example.springboot_20_jetcache.domain.SMSCode;
import com.example.springboot_20_jetcache.service.SMSCodeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/sms")
public class SMSCodeController {

    @Autowired
    private SMSCodeService smsCodeService;

    @GetMapping
    public String getCode(String tele) {
        String code = smsCodeService.sendCodeToSMS(tele);
        return code;
    }

    @PostMapping
    public boolean checkCode(SMSCode smsCode) {
        return smsCodeService.checkCode(smsCode);
    }
}

BookDao.interface

package com.example.springboot_20_jetcache.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.springboot_20_jetcache.domain.Book;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface BookDao extends BaseMapper<Book> {
}

Book.class

package com.example.springboot_20_jetcache.domain;

import lombok.Data;

@Data
public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;
}

SMSCode.class

package com.example.springboot_20_jetcache.domain;

import lombok.Data;

@Data
public class SMSCode {
    private String tele;
    private String code;
}

BookServiceImpl.class

package com.example.springboot_20_jetcache.service.impl;

import com.example.springboot_20_jetcache.dao.BookDao;
import com.example.springboot_20_jetcache.domain.Book;
import com.example.springboot_20_jetcache.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;

    @Override
    public Book getById(Integer id) {
        Book queryBook = bookDao.selectById(id);
        return queryBook;
    }


    @Override
    public boolean save(Book book) {
        return bookDao.insert(book) > 0;
    }

    @Override
    public boolean update(Book book) {
        return bookDao.updateById(book) > 0;
    }

    @Override
    public boolean delete(Integer id) {
        return bookDao.deleteById(id) > 0;
    }

    @Override
    public List<Book> getAll() {
        return bookDao.selectList(null);
    }
}

SMSCodeServiceImpl.class

package com.example.springboot_20_jetcache.service.impl;

import com.alicp.jetcache.Cache;
import com.alicp.jetcache.anno.CreateCache;
import com.example.springboot_20_jetcache.domain.SMSCode;
import com.example.springboot_20_jetcache.service.SMSCodeService;
import com.example.springboot_20_jetcache.utils.CodeUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class SMSCodeServiceImpl implements SMSCodeService {
    @Autowired
    private CodeUtils codeUtils;

    @CreateCache(name = "jetCache", expire = 10, timeUnit = TimeUnit.SECONDS)
    private Cache<String, String> jetCache;

    @CreateCache(area = "sms", name = "jetCache2", expire = 10, timeUnit = TimeUnit.SECONDS)
    private Cache<String, String> jetCache2;

    @Override
    public String sendCodeToSMS(String tele) {
        String code = codeUtils.generator(tele);
        jetCache.put(tele, code);
        return code;
    }

    @Override
    public boolean checkCode(SMSCode smsCode) {
        String code = jetCache.get(smsCode.getTele());
        return smsCode.getCode().equals(code);
    }
}

BookService.interface

package com.example.springboot_20_jetcache.service;


import com.example.springboot_20_jetcache.domain.Book;

import java.util.List;

public interface BookService {
    public boolean save(Book book);

    public Book getById(Integer id);

    public boolean update(Book book);

    public boolean delete(Integer id);

    public List<Book> getAll();
}

SMSCodeService.interface

package com.example.springboot_20_jetcache.service;

import com.example.springboot_20_jetcache.domain.SMSCode;

public interface SMSCodeService {
    public String sendCodeToSMS(String tele);

    public boolean checkCode(SMSCode smsCode);
}

CodeUtils.class

package com.example.springboot_20_jetcache.utils;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

@Component
public class CodeUtils {

    private String[] patch = {"000000", "00000", "0000", "000", "00", "0", ""};

    public String generator(String tele) {
        int hash = tele.hashCode();
        int encryption = 20206666;
        long result = hash ^ encryption;
        long nowTime = System.currentTimeMillis();
        result = result ^ nowTime;
        long code = result % 1000000;
        code = code < 0 ? -code : code;
        String codeStr = code + "";
        int len = codeStr.length();

        return patch[len] + codeStr;
    }


    @Cacheable(value = "smsCode", key = "#tele")
    public String get(String tele) {
        return null;
    }

    public static void main(String[] args) {
        System.out.println(new CodeUtils().generator("15033657967"));
    }
}

Springboot20JetcacheApplication.class

package com.example.springboot_20_jetcache;

import com.alicp.jetcache.anno.config.EnableCreateCacheAnnotation;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableCreateCacheAnnotation
public class Springboot20JetcacheApplication {

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

}

2.jetcache本地缓存方案

application.yml

server:
  port: 8080

mybatis-plus:
  global-config:
    db-config:
      table-prefix: tbl_
      id-type: auto
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl


spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3308/test_db
      username: root
      password: 666666

jetcache:
  local:
    default:
      type: linkedhashmap
      keyConvertor: fastjson
  remote:
    default:
      type: redis
      host: localhost
      port: 6379
      poolConfig:
        maxTotal: 50
    sms:
      type: redis
      host: localhost
      port: 6379
      poolConfig:
        maxTotal: 50

SMSCodeServiceImpl.class

package com.example.springboot_20_jetcache.service.impl;

import com.alicp.jetcache.Cache;
import com.alicp.jetcache.anno.CacheType;
import com.alicp.jetcache.anno.CreateCache;
import com.example.springboot_20_jetcache.domain.SMSCode;
import com.example.springboot_20_jetcache.service.SMSCodeService;
import com.example.springboot_20_jetcache.utils.CodeUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class SMSCodeServiceImpl implements SMSCodeService {
    @Autowired
    private CodeUtils codeUtils;

//    @CreateCache(name = "jetCache", expire = 10, timeUnit = TimeUnit.SECONDS)
//    private Cache<String, String> jetCache;
//
//    @CreateCache(area = "sms", name = "jetCache2", expire = 10, timeUnit = TimeUnit.SECONDS)
//    private Cache<String, String> jetCache2;


    @CreateCache(name = "jetCache", expire = 1000, timeUnit = TimeUnit.SECONDS,cacheType = CacheType.LOCAL)
    private Cache<String, String> jetCache;

    @Override
    public String sendCodeToSMS(String tele) {
        String code = codeUtils.generator(tele);
        jetCache.put(tele, code);
        return code;
    }

    @Override
    public boolean checkCode(SMSCode smsCode) {
        String code = jetCache.get(smsCode.getTele());
        return smsCode.getCode().equals(code);
    }
}

3.jetcache方法缓存

启用方法注解

使用方法注解操作缓存

 

缓存对象必须保障可序列化

 

查看缓存统计报告

application.yml

server:
  port: 8080

mybatis-plus:
  global-config:
    db-config:
      table-prefix: tbl_
      id-type: auto
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl


spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3308/test_db
      username: root
      password: 666666

jetcache:
  statIntervalMinutes: 1
  local:
    default:
      type: linkedhashmap
      keyConvertor: fastjson
  remote:
    default:
      type: redis
      host: localhost
      port: 6379
      keyConvertor: fastjson
      valueEncode: java
      valueDecode: java
      poolConfig:
        maxTotal: 50
    sms:
      type: redis
      host: localhost
      port: 6379
      poolConfig:
        maxTotal: 50

BookServiceImpl.class

package com.example.springboot_20_jetcache.service.impl;

import com.alicp.jetcache.anno.*;
import com.example.springboot_20_jetcache.dao.BookDao;
import com.example.springboot_20_jetcache.domain.Book;
import com.example.springboot_20_jetcache.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;

    @Override
    @Cached(area = "default", name = "book", key = "#id", expire = 3600, cacheType = CacheType.REMOTE)
    //    @CacheRefresh(refresh = 5)
    public Book getById(Integer id) {
        Book queryBook = bookDao.selectById(id);
        return queryBook;
    }


    @Override
    public boolean save(Book book) {
        return bookDao.insert(book) > 0;
    }

    @Override
    @CacheUpdate(name = "book", key = "#book.id", value = "#book")
    public boolean update(Book book) {
        return bookDao.updateById(book) > 0;
    }

    @Override
    @CacheInvalidate(name = "book", key = "#id")
    public boolean delete(Integer id) {
        return bookDao.deleteById(id) > 0;
    }

    @Override
    public List<Book> getAll() {
        return bookDao.selectList(null);
    }
}

4.j2cache基本操作

  • j2cache是一个缓存整合框架，可以提供缓存的整合方案，使各种缓存搭配使用，自身不提供缓存功能
  • 基于ehcache + nedis.进行整合

加入j2cache坐标，加入整合缓存的坐标

配置使用j2cache (application.yml)

配置─级缓存与二级缓存以及一级缓存数据到二级缓存的发送方式 (j2cache.properties)

设置使用缓存

 

5.springboot整合quartz

  • 定时任务是企业级应用中的常见操作
    • 年度报表
    • 缓存统计报告
  • 市面上流行的定时任务技术
    • Quartz
    • Spring Task

相关概念

  • 工作 (Job)∶用于定义具体执行的工作
  • 工作明细(JobDetail):用于描述定时工作相关的信息
  • 触发器（Trigger)∶用于描述触发工作的规则，通常使用cron表达式定义调度规则
  • 调度器(Scheduler):描述了工作明细与触发器的对应关系

导入SpringBoot整合quartz的坐标

定义具体要执行的任务，继承QuartzJobBean

定义工作明细与触发器，并绑定对应关系

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.17</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springboot_22_task</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_22_task</name>
    <description>springboot_22_task</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <image>
                        <builder>paketobuildpacks/builder-jammy-base:latest</builder>
                    </image>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

QuartzConfig.class

package com.example.springboot_22_task.config;

import com.example.springboot_22_task.quartz.MyQuartz;
import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QuartzConfig {
    @Bean
    public JobDetail printJobDetail() {
        return JobBuilder.newJob(MyQuartz.class).storeDurably().build();
    }

    @Bean
    public Trigger printJobTrigger() {
        ScheduleBuilder schedBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
        return TriggerBuilder.newTrigger().forJob(printJobDetail()).withSchedule(schedBuilder).build();
    }
}

MyQuartz.class

package com.example.springboot_22_task.quartz;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class MyQuartz extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        System.out.println("quartz task run...");
    }
}

6.springboot整合task

开启定时任务功能

设置定时执行的任务，并设定执行周期

定时任务相关配置

MyBean.class

package com.example.springboot_22_task.quartz;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class MyBean {
    @Scheduled(cron = "0/1 * * * * ?")
    public void print() {
        System.out.println(Thread.currentThread().getName() + " :spring task run...");
    }
}

Springboot22TaskApplication.class

package com.example.springboot_22_task;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class Springboot22TaskApplication {

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

}

application.yml

spring:
  task:
    scheduling:
      thread-name-prefix: spring_tasks_

7.发送简单邮件

  • SMTP (Simple Mail Transfer Protocol):简单邮件传输协议，用于发送电子邮件的传输协议
  • POP3 ( Post Office Protocol - Version 3):用于接收电子邮件的标准协议
  • IMAP ( Internet Mail Access Protocol) :互联网消息协议，是POP3的替代协议

导入SpringBoot整合JavaMail的坐标

配置JavaMail

 

代码示例:

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.17</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springboot_23_mail</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_23_mail</name>
    <description>springboot_23_mail</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <image>
                        <builder>paketobuildpacks/builder-jammy-base:latest</builder>
                    </image>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

 SendMailService.interface

package com.example.springboot_23_mail.service;

public interface SendMailService {
    void sendMail();
}

SendMailServiceImpl.class

package com.example.springboot_23_mail.service.impl;

import com.example.springboot_23_mail.service.SendMailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.stereotype.Service;

@Service
public class SendMailServiceImpl implements SendMailService {

    @Autowired
    private JavaMailSender javaMailSender;

    private String from = "348904@qq.com";

    private String to = "ter@126.com";

    private String subject = "测试邮件";

    private String context = "测试邮件正文内容";

    @Override
    public void sendMail() {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setFrom(from + "(小甜甜)");
        message.setTo(to);
        message.setSubject(subject);
        message.setText(context);
        javaMailSender.send(message);
    }
}

Springboot23MailApplicationTests.class

package com.example.springboot_23_mail;

import com.example.springboot_23_mail.service.SendMailService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;


@SpringBootTest
class Springboot23MailApplicationTests {


    @Autowired
    private SendMailService sendMailService;

    @Test
    void contextLoads() {
        sendMailService.sendMail();
    }

}

 application.yml

spring:
  mail:
    username: 3864@qq.com
    password: pn............qcjbc
    host: smtp.qq.com

8.发送多部件邮件

附件与HTML文本支持

SendMailServiceImpl2.class

package com.example.springboot_23_mail.service.impl;

import com.example.springboot_23_mail.service.SendMailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import java.io.File;

//@Service
public class SendMailServiceImpl2 implements SendMailService {

    @Autowired
    private JavaMailSender javaMailSender;

    private String from = "344@qq.com";

    private String to = "tar@126.com";

    private String subject = "测试邮件";

    private String context = "<a href='https://www.baidu.com'>点开有惊喜</a>";

    @Override
    public void sendMail() {
        try {
            MimeMessage message = javaMailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setFrom(from + "(小甜甜)");
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setText(context, true);

            File f1 = new File("D:\\hdc\\test.txt");
            File f2 = new File("D:\\hdc\\test2.txt");
            helper.addAttachment(f1.getName(), f1);
            helper.addAttachment(f2.getName(), f2);

            javaMailSender.send(message);
        } catch (MessagingException e) {
            throw new RuntimeException(e);
        }
    }
}

SendMailServiceImpl3.class

package com.example.springboot_23_mail.service.impl;

import com.example.springboot_23_mail.service.SendMailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;

import javax.mail.MessagingException;
import javax.mail.internet.MimeMessage;
import java.io.File;

@Service
public class SendMailServiceImpl3 implements SendMailService {

    @Autowired
    private JavaMailSender javaMailSender;

    private String to = "34@qq.com";

    private String from = "ter@126.com";

    private String subject = "测试邮件";

    private String context = "<a href='https://www.baidu.com'>点开有惊喜</a>";

    @Override
    public void sendMail() {
        try {
            MimeMessage message = javaMailSender.createMimeMessage();
            MimeMessageHelper helper = new MimeMessageHelper(message, true);
            helper.setFrom(from + "(小甜甜)");
            helper.setTo(to);
            helper.setSubject(subject);
            helper.setText(context, true);

            File f1 = new File("D:\\hdc\\test.txt");
            File f2 = new File("D:\\hdc\\test2.txt");
            helper.addAttachment(f1.getName(), f1);
            helper.addAttachment(f2.getName(), f2);

            javaMailSender.send(message);
        } catch (MessagingException e) {
            throw new RuntimeException(e);
        }
    }
}

application.yml

#spring:
#  mail:
#    username: 34864@qq.com
#    password: pndkzucx
#    host: smtp.qq.com

spring:
  mail:
    username: ter@126.com
    password: HESHJP
    host: smtp.126.com

9.消息简介

企业级应用中广泛使用的三种异步消息传递技术

  • JMS
  • AMQP
  • MQTT

JMS (Java Message Service):一个规范，等同于JDBC规范，提供了与消息服务相关的API接口JMS消息模型

  • peer-2-peer:点对点模型，消息发送到一个队列中，队列保存消息。队列的消息只能被一个消费者消费，或超时
  • publish-subscribe: 发布订阅模型，消息可以被多个消费者消费，生产者和消费者完全独立，不需要感知对方的存在

JMS消息种类

  • TextMessage
  • MapMessage
  • BytesMessage
  • StreamMessage
  • ObjectMessage.
  • Message(只有消息头和属性) 

JMS实现:ActiveMQ、Redis、HornetMQ、RabbitMQ、RocketMQ(没有完全遵守JMS规范)

AMQP 

  • AMQP(advanced message queuing protocol):一种协议（高级消息队列协议，也是消息代理规范)，规范了网络交换的数据格式，兼容JMS
  • 优点:具有跨平台性，服务器供应商，生产者，消费者可以使用不同的语言来实现
  • AMQP消息模型
    • direct exchange
    • fanout exchange
    • topic exchange
    • headers exchange
    • system exchange
  • AMQP消息种类: byte[]
  • AMQP实现:RabbitMQ.StormMQ..RocketMQ 

MQTT

MQTT(Message Queueing Telemetry Transport)）消息队列遥测传输，专为小设备设计，是物联网(IOT)生态系统中主要成分之一.

Kafka

  • Kafka，一种高吞吐量的分布式发布订阅消息系统，提供实时消息功能。

消息

  • ActiveMQ
  • RabbitMQ
  • RocketMQ
  • Kafka

10.购物订单案例-发送短信

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.17</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springboot_24_mq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_24_mq</name>
    <description>springboot_24_mq</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

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

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <image>
                        <builder>paketobuildpacks/builder-jammy-base:latest</builder>
                    </image>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

MessageController.class

package com.example.springboot_24_mq.controller;

import com.example.springboot_24_mq.service.MessageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/msgs")
public class MessageController {
    @Autowired
    private MessageService messageService;

    @GetMapping
    public String doMessage() {
        String id = messageService.doMessage();
        return id;
    }
}

OrderController.class

package com.example.springboot_24_mq.controller;

import com.example.springboot_24_mq.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/orders")
public class OrderController {
    @Autowired
    private OrderService orderService;

    @PostMapping("{id}")
    public void order(@PathVariable String id) {
        orderService.order(id);
    }
}

MessageServiceImpl.class

package com.example.springboot_24_mq.service.impl;

import com.example.springboot_24_mq.service.MessageService;
import org.springframework.stereotype.Service;

import java.util.ArrayList;

@Service
public class MessageServiceImpl implements MessageService {
    private ArrayList<String> msgList = new ArrayList<>();

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入待处理队列，id:" + id);
        msgList.add(id);
    }

    @Override
    public String doMessage() {
        String id = msgList.remove(0);
        System.out.println("已完成短信发送业务，id:" + id);
        return id;
    }
}

OrderServiceImpl.class

package com.example.springboot_24_mq.service.impl;

import com.example.springboot_24_mq.service.MessageService;
import org.springframework.stereotype.Service;

import java.util.ArrayList;

@Service
public class MessageServiceImpl implements MessageService {
    private ArrayList<String> msgList = new ArrayList<>();

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入待处理队列，id:" + id);
        msgList.add(id);
    }

    @Override
    public String doMessage() {
        String id = msgList.remove(0);
        System.out.println("已完成短信发送业务，id:" + id);
        return id;
    }
}

MessageService.interface

package com.example.springboot_24_mq.service;

public interface MessageService {
    void sendMessage(String id);

    String doMessage();

}

OrderService.interface

package com.example.springboot_24_mq.service;

public interface OrderService {
    void order(String id);

}

application.yml

server:
  port: 8080

11.ActiveMQ安装

  • 下载地址: https://activemq.apache.org/components/classic/download/
  • 安装:解压缩 

启动服务

访问服务器

服务端口:61616，管理后台端口:8161

用户名&密码:admin

12.springboot整合ActiveMQ

导入SpringBoot整合ActiveMQ坐标

配置ActiveMQ(采用默认配置) 

生产与消费消息（使用默认消息存储队列)

生产与消费消息(指定消息存储队列)

使用消息监听器对消息队列监听

流程性业务消息消费完转入下一个消息队列

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.17</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springboot_24_mq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_24_mq</name>
    <description>springboot_24_mq</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-activemq</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <image>
                        <builder>paketobuildpacks/builder-jammy-base:latest</builder>
                    </image>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

 application.yml

server:
  port: 8080


spring:
  activemq:
    broker-url: tcp://localhost:61616
  jms:
    template:
      default-destination: itheima

MessageListener.class

package com.example.springboot_24_mq.service.impl.activemq.listener;

import org.springframework.jms.annotation.JmsListener;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Component;

@Component
public class MessageListener {
    @JmsListener(destination = "order.queue.id")
    @SendTo("order.other.queue.id")
    public String receive(String id) {
        System.out.println("已完成短信发送业务，id:" + id);
        return "new:" + id;
    }
}

MessageServiceActivemqImpl.class

package com.example.springboot_24_mq.service.impl.activemq;

import com.example.springboot_24_mq.service.MessageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsMessagingTemplate;
import org.springframework.stereotype.Service;

import java.util.ArrayList;

@Service
public class MessageServiceActivemqImpl implements MessageService {
    @Autowired
    private JmsMessagingTemplate messagingTemplate;

    @Override
    public void sendMessage(String id) {
        System.out.println("待发送短信的订单已纳入待处理队列，id:" + id);
        messagingTemplate.convertAndSend("order.queue.id", id);
    }

    @Override
    public String doMessage() {
        String id = messagingTemplate.receiveAndConvert("order.queue.id", String.class);
        System.out.println("已完成短信发送业务，id:" + id);
        return id;
    }
}

13.RabbitMQ安装

  • RabbitMQ基于Erlang语言编写，需要安装Erlang
  • Erlang
  • 下载地址: https://www.erlang.org/downloads
  • 安装:一键傻瓜式安装，安装完毕需要重启，需要依赖Windows组件
  • 环境变量配置
    • ERLANG_HOME
    • PATH
  • 下载地址: https://rabbitmq.com/install-windows.html
  • 安装:一键傻瓜式安装

RabbitMQ

启动服务

关闭服务

查看服务状态

服务管理可视化(插件形式)

查看已安装的插件列表 

开启服务管理插件

访问服务器

服务端口:5672，管理后台端口:15672

用户名&密码:guest 

14.springboot整合RabbitMQ(direct模式)

配置RabbitMQ(采用默认配置)

定义消息队列(direct)

生产与消费消息(direct)

使用消息监听器对消息队列监听(direct)

使用多消息监听器对消息队列监听进行消息轮循处理(direct)

15. springboot整合RabbitMQ(topic模式)

定义消息队列(topic)

绑定键匹配规则

  • *(星号):用来表示—个单词，且该单词是必须出现的
  • #(井号):用来表示任意数量 

生产与消费消息(topic)

使用消息监听器对消息队列监听(topic)

16.RocketMQ安装

  • 下载地址: https://rocketmq.apache.org/
  • 安装:解压缩
    • 默认服务端口:9876
  • 环境变量配置
    • ROCKETMQ_HOME
    • PATH
    • NAMESRV_ADDR (建议) : 127.0.0.1:9876

命名服务器与broker

 

 

启动命名服务器

启动broker

服务器功能测试:生产者

服务器功能测试:消费者

17.springboot整合RockeMQ

 导入SpringBoot整合RocketMQ坐标

配置RocketMQ(采用默认配置) 

生产消息

 

生产异步消息

使用消息监听器对消息队列监听

 

18.Kafka安装

  • 下载地址: https://kafka.apache.org/downloads
  • windows系统下3.0.0版本存在BUG，建议使用2.X版本
  • 安装:解压缩 

启动zookeeper

默认端口:2181

启动kafka

默认端口:9092

创建topic

查看topic

册除topic

生产者功能测试

消费者功能测试

 

19.springboot整合Kafka 

导入SpringBoot整合Kafka坐标

配置Kafka(采用默认配置) 

生产消息

使用消息监听器对消息队列监听

 

20.监控的意义

  • 监控服务状态是否宕机
  • 监控服务运行指标(内存、虚拟机、线程、请求等)
  • 监控日志
  • 管理服务（服务下线)

监控的实施方式

  • 显示监控信息的服务器:用于获取服务信息，并显示对应的信息
  • 运行的服务:启动时主动上报，告知监控服务器自己需要受到监控 

 

21.SpringBootAdmin

可视化监控平台

  • Spring Boot Admin，开源社区项目，用于管理和监控SpringBoot应用程序。客户端注册到服务端后，通过HTTP请求方式，服务端定期从客户端获取对应的信息，并通过UIl界面展示对应信息。
  • Admin服务端 

 

Admin客户端

 

Admin服务端

 

Admin客户端

Admin服务端

 

设置启用Spring-Admin

Admin客户端

 

 

 22.actuator

  • Actuator提供了SpringBoot生产就绪功能，通过端点的配置与访问，获取端点信息
  • 端点描述了一组监控信息，SpringBoot提供了多个内置端点，也可以根据需要自定义端点信息
  • 访问当前应用所有端点信息:/actuator
  • 访问端点详细信息:/actuator/端点名称

ID

描述

默认启用

auditevents

暴露当前应用程序的审计事件信息。

是

beans

显示应用程序中所有 Spring bean 的完整列表。

是

caches

暴露可用的缓存。

是

conditions

显示在配置和自动配置类上评估的条件以及它们匹配或不匹配的原因。

是

configprops

显示所有 @ConfigurationProperties 的校对清单。

是

env

暴露 Spring ConfigurableEnvironment 中的属性。

是

flyway

显示已应用的 Flyway 数据库迁移。

是

health

显示应用程序健康信息

是

httptrace

显示 HTTP 追踪信息（默认情况下，最后 100 个 HTTP 请求/响应交换）。

是

info

显示应用程序信息。

是

integrationgraph

显示 Spring Integration 图。

是

 

ID

描述

默认启用

loggers

显示和修改应用程序中日志记录器的配置。

是

liquibase

显示已应用的 Liquibase 数据库迁移。

是

metrics

显示当前应用程序的指标度量信息。

是

mappings

显示所有 @RequestMapping 路径的整理清单。

是

scheduledtasks

显示应用程序中的调度任务。

是

sessions

允许从 Spring Session 支持的会话存储中检索和删除用户会话。当使用 Spring Session 的响应式 Web 应用程序支持时不可用。

是

shutdown

正常关闭应用程序。

否

threaddump

执行线程 dump。

是

Web程序专用端点

ID

描述

默认启用

heapdump

返回一个 hprof 堆 dump 文件。

是

jolokia

通过 HTTP 暴露 JMX bean（当 Jolokia 在 classpath 上时，不适用于 WebFlux）。

是

logfile

返回日志文件的内容（如果已设置 logging.file 或 logging.path 属性）。支持使用 HTTP Range 头来检索部分日志文件的内容。

是

prometheus

以可以由 Prometheus 服务器抓取的格式暴露指标。

是

启用指定端点

启用所有端点

暴露端点功能

  • 端点中包含的信息存在敏感信息，需要对外暴露端点功能时手动设定指定端点信息 

属性

默认

management.endpoints.jmx.exposure.exclude

management.endpoints.jmx.exposure.include

*

management.endpoints.web.exposure.exclude

management.endpoints.web.exposure.include

info, health

 

ID

JMX

Web

auditevents

是

否

beans

是

否

caches

是

否

conditions

是

否

configprops

是

否

env

是

否

flyway

是

否

health

是

是

heapdump

N/A

否

httptrace

是

否

info

是

是

ID

JMX

Web

integrationgraph

是

否

jolokia

N/A

否

logfile

N/A

否

loggers

是

否

liquibase

是

否

metrics

是

否

mappings

是

否

prometheus

N/A

否

scheduledtasks

是

否

sessions

是

否

shutdown

是

否

threaddump

是

否

23.info端点指标控制

为info端点添加自定义指标

24.health端点指标控制

为Health端点添加自定义指标

25.metrics端点指标控制

为Metrics端点添加自定义指标 

26.自定义端点 

自定义端点

 

阿瞒有我良计15
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
实用的jdbc连接clickhouse数据库，以及用阿里巴巴连接池管理连接
qq_36973384的博客
11-14 2474
【代码】实用的jdbc连接clickhouse数据库，以及用阿里巴巴连接池管理连接。
还用第三方Docker插件？SpringBoot官方插件真香
m0_63437643的博客
04-08 2282
为了方便为SpringBoot应用构建Docker镜像，我们经常会使用Maven插件来打包镜像。之前一直使用的是第三方插件，有spotify和fabric8出品的两种docker-maven-plugin。最近SpringBoot 2.4.0发布了，官方插件也增加了对Docker的支持，体验了一把发现也很好用，推荐给大家！ 第三方插件使用 我们先了解下第三方插件的使用，方便和官方插件做对比 值得注意的是，在我们使用插件时，需要自己定义镜像构建过程，比如在pom.xml中使用如下配置，<image
SpringBoot+Thymeleaf增删改查简单示例
gjxcool的博客
11-11 568
SpringBoot+Thymeleaf增删改查简单示例
SpringBoot : ch12 多模块配置YAML文件
zhiqiuqiu2的博客
11-29 1641
当您使用SpringBoot框架进行项目开发时，通常需要配置一些参数和属性。在实际开发中，可能需要将这些配置参数分成多个不同的YAML文件，并将它们组织到不同的模块中。这样可以方便管理和维护配置文件，并且可以避免配置文件的冲突。本文将为您介绍如何在SpringBoot多模块项目中配置YAML文件。并演示如何将配置文件组织到不同的模块中，以及如何在应用程序中读取和使用这些配置文件。
KubeSphere应用【五】发布镜像
Matrix
12-21 634
BindPort:前一个是服务器对外暴露端口（访问服务使用），后一个是容器端口。Dockerfile:选择上一步创建的Dockerfile文件。ContainerName：容器名称自定义。maven package:进行打包。ImageTag:镜像标签自定义。
Springboot整合JSP-修订版本(Springboot3.1.6+IDEA2022版本)
最新发布
雾林小妖的博客
12-29 1372
springboot整合JSP使用JSP模板引擎
黑马程序员——Android移动开发源码
04-29
黑马程序员——Android移动开发源码
SpringBoot基础篇--黑马
06-22
"SpringBoot基础篇--黑马" 本资源主要介绍了SpringBoot基础篇的课程大纲，旨在帮助学习者快速掌握SpringBoot技术。课程主要分为三个阶段：基础篇、应用篇和原理篇。 基础篇主要介绍了SpringBoot的基础知识，包括...
SpringBoot企业级开发教程教学大纲.pdf
06-23
《Spring Boot企业级开发教程》是一门针对计算机及相关专业学生的高级Java应用开发课程，旨在教授学生如何使用Spring Boot这一主流框架进行企业级项目开发。这门课程覆盖了Spring Boot的基础知识，集成第三方技术，...
黑马程序员入学Java知识——精华总结.doc
05-09
程序员编写代码，计算机执行这些代码，最终产生预期的结果。 2. **Java语言的特点**： - **简单性**：Java简化了C++的一些复杂特性，如指针，使得初学者更容易上手。 - **面向对象**：Java强调类和对象，支持封装...
黑马程序员Javase笔记
01-18
"黑马程序员Javase笔记"是一个自学者在学习黑马程序员提供的Java全套课程过程中整理的笔记，主要涵盖了Java Standard Edition (Javase) 的核心内容。下面将详细讨论其中的关键知识点。 首先，DOS命令是操作系统中的...
14.基于项目驱动快速上手SSM框架
qq_43303296的博客
11-12 65
SpringBoot可以提升我们的开发效率，把我们从传统的SSM项目的繁杂的依赖于配置文件/注解中解放出来。SpringBoot主要解决的是在微服务的架构下简化配置（有快速配置）、前后端分离、快速开发。Spring Initializer：spring项目的脚手架，直接给我们提供一个jar包，包含了我们所需的所有jar（根据之前人总结出来的），直接给我们一个空项目。屏蔽了比如用maven手动导入依赖的依赖冲突等问题。如下图，最重要的选择：我们可以根据自己的需求添加依赖。
Spring Boot 开发16个实用的技巧
canduecho的专栏
10-04 331
1. **使用Spring Initializr**：Spring Initializr是一个快速创建Spring Boot项目的工具，可以帮助您选择项目依赖和生成项目骨架。4. **使用Spring Boot Starter依赖**：Spring Boot Starter依赖简化了项目的依赖管理，它们是一组常见依赖的预配置集合。2. **自动配置**：Spring Boot提供了自动配置，根据项目的依赖自动配置应用程序，减少了配置的复杂性。
【SpringBoot3+Vue3】一【基础篇】
春天的波菜
11-13 5232
Spring Boot是Spring提供的一个子项目，用于快速构建Spring应用程序发送邮件为例@AutoConfiguration//表示当前类是一个自动配置类@Bean@Bean//扫描的包:启动类所在的包及其子包//扫描的注解。
SpringBoot : ch04 整合数据源
zhiqiuqiu2的博客
11-22 243
Spring Boot 是当今最流行的 Java 开发框架之一，它以简洁、高效的特点帮助开发者快速构建稳健的应用程序。在实际项目中，涉及到数据库操作的需求时，我们需要对数据源进行整合。本文将重点介绍如何在 Spring Boot 中整合数据源，以及如何利用 Spring Boot 的便利特性来简化这一过程。无论是传统的关系型数据库，还是当下流行的 NoSQL 数据库，Spring Boot 都提供了丰富的支持。
springboot最全，最完整，最适合小白教程（开发实用篇）
abjtxf的博客
08-21 1254
开发实用篇
SpringBoot开发小技巧
越努力越幸运的博客
09-08 1581
文章目录三、SpringBoot开发小技巧3.1 Lombok3.2 dev-tools3.3 Spring Initializr 三、SpringBoot开发小技巧 3.1 Lombok 作用：在程序编译的时候，自动帮我们生成setter和getter方法以及我们的toString方法和我们的全参和无参构造器等等。 那么，怎么用呢？很简单，用下边这四个注解就行了： 1、@Data：自动生成setter和getter方法。 2、@ToString：自动生成toString方法。 3、@AllArgsCons
这一篇就够了！全套SpringBoot教程02
思索的涟漪，突破自我
12-17 988
SpringBoot运维实用篇 基础篇发布以后，看到了很多小伙伴在网上的留言，也帮助超过100位小伙伴解决了一些遇到的问题，并且已经发现了部分问题具有典型性，预计将有些问题在后面篇章的合适位置添加到本套课程中，作为解决方案提供给大家。 ​ 从此刻开始，咱们就要进入到实用篇的学习了。实用篇是在基础篇的根基之上，补全SpringBoot的知识图谱。比如在基础篇中只给大家讲了yaml的语法格式，但是具体写yaml文件的时候还有很多实用开发过程中的坑，这些在实用篇中都要进行学习。 ​ 实用篇共分为两块内容，分别
14个SpringBoot优化小妙招，看完后同事说写代码像写诗！
09-14 145
作者：国涛i来源：blog.csdn.net/weixin_44912855/article/details/120866194每次聊到代码优化，都会有很多人说理论、架构、核心思路，其实我觉得代码优化这事说简单了很简单，说复杂了吧它也有一定的难度，但是我觉得有一个良好的编码习惯很重要，下面分享一下14个springboot项目中优化代码的小技巧，让代码优化跟容易，就像完成一件小事。1. 定义配置文...
黑马程序员springboot
07-27
你想了解关于黑马程序员的Spring Boot课程吗？黑马程序员是一家知名的IT教育机构，提供了丰富的技术培训课程。他们的Spring Boot课程主要针对Java开发者，旨在帮助学员快速掌握Spring Boot框架的使用。 在这门课程中，你可以学习到Spring Boot的基本概念、开发环境的搭建、项目结构的规范以及常用的核心组件和特性。课程内容涵盖了Spring Boot的自动配置、数据访问、Web开发、安全性等方面。 通过学习黑马程序员的Spring Boot课程，你将能够快速上手并熟练运用Spring Boot框架进行项目开发。这门课程结合了理论讲解和实际案例演示，帮助你更好地理解和应用所学知识。 如果你对黑马程序员的Spring Boot课程感兴趣，可以去他们的官方网站或者咨询他们的客服了解更多详情。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿瞒有我良计15

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值