Spring Cloud+ Eureka微服务基础项目搭建（已实现调用增删改查微服务，持续更新）

最新推荐文章于 2024-04-21 21:06:16 发布

西丽沙河尚

最新推荐文章于 2024-04-21 21:06:16 发布

阅读量4.7k

点赞数 7

本文链接：https://blog.csdn.net/qq_15329947/article/details/87807018

版权

Spring Boot 同时被 3 个专栏收录

27 篇文章 1 订阅

订阅专栏

Spring Cloud

3 篇文章 0 订阅

订阅专栏

微服务

2 篇文章 0 订阅

订阅专栏

O、Spring Cloud Eureka概念

Spring Cloud Eureka是什么？

Spring Cloud Eureka是Spring Cloud Netflix微服务套件中的一部分，它基于Netflix
Eureka做了二次封装，主要负责完成微服务架构中的服务治理功能。Spring Cloud通过为Eureka增加了Spring
Boot风格的自动化配置，我们只需通过简单引入依赖和注解配置就能让Spring
Boot构建的微服务应用轻松地与Eureka服务治理体系进行整合。

关于Eureka的更多理论，可以参考《Spring Cloud微服务实战》第3章内容。

一、IntelliJ IDEA搭建并测试项目

本项目是一个多模块项目，每个独立功能被抽取为一个Module，这样便于在IntelliJ IDEA中管理项目，避免了在不同的Project窗口来回切换。

1.1 新建空工程

新建空工程，命名为eureka-mall
在这里插入图片描述

1.2 搭建公共实体类模块

新建一个Module，命名为mall-crud，引入Lombok依赖。
其中的实体类来自我的博文《SpringBoot+MySQL+MyBatis（Mapper.xml方式）实现简单的多表CRUD（RESTful风格HTTP接口）》
User.java

package com.jake.mallmodel.entity;

import lombok.Data;

@Data
public class User {

    private Integer uid;

    private String username;

    private String password;

}

UserInfo.java

package com.jake.mallmodel.entity;

import lombok.Data;

import java.util.List;

@Data
public class UserInfo {

    private List<User> users;

    private String cname;

    private String city;

}

1.3 搭建增删改查模块

此模块是Eureka的服务之一，对外提供User和UserInfo的增删改查操作，其CRUD三层架构代码也来自我的博文《SpringBoot+MySQL+MyBatis（Mapper.xml方式）实现简单的多表CRUD（RESTful风格HTTP接口）》，可以在IntelliJ IDEA中直接引入已存在的模块：
在这里插入图片描述
修改项目名为mall-crud（同时也修改包名），删除实体类，并在pom文件中（1）引入Eureka Server相关的依赖，（2）引入mall-model项目依赖，以便于导入User和UserInfo实体类：
pom.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.jake</groupId>
    <artifactId>mall-crud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>mall-crud</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </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>Greenwich.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.54</version>
        </dependency>

        <dependency>
            <groupId>com.jake</groupId>
            <artifactId>mall-model</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
        </repository>
    </repositories>

</project>

application.yml

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/eureka-db?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
    username: root
    password: 123
    driver-class-name: com.mysql.cj.jdbc.Driver
  application:
    name: mall-crud
mybatis:
  mapper-locations: classpath:mapper/*xml
server:
  port: 8083
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8081/eureka/

在启动类上加入@EnableEurekaClient注解，标志这是Eureka客户端，可以将自身注册到服务端上。

package com.jake.eurekaclient;

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

@SpringBootApplication
@EnableEurekaClient
public class EurekaClientApplication {

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

}

为了方便与后面Eureka客户端调用接口的代码比较，在此处贴出CRUD接口所在控制层的代码：

package com.jake.mallcrud.controller;

import com.jake.mallcrud.service.UserService;
import com.jake.mallmodel.entity.User;
import com.jake.mallmodel.entity.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("users")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 查找所有用户
     * @return
     */
    @GetMapping
    public List<User> findAllUsers() {
        return userService.findAllUsers();
    }

    /**
     * 查找所有用户信息
     * @return
     */
    @GetMapping("info")
    public List<User> findAllUserInfo() {
        return userService.findAllUserInfo();
    }

    /**
     * 通过id查找用户
     * @param uid
     * @return
     */
    @GetMapping("{uid}")
    public User findUserById(@PathVariable Integer uid) {
        return userService.findUserById(uid);
    }

    /**
     * 通过id查找用户信息
     * @param uid
     * @return
     */
    @GetMapping("info/{uid}")
    public UserInfo findUserInfoById(@PathVariable Integer uid) {
        return userService.findUserInfoById(uid);
    }

    /**
     * 通过用户名和公司名查找用户
     * @param username
     * @param cname
     * @return
     */
    @GetMapping("info/{cname}/{username}")
    public List<UserInfo> findUserInfoByUsernameAndCname(@PathVariable String username, @PathVariable String cname) {
        return userService.findUserInfoByUsernameAndCname(username, cname);
    }

    /**
     * 新增用户
     * @param user
     * @return
     */
    @PostMapping
    public String createUser(@RequestBody User user) {
        if (user != null) {
            userService.createUser(user);
            return "添加用户成功";
        } else {
            return "添加用户失败";
        }
    }

    /**
     * 修改用户
     * @param user
     * @return
     */
    @PutMapping
    public String updateUser(@RequestBody User user) {
        User userInDb = userService.findUserById(user.getUid());
        if (userInDb != null) {
            userService.updateUser(user);
            return "更新用户成功";
        } else {
            return "更新用户失败";
        }
    }

    /**
     * 删除用户
     * @param uid
     * @return
     */
    @DeleteMapping("{uid}")
    public String removeUserById(@PathVariable Integer uid) {
        User user = userService.findUserById(uid);
        if (user == null) {
            return "数据库中不存在id为" + uid + "的用户";
        } else {
            userService.removeUserById(uid);
            return "删除成功";
        }
    }

}

1.4 搭建Eureka服务端

Eureka服务端是一个服务注册和发现中心，并可以通过心跳检测时刻更新微服务的注册信息。
新建一个Module，命名为eureka-server，在Dependencies中选择Cloud Discovery，建立好工程：
在这里插入图片描述
在启动类上加入@EnableEurekaServer注解，标记这是Eureka服务端：

package com.jake.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

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

}

application.yml中做如下配置：

server:
  port: 8081
eureka:
  instance:
    hostname: eureka-server
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

其中配置文件中各个变量的作用可通过查看源码的注释了解。

1.5 搭建Eureka客户端

新建模块，选择的Dependencies如下图：
在这里插入图片描述
此模块用于测试，可以调用其他注册到Eureka Server的服务提供的接口，同时其自身也是一个服务。本文中用于调用mall-crud提供的CRUD接口。
application.yml：

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8081/eureka/
server:
  port: 8082
spring:
  application:
    name: eureka-client

配置RestTemplate的Bean对象：

package com.jake.eurekaclient.config;

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 RestConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

}

记得在启动类上加入@EnableEurekaClient注解。
测试mall-crud项目接口用的控制层：

package com.jake.eurekaclient.controller;

import com.jake.mallmodel.entity.User;
import com.jake.mallmodel.entity.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("users")
@SuppressWarnings("unchecked")
public class UserController {

    @Autowired
    private RestTemplate restTemplate;

    private static final String MALL_CRUD_USERS_URL = "http://mall-crud/users/";

    @GetMapping
    public List<User> getUsers() {
        List<User> users = restTemplate.getForObject(MALL_CRUD_USERS_URL, List.class);
        return users;
    }

    @GetMapping("info")
    public List<UserInfo> getAllUserInfo() {
        List<UserInfo> allUserInfo = restTemplate.getForObject(MALL_CRUD_USERS_URL + "info/", List.class);
        return allUserInfo;
    }

    @GetMapping("{uid}")
    public User getUserById(@PathVariable Integer uid) {
        User user = restTemplate.getForObject(MALL_CRUD_USERS_URL + uid, User.class);
        return user;
    }

    @GetMapping("info/{uid}")
    public UserInfo getUserInfoById(@PathVariable Integer uid) {
        UserInfo userInfo = restTemplate.getForObject(MALL_CRUD_USERS_URL + "info/" + uid, UserInfo.class);
        return userInfo;
    }

    @GetMapping("info/{cname}/{username}")
    public List<UserInfo> getUserInfoByUsernameAndCname(@PathVariable String username, @PathVariable String cname) {
        List<UserInfo> userInfoList = restTemplate.getForObject(MALL_CRUD_USERS_URL + "info/" + cname + "/" + username, List.class);
        return userInfoList;
    }

    @PostMapping
    public String addUser(@RequestBody User user) {
        String msg = restTemplate.postForObject(MALL_CRUD_USERS_URL, user, String.class);
        return msg;
    }

    @PutMapping
    public void updateUser(@RequestBody User user) {
        restTemplate.put(MALL_CRUD_USERS_URL, user);
    }

    @DeleteMapping("{uid}")
    public void deleteUserById(@PathVariable Integer uid) {
        restTemplate.delete(MALL_CRUD_USERS_URL + uid);
    }

}

其中实体类User来自项目mall-model，从URL可知，此客户端要调用的是mall-crud的RESTFUL接口，获取用户数据。
注：此处有个缺陷：restTemplate的put和delete方法的类型为void，所以访问eureka-client的新增和删除接口没有获取mall-crud接口的提示信息，并返回给前端。

二、测试Eureka微服务调用

2.1 访问Eureka后台管理页面

在浏览器中输入：localhost:8081，可进入Eureka Server主页
在这里插入图片描述
由页面信息可知，eureka-client（8082）和mall-crud（8083）已注册到Eureka Server，两者可以获取对方的注册信息，并相互访问接口，本文中，我们通过postman测试eureka-client（8082）来访问mall-crud（8083）的CRUD接口。

2.2 Postman测试CRUD接口

2.2.1 查找用户

HTTP请求方式选为GET
localhost:8082/users
localhost:8082/users/info
localhost:8082/users/1
localhost:8082/users/info/admin.com/admin

2.2.2 新增用户

HTTP请求方式选为POST，请求头选为Content-Type：application/json
localhost:8082/users/

{
	"username": "Jason Tang",
	"uid": 10
}

2.2.3 更新用户

HTTP请求方式选为PUT，请求头选为Content-Type：application/json
localhost:8082/users/

{
	"username": "Jason.Tang",
	"uid": 10
}

2.2.4 删除用户

HTTP请求方式选为DELETE
localhost:8082/users/10

西丽沙河尚

关注

7
点赞
踩
26

收藏

觉得还不错? 一键收藏
2
评论
Spring Cloud+ Eureka微服务基础项目搭建（已实现调用增删改查微服务，持续更新）

O、Spring Cloud Eureka概念Spring Cloud Eureka是什么？Spring Cloud Eureka是Spring Cloud Netflix微服务套件中的一部分，它基于NetflixEureka做了二次封装，主要负责完成微服务架构中的服务治理功能。Spring Cloud通过为Eureka增加了SpringBoot风格的自动化配置，我们只需通过简单引入依赖...
复制链接

扫一扫