SpringBoot實現(xiàn)本地與遠程方法調(diào)用的無縫切換
更新時間：2025年06月27日 08:15:46 作者：風象南
如何能在不修改大量業(yè)務代碼的情況下,實現(xiàn)從本地方法調(diào)用到遠程方法調(diào)用（RPC）的平滑切換呢,下面小編就來和大家分享一種方法,希望對大家有所幫助
一、引言
公司業(yè)務發(fā)展過程中，前期一般需要快速實現(xiàn)產(chǎn)品的MVP版本，用于市場驗證。
此時選擇單體架構(gòu)有助于快速完成MVP版本的功能開發(fā)，降低前期的投入成本。
但往往我們又需要考慮未來如果業(yè)務發(fā)展起來，用戶數(shù)、訪問量等快速增長的情況下，如何能讓單體架構(gòu)又快速切換到微服務架構(gòu)以很好的支撐產(chǎn)品的正常運行。
在將單體架構(gòu)切換為微服務架構(gòu)的過程中，存在一個關(guān)鍵問題就是將原來的本地調(diào)用需要切換為遠程調(diào)用。如果前期實現(xiàn)未預留相關(guān)切換機制，這個過程勢必會存在大量的代碼修改甚至重寫。
那么如何能在不修改大量業(yè)務代碼的情況下，實現(xiàn)從本地方法調(diào)用到遠程方法調(diào)用（RPC）的平滑切換？
本文將分享一種實現(xiàn)方案，能夠以統(tǒng)一的方式編寫代碼，而無需關(guān)心底層是本地方法調(diào)用還是遠程服務調(diào)用，通過配置即可實現(xiàn)方法調(diào)用的平滑切換。
二、技術(shù)背景
在深入討論實現(xiàn)方案前，我們先了解一下相關(guān)的技術(shù)概念：
本地調(diào)用：在同一個JVM內(nèi)，直接通過方法調(diào)用實現(xiàn)，性能高，無網(wǎng)絡開銷
遠程調(diào)用：跨JVM、跨網(wǎng)絡的服務調(diào)用，涉及序列化/反序列化、網(wǎng)絡傳輸?shù)?，有性能損耗
三、設計思路
實現(xiàn)本地遠程方法調(diào)用的無縫切換，核心思路是設計一個統(tǒng)一的抽象層，該層能夠：
- 1. 提供統(tǒng)一的API接口
- 2. 根據(jù)配置或運行環(huán)境決定使用本地實現(xiàn)還是遠程調(diào)用
- 3. 對上層業(yè)務代碼透明，無需修改業(yè)務邏輯
基于這一思路，我們可以設計如下幾個關(guān)鍵組件
- 統(tǒng)一服務接口：定義業(yè)務服務的API
- 本地實現(xiàn)類：接口的本地具體實現(xiàn)
- 遠程代理類：通過Feign等技術(shù)實現(xiàn)的遠程調(diào)用代理
- 自動配置：基于SpringBoot的自動配置機制實現(xiàn)動態(tài)切換
四、實現(xiàn)方案
4.1 定義統(tǒng)一服務接口
首先，我們需要定義服務接口。這些接口將同時作為本地實現(xiàn)和遠程調(diào)用的契約。
// 用戶服務接口
public interface UserService {
User getUserById(Long id);
List<User> getAllUsers();
User createUser(User user);
void updateUser(User user);
void deleteUser(Long id);
}
4.2 創(chuàng)建本地實現(xiàn)
為服務接口提供本地實現(xiàn)：
@Service
@ConditionalOnProperty(name = "service.mode", havingValue = "local", matchIfMissing = true)
public class UserServiceLocalImpl implements UserService {
@Autowired
private UserRepository userRepository;
@Override
public User getUserById(Long id) {
return userRepository.findById(id).orElse(null);
}
@Override
public List<User> getAllUsers() {
return userRepository.findAll();
}
@Override
public User createUser(User user) {
return userRepository.save(user);
}
@Override
public void updateUser(User user) {
userRepository.save(user);
}
@Override
public void deleteUser(Long id) {
userRepository.deleteById(id);
}
}
4.3 定義遠程接口
使用OpenFeign定義遠程調(diào)用接口：
@FeignClient(name = "user-service", fallback = UserServiceFallback.class)
public interface UserServiceFeignClient {
@GetMapping("/api/users/{id}")
User getUserById(@PathVariable("id") Long id);
@GetMapping("/api/users")
List<User> getAllUsers();
@PostMapping("/api/users")
User createUser(@RequestBody User user);
@PutMapping("/api/users")
void updateUser(@RequestBody User user);
@DeleteMapping("/api/users/{id}")
void deleteUser(@PathVariable("id") Long id);
}
4.4 創(chuàng)建遠程實現(xiàn)代理
將Feign客戶端封裝為符合服務接口的實現(xiàn)：
@Service
@ConditionalOnProperty(name = "service.mode", havingValue = "remote")
public class UserServiceRemoteImpl implements UserService {
@Autowired
private UserServiceFeignClient feignClient;
@Override
public User getUserById(Long id) {
return feignClient.getUserById(id);
}
@Override
public List<User> getAllUsers() {
return feignClient.getAllUsers();
}
@Override
public User createUser(User user) {
return feignClient.createUser(user);
}
@Override
public void updateUser(User user) {
feignClient.updateUser(user);
}
@Override
public void deleteUser(Long id) {
feignClient.deleteUser(id);
}
}
4.5 配置類
創(chuàng)建自動配置類，根據(jù)配置選擇合適的實現(xiàn)：
@Configuration
@EnableFeignClients(basePackages = "com.example.service.feign")
public class ServiceConfiguration {
@Bean
@ConditionalOnProperty(name = "service.mode", havingValue = "remote")
public UserService userServiceRemote(UserServiceFeignClient feignClient) {
return new UserServiceRemoteImpl(feignClient);
}
@Bean
@ConditionalOnProperty(name = "service.mode", havingValue = "local", matchIfMissing = true)
public UserService userServiceLocal(UserRepository userRepository) {
return new UserServiceLocalImpl(userRepository);
}
}
4.6 實現(xiàn)動態(tài)切換
通過配置屬性實現(xiàn)動態(tài)切換：
# application.yml service: mode: local # 可選值: local, remote
業(yè)務代碼中的使用方式保持一致：
@Service
public class UserBusinessService {
@Autowired
private UserService userService; // 自動注入適合的實現(xiàn)
public void processUser(Long userId) {
User user = userService.getUserById(userId);
// 處理用戶數(shù)據(jù)...
}
}
五、進階實現(xiàn)
5.1 混合模式
在某些場景下，我們可能希望部分服務使用本地調(diào)用，部分服務使用遠程調(diào)用。這可以通過更細粒度的配置實現(xiàn)：
service: user: local order: remote product: local
然后調(diào)整條件配置：
@ConditionalOnProperty(name = "service.user", havingValue = "local", matchIfMissing = true)
public class UserServiceLocalImpl implements UserService {
// ...
}
@ConditionalOnProperty(name = "service.user", havingValue = "remote")
public class UserServiceRemoteImpl implements UserService {
// ...
}
5.2 利用AOP實現(xiàn)智能路由
我們可以使用AOP實現(xiàn)更智能的路由策略，例如根據(jù)負載、性能等因素動態(tài)決定是使用本地調(diào)用還是遠程調(diào)用：
/**
* 標記支持智能路由的方法，會根據(jù)負載情況自動選擇本地或遠程執(zhí)行
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface SmartRouting {
/**
* 是否啟用智能路由，默認為true
*/
boolean enabled() default true;
/**
* 指定遠程服務名，如果為空則自動推斷
*/
String serviceName() default "";
}
@Aspect
@Component
public class SmartRoutingAspect {
private static final Logger logger = LoggerFactory.getLogger(SmartRoutingAspect.class);
@Autowired
private SmartLoadBalancingService loadBalancingService;
@Autowired
private ApplicationContext applicationContext;
@Around("@annotation(com.example.annotation.SmartRouting) || @within(com.example.annotation.SmartRouting)")
public Object routeService(ProceedingJoinPoint joinPoint) throws Throwable {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
// 獲取方法或類上的注解
SmartRouting annotation = method.getAnnotation(SmartRouting.class);
if (annotation == null) {
annotation = method.getDeclaringClass().getAnnotation(SmartRouting.class);
}
// 如果注解被禁用，直接本地執(zhí)行
if (annotation != null && !annotation.enabled()) {
return joinPoint.proceed();
}
long startTime = System.currentTimeMillis();
boolean isLocal = loadBalancingService.shouldRouteLocally(method);
boolean success = true;
try {
Object result;
if (isLocal) {
// 本地執(zhí)行
logger.debug("Executing locally: {}", method.getName());
result = joinPoint.proceed();
} else {
// 遠程執(zhí)行
logger.debug("Routing to remote service: {}", method.getName());
String serviceName = getServiceName(method, annotation);
result = invokeRemoteService(method, joinPoint.getArgs(), serviceName);
}
return result;
} catch (Throwable t) {
success = false;
throw t;
} finally {
long executionTime = System.currentTimeMillis() - startTime;
loadBalancingService.recordExecution(method, isLocal, executionTime, success);
}
}
private String getServiceName(Method method, SmartRouting annotation) {
if (annotation != null && !annotation.serviceName().isEmpty()) {
return annotation.serviceName();
}
// 從方法所在類名推斷服務名
String className = method.getDeclaringClass().getSimpleName();
return className.replaceAll("Service$", "")
.replaceAll("([a-z])([A-Z])", "$1-$2")
.toLowerCase();
}
private Object invokeRemoteService(Method method, Object[] args, String serviceName) throws Throwable {
// 查找對應服務的Feign客戶端
Class<?> interfaceClass = method.getDeclaringClass();
String feignClientName = interfaceClass.getName() + "FeignClient";
try {
// 嘗試直接按名稱查找
Object feignClient = applicationContext.getBean(feignClientName);
return method.invoke(feignClient, args);
} catch (Exception e) {
// 如果按名稱找不到，嘗試按類型查找
try {
Class<?> feignClientClass = Class.forName(feignClientName);
Object feignClient = applicationContext.getBean(feignClientClass);
return method.invoke(feignClient, args);
} catch (Exception ex) {
logger.error("Failed to find or invoke remote service: {}", serviceName, ex);
throw new RuntimeException("Remote service invocation failed", ex);
}
}
}
}
/**
* 智能負載均衡服務實現(xiàn)
* 基于方法調(diào)用的性能指標和系統(tǒng)負載狀態(tài)做出路由決策
*/
@Service
public class SmartLoadBalancingService {
private static final Logger logger = LoggerFactory.getLogger(SmartLoadBalancingService.class);
// 方法執(zhí)行統(tǒng)計數(shù)據(jù)
private static class MethodStats {
final AtomicInteger localCallCount = new AtomicInteger(0);
final AtomicInteger remoteCallCount = new AtomicInteger(0);
final AtomicLong localTotalTimeMs = new AtomicLong(0);
final AtomicLong remoteTotalTimeMs = new AtomicLong(0);
final AtomicInteger localErrorCount = new AtomicInteger(0);
final AtomicInteger remoteErrorCount = new AtomicInteger(0);
// 獲取本地平均執(zhí)行時間
double getLocalAvgTimeMs() {
int count = localCallCount.get();
return count > 0 ? (double) localTotalTimeMs.get() / count : 0;
}
// 獲取遠程平均執(zhí)行時間
double getRemoteAvgTimeMs() {
int count = remoteCallCount.get();
return count > 0 ? (double) remoteTotalTimeMs.get() / count : 0;
}
// 獲取本地錯誤率
double getLocalErrorRate() {
int count = localCallCount.get();
return count > 0 ? (double) localErrorCount.get() / count : 0;
}
// 獲取遠程錯誤率
double getRemoteErrorRate() {
int count = remoteCallCount.get();
return count > 0 ? (double) remoteErrorCount.get() / count : 0;
}
}
// 每個方法的統(tǒng)計數(shù)據(jù)
private final Map<String, MethodStats> methodStatsMap = new ConcurrentHashMap<>();
// 系統(tǒng)負載指標
private volatile double systemLoadAverage = 0.0;
private volatile int availableProcessors = Runtime.getRuntime().availableProcessors();
@Autowired(required = false)
private DiscoveryClient discoveryClient;
// 配置參數(shù)
@Value("${loadbalancing.local-threshold:0.7}")
private double localThreshold;
@Value("${loadbalancing.performance-weight:0.6}")
private double performanceWeight;
@Value("${loadbalancing.error-weight:0.3}")
private double errorWeight;
@Value("${loadbalancing.load-weight:0.1}")
private double loadWeight;
@Value("${loadbalancing.remote-services-enabled:true}")
private boolean remoteServicesEnabled;
@PostConstruct
public void init() {
logger.info("Smart load balancing service initialized with local-threshold={}, " +
"performance-weight={}, error-weight={}, load-weight={}",
localThreshold, performanceWeight, errorWeight, loadWeight);
}
@Override
public boolean shouldRouteLocally(Method method) {
if (!remoteServicesEnabled) {
return true; // 如果遠程服務被禁用，總是本地執(zhí)行
}
// 檢查遠程服務是否可用
if (!isRemoteServiceAvailable(method)) {
return true; // 遠程服務不可用，使用本地執(zhí)行
}
String methodKey = getMethodKey(method);
MethodStats stats = methodStatsMap.computeIfAbsent(methodKey, k -> new MethodStats());
// 如果沒有足夠的統(tǒng)計數(shù)據(jù)，交替使用本地和遠程
if (stats.localCallCount.get() < 10 || stats.remoteCallCount.get() < 10) {
return stats.localCallCount.get() <= stats.remoteCallCount.get();
}
// 計算決策得分，得分越高越傾向于本地執(zhí)行
double score = calculateRoutingScore(stats);
// 記錄決策過程
logger.debug("Routing decision for {}: score={}, threshold={}, route={}",
methodKey, score, localThreshold, score >= localThreshold ? "local" : "remote");
return score >= localThreshold;
}
@Override
public void recordExecution(Method method, boolean isLocal, long executionTimeMs, boolean success) {
String methodKey = getMethodKey(method);
MethodStats stats = methodStatsMap.computeIfAbsent(methodKey, k -> new MethodStats());
if (isLocal) {
stats.localCallCount.incrementAndGet();
stats.localTotalTimeMs.addAndGet(executionTimeMs);
if (!success) {
stats.localErrorCount.incrementAndGet();
}
} else {
stats.remoteCallCount.incrementAndGet();
stats.remoteTotalTimeMs.addAndGet(executionTimeMs);
if (!success) {
stats.remoteErrorCount.incrementAndGet();
}
}
// 記錄詳細統(tǒng)計數(shù)據(jù)（可用于監(jiān)控）
logger.debug("Execution recorded: method={}, local={}, time={}ms, success={}",
methodKey, isLocal, executionTimeMs, success);
}
/**
* 計算路由決策得分
*
* @param stats 方法統(tǒng)計數(shù)據(jù)
* @return 得分，范圍0-1，越高越傾向于本地執(zhí)行
*/
private double calculateRoutingScore(MethodStats stats) {
// 性能因素（本地更快得分更高）
double localAvgTime = stats.getLocalAvgTimeMs();
double remoteAvgTime = stats.getRemoteAvgTimeMs();
double performanceScore;
if (localAvgTime <= 0 || remoteAvgTime <= 0) {
performanceScore = 0.5; // 數(shù)據(jù)不足時取中間值
} else {
// 歸一化處理，確保分數(shù)在0-1之間
performanceScore = remoteAvgTime / (localAvgTime + remoteAvgTime);
}
// 錯誤率因素（本地錯誤率低得分更高）
double localErrorRate = stats.getLocalErrorRate();
double remoteErrorRate = stats.getRemoteErrorRate();
double errorScore = 0.5;
if (localErrorRate > 0 || remoteErrorRate > 0) {
double totalErrorRate = localErrorRate + remoteErrorRate;
if (totalErrorRate > 0) {
errorScore = 1 - (localErrorRate / totalErrorRate);
}
}
// 系統(tǒng)負載因素（負載高時傾向于遠程執(zhí)行）
double loadScore = 1.0 - Math.min(1.0, systemLoadAverage / availableProcessors);
// 綜合得分（加權(quán)平均）
return performanceScore * performanceWeight +
errorScore * errorWeight +
loadScore * loadWeight;
}
/**
* 定期更新系統(tǒng)負載信息
*/
@Scheduled(fixedRate = 10000) // 每10秒更新一次
public void updateSystemLoad() {
try {
java.lang.management.OperatingSystemMXBean osBean =
java.lang.management.ManagementFactory.getOperatingSystemMXBean();
if (osBean instanceof com.sun.management.OperatingSystemMXBean) {
com.sun.management.OperatingSystemMXBean sunOsBean =
(com.sun.management.OperatingSystemMXBean) osBean;
systemLoadAverage = sunOsBean.getSystemLoadAverage();
availableProcessors = osBean.getAvailableProcessors();
logger.debug("System load updated: load={}, processors={}",
systemLoadAverage, availableProcessors);
}
} catch (Exception e) {
logger.warn("Failed to update system load", e);
}
}
/**
* 檢查遠程服務是否可用
*/
private boolean isRemoteServiceAvailable(Method method) {
if (discoveryClient == null) {
return true; // 沒有服務發(fā)現(xiàn)客戶端，假設服務可用
}
// 從方法所在類或包名推斷服務名
String serviceName = inferServiceName(method);
List<ServiceInstance> instances = discoveryClient.getInstances(serviceName);
boolean available = !instances.isEmpty();
if (!available) {
logger.warn("Remote service {} is not available", serviceName);
}
return available;
}
/**
* 從方法推斷服務名
*/
private String inferServiceName(Method method) {
// 簡單示例：從類名推斷服務名
// 實際實現(xiàn)可能需要更復雜的邏輯或配置
String className = method.getDeclaringClass().getSimpleName();
// 去掉"Service"后綴并轉(zhuǎn)換為小寫短橫線格式
return className.replaceAll("Service$", "")
.replaceAll("([a-z])([A-Z])", "$1-$2")
.toLowerCase();
}
/**
* 獲取方法的唯一標識
*/
private String getMethodKey(Method method) {
return method.getDeclaringClass().getName() + "#" + method.getName();
}
/**
* 提供監(jiān)控API用的統(tǒng)計數(shù)據(jù)
*/
public Map<String, Object> getStatistics() {
Map<String, Object> stats = new ConcurrentHashMap<>();
methodStatsMap.forEach((methodKey, methodStats) -> {
Map<String, Object> methodData = new ConcurrentHashMap<>();
methodData.put("localCalls", methodStats.localCallCount.get());
methodData.put("remoteCalls", methodStats.remoteCallCount.get());
methodData.put("localAvgTimeMs", methodStats.getLocalAvgTimeMs());
methodData.put("remoteAvgTimeMs", methodStats.getRemoteAvgTimeMs());
methodData.put("localErrorRate", methodStats.getLocalErrorRate());
methodData.put("remoteErrorRate", methodStats.getRemoteErrorRate());
stats.put(methodKey, methodData);
});
stats.put("systemLoad", systemLoadAverage);
stats.put("availableProcessors", availableProcessors);
return stats;
}
}
5.3 服務降級
在遠程調(diào)用模式下，為了提高系統(tǒng)的可靠性，我們可以實現(xiàn)服務降級：
public class UserServiceFallback implements UserServiceFeignClient {
@Override
public User getUserById(Long id) {
// 返回一個默認用戶或從緩存獲取
return new User(id, "Default User", "default@example.com");
}
@Override
public List<User> getAllUsers() {
// 返回空列表或緩存數(shù)據(jù)
return Collections.emptyList();
}
// 其他方法實現(xiàn)...
}
六、方案優(yōu)缺點分析
6.1 優(yōu)點
代碼統(tǒng)一：業(yè)務代碼不需要關(guān)心底層實現(xiàn)方式，保持一致的調(diào)用方式
靈活部署：可以根據(jù)需要靈活切換部署模式，支持單體和微服務架構(gòu)
平滑遷移：支持系統(tǒng)架構(gòu)的漸進式演進，無需一次性重構(gòu)
便于測試：可以在測試環(huán)境使用本地實現(xiàn)，降低測試復雜度
運維便利：通過配置變更實現(xiàn)部署調(diào)整，無需修改代碼
6.2 缺點
額外復雜性：增加了系統(tǒng)設計的復雜度
性能差異：本地調(diào)用和遠程調(diào)用的性能特性不同，可能需要針對性優(yōu)化
一致性考量：需要確保本地實現(xiàn)和遠程實現(xiàn)的行為一致
異常處理：遠程調(diào)用涉及網(wǎng)絡異常等情況，異常處理策略需要統(tǒng)一
七、實際應用場景
7.1 單體應用逐步拆分為微服務
當需要將單體應用逐步拆分為微服務時，可以首先將業(yè)務功能模塊化，定義清晰的服務接口，實現(xiàn)本地調(diào)用。
然后逐步將部分服務遷移到獨立部署的微服務，并將調(diào)用模式從本地切換為遠程，業(yè)務代碼無需修改。
7.2 微服務合并簡化架構(gòu)
當發(fā)現(xiàn)某些微服務之間耦合度高、頻繁交互時，可以考慮將它們合并部署。
使用本文提出的方案，只需修改配置將調(diào)用模式從遠程切換為本地，無需修改業(yè)務代碼。
7.3 多環(huán)境部署策略
在不同環(huán)境中可以采用不同的部署策略
開發(fā)環(huán)境: 全部使用本地模式，簡化開發(fā)和調(diào)試
測試環(huán)境: 模擬生產(chǎn)的遠程模式，驗證服務間通信
生產(chǎn)環(huán)境: 根據(jù)實際需求選擇最優(yōu)部署方式
八、總結(jié)
在實際應用中，可以根據(jù)自身業(yè)務特點和技術(shù)棧，對本文提出的方案進行適當?shù)恼{(diào)整和擴展，以滿足特定場景的需求。
以上就是SpringBoot實現(xiàn)本地與遠程方法調(diào)用的無縫切換的詳細內(nèi)容，更多關(guān)于SpringBoot本地與遠程調(diào)用切換的資料請關(guān)注腳本之家其它相關(guān)文章！
相關(guān)文章
有的運維工具使用了java的ssh客戶端,這些客戶端和服務端間有時會出現(xiàn)加密算法協(xié)商失敗和主機密鑰類型協(xié)商失敗的問題,該問題是由于新客戶端/服務端禁用了相關(guān)的不安全算法和密鑰類型,本文簡要記錄下該問題的解決方法以備不時之需2026-01-01
Java利用Phantomjs實現(xiàn)生成圖片的功能
這篇文章主要介紹了Java利用Phantomjs實現(xiàn)生成圖片的功能，文中講解非常細致，代碼幫助大家更好的理解和學習，感興趣的朋友可以了解下2020-08-08
在Java開發(fā)中,我們通常會將我們的項目打包成可執(zhí)行的Jar包,以便于在其他環(huán)境中部署和運行,本文將介紹如何使用IDEA集成開發(fā)環(huán)境將Java項目打包成可執(zhí)行的Jar包,需要的朋友可以參考下2025-08-08
Java數(shù)據(jù)結(jié)構(gòu)之插入排序與希爾排序
在本篇文章，我們將為小伙伴們進行排序概念的基本講解并具體講解其中的兩種基礎(chǔ)排序：插入排序和希爾排序，希望小伙伴們能夠從中有所收獲2023-04-04
解決java攔截器獲取POST入?yún)е翤RequestBody參數(shù)丟失問題
文章講述了在Java開發(fā)中使用攔截器獲取POST請求入?yún)r,由于流關(guān)閉導致`@RequestBody`參數(shù)丟失的問題,并提出了一種解決方案,解決方案包括自定義方法、防止流丟失、過濾器和攔截器的合理組織和使用,最終確保了參數(shù)的正確傳遞2024-11-11
這篇文章主要為大家詳細介紹了java多線程開啟的三種方式，使用數(shù)據(jù)庫，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下<BR>2022-02-02
這篇文章主要為大家詳細介紹了Java中兩種常用的解決線程安全的方式——Synchornized和Lock，文中的示例代碼簡潔易懂，快跟隨小編一起學習起來吧2023-06-06
springboot如何使用@ConfigurationProperties封裝配置文件
springboot如何使用@ConfigurationProperties封裝配置文件的操作，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-08-08
這篇文章主要給大家介紹了關(guān)于SpringBoot如何優(yōu)雅的處理全局異常的相關(guān)資料，文中通過示例代碼介紹的非常詳細，對大家學習或者使用SpringBoot具有一定的參考學習價值，需要的朋友們下面來一起學習學習吧2019-05-05
這篇文章主要介紹了Spring中的@CrossOrigin注解的使用詳細解讀,跨源資源共享（CORS）,是由大多數(shù)瀏覽器實現(xiàn)的W3C規(guī)范,允許對跨域請求進行靈活授權(quán),用來代替IFRAME或JSONP等非正規(guī)實現(xiàn)方式,需要的朋友可以參考下2023-11-11