springCloud核心教程_IDEA版本

最新推荐文章于 2023-08-04 14:55:09 发布

BLUESKYHOST

最新推荐文章于 2023-08-04 14:55:09 发布

阅读量340

点赞数

分类专栏： SpringBoot java 文章标签： springcloud

本文链接：https://blog.csdn.net/BLUESKYHOST/article/details/109495064

版权

java 同时被 2 个专栏收录

18 篇文章 0 订阅

订阅专栏

SpringBoot

4 篇文章 0 订阅

订阅专栏

码云项目地址

父工程创建

创建普通maven项目

在这里插入图片描述

删除src
配置核心xml

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.llt</groupId>
    <artifactId>springcloud</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springcloudapi</module>
    </modules>
    <!--打包方式-->
    <packaging>pom</packaging>
    <!--版本号-->
    <properties>
        <junit.version>4.13.1</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <logback.core.version>1.3.0-alpha5</logback.core.version>
        <mysql.connector.java>8.0.12</mysql.connector.java>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <!--dependencies即使在子项目中不写该依赖项，那么子项目仍然会从父项目中继承该依赖项（全部继承）-->
    <!--dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。如果不在子项目中声明依赖，
    是不会从父项目中继承下来的；-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR8</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-dependencies -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.3.5.RELEASE</version>
                <type>pom</type>
                <!--用户很可能需要继承自己公司的标准parent配置，这个时候可以使用 scope=import 来实现多继承-->
                <scope>import</scope>
            </dependency>
        <!--数据库-->
            <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.connector.java}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.2.2</version>
            </dependency>
            <!--springboot 启动器-->
            <!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.1.3</version>
            </dependency>
            <!--junit-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/ch.qos.logback/logback-core -->
            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>${logback.core.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

创建子工程一样是maven

在这里插入图片描述

创建数据库

命名以及字符集排序
在这里插入图片描述

调用远程服务注意事项

如果是post请求需要在方法括号添加@RequestBody

   @PostMapping("/dept/add")
    public   boolean addDept(@RequestBody Dept dept){
        System.out.println(dept.getDname());
        return deptService.addDept(dept);
    }

Eureka服务注册发现

服务段

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

yaml
service-url: # 监控页面
defaultZone 新版本不用配置默认ip地址+端口号

server:
 port: 7001
#Eureka
eureka:
 instance:
   hostname: localhost
 client:
# register-with-eureka 是否在注册中心注册自己 false 不注册
   register-with-eureka: false
#  fetch-registry 如果是false 说明自己是注册中心
   fetch-registry: false
   service-url: # 监控页面
     defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

客户端

xml
添加监控信息

<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-netflix-eureka-client -->
 <!--完善监控信息-->
  <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-actuator</artifactId>
           <version>2.3.5.RELEASE</version>
       </dependency>
<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
   <version>2.2.5.RELEASE</version>
</dependency>

yaml

server:
  port: 8001
#mybatis 配置
mybatis:
  type-aliases-package: com.llt.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml
spring:
  application:
    name: springcloud-provider-dept8001
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db01?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=false
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka/
  instance:
    instance-id: springcloud-provider-dept8001
 # spring-boot-starter-actuator 配置
info:
  app.name: llt
  company.name: mingwen

Ribbon 消费者负载均衡

默认的轮询

package com.llt.springcloud.config;

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {
//    Configuration spring applicationContext.xml
    @Bean
    //负责均衡 RestTemplate
    @LoadBalanced
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }


}

自定义
* 启动类

package com.llt.springcloud;

import com.llt.myrule.LltRule;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.ribbon.RibbonClient;

@SpringBootApplication
@EnableEurekaClient
//微服务启动就可以加载自定义的
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = LltRule.class)
// eureka 于 ribbom 整合以后 客户端可以直接调用方法 不用关心ip地址
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

LlRule

package com.llt.myrule;

import com.netflix.loadbalancer.IRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class LltRule {
    @Bean
    public IRule myIRule(){
        //返回值可以改成自己写的
        return new LltRandomRule();
    }
}

LltRandomRule

package com.llt.myrule;

import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.ILoadBalancer;
import com.netflix.loadbalancer.Server;

import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

/**
 * 1. 每个服务 访问2次换下一个服务
 * total = 0 total==2 指向下一节点
 * index = 0 默认节点选择1
 *
 */
public class LltRandomRule extends AbstractLoadBalancerRule {
    private int total=0;//被调用的次数
    private int currentIndex=0;//当前谁在提供服务
    public LltRandomRule() {
    }

    @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        } else {
            Server server = null;

            while(server == null) {
                if (Thread.interrupted()) {
                    return null;
                }

                List<Server> upList = lb.getReachableServers();
                List<Server> allList = lb.getAllServers();
                int serverCount = allList.size();
                if (serverCount == 0) {
                    return null;
                }

//                int index = this.chooseRandomInt(serverCount);
//                server = (Server)upList.get(index);
                //=================自定义======================
//                int currentindex = this.chooseRandomInt(serverCount);

                if (total<1){
                    server = upList.get(total);
                    total++;
                }else {
                 total = 0;
//                    currentIndex=currentIndex+1;
//                    if(currentIndex>=upList.size());{
//                        currentIndex = 0;
//                    }
                    server = upList.get(total);
                }
                System.out.println("total:==="+total);
                System.out.println("upList.size():==="+upList.size());
                //=================自定义======================
                if (server == null) {
                    Thread.yield();
                } else {
                    if (server.isAlive()) {
                        return server;
                    }

                    server = null;
                    Thread.yield();
                }
            }

            return server;
        }
    }

    protected int chooseRandomInt(int serverCount) {

        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

Feign 负载均衡

feign是声明式的web service客户端，它让微服务之间的调用变得更简单了，类似controllr调用service。SpringCloud集成了Ribbon和Eureka,可在使用Feign时提供负载均衡的http客户端。
feign,主要是社区，大家都习惯面向接口编程。这个是很多开发人员的规范。调用微服务访问两种方法
1.微服务名字[ribbon]
2.接口和注解[feign ]
Feign 不建议用get请求传参很麻烦
启动项目用80 别用feign
在这里插入图片描述

这样子可以用

package com.llt.springcloud.service;

import com.llt.springcloud.pojo.Dept;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
@Controller
public interface DeptClientSerevice {
     @GetMapping("/dept/getById/{id}")
     Dept queryById(@PathVariable("id") Long id);
     @GetMapping("/dept/list")
     List<Dept> queryAll();
     @PostMapping("/dept/add")
     boolean addDept(Dept dept);
}

BLUESKYHOST

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
springCloud核心教程_IDEA版本

父工程创建创建普通maven项目删除src配置核心xml<?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.
复制链接

扫一扫