springcloud项目搭建基础教程_项目情况介绍模板「建议收藏」

springcloud项目搭建基础教程_项目情况介绍模板「建议收藏」SpringCloud远程方法调用RPC:dubbo和微服务,都是分布式的,分布式最少是两台电脑以上,然后,电脑之间相互协作需要完成通讯

springcloud项目搭建基础教程_项目情况介绍模板「建议收藏」"

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访问的地址。

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

今天的文章springcloud项目搭建基础教程_项目情况介绍模板「建议收藏」分享到此就结束了,感谢您的阅读。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/86818.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用 * 标注