在Spring Cloud中，开发者可以通过扩展Spring Boot应用程序来创建自己的中间件。以下是一个简单的示例，展示了如何创建一个自定义的Spring Cloud中间件。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 
@SpringBootApplication
@EnableDiscoveryClient
public class CustomMiddlewareApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(CustomMiddlewareApplication.class, args);
    }
 
}

在这个示例中，我们创建了一个简单的Spring Boot应用程序，并通过@EnableDiscoveryClient注解将其标记为一个Spring Cloud的服务发现客户端。这意味着它可以与Spring Cloud服务发现组件（如Eureka）集成，并且可以被服务发现组件管理。

要创建一个完整的中间件，你还需要添加必要的依赖和逻辑来处理网络请求，例如使用Spring Web模块来创建REST API。

<dependencies>
    <!-- Spring Web Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
 
    <!-- Spring Cloud Discovery Client -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>

在这个依赖中，我们添加了Spring Web Starter来支持HTTP请求处理，以及Spring Cloud的Eureka客户端来支持服务注册与发现。

最后，你需要实现自定义的业务逻辑，并通过REST控制器暴露这些功能。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class CustomMiddlewareController {
 
    @GetMapping("/custom-endpoint")
    public String customEndpoint() {
        // 实现自定义逻辑
        return "Custom Middleware Response";
    }
}

这个简单的示例展示了如何创建一个基于Spring Boot的自定义中间件，并且可以通过Spring Cloud服务发现组件进行管理。通过这个示例，开发者可以学习如何扩展Spring Cloud的功能，以满足特定的业务需求。

在Spring Cloud中，Sentinel的规则可以通过两种方式进行持久化：使用Sentinel控制台和将规则持久化到文件系统。

1. 使用Sentinel控制台：

Sentinel控制台是Sentinel提供的一个工具，用于远程管理和监控Sentinel保护的服务。规则可以通过Sentinel控制台实时推送到Sentinel客户端。

首先，需要在Spring Cloud项目中集成Sentinel控制台客户端，并配置好控制台的地址。

@Bean
public ServletRegistrationBean<Servlet> sentinelServlet() {
    return new ServletRegistrationBean<>(new SentinelWebServlet(), "/sentinel-dashboard/*");
}

然后，在application.properties或application.yml中配置控制台地址：

# Sentinel dashboard address
spring.cloud.sentinel.transport.dashboard=127.0.0.1:8080
# Sentinel transport configuration, default port is 8719(dashboard port) + 1
spring.cloud.sentinel.transport.port=8720

启动Spring Cloud应用和Sentinel控制台，然后通过Sentinel控制台即可远程管理和监控服务。

2. 将规则持久化到文件系统：

Sentinel支持将规则持久化到文件系统，比如本地文件系统或者Zookeeper等。

以本地文件系统为例，在application.properties或application.yml中配置：

# Sentinel rule file path
spring.cloud.sentinel.datasource.file.file=classpath:flowrule.json
# Polling interval for rule file checking
spring.cloud.sentinel.datasource.file.poll-interval=1000

在classpath下提供一个名为flowrule.json的规则配置文件，Sentinel会定期检查这个文件的变化，并加载新的规则。

以上两种方式均可以实现Sentinel规则的持久化，具体使用哪种方式取决于实际需求和部署环境。

"SpringBoot-餐饮业供应商管理系统-94116"是一个开源项目，可以作为计算机毕设的一个选择。该项目提供了一个简单的供应商管理系统的实现，使用Spring Boot框架开发。

要进行设置并运行此项目，请按照以下步骤操作：

1. 确保您的开发环境已安装Java和Spring Boot的相关依赖。
2. 从GitHub或其他源克隆或下载该项目的源代码。
3. 使用IDE（如IntelliJ IDEA或Eclipse）打开项目。
4. 在项目的src/main/resources目录下，找到application.properties或application.yml文件，根据需要配置数据库连接等属性。
5. 运行com.example.demosupplier.DemoSupplierApplication作为Spring Boot应用。
6. 应用启动后，通过浏览器或API测试工具访问应用提供的API接口。

项目中的代码结构清晰，注释丰富，可以作为学习Spring Boot和Web开发的良好示例。

需要注意的是，由于是学习项目，在进行修改时，应确保遵循原作品的许可协议，并在参考或引用时注明出处。

该系统主要功能包括：用户管理、疫苗接种管理、数据统计分析等。以下是部分核心代码示例：

1. 用户注册接口（UserController.java）：

@RestController
@RequestMapping("/user")
public class UserController {
 
    @Autowired
    private UserService userService;
 
    @PostMapping("/register")
    public Result register(@RequestBody User user) {
        return userService.register(user);
    }
}

2. 疫苗接种服务接口（VaccineService.java）：

@Service
public class VaccineService {
 
    @Autowired
    private VaccineRecordMapper vaccineRecordMapper;
 
    public Result recordVaccine(VaccineRecord vaccineRecord) {
        // 保存接种记录的逻辑
        vaccineRecordMapper.insert(vaccineRecord);
        return Result.success("接种记录保存成功");
    }
}

3. 统计接种数据接口（StatisticsController.java）：

@RestController
@RequestMapping("/statistics")
public class StatisticsController {
 
    @Autowired
    private StatisticsService statisticsService;
 
    @GetMapping("/vaccine")
    public Result getVaccineStatistics() {
        return statisticsService.getVaccineStatistics();
    }
}

这些代码示例展示了如何使用SpringBoot框架进行接口的定义和服务的调用。具体的业务逻辑需要根据实际需求进行实现。

在这个问题中，我们需要创建一个基于Spring Cloud和Vue.js的校园招聘系统，其中包含Eureka作为服务发现和注册的组件。

以下是一个简化的解决方案，包括核心的服务注册和发现逻辑：

Spring Cloud端

1. 创建Eureka服务注册中心：

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

2. 创建服务提供者并注册到Eureka：

@SpringBootApplication
@EnableEurekaClient
public class JobServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(JobServiceApplication.class, args);
    }
}

Vue.js端

1. 前端应用需要通过某种方式（例如API调用）获取服务列表。
2. 使用服务列表进行负载均衡的服务调用。

配置文件

application.properties（Eureka服务注册中心配置）:

spring.application.name=eureka-server
server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

application.properties（服务提供者配置）:

spring.application.name=job-service
server.port=8081
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

以上代码提供了服务注册中心和服务提供者的简单示例。在实际应用中，你需要根据具体的服务接口和需求来扩展和完善服务提供者的代码。

注意：这只是一个代码框架，你需要根据具体的需求来扩展和完善服务提供者的代码，以及在Vue.js前端应用中实现服务的调用和消费。

在Spring Boot中，要实现服务的分布式部署，通常需要以下步骤：

1. 确保你的应用程序可以在不同的服务器上运行。
2. 配置不同的环境配置，如数据库连接、端口号等。
3. 使用Spring Cloud进行服务注册与发现。
4. 负载均衡器等分布式解决方案来管理服务实例。

以下是一个简化的示例，展示如何在Spring Boot应用中使用Spring Cloud进行服务注册与发现：

pom.xml中添加Spring Cloud依赖

<dependencies>
    <!-- Spring Cloud -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <!-- 其他依赖 -->
</dependencies>
 
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

application.properties中配置Eureka服务器地址

spring.application.name=my-service
server.port=8080
 
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

启动类添加@EnableDiscoveryClient注解

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 
@SpringBootApplication
@EnableDiscoveryClient
public class MyServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyServiceApplication.class, args);
    }
}

以上代码展示了如何在Spring Boot应用中集成Eureka客户端，这样你的服务就可以注册到Eureka服务器上，并且可以被其他服务发现和调用。在实际部署时，你可能需要对这些示例进行更多的配置，比如配置不同的环境、负载均衡器的设置等。

import org.redisson.api.RedissonClient;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
 
@Component
public class DistributedScheduledTask {
 
    private final RedissonClient redissonClient;
 
    public DistributedScheduledTask(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }
 
    @Scheduled(fixedRate = 60000) // 每分钟执行一次
    public void scheduleTask() {
        // 使用Redisson提供的锁机制实现分布式锁
        RLock lock = redissonClient.getLock("scheduledTaskLock");
 
        try {
            // 尝试加锁，最多等待10秒，锁超时10秒自动释放
            if (lock.tryLock(10, 10, TimeUnit.SECONDS)) {
                // 加锁成功，执行任务逻辑
                System.out.println("执行定时任务...");
                // 这里放置定时任务的具体执行逻辑
            } else {
                System.out.println("无法获取锁，任务被跳过...");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            // 处理异常情况
        } finally {
            // 释放锁
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

这段代码使用了Redisson提供的RedLock机制来实现分布式锁，确保了即使在多实例的环境下，同一时间只有一个实例执行定时任务。这是一个简化的例子，实际应用中你需要将System.out.println替换为具体的业务逻辑，并处理好异常情况。

以下是一个使用Spring Cloud Alibaba的Eureka服务器示例代码：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
 
@SpringBootApplication
@EnableDiscoveryClient
public class EurekaServerApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

在application.properties或application.yml中，你需要配置应用名和Eureka服务器的地址：

spring.application.name=eureka-server
server.port=10086
 
eureka.instance.hostname=localhost
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.service-url.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/

这段代码创建了一个Eureka服务器，其他微服务可以通过指定的URL来注册和发现彼此。在这个例子中，Eureka服务器运行在本机的10086端口上。

在Spring Boot 3中，你可以使用Spring Cache和Ehcache 3来实现本地缓存，并结合Redis进行分布式缓存管理。以下是一个简化的例子：

1. 添加依赖到你的pom.xml：

<!-- Spring Boot Cache Abstraction -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
 
<!-- Ehcache 3 -->
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
</dependency>
 
<!-- Ehcache 3 for Spring Cache -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
 
<!-- Redis with Lettuce -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-lettuce</artifactId>
</dependency>
 
<!-- Redis for Spring Cache -->
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-redis</artifactId>
</dependency>

2. 配置application.properties或application.yml：

# Ehcache 3 configuration
spring.cache.jcache.config=classpath:ehcache3.xml
 
# Redis configuration
spring.redis.host=localhost
spring.redis.port=6379

3. 创建ehcache3.xml配置文件：

<config xmlns='http://www.ehcache.org/v3'>
    <service>
        <scheduler-mode>lightweight</scheduler-mode>
    </service>
    <cache-template name="default">
        <key-type>java.lang.String</key-type>
        <value-type>java.lang.Object</value-type>
        <heap unit="entries">2000</heap>
        <expiry>
            <ttl unit="minutes">10</ttl>
        </expiry>
        <swap-space-refill-percentage>90</swap-space-refill-percentage>
        <swap-space-max-size-mb>100</swap-space-max-size-mb>
    </cache-template>
    <cache alias="localCache" uses-template="default">
        <!-- Ehcache 3 specific configuration -->
    </cache>
</config>

4. 配置Ehcache和Redis缓存管理器：

@Configuration
@EnableCaching
public class CacheConfig {
 
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        EhCacheCacheManager ehCacheCacheManager = new EhCacheCacheManager(ehCacheManager());
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(determineRedisCacheConf

ShedLock 是一个用于协调分布式任务执行的工具，在 Spring Cloud Alibaba 中，我们可以使用 ShedLock 来确保定时任务在集群环境中仅被某个节点执行。

以下是一个使用 ShedLock 的简单示例：

1. 添加 Maven 依赖：

<dependency>
    <groupId>net.javacrumbs.shedlock</groupId>
    <artifactId>shedlock-spring</artifactId>
    <version>最新版本</version>
</dependency>
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
    <version>最新版本</version>
</dependency>

2. 配置 ShedLock：

@Configuration
public class ShedLockConfig {
 
    @Bean
    public LockProvider lockProvider(String dataIdPrefix) {
        return new NacosLockProvider(dataIdPrefix);
    }
 
    @Bean
    public ScheduledLockConfiguration scheduledLockConfiguration(LockProvider lockProvider) {
        return ScheduledLockConfigurationBuilder.withLockProvider(lockProvider)
                .withPoolSize(10)
                .build();
    }
}

3. 使用 ShedLock 注解：

@Component
public class SampleTask {
 
    @ScheduledLock(name = "scheduledTaskName", lockAtMostFor = "30s", lockAtLeastFor = "20s")
    @Scheduled(fixedRate = 60000)
    public void executeTask() {
        // 任务逻辑
    }
}

在这个例子中，我们定义了一个定时任务 executeTask()，并使用 @ScheduledLock 注解来确保在同一时间只有一个节点执行这个任务。任务执行的锁是通过 Nacos 作为后端存储进行协调的。

请注意，示例中的 dataIdPrefix 应该是 Nacos 中用于存储锁信息的 dataId 前缀，确保与 Nacos 配置中心集成时使用相同的前缀。

以上代码仅为示例，实际使用时需要根据具体环境进行调整，例如配置 Nacos 的服务地址、命名空间等。