Rest微服务构建 案例工程模块

总体介绍

承接着我们的springmvc+mybatis+mysql初级高级课程，以Dept部门模块做一个微服务通用案例
Consumer消费者（Client）通过REST调用Provider提供者（Server）提供的服务

Maven的分包分模块架构复习

一个简单的Maven模块结构是这样的：

springcloud父工程（Project）下初次带着3个子模块（Module）

创建pom文件

<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.spring.springcloud</groupId>
  <artifactId>springcloud_parent</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>pom</packaging>

  <properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
		<junit.version>4.12</junit.version>
		<log4j.version>1.2.17</log4j.version>
		<lombok.version>1.16.18</lombok.version>
	</properties>

  <dependencyManagement>
      <dependencies>
          <!-- springcloud -->
          <dependency>
             <groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>Dalston.SR1</version>
				<type>pom</type>
				<scope>import</scope>
          </dependency>

           <!-- springboot依赖 -->
           <dependency>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-dependencies</artifactId>
				<version>1.5.9.RELEASE</version>
				<type>pom</type>
				<scope>import</scope>
		  </dependency>

		  <!-- mysql依赖 -->
		  <dependency>
				<groupId>mysql</groupId>
				<artifactId>mysql-connector-java</artifactId>
				<version>5.0.4</version>
			</dependency>

			<!-- druid依赖 -->
			<dependency>
				<groupId>com.alibaba</groupId>
				<artifactId>druid</artifactId>
				<version>1.0.31</version>
			</dependency>

			<!-- spring-boot依赖 -->
			<dependency>
				<groupId>org.mybatis.spring.boot</groupId>
				<artifactId>mybatis-spring-boot-starter</artifactId>
				<version>1.3.0</version>
			</dependency>

			<!-- logback插件 -->
			<dependency>
                 <groupId>ch.qos.logback</groupId>
                 <artifactId>logback-core</artifactId>
                 <version>1.2.3</version>
            </dependency>

			<!-- junit插件 -->
			<dependency>
				<groupId>junit</groupId>
				<artifactId>junit</artifactId>
				<version>${junit.version}</version>
				<scope>test</scope>
			</dependency>

			<!-- log4j日志包 -->
			<dependency>
				<groupId>log4j</groupId>
				<artifactId>log4j</artifactId>
				<version>${log4j.version}</version>
			</dependency>
      </dependencies>

  </dependencyManagement>

  <build>
      <finalName>springcloud_parent</finalName>
      <resources>
			<resource>
				<directory>src/main/resources</directory>
				<filtering>true</filtering>
			</resource>
		</resources>

		<plugins>
		    <plugin>
		      <groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-resources-plugin</artifactId>
				<configuration>
					<delimiters>
						<delimit>$</delimit>
					</delimiters>
				</configuration>
		    </plugin>

		</plugins>

  </build>

  <modules>
  	<module>springcloud_api</module>
  	<module>springcloud_provider_dept</module>
  	<module>springcloud_consumer_dept</module>
  	<module>springcloud_eureka</module>
  	<module>springcloud_eureka_7002</module>
  	<module>springcloud_eureka_7003</module>
  </modules>
</project>

　　

microservicecloud-api

封装的整体Entity/接口/公共配置等

jar文件

package com.spring.pojo;

import java.io.Serializable;

import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

//@SuppressWarnings("serial")
@NoArgsConstructor
@Data
@Accessors(chain=true)
public class Dept implements Serializable{

	public Long deptno;
	public String dname;
	public String db_source;

	public Dept(String dname)
	{
		super();
		this.dname = dname;
	}

	public Dept(Long deptno, String dname, String db_source) {
		super();
		this.deptno = deptno;
		this.dname = dname;
		this.db_source = db_source;
	}

}

　　

<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>
  <parent>
    <groupId>com.spring.springcloud</groupId>
    <artifactId>springcloud_parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>

  <artifactId>springcloud_api</artifactId>

  <dependencies><!-- 当前Module需要用到的jar包，按自己需求添加，如果父类已经包含了，可以不用写版本号 -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-feign</artifactId>
		</dependency>
	</dependencies>

</project>

　　

创建springcloud_provider_dept       微服务提供者

jar项目 pom文件

<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>
  <parent>
    <groupId>com.spring.springcloud</groupId>
    <artifactId>springcloud_parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>

  <properties>
       <version>0.0.1-SNAPSHOT</version>
  </properties>

  <artifactId>springcloud_provider_dept</artifactId>

  <dependencies>
           <!-- 引用自己定义的api通用包,可以使用Dept部门Entity -->
           <dependency>
                  <groupId>com.spring.springcloud</groupId>
                  <artifactId>springcloud_api</artifactId>
                  <version>${version}</version>
           </dependency>

            <!-- actuator监控信息完善 -->
            <dependency>
                   <groupId>org.springframework.boot</groupId>
			       <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>

            <!-- 将微服务provider侧注册进eureka -->
            <dependency>
                    <groupId>org.springframework.cloud</groupId>
			        <artifactId>spring-cloud-starter-eureka</artifactId>
            </dependency>

            <!--  -->
            <dependency>
                   <groupId>org.springframework.cloud</groupId>
			       <artifactId>spring-cloud-starter-config</artifactId>
            </dependency>

            <!-- junit插件 -->
            <dependency>
                   <groupId>junit</groupId>
			       <artifactId>junit</artifactId>
            </dependency>

             <!-- mysql -->
             <dependency>
                    <groupId>mysql</groupId>
			        <artifactId>mysql-connector-java</artifactId>
             </dependency>

             <!-- druid连接池 -->
             <dependency>
                     <groupId>com.alibaba</groupId>
			         <artifactId>druid</artifactId>
             </dependency>

              <!-- logback  -->
              <dependency>
                    <groupId>ch.qos.logback</groupId>
			         <artifactId>logback-core</artifactId>
              </dependency>

              <!-- mybatis-spring -->
              <dependency>
                     <groupId>org.mybatis.spring.boot</groupId>
			         <artifactId>mybatis-spring-boot-starter</artifactId>
              </dependency>

              <!-- spring-jetty -->
              <dependency>
                     <groupId>org.springframework.boot</groupId>
			         <artifactId>spring-boot-starter-jetty</artifactId>
              </dependency>

              <!-- spring-starter -->
              <dependency>
                    <groupId>org.springframework.boot</groupId>
			         <artifactId>spring-boot-starter-web</artifactId>
              </dependency>

              <!-- spring-starter -->
              <dependency>
                    <groupId>org.springframework.boot</groupId>
			        <artifactId>spring-boot-starter-test</artifactId>
              </dependency>

              <!-- 修改后立即生效，热部署 -->
              <dependency>
                     <groupId>org.springframework</groupId>
			         <artifactId>springloaded</artifactId>
              </dependency>
              <dependency>
			         <groupId>org.springframework.boot</groupId>
			          <artifactId>spring-boot-devtools</artifactId>
		       </dependency>
       </dependencies>

</project>

　　application.yml

server:
  port: 8001

mybatis:
  config-location: classpath:mybatis/mybatis.cfg.xml        # mybatis配置文件所在路径
  type-aliases-package: com.spring.pojo    # 所有Entity别名类所在包
  mapper-locations:
  - classpath:mybatis/mapper/**/*.xml                       # mapper映射文件

spring:
   application:
    name: spingcloud-dept
   datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
    url: jdbc:mysql://localhost:3306/cloudDB01              # 数据库名称
    username: root
    password: root
    dbcp2:
      min-idle: 5                                           # 数据库连接池的最小维持连接数
      initial-size: 5                                       # 初始化连接数
      max-total: 5                                          # 最大连接数
      max-wait-millis: 200                                  # 等待连接获取的最大超时时间

eureka:
    client: #客户端注册进eureka服务列表内
     service-url:
       # defaultZone: http://localhost:7001/eureka
        defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

instance:
    instance-id: spingcloud-dept:8001
    prefer-ip-address:  true  #访问路径可以显示IP地址

info:
  app.name: springcloud-dept
  company.name: www.leitf.com
  build.artifactId: $project.artifactId$
  build.version: $project.version$

　　mybatis.cfg.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

	<settings>
		<setting name="cacheEnabled" value="true" /><!-- 二级缓存开启 -->
	</settings>

</configuration>

　　DeptMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.spring.dao.DeptDao">

	<select id="findeById" resultType="Dept" parameterType="Long">
	   select deptno,dname,db_source from dept where deptno=#{deptno};
	</select>

    <select id="findAll" resultType="Dept">
      select deptno,dname,db_source from dept;
    </select>

    <insert id = "addDept" parameterType="Dept">
      insert into dept(dname,db_source) values(#{dname},#{db_source});
    </insert>
</mapper>

　　DeptDao

package com.spring.dao;

import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import com.spring.pojo.Dept;

@Mapper
public interface DeptDao {

	//添加部门
	public boolean addDept(Dept dept);

	//根据id
	public Dept findeById(Long id);

	//查询所有
	public List<Dept> findAll();

}

　　DeptService

package com.spring.service;

import java.util.List;

import com.spring.pojo.Dept;

public interface DeptService {

	    //添加部门
		public boolean add(Dept dept);

		//根据id
		public Dept get(Long id);

		//查询所有
		public List<Dept> list();
}

　　DeptServiceImpl

package com.spring.service.impl;

import java.util.List;

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

import com.spring.dao.DeptDao;
import com.spring.pojo.Dept;
import com.spring.service.DeptService;

@Service
public class DeptServiceImpl implements DeptService {

	@Autowired
	private DeptDao deptdao;

	@Override
	public boolean add(Dept dept) {
		// TODO Auto-generated method stub
		return deptdao.addDept(dept);
	}

	@Override
	public Dept get(Long id) {
		// TODO Auto-generated method stub
		return deptdao.findeById(id);
	}

	@Override
	public List<Dept> list() {
		// TODO Auto-generated method stub
		System.out.println("==================");
		return deptdao.findAll();
	}

}

　　DeptController

package com.spring.controller;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.spring.pojo.Dept;
import com.spring.service.DeptService;

@RestController
public class DeptController {

	@Autowired
	private DeptService deptService;

	@Autowired
	private DiscoveryClient client;

	@RequestMapping(value="/dept/add",method=RequestMethod.POST)
	public boolean add(@RequestBody Dept dept){
		return deptService.add(dept);
	}

	@RequestMapping(value="/dept/get/{id}",method=RequestMethod.GET)
	public Dept get(Long id){
		return deptService.get(id);
	}

	@RequestMapping(value="/dept/list",method=RequestMethod.GET)
	public List<Dept> list(){
		return deptService.list();
	}

//	@Autowired
//	private DiscoveryClient client;
	@RequestMapping(value = "/dept/discovery", method = RequestMethod.GET)
	public Object discovery()
	{
		List<String> list = client.getServices();
		System.out.println("**********" + list);

		List<ServiceInstance> srvList = client.getInstances("MICROSERVICECLOUD-DEPT");
		for (ServiceInstance element : srvList) {
			System.out.println(element.getServiceId() + "\t" + element.getHost() + "\t" + element.getPort() + "\t"
					+ element.getUri());
		}
		return this.client;
	}

}

　sp

package com.spring;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient //本服务启动后会自动注册到Eureka中
@EnableDiscoveryClient
public class springcloud_dept8001_App {
  public static void main(String[] args){
	  SpringApplication.run(springcloud_dept8001_App.class, args);
  }
}

　　

ringcloud_consumer_dept   部门消费者

<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>
  <parent>
    <groupId>com.spring.springcloud</groupId>
    <artifactId>springcloud_parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
  </parent>
  <properties>
       <version>0.0.1-SNAPSHOT</version>
  </properties>
  <artifactId>springcloud_consumer_dept</artifactId>
  	<description>部门微服务消费者</description>

  <dependencies>
        <!-- 引用自己定义的api通用包,可以使用Dept部门Entity -->
           <dependency>
                  <groupId>com.spring.springcloud</groupId>
                  <artifactId>springcloud_api</artifactId>
                  <version>${version}</version>
           </dependency>

         <!-- Ribbon相关 -->
         <dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-eureka</artifactId>
		</dependency>

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

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

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<!-- 修改后立即生效，热部署 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>springloaded</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
		</dependency>
  </dependencies>
</project>

　　application.yml

server:
  port: 80

　　configBeans

package com.spring;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient //本服务启动后会自动注册到Eureka中
@EnableDiscoveryClient
public class springcloud_dept8001_App {
  public static void main(String[] args){
	  SpringApplication.run(springcloud_dept8001_App.class, args);
  }
}

　　controller

package com.spring.controller;

import java.util.List;

import javax.ws.rs.ApplicationPath;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.spring.pojo.Dept;

@RestController
public class DeptController_consumer {

	private static String REST_URL_PREFIX="http://localhost:8001";
	@Autowired
	private RestTemplate restTemplate;

	@RequestMapping(value="/consumer/dept/add")
	public boolean add(Dept dept){
		return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add", dept, boolean.class);
	}

	@RequestMapping(value="/consumer/dept/get/{id}")
	public Dept get(@PathVariable("id") Long id){
		return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get"+id, Dept.class);
	}

	@SuppressWarnings("unchecked")
	@RequestMapping(value="/consumer/dept/list")
    public List<Dept> list(){
		return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list", List.class);
	}

	@RequestMapping(value="/consumer/dept/discovery")
	public Object discovery(){
		return restTemplate.getForObject(REST_URL_PREFIX+"/dept/discovery", Object.class);
	}
}

　　

package com.spring;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class springcloud_dept80_App {

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

　　

80端口是为HTTP(HyperText Transport Protocol)即超文本传输协议开放的
此为上网冲浪使用次数最多的协议，主要用于WWW(World Wide Web)即万维网传输信息的协议。

可以通过HTTP地址(即常说的"网址")加":80"来访问网站，

因为浏览网页服务默认的端口号都是80，因此只需输入网址即可，不用输入":80"了。

　

原文地址：https://www.cnblogs.com/jacksonxiao/p/11487862.html

时间： 2024-08-29 07:12:36

Rest微服务构建 案例工程模块的相关文章

SpringCloud学习系列-Rest微服务构建-整体父工程Project

总体介绍 承接着我们的springmvc+mybatis+mysql初级高级课程,以Dept部门模块做一个微服务通用案例Consumer消费者(Client)通过REST调用Provider提供者(Server)提供的服务    Maven的分包分模块架构   一个Project带着多个Module子模块  MicroServiceCloud父工程(Project)下初次带着3个子模块(Module) microservicecloud-api 封装的整体Entity/接口/公共配置等 micr

微服务监控案例之一

     首先,您需要了解什么是微服务架构设计,同时了解相关微服务与Docker介绍, 微服务架构的本质,是把整体的业务拆分成很多有特定明确功能的服务,通过很多分散的小服务之间的配合,去解决更大,更复杂的问题.对被拆分后的服务进行分类和管理,彼此之间使用统一的接口来进行交互.      微服务的特点决定了功能模块的部署是分布式的,以往在单应用环境下,所有的业务都在同一个服务器上,如果服务器出现错误和异常,我们只要盯住一个点,就可以快速定位和处理问题,但是在微服务的架构下,大部分功能模块都是单独部

基于Spring Cloud的微服务构建学习-3 服务治理：Spring Cloud Eureka

基于Spring Cloud的微服务构建学习-3 服务治理:Spring Cloud Eureka 什么是服务治理 服务治理可以说是微服务架构中最为核心和基础的模块,它主要用来实现各个微服务实例的自动化注册与发现. 为什么需要服务治理模块 在最初构建微服务系统的时候可能服务并不多,我们可以通过做一些静态配置来完成服务调用 此时看着一切都还正常. 随着项目逐渐接近尾声,维护人员需要维护的服务越来越多,越来越复杂,最终形成大量的配置文件,维护将会变得越来越困难.此时,微服务应用实例自动化管理框架变得

基于Spring Cloud的微服务构建学习-2 Spring Boot

基于Spring Cloud的微服务构建学习-2 Spring Boot 为什么使用Spring Boot而不是Spring Spring Boot具有自动化配置,快速开发,轻松部署优点,非常适合用作微服务架构中各项具体微服务的开发框架.它不仅可以帮助我们快速的构建微服务,还可以轻松简单的整合Spring Cloud实现系统服务化,而如果使用了传统的Spring构建方式的话,在整合过程中我们还需要做更多的依赖管理工作才能让它们完好的运行起来. Spring Boot的宗旨并非是重写Spring或

微服务构建持久 API 的7大规则

近年来,微服务架构发展迅速,SparkPost 就是早期落地微服务架构公司之一,他们发现落地微服务过程中,不光需要考虑服务发现.服务注册.服务调用跟踪链等等架构问题,也需要重视微服务 API 的变更管理.微服务的一大特性就是独立发布,快速迭代,但前提是足够稳定,他们在使用微服务构建API的过程中就遇到很多问题: 客户(微服务使用方)经常反馈 API 升级变更后不可用,有时影响范围不可控,导致该微服务上线延期,甚至线上故障,违背了微服务初衷. API 参数变化或返回结果变化而导致客户端行为不一致,

微服务架构案例(01)：项目技术选型简介，架构图解说明

本文源码:GitHub·点这里 || GitEE·点这里 一.单体架构 单体架构在中等偏小的业务中比较常见,场景模式就是单个应用.单个数据库.一个程序包(例如war格式或者Jar格式)包含所有业务需求功能,这是一种比较传统的架构风格. 单体架构的缺陷 复杂性高,整个项目包含的模块多,依赖模糊,修改程序容易触发不可知问题. 扩展能力受限,单体应用只能整体进行扩展,无法针对业务模块的特性进行伸缩. 稳定性差,任何微小的问题,都可能导致整个应用服务直接挂掉. 二.微服务架构 微服务架构是一种架构概念,

【SpringCloud】(1)---基于RestTemplate微服务项目案例

基于RestTemplate微服务项目 在写SpringCloud搭建微服务之前,我想先搭建一个不通过springcloud只通过SpringBoot和Mybatis进行模块之间额通讯.然后在此基础上再添加SpringCloud框架. 下面先对案例做个说明 该项目有一个maven父模块,其中里面有三个子模块:  serverspringcloud:整体父工程.    serverspringcloud-api:公共子模块,放公共实体对象.  serverspringcloud-provider-

深入理解SpringCloud与微服务构建

旭日Follow_24 的CSDN 博客 ,全文地址请点击: https://blog.csdn.net/xuri24/article/details/81742534 目录 一.SpringCloud微服务技术简介 1.1 微服务的功能主要体现在以下儿个方面. 1.2 微服务具有以下的特点. 二.开发框架SpringBoot 三.服务注册和发现Ereka 3.1 什么是Eureka 3.2 Ereka优势 ( l ) Registe 「一一服务注册 (2) Renew一一服务续约 (3) Fe

基于Spring Cloud的微服务构建学习-3 Spring Cloud Eureka配置详解

配置详解 在Eureka的服务治理体系中,主要分为服务端与客户端.服务端为服务注册中心,而客户端为各个提供接口的微服务应用.当部署高可用注册中心时,每个服务端也已经成为了客户端,因此,在使用Spring Cloud Eureka的过程中,我们所做的配置内容几乎都是对Eureka客户端配置进行的操作,所以了解这部分的配置内容,对于用好Eureka非常有帮助. 而Eureka服务端更多类似于一个现成产品,大多数情况下,我们不需要修改它的配置信息. Eureka客户端配置分类 服务注册相关配置,包括服