建立spring父模块

删除不必要的src目录
父模块中的pom.xml中添加相应的依赖以及插件、远程仓库地址

     <!-- 项目的打包类型, 即项目的发布形式, 默认为 jar. 对于聚合项目的父模块来说, 必须指定为 pom -->

     <packaging>pom</packaging>

     <name>spring-cloud-home-page</name>

     <description>Project For VastHomepage SpringCloud</description>

     <parent>

         <groupId>org.springframework.boot</groupId>

         <artifactId>spring-boot-starter-parent</artifactId>

         <version>2.1.4.RELEASE</version>

     </parent>

     <properties>

         <spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>

     </properties>

     <dependencies>

         <!-- lombok 工具通过在代码编译时期动态的将注解替换为具体的代码,

         IDEA 需要添加 lombok 插件 -->

         <dependency>

             <groupId>org.projectlombok</groupId>

             <artifactId>lombok</artifactId>

             <version>1.16.18</version>

         </dependency>

         <dependency>

             <groupId>org.springframework.boot</groupId>

             <artifactId>spring-boot-starter-test</artifactId>

             <scope>test</scope>

         </dependency>

     </dependencies>

     <!-- 标识 SpringCloud 的版本 -->

     <dependencyManagement>

         <dependencies>

             <dependency>

                 <groupId>org.springframework.cloud</groupId>

                 <artifactId>spring-cloud-dependencies</artifactId>

                 <version>${spring-cloud.version}</version>

                 <type>pom</type>

                 <scope>import</scope>

             </dependency>

         </dependencies>

     </dependencyManagement>

     <!-- 配置远程仓库 -->

     <repositories>

         <repository>

             <id>spring-milestones</id>

             <name>Spring Milestones</name>

             <url>https://repo.spring.io/milestone</url>

             <snapshots>

                 <enabled>false</enabled>

             </snapshots>

         </repository>

     </repositories>

创建 Eureka注册服务子模块

pom.xml中引入必要的依赖以及插件

   <!-- 模块名及描述信息 -->

    <name>spring-cloud-eureka</name>

    <description>Spring Cloud Eureka</description>

    <!-- eureka server: 提供服务发现与服务注册 -->

    <dependencies>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>

        </dependency>

    </dependencies>

    <!--

        SpringBoot的Maven插件, 能够以Maven的方式为应用提供SpringBoot的支持，可以将

        SpringBoot应用打包为可执行的jar或war文件, 然后以通常的方式运行SpringBoot应用

     -->

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

资源文件夹（resources）中创建application.yml

spring:

  application:

    name: spring-cloud-eureka

server:

  port: 8000

eureka:

  instance:

    hostname: localhost

  client:

    fetch-registry: false

    register-with-eureka: false

    service-url:

      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

启动类上，加上两个注解@EnableEurekaServer、@SpringBootApplication

启动

方式一：Teriminal窗口

/** 进入项目目录 */

cd 项目名

/** 将项目打包成jar */

mvn clean package -Dmaven.test.skip=true -U

/** 进入target目录 */

cd target

/** 用jar命令启动项目 */

java -jar 项目名.jar

方式二：

直接运行application，启动即可

上面是Eureka的单节点启动方式，公司中一般为了防止Eureka单节点故障，下面介绍Eureka的多节点伪集群配置方式

在原项目资源文件夹下创建bootstrap.yml,注释掉application.yml中的配置，因为在springBoot项目中会先加载bootstrap.yml
修改Windows中C:\Windows\System32\drivers\etc路径下的hosts文件

127.0.0.1 server1

127.0.0.1 server2

127.0.0.1 server3

bootstrap.yml：

spring:

  application:

    name: spring-cloud-eureka

  profiles: server1

server:

  port: 8000

eureka:

  instance:

    hostname: server1

    prefer-ip-address: false

  client:

    service-url:

      defaultZone: http://server2:8001/eureka/,http://server3:8002/eureka/

---

spring:

  application:

    name: spring-cloud-eureka

  profiles: server2

server:

  port: 8001

eureka:

  instance:

    hostname: server2

    prefer-ip-address: false

  client:

    service-url:

      defaultZone: http://server1:8000/eureka/,http://server3:8002/eureka/

---

spring:

  application:

    name: spring-cloud-eureka

  profiles: server3

server:

  port: 8002

eureka:

  instance:

    hostname: server3

    prefer-ip-address: false

  client:

    service-url:

      defaultZone: http://server1:8000/eureka/,http://server2:8001/eureka/

以上配置完成后，在以上启动方式一的基础上，在启动时需加上一个命令，以表示启动哪个Eureka节点

java -jar 项目名.jar --spring.profiles.active=server1 #标识启动Eureka的server1的服务，以此类推

启动完成后可在浏览器中访问

http://127.0.0.1:8000/

父模块中创建zuul网关服务

pom.xml中引入相关依赖、插件

    <!-- 模块名及描述信息 -->

    <name>spring-cloud-zuul</name>

    <description>Spring Cloud Gateway</description>

    <dependencies>

        <!--

            Eureka 客户端, 客户端向 Eureka Server 注册的时候会提供一系列的元数据信息, 例如: 主机, 端口, 健康检查url等

            Eureka Server 接受每个客户端发送的心跳信息, 如果在某个配置的超时时间内未接收到心跳信息, 实例会被从注册列表中移除

        -->

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>

        </dependency>

        <!-- 服务网关 -->

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>

        </dependency>

        <!-- apache 工具类 -->

        <dependency>

            <groupId>commons-io</groupId>

            <artifactId>commons-io</artifactId>

            <version>1.3.2</version>

        </dependency>

    </dependencies>

    <!--

        SpringBoot的Maven插件, 能够以Maven的方式为应用提供SpringBoot的支持，可以将

        SpringBoot应用打包为可执行的jar或war文件, 然后以通常的方式运行SpringBoot应用

     -->

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

资源文件夹中创建application.yml

spring:

  application:

    name: spring-cloud-zuul

server:

  port: 9000

eureka:

  client:

    service-url:

      defaultZone: http://server1:8000/eureka

zuul:

  prefix: /vast

  routes:

    course:

      path: /course/**

      serviceId: spring-cloud-course-service

      strip-prefix: false

    user:

      path: /user/**

      serviceId: spring-cloud-user-service

      strip-prefix: false

启动类添加两个注解

@SpringCloudApplication
@EnableZuulProxy

注意：这两个注解和Eureka中启动类中声明的注解是不一样的

创建两个过滤类，来计算不同URL请求到响应时所需要的时间

PreFilter.class

package com.vast.zuul.filters;

import com.netflix.zuul.ZuulFilter;

import com.netflix.zuul.context.RequestContext;

import com.netflix.zuul.exception.ZuulException;

import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;

import org.springframework.stereotype.Component;

@Component

public class PreFilter extends ZuulFilter {

    @Override

    public String filterType() {

        return FilterConstants.PRE_TYPE;

    }

    @Override

    public int filterOrder() {

        return 0;

    }

    @Override

    public boolean shouldFilter() {

        return true;

    }

    @Override

    public Object run() throws ZuulException {

        RequestContext currentContext = RequestContext.getCurrentContext();

        currentContext.set("startTime", System.currentTimeMillis());

        return null;

    }

}

AccessLogFilter.class

package com.vast.zuul.filters;

import com.netflix.zuul.ZuulFilter;

import com.netflix.zuul.context.RequestContext;

import com.netflix.zuul.exception.ZuulException;

import lombok.extern.slf4j.Slf4j;

import org.springframework.cloud.netflix.zuul.filters.support.FilterConstants;

import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

@Slf4j

@Component

public class AccessLogFilter extends ZuulFilter {

    @Override

    public String filterType() {

        return FilterConstants.POST_TYPE;

    }

    @Override

    public int filterOrder() {

        return FilterConstants.SEND_RESPONSE_FILTER_ORDER - 1;

    }

    @Override

    public boolean shouldFilter() {

        return true;

    }

    @Override

    public Object run() throws ZuulException {

        RequestContext currentContext = RequestContext.getCurrentContext();

        Long startTime = (Long) currentContext.get("startTime");

        HttpServletRequest request = currentContext.getRequest();

        String requestURI = request.getRequestURI();

        Long duration = System.currentTimeMillis() - startTime;

        log.info("uri:{},duration:{}ms", requestURI, duration / 100);

        return null;

    }

}

在父模块下再创建一个子模块服务，作为另外几个服务的父模块（spring-cloud-service）

删掉不需要的src文件夹
在pom.xml中添加

<packaging>pom</packaging>

在该模块下，建立公共服务spring-cloud-common

在服务于服务之间，会有一些公共使用的类或方法，避免重复创建以及维护困难，建立公共模块

在pom.xml引入一些依赖

    <dependencies>

        <!-- JSON 处理工具 -->

        <dependency>

            <groupId>com.alibaba</groupId>

            <artifactId>fastjson</artifactId>

            <version>1.2.31</version>

        </dependency>

        <!-- apache 提供的一些工具类 -->

        <dependency>

            <groupId>commons-codec</groupId>

            <artifactId>commons-codec</artifactId>

            <version>1.9</version>

        </dependency>

    </dependencies>

在当前父模块（spring-cloud-service）中创建一个课程服务模块（spring-cloud-course-service）

在pom.xml中引入相关依赖以及插件

    <dependencies>

        <!-- 引入 Web 功能 -->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <!--

            Eureka 客户端, 客户端向 Eureka Server 注册的时候会提供一系列的元数据信息, 例如: 主机, 端口, 健康检查url等

            Eureka Server 接受每个客户端发送的心跳信息, 如果在某个配置的超时时间内未接收到心跳信息, 实例会被从注册列表中移除

        -->

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>

        </dependency>

        <!-- Java Persistence API, ORM 规范 -->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-jpa</artifactId>

        </dependency>

        <!-- MySQL 驱动, 注意, 这个需要与 MySQL 版本对应 -->

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>6.0.6</version>

        </dependency>

        <!-- 通用模块 -->

        <dependency>

            <groupId>com.vast.spring-cloud</groupId>

            <artifactId>spring-cloud-common</artifactId>

            <version>1.0-SNAPSHOT</version>

        </dependency>

    </dependencies>

    <!--

        SpringBoot的Maven插件, 能够以Maven的方式为应用提供SpringBoot的支持，可以将

        SpringBoot应用打包为可执行的jar或war文件, 然后以通常的方式运行SpringBoot应用

     -->

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

创建application.yml

server:

  port: 7001

  servlet:

    context-path: /course

spring:

  application:

    name: spring-cloud-course-service

  jpa:

    show-sql: true

    hibernate:

      ddl-auto: none

    properties:

      hibernate.format_sql: true

    open-in-view: false

  datasource:

    url: jdbc:mysql://127.0.0.1:3306/test?autoReconnect=true&useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8

    username: root

    password: root

    driver-class-name: com.mysql.cj.jdbc.Driver

    tomcat:

      max-active: 4

      min-idle: 2

      initial-size: 2

eureka:

  client:

    service-url:

      defaultZone: http://server1:8000/eureka/

在启动类中添加三个注解

@SpringBootApplication

/** 向Eureka中注册服务 */

@EnableEurekaClient

/** 用JPA来管理数据 */

@EnableJpaAuditing

建立实体类

package com.vast.entry;

import lombok.AllArgsConstructor;

import lombok.Builder;

import lombok.Data;

import lombok.NoArgsConstructor;

import org.springframework.data.annotation.CreatedDate;

import org.springframework.data.annotation.LastModifiedDate;

import org.springframework.data.jpa.domain.support.AuditingEntityListener;

import javax.persistence.*;

import java.util.Date;

@Data
/* 表明该实体类中的setter方法是private的，需要通过Builder进行build() **/

@Builder

@Entity

@NoArgsConstructor

@AllArgsConstructor
/** 用来通过注解自动向数据库中插入时间 */

@EntityListeners(AuditingEntityListener.class)

@Table(name = "t_course")

public class CoursePo {

    @Id

    @GeneratedValue(strategy = GenerationType.IDENTITY)

    @Column(name = "id")

    /** 自增 id */

    private Long id;

    @Column(name = "course_name", nullable = false)

    /** 课程名称 */

    private String courseName;

    @Column(name = "course_type", nullable = false)

    /** 课程类型 */

    private Integer courseType;

    @Column(name = "course_icon", nullable = false)

    /** 课程图标 */

    private String courseIcon;

    @Column(name = "course_intro", nullable = false)

    /** 课程介绍 */

    private String courseIntro;

    @CreatedDate

    @Column(name = "create_time")

    /** 创建时间 */

    private Date createTime;


    /** Basic用来表明是列，默认的，不用写也是可以的 */

    @Basic

    @LastModifiedDate

    @Column(name = "update_time")

    /** 更新时间 */

    private Date updateTime;

}

创建Dao

package com.vast.dao;

import com.vast.entry.CoursePo;

import org.springframework.data.jpa.repository.JpaRepository;

/** Jpa中有许多已经配置好的方法，以及查询规则，只要按照其指定的规则来即可快速操作数据库中的数据 */

public interface CourseDao extends JpaRepository<CoursePo, Long> {

}

课程实现类 CourseImpl

package com.vast.service.impl;

import com.vast.service.ICourseService;

import com.vast.common.entry.Course;

import com.vast.common.entry.RequestContent;

import com.vast.dao.CourseDao;

import com.vast.entry.CoursePo;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.util.CollectionUtils;

import java.util.Collections;

import java.util.List;

import java.util.Optional;

import java.util.stream.Collectors;

@Service

public class CourseImpl implements ICourseService {

    @Autowired

    private CourseDao courseDao;

    @Override

    public Course getCourseById(Long id) {

        Optional<CoursePo> course = courseDao.findById(id);
        /** java8特性，Lambda表达式，判断实体类是否为空，防止抛出空指针异常 */

        return builderCoursePo(course.orElseGet(() -> CoursePo.invalid()));

    }

    @Override

    public List<Course> getCourseListByIds(RequestContent requestContent) {

        List<Long> ids = requestContent.getIds();

        if (CollectionUtils.isEmpty(ids)) {

            return Collections.emptyList();

        }

        List<CoursePo> courseList = courseDao.findAllById(ids);
        /** java8 特性 */

        return courseList.stream().map(this::builderCoursePo)

                .collect(Collectors.toList());

    }

    /**

     * @param course

     * @return

     * @Description 构造课程信息
     * Builder使用方法

     */

    public Course builderCoursePo(CoursePo course) {

        return Course.builder()

                .courseIcon(course.getCourseIcon())

                .courseIntro(course.getCourseIntro())

                .courseName(course.getCourseName())

                .courseType(course.getCourseType() == 0

                        ? "SpringCloud" : "SSM")

                .build();

    }

}

测试类

启动类中添加注解

@SpringBootApplication

测试类中添加注解

@RunWith(SpringRunner.class)

@SpringBootTest(classes = {TestCourseApplication.class}, webEnvironment = SpringBootTest.WebEnvironment.NONE)

在当前父模块（spring-cloud-service）中创建一个课程服务模块（spring-cloud-user-service）

在pom.xml中引入相关依赖、插件

    <dependencies>

        <!-- 引入 Web 功能 -->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

        <!--

            Eureka 客户端, 客户端向 Eureka Server 注册的时候会提供一系列的元数据信息, 例如: 主机, 端口, 健康检查url等

            Eureka Server 接受每个客户端发送的心跳信息, 如果在某个配置的超时时间内未接收到心跳信息, 实例会被从注册列表中移除

        -->

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>

        </dependency>

        <!-- 引入 Feign, 可以以声明的方式调用微服务 -->

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-openfeign</artifactId>

        </dependency>

        <!-- 引入服务容错 Hystrix 的依赖 -->

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>

        </dependency>

        <!-- Java Persistence API, ORM 规范 -->

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-jpa</artifactId>

        </dependency>

        <!-- MySQL 驱动, 注意, 这个需要与 MySQL 版本对应 -->

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->

        <dependency>

            <groupId>mysql</groupId>

            <artifactId>mysql-connector-java</artifactId>

            <version>6.0.6</version>

        </dependency>

        <!-- 通用模块 -->

        <dependency>

            <groupId>com.vast.spring-cloud</groupId>

            <artifactId>spring-cloud-common</artifactId>

            <version>1.0-SNAPSHOT</version>

        </dependency>

        <dependency>

            <groupId>org.jetbrains</groupId>

            <artifactId>annotations</artifactId>

            <version>RELEASE</version>

            <scope>compile</scope>

        </dependency>

    </dependencies>

    <!--

        SpringBoot的Maven插件, 能够以Maven的方式为应用提供SpringBoot的支持，可以将

        SpringBoot应用打包为可执行的jar或war文件, 然后以通常的方式运行SpringBoot应用

     -->

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

在资源文件夹创建application.yml

server:

  port: 7000

  servlet:

    context-path: /user

spring:

  main:

    allow-bean-definition-overriding: true

  application:

    name: spring-cloud-user-service

  jpa:

    show-sql: true

    hibernate:

      ddl-auto: none

    properties:

      hibernate.format_sql: true

    open-in-view: false

  datasource:

    url: jdbc:mysql://127.0.0.1:3306/test?autoReconnect=true&useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8

    username: root

    password: root

    driver-class-name: com.mysql.cj.jdbc.Driver

    tomcat:

      max-active: 4

      min-idle: 2

      initial-size: 2

eureka:

  client:

    service-url:

      defaultZone: http://server1:8000/eureka/

feign:

  hystrix:

    enabled: true

在启动类添加注解

/** 支持Feign调用 */

@EnableFeignClients

/** 支持服务熔断降级 */

@EnableCircuitBreaker

/** 支持JPA */

@EnableJpaAuditing

/** 支持想Eureka注册服务 */

@EnableEurekaClient

@SpringBootApplication

实现类UserInfoServiceImpl

package com.vast.service.impl;

import com.vast.client.ICourseFeignClient;

import com.vast.common.entry.Course;

import com.vast.common.entry.RequestContent;

import com.vast.common.entry.User;

import com.vast.dao.UserCourseDao;

import com.vast.dao.UserDao;

import com.vast.entity.UserCourseInfo;

import com.vast.entity.UserInfo;

import com.vast.service.IUserService;

import com.vast.vo.CreateUserRequestVo;

import com.vast.vo.UserCourseInfoVo;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.util.CollectionUtils;

import java.util.Collections;

import java.util.List;

import java.util.Optional;

import java.util.stream.Collectors;

@Slf4j

@Service

public class UserInfoServiceImpl implements IUserService {

    private final UserDao userDao;

    private final UserCourseDao userCourseDao;

    private final ICourseFeignClient iCourseFeignClient;

    @Autowired

    public UserInfoServiceImpl(UserDao userDao, UserCourseDao userCourseDao, ICourseFeignClient iCourseFeignClient) {

        this.userDao = userDao;

        this.userCourseDao = userCourseDao;

        this.iCourseFeignClient = iCourseFeignClient;

    }

    @Override

    public User getUserInfoById(Long id) {

        Optional<UserInfo> userInfoById = userDao.findById(id);
         /** 判断对象是否为空 */

        if (!userInfoById.isPresent()) {

            return new User().invalidate();

        }

        return builderUserInfo(userInfoById.get());

    }

    @Override

    public User createUserInfo(CreateUserRequestVo createUserRequestVo) {

        /** 判断传的参数是否为空 */

        if (!createUserRequestVo.validate()) {

            return User.invalidate();

        }

        /** 判断该用户在用户表中已存在 */

        UserInfo userInfoByUsername = userDao.findByUsername(createUserRequestVo.getUsername());

        if (null != userInfoByUsername) {

            return User.invalidate();

        }

        UserInfo saveUserInfo = userDao.save(new UserInfo(createUserRequestVo.getUsername(), createUserRequestVo.getEmail()));

        return new User(saveUserInfo.getId(), saveUserInfo.getUsername(), saveUserInfo.getEmail());

    }

    @Override

    public UserCourseInfoVo getUserCourseInfoById(Long id) {

        /** 根据用户id判断是否有该用户 */

        Optional<UserInfo> userInfoById = userDao.findById(id);

        if (!userInfoById.isPresent()) {

            return UserCourseInfoVo.invalidate();

        }

        /** 获取对象 */

        UserInfo userInfo = userInfoById.get();

        User user = new User(userInfo.getId(), userInfo.getUsername(), userInfo.getEmail());

        /** 根据用户id判断用户课程表中是否有该对应的信息 */

        List<UserCourseInfo> allUserCourseInfoByUserId = userCourseDao.findAllByUserId(id);

        if (CollectionUtils.isEmpty(allUserCourseInfoByUserId)) {

            return new UserCourseInfoVo(Collections.emptyList(), user);

        }

        /** 如果用户id在用户表、用户课程表中都存在，则用feign客户端调用课程服务，获取对应

         * 的课程信息，并将用户、课程信息进行返回

         * */

        List<Course> coursesByIds = iCourseFeignClient.getCoursesByIds(new RequestContent(allUserCourseInfoByUserId.stream()

                .map(UserCourseInfo::getCourseId).collect(Collectors.toList())));

        return new UserCourseInfoVo(coursesByIds, user);

    }

    private User builderUserInfo(UserInfo userInfo) {

        return User.builder()

                .id(userInfo.getId())

                .email(userInfo.getEmail())

                .username(userInfo.getUsername())

                .build();

    }

}

Feign调用客户端

package com.vast.client;

import com.vast.common.entry.Course;

import com.vast.common.entry.RequestContent;

import org.springframework.cloud.openfeign.FeignClient;

import org.springframework.web.bind.annotation.*;

import java.util.List;

/** 1.FeignClient表明是Feign调用；
  * 2.value表明是调用哪个服务实例；
  * 3.fallback是表明熔断时调用哪个类;
  * 4.@RequestMapping中的请求方式以及URL和所调用的服务的控制层中的保持一致
 */

@FeignClient(value = "spring-cloud-course-service", fallback = CourseHystrixClient.class)

public interface ICourseFeignClient {

    @RequestMapping(value = "/get/course/", method = RequestMethod.GET)

    public Course getCourseInfoById(Long id);

    @RequestMapping(value = "/get/courses", method = RequestMethod.POST)

    public List<Course> getCoursesByIds(@RequestBody RequestContent requestContent);

}

Hystrix

package com.vast.client;

import com.vast.common.entry.Course;

import com.vast.common.entry.RequestContent;

import org.springframework.stereotype.Component;

import java.util.Collections;

import java.util.List;

/** 1.@Component声明该类是spring的bean实例；
  * 2.实现Feign客户端接口方法；
  * 3.进行熔断处理;
 */

@Component

public class CourseHystrixClient implements ICourseFeignClient {

    @Override

    public Course getCourseInfoById(Long id) {

        return Course.inValidEntry();

    }

    @Override

    public List<Course> getCoursesByIds(RequestContent requestContent) {

        return Collections.emptyList();

    }

}

测试类

启动类中添加注解

@EnableFeignClients(basePackages = {"com.vast"})

@SpringBootApplication

测试类中添加注解

@RunWith(SpringRunner.class)

@SpringBootTest(classes = CourseApplication.class)

效果图

搭建SpringCloud微服务的更多相关文章

快速搭建 SpringCloud 微服务开发环境的脚手架
本文适合有 SpringBoot 和 SpringCloud 基础知识的人群,跟着本文可使用和快速搭建 SpringCloud 项目. 本文作者:HelloGitHub-秦人 HelloGitHub ...
搭建SpringCloud微服务框架：一、结构和各个组件
搭建微服务框架(结构和各个组件) 简介 SQuid是基于Spring,SpringBoot,使用了SpringCloud下的组件进行构建,目的是想搭建一套可以快速开发部署,并且很好上手的一套微服务框架 ...
十一、Docker搭建部署SpringCloud微服务项目Demo
环境介绍技术选型:SpringCloud&SpringCloud Alibaba&Docker 微服务模块划分: 员工模块:ems-employees 部门模块:ems-depart ...
SpringCloud微服务项目实战 - API网关Gateway详解实现
前面讲过zuul的网关实现,那为什么今天又要讲Spring Cloud Gateway呢?原因很简单.就是Spring Cloud已经放弃Netflix Zuul了.现在Spring Cloud中引用 ...
springcloud微服务架构搭建
SpringCloud微服务框架搭建一.微服务架构 1.1什么是分布式不同模块部署在不同服务器上作用:分布式解决网站高并发带来问题 1.2什么是集群多台服务器部署相同应用构成一个集群作用:通 ...
springcloud(十四)：搭建Zuul微服务网关
springcloud(十四):搭建Zuul微服务网关 1. 2. 3. 4.
【微服务】之二：从零开始，轻松搞定SpringCloud微服务系列--注册中心（一）
微服务体系,有效解决项目庞大.互相依赖的问题.目前SpringCloud体系有强大的一整套针对微服务的解决方案.本文中,重点对微服务体系中的服务发现注册中心进行详细说明.本篇中的注册中心,采用Netf ...
【微服务】之六：轻松搞定SpringCloud微服务-API网关zuul
通过前面几篇文章的介绍,我们可以轻松搭建起来微服务体系中比较重要的几个基础构建服务.那么,在本篇博文中,我们重点讲解一下,如何将所有微服务的API同意对外暴露,这个就设计API网关的概念. 本系列教程 ...
java~springcloud微服务目录索引
回到占占推荐博客索引最近写了不过关于java,spring,微服务的相关文章,今天把它整理一下,方便大家学习与参考. java~springcloud微服务~目录索引 springcloud~服务注 ...

随机推荐

LXC容器
1． LXC简述 Linux container是一种资源隔离机制而非虚拟化技术.VMM(VMM Virtual Machine Monitor)或者叫Hypervisor是标准的虚拟化技术,这 ...
Sleep和 SleepEx函数
Sleep和 SleepEx函数的功能是在指定的执行时间内中止所在线程的执行. SleepEx扩展了Sleep的功能,在最短超时时间间隔已到的情况下恢复线程执行外,在以下两种情况下发生时也可以恢复执行 ...
《基于 UML 的教务系统设计方法研究》论文笔记（十五）
标题:基于 UML 的教务系统设计方法研究时间:2009 来源:太原师范学院关键词:UML:面向对象:建模:教务管理系统. 二.研究内容 UML 建模 UML 涵盖了面向对象的分析.设计和实现,融 ...
sql null+字符=null
哦,谢谢你,我还想问一个declare @temp varchar(10),@identity varchar(10),@sura varchar(10),@p int,@len int,@nod1 ...
Ranger安装部署
1. 概述 Apache Ranger是大数据领域的一个集中式安全管理框架,目的是通过制定策略(policies)实现对Hadoop组件的集中式安全管理.用户可以通过Ranger实现对集群中数据的安全 ...
git下载带有子项目的项目
我用的win 系统 bash命令 git clone --recursive xxxx.git
STM32启动代码详细分析
最近需要学习iap的功能,因此离不开stm32的启动代码的分析,以前看了很多遍,都看不懂,读书百遍,其义自见,因此我有看了一遍,下面的文章,挺好的,因此转载: 在上电复位后,我们都知道会先运行启动代码 ...
【模板】A*B Problem（FFT快速傅里叶）
题目:给出两个n位10进制整数x和y,你需要计算x*y.($n \leq 60000$) 分析: 两个正整数的相乘可以视为两个多项式的相乘, 例如 $15 \times 16 = 240$, 可写成 ...
Stirling数入门
第一类Stirling数定义 $$\begin{aligned}(x)_n & =x(x-1)...(x-n+1)\\&= s(n, 0) + s(n,1)x +..+s(n,n)x ...
C# where 泛型类型约束
泛型定义中的 where 子句指定对用作泛型类型.方法.委托或本地函数中类型参数的参数类型的约束. 约束可指定接口.基类或要求泛型类型为引用.值或非托管类型. 它们声明类型参数必须具备的功能. 作为约 ...

搭建SpringCloud微服务

建立spring父模块

创建 Eureka注册服务子模块

在父模块下再创建一个子模块服务，作为另外几个服务的父模块（spring-cloud-service）

在当前父模块（spring-cloud-service）中创建一个课程服务模块（spring-cloud-course-service）

在当前父模块（spring-cloud-service）中创建一个课程服务模块（spring-cloud-user-service）

搭建SpringCloud微服务的更多相关文章

随机推荐

热门专题