SpringCloud项目创建及详细介绍

最新推荐文章于 2024-04-30 11:53:50 发布

6x6x6x

最新推荐文章于 2024-04-30 11:53:50 发布

阅读量480

点赞数

文章标签： spring java

本文链接：https://blog.csdn.net/x6x6x6x/article/details/104720497

版权

SpringCloud

远程方法调用

RPC：dubbo和微服务，都是分布式的，分布式最少是两台电脑以上，然后，电脑之间相互协作需要完成通讯。dubbo是基于RPC的。RPC意思就是A服务器可以调用B服务器的服务，两者保持数据传输格式相同。
http：网络传输协议，客户端和服务端采用Http协议。SpringCloud基于HTTP协议。浏览器访问网站。

两种方式比较

速度：RPC比HTTP更快，虽然底层都是TCP，但是http协议的而信息旺旺比较臃肿，不过可以采用gzip压缩。
难度：RPC实现比较复杂，http相对比较简单。
灵活：http更胜一筹，因为它不关心实现细节，跨平台、跨语言。
如果对效率要求比较高，并且开发过程中使用统一的技术栈，那么RPC还是不错的。例如：dubbo
如果需要更加灵活，跨语言、跨平台，http更适合。例如：SpringCloud

HttpClient

Apache公司产品，是Http Components下的一个组件。用于模仿浏览器发出http请求。

HTTPClient案例实现：

第一步：引入依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.8.RELEASE</version>
</parent>
 <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
</properties>
<dependencies>
    <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>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.6</version>
    </dependency>
</dependencies>

第二步，创建启动类

//启动类
@SpringBootApplication
public class HttpDemoApplication {
    @Bean
    public RestTemplate getTemplate(){
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(HttpDemoApplication.class,args);
    }
}
//测试类
public class HttpTests {
    CloseableHttpClient httpClient;
    @Before
    public void init(){
        httpClient = HttpClients.createDefault();
    }
    @Test
    public void testGet() throws IOException{
        HttpGet request = new HttpGet("www.baidu.com");
        String response = this.httpClient.execute(request,new BasicResponseHandler());
        System.out.println(response);
    }
    @Test
    public void testPost() throws IOException{
        HttpGet request = new HttpGet("www.oschina.net");
        request.set("user-Agent","Mozilla/5.0");
        String response = this.httpClient.execute(request,new BasicResponseHandler());
        System.out.println(response);
    }
}

SpringCloud

现阶段最流行的框架，SpringCloud封装NetFlix。微服务是一种架构方式，最终肯定需要技术架构去实施。

微服务的实现方式有很多，但是最火莫过于SpringCloud，为什么？

1.后台硬：作为Spring家族的一员，有整个Spring全家桶靠山，背景十分强大。
2.技术强：Spring作为Java领域的前辈，可以说是功力深厚，有强力的技术团队支撑，一般人还真比不了
3.群众基础好：可以说大多数程序员的成长都伴随着Spring框架，试问：现在有几家公司开发不用Spring？SpringCloud与Spring的各个框架无缝整合，对大家来说一切都是熟悉的配方，熟悉的味道。
4.使用方便：相信大家都体会到了SpringBoot给我们开发带来的便利，而SoringCloud完全支持SpringBoot的开发，用很少的配置就能完成微服务框架的搭建。
SpringCloud最擅长的就是集成，把世界上最好的框架拿过来，集成到自己项目中。SpringCloud也是一样，他将现在非常流行的一些技术整合到一起，实现了注入：配置管理，服务发现，智能路由，负载均衡，熔断路，控制总线，集群状态等功能，其主要涉及的组件包括：
netflix:
·Eureka：注册中心
·Zuul：服务网关
·Ribbon：负载均衡
·Feign：服务调用
·Hystix：熔断器

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

案例实现

1.创建父项目

添加依赖

父项目作为一个数据仓库，子项目需要时从此处拿取。父项目不具备这个jar包，只是作为一个仓库。

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
    </parent>

    <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>Finchley.RC1</spring-cloud.version>
        <mybatis.starter.version>1.3.2</mybatis.starter.version>
        <mapper.starter.version>2.0.2</mapper.starter.version>
        <druid.starter.version>1.1.9</druid.starter.version>
        <mysql.version>8.0.18</mysql.version>
        <lombok.version>1.16.10</lombok.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!--Spring Cloud-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-build-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--Mybatis启动器-->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.starter.version}</version>
            </dependency>
            <!--通用Mapper启动器，简单SQL封装-->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>${mapper.starter.version}</version>
            </dependency>
            <!--MySQL驱动类-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <plugin>
                <!--SpringBoot与Maven的一个插件-->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
	<!--仓库，这个项目优先从下面地址下载，如果没有就找Settings设置-->
    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

2.User_Service子项目

客户端，

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>tk.mybatis</groupId>
        <artifactId>mapper-spring-boot-starter</artifactId>
        <version>2.0.2</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.10</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

然后创建启动类、application.yml，Controller，Service，Mapper，pojo。

启动类核心：@SpringBootApplication	@MapperScan("com.aa.mapper")
Controller：@RestController	@RequestMapping	@PathVariable
Service：@Service
Mapper：extends Mapper(User)
pojo:实体类，@Table(name = "user_table") @Data @Id @GeneratedValue(strategy=..IDENTITY)
Controller注入Service,Service注入Mapper，Mapper返回数据,pojo存放实体对象。

application.yml

server:
  port: 8089
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8
    username: root
    password: root
mybatis:
  type-aliases-package: com.aa.pojo

3.Consumer_Service子项目

添加依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
    </dependencies>

启动类创建

@SpringBootApplication
public class ConsumerApplication {
    @Bean
    public RestTemplate getTemplate(){
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

User类，接收对象

@Data
public class User {
    private Integer id;
    private String name;
    private Integer age;
    private String sex;
    private Date birthday;
}

Controller类

@RestController
@RequestMapping("/consumer")
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/{id}")
    public User getUser(@PathVariable("id") Long id){
       User user = restTemplate.getForObject("http://localhost:8089/wa/user/"+id,User.class);
        return user;
    }
}

4.Eureka_Service子项目

Eureka负责管理、记录服务提供的信息。服务调用者无需自己寻找服务，而是把自己的需求告诉Eureka。然后Eureka会把符合你需求的服务告诉你。同时，服务提供方与Eureka之间通过“心跳”机制进行监控，当某个服务出现问题，Eureka自然会把它从服务列表中剔除。

流程：User向Eureka注册服务，然后Consumer定期从Eureka拉取服务，建立与User之间的连接，User与Consumer然后开始通讯，完成功能。

添加依赖

<dependency>
    <!--添加Eureka服务端-->
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    <version>2.0.2.RELEASE</version>
</dependency>

启动类

@SpringBootApplication
@EnableEurekaServer			//关键注解
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class,args);
    }
}

添加配置application.yml

eureka:
  client:
    serviceUrl:	#EurekaServer地址
      defaultZone: http://127.0.0.1:10086/eureka/	#注册中心
    register-with-eureka: false	#是否注册自己信息到Eureka，默认True
    fetch-registry: false	#是否拉取其他服务信息，默认为True
  server:
    enable-replicated-request-compression: false	#关闭自我保护模式，默认True
    eviction-interval-timer-in-ms: 1000	#扫描失效服务的时间，默认为60*1000ms

server:
  port: 10086	#IP访问端口
spring:
  application:
    name: eureka_server	#设置
#service-url应该写成serviceUrl，可能存在格式问题。遵循驼峰式命名规则

此时三个服务器基本搭建完毕，需要完成服务器之间的通讯。首先是User注册到Eureka

5.User注册到Eureka

user将自己的信息注册到Eureka，Eureka记录user的访问地址、端口号等其他信息。

添加依赖

<dependency>
    <!--添加Eureka客户端依赖-->
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    <version>2.1.2.RELEASE</version>
</dependency>

添加配置，配置Application名称，服务拉取将根据name查找。以及Eureka配置。

spring:
  application:
    name: user_service
eureka:
  client:
    serviceUrl:
      defaultZone: http://127.0.0.1:10086/eureka	#去这个地址进行注册
    registry-fetch-interval-seconds: 5		#5s间隔拉取服务列表
  instance:
    prefer-ip-address: true	#当调用getHostname获取实例的hostname时，返回ip而不是host名称
    ip-address: 127.0.0.1	#指定自己的ip信息，不指定会自己寻找

启动类添加注解：@EnableDiscoveryClient

Consumer注册到Eureka

添加依赖，启动类添加注解，添加yml配置。因为都是Eureka的客户端，配置基本一致。需要修改端口以及applicationName。

修改Controller，ip地址通过服务访问进行获取，而不是直接指定(写死了)

@GetMapping("/{id}")
public User getUser(@PathVariable("id") Integer id){
    //获取UserService客户端
    List<ServiceInstance> instances = discoveryClient.getInstances("user_service");
    //取第一个，更多的任务将被分配到第一个user_service
    ServiceInstance serviceInstance = instances.get(0);
    //通过动态服务端口访问数据
    String url = "HTTP://"+serviceInstance.getHost()+":"+serviceInstance.getPort()+"/wa/user/"+id;
    System.out.println(url);
    User user = restTemplate.getForObject(url,User.class);
    return user;
}

6.高可用Eureka配置

高可用模式：只有一台服务器时，如果出现故障，损失将无法挽回；而配置多台服务器，他们相互注册，当一台宕机后，另一台顶上继续提供服务。这就是高可用模式。

修改application.yml配置，删除注册、拉取为false的配置。端口为10086，注册地址为：http://127.0.0.1:10087/eureka。启动

然后复制一份启动类，操作如下：右上角锤子图标右边三角图标下拉→Edit Configurations→左上角第一个图标+→然后点击第三个图标复制→修改名称Application2→OK→修改端口为10087，注册为10086。启动

User与Consumer配置中添加新的注册地址http://127.0.0.1:10087/eureka。向两台注册。

当其中一台服务直接关闭时，依旧能提供服务。模拟完毕。

7.服务提供者

服务注册

服务提供者在启动时，会检查配置属性中的：eureka.client.register-with-eureka=true是否正确，默认为true。如果为true，则会向EurekaServer发起一个Rest请求，并携带自己的元数据信息，EurekaServer会把这戏信息保存在一个双层的Map结构中，第一层Map的key就是服务名称，第二层Map的key是服务的实例id。

服务续约

在注册服务完以后，服务提供者会维持一个心跳(定时向EurekaServer发起Rest请求)告诉它：我还活着。这个我们称为服务的续约。

有两个重要参数可以修改服务续约的行为。

eureka:
  instance:
    lease-expiration-duration-in-seconds: 90	#服务失效时间，默认90秒
    lease-renewal-interval-in-seconds: 30		#服务续约间隔，默认30秒

也就是说每隔30秒向服务注册中心，发起一次Rest请求，如果超过90s没有发送心跳，Eureka会人为该服务宕机，从服务列表移除。开发阶段可以适当调小，生产环境默认就好。

服务注册信息

在status一列中，显示如下信息

up(1):代表现在是启动了一个实例，没有集群
DESKTOP-OLLRSUH:user_service:8089：是实例的名称(instance-id)
	默认格式:${hostname}+${spring.application.name}+${server.port}
	instance-id是区分同一服务的不同实例的唯一标准，因此不能重复
修改instance-id的结构
eureka:
	instance:
		instance-id: ${spring.application.name}+${server.port}

失效剔除保护

失效剔除：有时候，我们服务提供方不一定会正常下线，可能因为内存溢出、网络故障等原因到时服务无法正常工作。Eureka需要将这样的服务剔除出服务列表。因此它会开启一个定时任务，每隔60s对所有失效的服务(超过90s未响应)进行剔除。可以通过eureka.server.eviction-interval-timer-in-ms参数对其进行修改，单位是毫秒，生产环境不要修改。而在开发环境，你重启一个服务，60秒后eureka才反应过来，极不方便，可改为10s。

自我保护，关停一个服务时，在eureka面板会看到一条红色警告(EMERGENCY!..)这就是出发了eureka的自我保护机制。当一个服务未按时进行心跳续约时，eureka会统计最近15分钟心跳失败的服务实例的比例是否超过了85%。在生产环境下，因为网络延迟等原因，心跳失败实例的比例很有可能超标，但是此时就把服务剔除列表并不妥当，因为服务可能没有宕机。eureka就会把当前实例的注册信息保护起来，不予剔除。生产环境下很有效，保证了多数服务依然可用。但开发环境很麻烦，因此开发环境下关闭自我保护。

8.负载均衡Robbin

在以上的代码实例中，我们使用ServiceInstance serviceInstance = instances.get(0);获取第一个user_service服务，然后分配任务，在空闲时，任务往往总被分配到第一个服务器，这就造成对此节点的使用频率太高，而其他节点就很闲。而负载均衡就是为了解决这一问题。

在刚在的案例中，我们启动了一个user_Service，然后启动了DiscoveryClient来获取服务实例信息，然后获取ip和端口来访问。但是实际环境中，我们往往会开启很多个user-service的集群。此时我们获取的服务列表就会有多个，到底该访问哪一个？一般这种情况下我们就需要编写负载均衡算法，在多个实例列表中进行选择。不过Eureka中已经帮我们继承了负载均衡组件：Ribbon，简单修改代码即可使用。

什么是Ribbon：

Ribbon是Netflix发布的负载均衡器，它有助于控制HTTP和TCP客户端的行为。为Ribbon配置服务提供地址列表后，Ribbon就可基于某种负载均衡算法，自动的帮助服务消费者去请求，Ribbon默认为我们提供了很多的负载均衡算法，例如轮询、随机等。当然，我们也可为Ribbon实现自定义的负载均衡算法。

案例实现

添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

Consumer启动类添加注解

@SpringBootApplication
@EnableDiscoveryClient
public class ConsumerApplication {
    @Bean
    @LoadBalanced	//负载均衡启动
    public RestTemplate getTemplate(){
        return new RestTemplate();
    }
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

Controller修改

    @GetMapping("/{id}")
    public User getUser(@PathVariable("id") Integer id){
        //不用再指定哪个进行服务，负载均衡自动帮忙选取
        String url = "HTTP://user-service/wa/user/"+id;
        System.out.println(url);
        User user = restTemplate.getForObject(url,User.class);
        return user;
    }

复制一个User_service启动，后台打印url观察url访问的地址。

负载均衡就是将工作任务分摊到多个节点，避免一个节点很闲一个节点很忙的情况。

6x6x6x

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SpringCloud项目创建及详细介绍

SpringCloud远程方法调用RPC：dubbo和微服务，都是分布式的，分布式最少是两台电脑以上，然后，电脑之间相互协作需要完成通讯。dubbo是基于RPC的。RPC意思就是A服务器可以调用B服务器的服务，两者保持数据传输格式相同。http：网络传输协议，客户端和服务端采用Http协议。SpringCloud基于HTTP协议。浏览器访问网站。两种方式比较速度：RPC比HTTP更快，...
复制链接

扫一扫