微服务-SpringCloud(附案例)

最新推荐文章于 2024-08-20 12:46:47 发布
最新推荐文章于 2024-08-20 12:46:47 发布
阅读量7.7k 收藏 18
点赞数
分类专栏： SpringCloud 文章标签： java 分布式 eureka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44217401/article/details/104266986
版权

微服务

微服务的特点

  • 单一职责：微服务中每一个服务都对应唯一的业务能力，做到单一职责
  • 微：微服务的服务拆分粒度很小，例如一个用户管理就可以作为一个服务。每个服务虽小，但“五脏俱全”。
  • 面向服务：面向服务是说每个服务都要对外暴露服务接口API。并不关心服务的技术实现，做到与平台和语言无关，也不限定用什么技术实现，只要提供Rest的接口即可。
  • 自治：自治是说服务间互相独立，互不干扰
    • 团队独立：每个服务都是一个独立的开发团队，人数不能过多。
    • 技术独立：因为是面向服务，提供Rest接口，使用什么技术没有别人干涉
    • 前后端分离：采用前后端分离开发，提供统一Rest接口，后端不用再为PC、移动段开发不同接口
    • 数据库分离：每个服务都使用自己的数据源
    • 部署独立，服务间虽然有调用，但要做到服务重启不影响其它服务。有利于持续集成和持续交付。每个服务都是独立的组件，可复用，可替换，降低耦合，易维护

微服务结构图
在这里插入图片描述

SpringCloud

微服务是一种架构方式，最终肯定需要技术架构去实施。

微服务的实现方式很多，但是最火的莫过于Spring Cloud了。为什么？

  • 后台硬：作为Spring家族的一员，有整个Spring全家桶靠山，背景十分强大。
  • 技术强：Spring作为Java领域的前辈，可以说是功力深厚。有强力的技术团队支撑，一般人还真比不了
  • 群众基础好：可以说大多数程序员的成长都伴随着Spring框架，试问：现在有几家公司开发不用Spring？SpringCloud与Spring的各个框架无缝整合，对大家来说一切都是熟悉的配方，熟悉的味道。
  • 使用方便：相信大家都体会到了SpringBoot给我们开发带来的便利，而SpringCloud完全支持SpringBoot的开发，用很少的配置就能完成微服务框架的搭建

简介

SpringCloud是Spring旗下的项目之一，官网地址：http://projects.spring.io/spring-cloud/

Spring最擅长的就是集成，把世界上最好的框架拿过来，集成到自己的项目中。

SpringCloud也是一样，它将现在非常流行的一些技术整合到一起，实现了诸如：配置管理，服务发现，智能路由，负载均衡，熔断器，控制总线，集群状态等等功能。其主要涉及的组件包括：

netflix

  • Eureka：注册中心
  • Zuul：服务网关
  • Ribbon：负载均衡
  • Feign：服务调用
  • Hystix：熔断器

以上只是其中一部分，架构图：
在这里插入图片描述

版本

SpringCloud的版本命名比较特殊，因为它不是一个组件，而是许多组件的集合，它的命名是以A到Z的为首字母的一些单词组成：
在这里插入图片描述

我们在项目中，会是以Hoxton.SR1的版本。

Eureka

认识Eureka

首先我们来解决第一问题，服务的管理。

问题分析

在刚才的案例中，user-service对外提供服务，需要对外暴露自己的地址。而consumer（调用者）需要记录服务提供者的地址。将来地址出现变更，还需要及时更新。这在服务较少的时候并不觉得有什么，但是在现在日益复杂的互联网环境，一个项目肯定会拆分出十几，甚至数十个微服务。此时如果还人为管理地址，不仅开发困难，将来测试、发布上线都会非常麻烦，这与DevOps的思想是背道而驰的。

网约车

这就好比是 网约车出现以前，人们出门叫车只能叫出租车。一些私家车想做出租却没有资格，被称为黑车。而很多人想要约车，但是无奈出租车太少，不方便。私家车很多却不敢拦，而且满大街的车，谁知道哪个才是愿意载人的。一个想要，一个愿意给，就是缺少引子，缺乏管理啊。

此时滴滴这样的网约车平台出现了，所有想载客的私家车全部到滴滴注册，记录你的车型（服务类型），身份信息（联系方式）。这样提供服务的私家车，在滴滴那里都能找到，一目了然。

此时要叫车的人，只需要打开APP，输入你的目的地，选择车型（服务类型），滴滴自动安排一个符合需求的车到你面前，为你服务，完美！

Eureka做什么？

Eureka就好比是滴滴，负责管理、记录服务提供者的信息。服务调用者无需自己寻找服务，而是把自己的需求告诉Eureka，然后Eureka会把符合你需求的服务告诉你。

同时，服务提供方与Eureka之间通过“心跳”机制进行监控，当某个服务提供方出现问题，Eureka自然会把它从服务列表中剔除。

这就实现了服务的自动注册、发现、状态监控。

原理图

基本架构
在这里插入图片描述

  • Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址
  • 提供者：启动后向Eureka注册自己信息（地址，提供什么服务）
  • 消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
  • 心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态

入门案例

对于下面的依赖设计，可以查看这篇博客：博客
超链接：
https://blog.csdn.net/weixin_44217401/article/details/104269431

父依赖

<?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>
    <modules>
        <module>userservice</module>
        <module>consumer</module>
        <module>eurekaserverdemo</module>
    </modules>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.geek</groupId>
    <artifactId>springcloud-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <name>springcloud-demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR1</spring-cloud.version>
        <mybatis.starter.version>2.1.1</mybatis.starter.version>
        <mysql.version>8.0.15</mysql.version>
        <mapper.starter.version>2.1.5</mapper.starter.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!--springCloud-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--mysql驱动-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <!-- 通用Mapper启动器 -->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>${mapper.starter.version}</version>
            </dependency>
            <!-- mybatis启动器 -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.starter.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--Web依赖-->
        <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>
            </plugin>
        </plugins>
    </build>

</project>

服务注册中心

启动类：

package com.geek;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;


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

application.yml配置

server:
  port: 8088 # 端口
spring:
  application:
    name: eurekaserverdemo # 应用名称，会在Eureka中显示
eureka:
  client:
    register-with-eureka: false # 是否注册自己的信息到EurekaServer，默认是true
    fetch-registry: false # 是否拉取其它服务的信息，默认是true
    service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
      defaultZone: http://127.0.0.1:8088/eureka

依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-demo</artifactId>
        <groupId>com.geek</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>eurekaserverdemo</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

</project>

服务提供者

MvcConfig

package com.geek.config;

import com.geek.interceptor.LoginInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Bean
    public LoginInterceptor loginInterceptor() {
        LoginInterceptor loginInterceptor = new LoginInterceptor();
        return loginInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(this.loginInterceptor()).addPathPatterns("/**");
    }
}

UserController

package com.geek.controller;

import com.geek.pojo.User;
import com.geek.servcice.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User queryById(@PathVariable("id") Long id) {
        return this.userService.queryById(id);
    }
}

LoginInterceptor

package com.geek.interceptor;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


public class LoginInterceptor implements HandlerInterceptor {

    private final Logger logger = LoggerFactory.getLogger(LoginInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        logger.debug("preHandle method is running");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        logger.debug("postHandle method is running");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        logger.debug("afterCompletion method is running");
    }
}

UserMapper

package com.geek.mapper;


import com.geek.pojo.User;
import tk.mybatis.mapper.common.Mapper;

public interface UserMapper extends Mapper<User> {
}

User

package com.geek.pojo;

import lombok.Data;

import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;
import java.util.Date;

@Table(name = "tb_user")
@Data
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    // 用户名
    private String userName;

    // 密码
    private String password;

    // 姓名
    private String name;

    // 年龄
    private Integer age;

    // 性别，1男性，2女性
    private Integer sex;

    // 出生日期
    private Date birthday;

    // 创建时间
    private Date created;

    // 更新时间
    private Date updated;

    // 备注
    private String note;

}

UserService

package com.geek.servcice;

import com.geek.mapper.UserMapper;
import com.geek.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public User queryById(Long id){
        return this.userMapper.selectByPrimaryKey(id);
    }

    @Transactional
    public void deleteById(Long id){
        this.userMapper.deleteByPrimaryKey(id);
    }

    public List<User> queryAll() {
        return this.userMapper.selectAll();
    }
}

启动类

package com.geek;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import tk.mybatis.spring.annotation.MapperScan;

//@EnableEurekaClient  该注解在采用eureka作为注册中心时使用，场景较为单一
@EnableDiscoveryClient //场景更为广泛
@SpringBootApplication
@MapperScan("com.geek.mapper")
public class UserserviceApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserserviceApplication.class);
    }
}

application.properties

spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/demo?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456

application.yml

server:
  port: 8081
spring:
  application:
    name: userservice # 应用名称，会在Eureka中显示
mybatis:
  type-aliases-package: com.geek.pojo
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:8088/eureka
  instance:
    prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
    ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找

依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-demo</artifactId>
        <groupId>com.geek</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>userservice</artifactId>

    <dependencies>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--通用Mapper-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
        </dependency>
        <!--Web依赖-->
        <!--<dependency>-->
            <!--<groupId>org.springframework.boot</groupId>-->
            <!--<artifactId>spring-boot-starter-web</artifactId>-->
        <!--</dependency>-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>

</project>

服务消费者

ConsumerController

package com.geek.controller;

import com.geek.pojo.User;
import com.netflix.appinfo.InstanceInfo;
import com.netflix.discovery.DiscoveryClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("consumer")
public class ConsumerController {

    @Autowired
    private RestTemplate restTemplate;

    @Autowired(required = false)
    private DiscoveryClient discoveryClient;

    @GetMapping("{id}")
    public User queryUserById(@PathVariable("id") Long id) {
        //根据服务id获取实例
        List<InstanceInfo> userserver = discoveryClient.getInstancesById("userservice");
        //从实例中取出ip和端口
        ServiceInstance instance = (ServiceInstance) userserver.get(0);
        String url = "http://" + instance.getHost() + ":" + instance.getPort() + "/user/" + id;
        User user = restTemplate.getForObject(url, User.class);
        return user;

//        String url = "http://localhost:8081/user/" + id;
//        return this.restTemplate.getForObject(url, User.class);
    }

}

User

package com.geek.pojo;


import lombok.Data;

import java.io.Serializable;
import java.util.Date;

@Data
public class User implements Serializable {

    private Long id;

    // 用户名
    private String userName;

    // 密码
    private String password;

    // 姓名
    private String name;

    // 年龄
    private Integer age;

    // 性别，1男性，2女性
    private Integer sex;

    // 出生日期
    private Date birthday;

    // 创建时间
    private Date created;

    // 更新时间
    private Date updated;

    // 备注
    private String note;

}

启动类

package com.geek;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.http.client.OkHttp3ClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

@EnableDiscoveryClient
@SpringBootApplication
public class ConsumerApplication {

    @Bean
    public RestTemplate restTemplate() {
        // 这次我们使用了OkHttp客户端,只需要注入工厂即可
        return new RestTemplate(new OkHttp3ClientHttpRequestFactory());
    }

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

application.yml

server:
  port: 8080
spring:
  application:
    name: userconsumer
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:8088/eureka
  instance:
    prefer-ip-address: true # 当其它服务获取地址时提供ip而不是hostname
    ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找

依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud-demo</artifactId>
        <groupId>com.geek</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>consumer</artifactId>

    <dependencies>
        <!-- 添加OkHttp支持 -->
        <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>4.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
    </dependencies>

</project>

sql

DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user` (
  `id` bigint(11) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  `name` varchar(255) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `sex` tinyint(1) DEFAULT NULL,
  `birthday` date DEFAULT NULL,
  `created` datetime DEFAULT NULL,
  `updated` datetime DEFAULT NULL,
  `note` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of tb_user
-- ----------------------------
INSERT INTO `tb_user` VALUES ('1', 'aaa', 'aaa', 'aaa', '1', '1', '2020-02-05', '2020-02-05 16:52:07', '2020-02-05 16:52:11', 'aaa');
INSERT INTO `tb_user` VALUES ('2', 'bbb', 'bbb', 'bbb', '2', '2', '2020-02-05', '2020-02-05 16:52:22', '2020-02-05 16:52:15', 'bbb');
INSERT INTO `tb_user` VALUES ('3', 'ccc', 'ccc', 'ccc', '3', '1', '2020-02-06', '2020-02-06 10:16:08', '2020-02-06 10:16:11', 'ccc');
INSERT INTO `tb_user` VALUES ('4', 'ddd', 'ddd', 'ddd', '4', '2', '2020-02-06', '2020-02-06 10:16:35', '2020-02-06 10:16:40', 'ddd');
INSERT INTO `tb_user` VALUES ('5', 'eee', 'eee', 'eee', '5', '1', '2020-02-06', '2020-02-06 10:16:08', '2020-02-06 10:16:08', 'eee');
INSERT INTO `tb_user` VALUES ('6', 'fff', 'fff', 'fff', '6', '2', '2020-02-06', '2020-02-06 10:16:08', '2020-02-06 10:16:08', 'fff');
INSERT INTO `tb_user` VALUES ('7', 'ggg', 'ggg', 'ggg', '7', '1', '2020-02-06', '2020-02-06 10:16:08', '2020-02-06 10:16:08', 'ggg');
INSERT INTO `tb_user` VALUES ('8', 'hhh', 'hhh', 'hhh', '8', '2', '2020-02-06', '2020-02-06 10:16:08', '2020-02-06 10:16:08', 'hhh');
INSERT INTO `tb_user` VALUES ('9', 'iii', 'iii', 'iii', '9', '1', '2020-02-06', '2020-02-06 10:16:08', '2020-02-06 10:16:08', 'iii');
INSERT INTO `tb_user` VALUES ('10', 'jjj', 'jjj', 'jjj', '10', '2', '2020-02-06', '2020-02-06 10:16:08', '2020-02-06 10:16:08', 'jjj');

最后讲一下Eureka详解

Eureka详解

基础架构

Eureka架构中的三个核心角色：

  • 服务注册中心
    Eureka的服务端应用，提供服务注册和发现功能
  • 服务提供者
    提供服务的应用，可以是SpringBoot应用，也可以是其它任意技术实现，只要对外提供的是Rest风格服务即可。
  • 服务消费者
    消费应用从注册中心获取服务列表，从而得知每个服务方的信息，知道去哪里调用服务方。

高可用的Eureka Server

Eureka Server即服务的注册中心，在刚才的案例中，我们只有一个EurekaServer，事实上EurekaServer也可以是一个集群，形成高可用的Eureka中心。

服务同步

多个Eureka Server之间也会互相注册为服务，当服务提供者注册到Eureka Server集群中的某个节点时，该节点会把服务的信息同步给集群中的每个节点，从而实现数据同步。因此，无论客户端访问到Eureka Server集群中的任意一个节点，都可以获取到完整的服务列表信息。

如果注册Eureka报错，可能是此问题
超链接：
https://blog.csdn.net/weixin_44217401/article/details/104266509

【微服务】springcloud-alibaba 配置多环境管理使用详解
congge
06-10 6609
springcloud-alibaba 配置多环境管理使用详解
springcloud例子（非常完整)
09-18
很全的springcloud例子，包括了网关，负载均衡，微服务之间的调用等。导入即可调用
SpringCloud简单实例
weixin_43751710的博客
05-16 5876
SpringCloud简单实例 SpringCloud是基于SpringBoot，需要先了解SpringBoot的相关知识。 这里只是一个非常简单的包含注册表、服务提供者、服务消费者三者的例子。 源码见： https://github.com/mengyuxiaofeng/SpringCloud 注册表如下 启动类 package demo; import org.springframewor...
微服务案例搭建
最新发布
m0_68041576的博客
08-20 597
Spring框架提供的RestTemplate类可⽤于在应⽤中调⽤rest服务，它简化了与http服务的通信⽅式，统 ⼀了RESTful的标准，封装了http链接， 我们只需要传⼊url及返回值类型即可。相较于之前常⽤的 HttpClient ，RestTemplate是⼀种更优雅的调⽤RESTful服务的⽅式。在Spring应⽤程序中访问第三⽅REST服务与使⽤Spring RestTemplate类有关。
推荐 7 个牛哄哄 Spring Cloud 实战项目
weixin_59617360的博客
07-01 3338
把一个大型的单个应用程序和服务拆分为数个甚至数十个的支持微服务，这就是微服务架构的架构概念，通过将功能分解到各个离散的服务中以实现对解决方案的解耦。 关于微服务相关的学习资料不多，而 GitHub 上的开源项目可以作为你微服务之旅的第一站。本文推荐 7 个非常火的微服务项目，从入门到实战，这篇文章值得收藏。 01.不二之选 第一个推荐的项目是高赞教程：PiggyMetrics ，这个开源项目是你开启微服务之旅的不二之选。 PiggyMetrics是一个很全面的微服务实践入门的实例集，它可以指导开..
SpringCloud入门实例
你我皆是黑马
09-08 318
SpringCloud入门实例 1、创建Maven项目 2、导入依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.5.3</version> <relativePath/> </parent>
绝无此例！用实例演示如何使用Spring搭建微服务框架，觉悟
如果频繁就私信一下呢
03-01 281
一个使用Spring, Spring Boot 和 Spring Cloud设置微服务系统的简单示例。 微服务允许从许多协作组件构建大型系统。它在流程级别执行Spring在组件级别执行的操作：松散耦合的流程而不是松散耦合的组件。 例如，设想一个在线商店，为用户帐户、产品目录订单处理和购物车提供单独的微服务： 不可避免地，要构建这样一个系统，必须设置和配置许多移动部件。如何让它们协同工作并不明显——你需要很好地熟悉Spring Boot，因为Spring Cloud充分利用了它，需要几个Net.
《springcloud&学习资料》--SpringCloud案例.zip
04-19
个人花大量时间整理出的实战资料，内容丰富，文档也很详细。无论做毕业设计还是用于学习技能，或工作中当做参考资料，都能发挥重要作用 亲们下载我任何一个付费资源后，即可私信联系我免费下载其他相关资源哦~ ...
《springcloud&学习资料》--Spring Cloud 学习案例，服务发现、服务治理、链路追踪、服务监控等.zip
04-19
个人花大量时间整理出的实战资料，内容丰富，文档也很详细。无论做毕业设计还是用于学习技能，或工作中当做参考资料，都能发挥重要作用 亲们下载我任何一个付费资源后，即可私信联系我免费下载其他相关资源哦~ ...
分布式事务 Seata AT 模式-Spring Cloud微服务案例（二）（csdn）————程序.pdf
12-04
本文将深入探讨Seata的AT（Automatic Transaction）模式在Spring Cloud微服务环境中的应用。 AT模式是Seata的一种自动提交或回滚事务的方式，它通过代理数据库操作来实现分布式事务的两阶段提交（2PC）。在这个模式...
《学习资料》--Spring Cloud 实践学习案例，由浅入深一步一步学习 Spring Cloud.zip
04-19
个人花大量时间整理出的实战资料，内容丰富，文档也很详细。无论做毕业设计还是用于学习技能，或工作中当做参考资料，都能发挥重要作用 亲们下载我任何一个付费资源后，即可私信联系我免费下载其他相关资源哦~ ...
springCloud例子
08-09
springCloud例子
springcloud例子
07-27
里面包含 springcloud中的 eureka ribbon feign hystrix zuul
SpringCloud 全部完整例子
07-11
springCloud 15个完整例子，从简单到复杂都有。直接可以导入使用，mavan项目，
微服务实例demo
12-29
这是一个微服务是实际操作的案例，一套完整的微服务demo，欢迎同学们下载学习。
springcloud 例子
03-16
springcloud 学习例子，涵盖注册中心、熔断器、路由网关等，欢迎大家下载学习交流
超赞！终于有人用130个案例把微服务方方面面完美演示出来了
Java圈全能架构师的博客
01-29 446
微服务架构 说到现在流行的微服务架构，我们都知道它主要的技术手段就是SpringBoot+SpringCloud。它能对项目进行有效的“业务区”划分，并利用合理的技术对业务性能做出提升和改善，同时又极大地简化了配置文件的使用。虽然是开发之中看起来非常简单的一种实现技术，但简单的背后考究的却是开发者对于开源技术的熟练程度。 但微服务架构相对于很多传统行业以及刚入行的小伙伴来说，大型互联网项目以及分布式微服务的概念在他们那里还不成体系，就算是接触过的开发人员也是很少有人能将里面需要用到的技术栈整合在一块，并
[转载]微服务实战（四）：服务发现的可行方案以及实践案例
iteye_20566的博客
03-07 169
这是关于使用微服务架构创建应用系列的第四篇文章。第一篇介绍了微服务架构的模式，讨论了使用微服务架构的优缺点。第二和第三篇描述了微服务架构内部的通讯机制。这篇文章中，我们将会探讨服务发现相关问题。 为什么要使用服务发现? 　　设想一下，我们正在写代码使用了提供RESTAPI或者ThriftAPI的服务，为了完成一次服务请求，代码需要知道服务实例的网络位置（IP地址和端口）。传统应用都运行在...
SpringCloud案例
商朝
04-01 844
今天写一个自己提供服务自己消费服务的项目 依赖 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>Hoxton.SR1</version>
微服务与Spring Cloud基础知识入门指南
本资料集为“微服务和SpringCloud入门介绍”，适合于希望入门微服务架构和Spring Cloud的技术人员，也可以作为知识分享会的材料。通过本资料的学习，可以帮助技术人员建立对微服务架构的基础认识，掌握Spring Cloud...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值