Spring Cloud是一系列框架的有序集合，它提供了配置管理、服务发现、断路器、智能路由、微代理、控制总线等微服务开发的必须解决方案。

以下是Spring Cloud的核心组件及其功能简述：

1. Spring Cloud Config：配置管理工具，使用版本控制系统存储配置信息，可以方便的管理不同环境下的配置。
2. Spring Cloud Netflix Eureka：服务发现工具，提供了完整的服务注册和发现支持。
3. Spring Cloud Netflix Hystrix：断路器工具，提供了断路器的功能，能帮助防止系统雪崩。
4. Spring Cloud Netflix Zuul：智能路由工具，提供了智能路由、负载均衡等功能。
5. Spring Cloud Netflix Archaius：配置管理工具，提供配置管理功能。
6. Spring Cloud Sleuth：日志收集工具，提供了日志收集、跟踪等功能。
7. Spring Cloud Data Flow：数据流工具，提供了数据流的开发、部署和运维的一体化解决方案。

以下是Spring Cloud的核心组件的简单使用示例：

Eureka Server 示例:

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

Eureka Client 示例:

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

Hystrix 示例:

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

Zuul 示例:

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

以上代码仅展示了如何在Spring Boot应用中启用Spring Cloud的核心组件。在实际应用中，还需要配置相应的参数，并且根据具体的业务逻辑进行编码。

Nacos 配置中心是一种在系统开发过程中应用的配置管理方式，它可以帮助开发者集中管理应用的配置信息，并且可以快速地对配置信息进行修改和发布。

在 Nacos 中，配置中心的使用主要包括以下几个步骤：

1. 引入 Nacos 配置中心的依赖
2. 在 Nacos 控制台进行配置信息的添加和修改
3. 在应用中加载 Nacos 配置中心的配置信息
4. 动态获取和监听 Nacos 配置中心的配置信息变化

以下是一个使用 Nacos 配置中心的 Java 示例代码：

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.exception.NacosException;
 
public class NacosConfigExample {
 
    public static void main(String[] args) throws NacosException {
        // 设置 Nacos 服务器地址
        String serverAddr = "127.0.0.1";
        // 设置配置项的数据 ID 和组名
        String dataId = "example";
        String group = "DEFAULT_GROUP";
 
        // 获取配置服务
        ConfigService configService = NacosFactory.createConfigService(serverAddr);
 
        // 获取配置
        String content = configService.getConfig(dataId, group, 5000);
        System.out.println("配置信息：" + content);
 
        // 监听配置变化
        configService.addListener(dataId, group, new Listener() {
            @Override
            public void receiveConfigInfo(String configInfo) {
                System.out.println("最新配置信息：" + configInfo);
            }
 
            @Override
            public Executor getExecutor() {
                return null;
            }
        });
    }
}

在这个示例中，我们首先设置了 Nacos 服务器的地址，然后定义了配置项的数据 ID 和组名。接着，我们通过 NacosFactory 创建了 ConfigService 对象，并使用它来获取配置信息。最后，我们添加了一个监听器来监听配置信息的变化。

需要注意的是，在实际的应用中，你需要确保 Nacos 服务器已经正确部署并且运行在指定的地址上，同时你需要在 Nacos 控制台进行相应的配置信息设置。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
 
@SpringBootApplication
@EnableScheduling
public class Application {
 
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
 
    @Configuration
    public class SchedulerConfig {
 
        @Bean
        public SchedulerTask schedulerTask() {
            return new SchedulerTask();
        }
    }
 
    public static class SchedulerTask {
 
        private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
 
        @Scheduled(fixedRate = 5000)
        public void reportCurrentTime() {
            System.out.println("现在时间是：" + dateFormat.format(new Date()));
        }
    }
}

这个代码示例展示了如何在Spring Boot应用程序中配置一个简单的定时任务。@Scheduled(fixedRate = 5000)注解用于设置定时任务的执行频率，这里设定为每5秒钟执行一次。SchedulerTask类中的reportCurrentTime方法将会按照这个频率打印当前时间。这个例子简单直观，易于理解和使用，同时展示了Spring Boot的定时任务调度功能。

由于篇幅所限，以下仅展示了如何使用Spring Boot创建一个简单的RESTful API服务，用于对接医疗药品管理系统的部分功能。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@SpringBootApplication
public class DrugManagementSystemApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(DrugManagementSystemApplication.class, args);
    }
}
 
@RestController
class DrugController {
 
    // 模拟查询药品信息
    @GetMapping("/drugs")
    public String getDrugs() {
        // 实际应用中，这里会调用MyBatis的mapper方法查询数据库
        return "drug_info_list";
    }
 
    // 模拟新增药品信息
    @GetMapping("/drugs/add")
    public String addDrug() {
        // 实际应用中，这里会接收前端传来的药品信息，并调用MyBatis的mapper方法保存到数据库
        return "drug_added";
    }
 
    // 模拟删除药品信息
    @GetMapping("/drugs/delete")
    public String deleteDrug() {
        // 实际应用中，这里会接收前端传来的药品ID，并调用MyBatis的mapper方法从数据库删除记录
        return "drug_deleted";
    }
 
    // 模拟更新药品信息
    @GetMapping("/drugs/update")
    public String updateDrug() {
        // 实际应用中，这里会接收前端传来的药品信息，并调用MyBatis的mapper方法更新数据库中的记录
        return "drug_updated";
    }
}

在这个简化的代码示例中，我们创建了一个Spring Boot应用程序，并定义了一个RESTful控制器DrugController，它提供了查询、添加、删除和更新药品信息的模拟接口。在实际的应用中，这些接口会与MyBatis的Mapper接口配合，实现对MySQL数据库中药品信息的持久化操作。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class LoggingApplication {
 
    private static final Logger logger = LoggerFactory.getLogger(LoggingApplication.class);
 
    public static void main(String[] args) {
        SpringApplication.run(LoggingApplication.class, args);
 
        logger.info("Spring Boot应用启动完毕，开始记录日志...");
        // 在此处进行其他操作...
    }
}

这段代码演示了如何在Spring Boot应用程序中使用SLF4j记录日志。首先，我们通过LoggerFactory获取一个Logger实例。在应用启动的main方法中，我们通过调用info方法记录了一条启动完毕的信息。这是一个简单的日志记录示例，实际应用中可以根据需要记录不同级别的日志信息。

在Spring Boot中，除了@Autowired注解之外，还有其他几种注入Bean的方式：

1. 使用@Inject注解（来自Java EE），这与@Autowired类似，但是提供了更大的灵活性，例如可以指定注入的范围和依赖的类型。
2. 使用@Resource注解，这也是来自Java EE，但它通常根据名称而不是类型进行注入。
3. 使用ApplicationContext获取Bean，这种方式适用于非注入式的用法，例如在方法中直接获取Bean。

以下是使用@Inject和@Resource的例子：

import javax.inject.Inject;
import javax.annotation.Resource;
 
public class MyService {
 
    // 使用@Inject
    @Inject
    private MyDependency myDependency;
 
    // 使用@Resource
    @Resource
    private MyDependency myDependency2;
 
    // ...
}

使用ApplicationContext的例子：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
 
@Service
public class MyService {
 
    private final ApplicationContext context;
 
    @Autowired
    public MyService(ApplicationContext context) {
        this.context = context;
    }
 
    public MyDependency getMyDependency() {
        return context.getBean(MyDependency.class);
    }
 
    // ...
}

请注意，@Inject和@Resource需要在类路径中有相应的依赖项，而ApplicationContext方法则需要一个已经配置好的Spring ApplicationContext实例。

解决IDEA中Tomcat日志乱码的问题，通常需要调整Tomcat的日志编码配置。

1. 打开IDEA的Tomcat配置。
2. 找到“Run/Debug Configurations”。
3. 选择你的Tomcat服务器。
4. 在"VM options"中添加-Dfile.encoding=UTF-8参数。
5. 应用并保存配置。
6. 重启Tomcat服务。

如果上述方法不奏效，可能需要检查IDEA的日志文件编码设置，在IDEA中：

1. 打开Settings/Preferences。
2. 搜索 "File Encodings"。
3. 确保"Global Encoding"和"Project Encoding"都设置为UTF-8。
4. 检查"Default encoding for properties files"是否设置正确。

此外，如果你直接运行Tomcat而不是通过IDEA，你可能需要在Tomcat的启动脚本中设置JVM的编码参数。

如果以上方法均不可行，可能需要检查你的操作系统或IDEA的控制台默认编码设置，确保它们支持UTF-8编码。

import com.google.protobuf.InvalidProtocolBufferException;
import com.googlecode.protobuf.format.JsonFormat;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class ProtobufController {
 
    // 将Protobuf转换为JSON的接口
    @GetMapping("/protobuf/to/json")
    public String protobufToJson() throws InvalidProtocolBufferException {
        // 假设已有的Protobuf消息对象
        com.example.demo.UserOuterClass.User userProto = ...;
        // 使用JsonFormat将Protobuf转换为JSON字符串
        return JsonFormat.printToString(userProto);
    }
 
    // 将JSON转换为Protobuf的接口
    @GetMapping("/json/to/protobuf")
    public com.example.demo.UserOuterClass.User jsonToProtobuf(String json)
            throws InvalidProtocolBufferException {
        // 使用JsonFormat将JSON字符串转换为Protobuf消息对象
        com.example.demo.UserOuterClass.User.Builder userBuilder = com.example.demo.UserOuterClass.User.newBuilder();
        JsonFormat.merge(json, userBuilder);
        return userBuilder.build();
    }
}

这个简单的Spring Boot控制器类提供了两个接口，分别用于将Protobuf消息转换为JSON和将JSON转换为Protobuf消息。这个例子假设你已经有了一个Protobuf的.proto文件，并生成了相应的Java类。在实际应用中，你需要替换...处的代码，以实现具体的Protobuf消息实例化和转换逻辑。

由于篇幅限制，这里提供一个简化的Spring Boot项目的核心代码示例。

// 导入Spring Boot的核心注解和MVC注解
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.web.bind.annotation.*;
 
// 标记这是一个Spring Boot应用
@SpringBootApplication
public class HelloWorldApplication {
 
    // 主函数，Spring Boot应用的入口
    public static void main(String[] args) {
        SpringApplication.run(HelloWorldApplication.class, args);
    }
}
 
// 创建一个控制器，用于处理Web请求
@RestController
public class HelloController {
 
    // 映射一个HTTP GET请求到index()方法
    @GetMapping("/")
    public String index() {
        return "Hello, Spring Boot!";
    }
}

这个简单的Spring Boot应用程序定义了一个REST控制器，它处理根URL的GET请求，并响应一个简单的“Hello, Spring Boot!”消息。这个示例展示了如何使用Spring Boot创建一个基本的Web服务。

import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.context.ContextUtil;
 
// 配置限流规则
private static void initFlowRules(){
    List<FlowRule> rules = new ArrayList<>();
    FlowRule rule = new FlowRule();
    rule.setResource(KEY);
    rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    // 设置限流阈值类型为QPS，每秒允许通过的请求数为1
    rule.setCount(1);
    rules.add(rule);
    FlowRuleManager.loadRules(rules);
}
 
public static void main(String[] args) {
    // 初始化限流规则
    initFlowRules();
 
    // 通过SphU.entry("key")进入资源，如果被限流，则抛出BlockException异常
    while (true) {
        Entry entry = null;
        try {
            entry = SphU.entry(KEY);
            // 被保护的代码
            System.out.println("Hello, Sentinel!");
        } catch (BlockException e) {
            // 处理被限流后的逻辑
            System.out.println("Blocked!");
        } finally {
            // 确保entry可以正常exit
            if (entry != null) {
                entry.exit();
            }
        }
        // 每隔1秒钟执行一次
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

这段代码展示了如何使用Sentinel进行限流。首先，我们配置了一个限流规则，设置了资源名称（KEY）和限流阈值。接着，在一个无限循环中，我们通过调用SphU.entry(KEY)来访问资源，如果请求被限流，会抛出BlockException异常。我们捕获这个异常并打印相关信息，然后继续循环。这个例子简单地展示了如何使用Sentinel进行限流，实际应用中可能需要根据具体情况调整限流策略和异常处理逻辑。