如何啟動一個SpringCloud項目

  作為一個剛剛步入職場的小白，剛進公司就接觸到springCloud，公司所有的項目構建都是基於springCloud部署的，在學校學過相關的概念但是沒實際操作過這種東西，所以想由淺入深學習下。該隨筆會記錄springCoud的構建過程。

 

一.首先，創建父工程

 1.選擇 new project

 

2.選擇Maven，不要勾選提示的內容，Next

 

3.寫項目名和選擇存放地址（IDEA版本不同此處會有差異，但是基本的步驟都是一樣的）,Finish

 

4.創建完父工程后，可以看到這樣的項目構造，右鍵src，delete刪除掉

 

5.pom.xml文件，引入相關依賴(maven地址：https://mvnrepository.com/)

<?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.shiwangeweishenme</groupId>
    <artifactId>springcloud</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <!-- 打包方式-->
    <packaging>pom</packaging>

    <!-- 版本控制 -->
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <swagger.version>2.8.0</swagger.version>
        <junit.verison>4.12</junit.verison>
        <lombok.version>1.18.12</lombok.version>
        <druid.version>1.1.2</druid.version>
        <springboot.version>2.1.4.RELEASE</springboot.version>
        <springCloud.version>Greenwich.SR1</springCloud.version>
        <log4j.version>2.13.3</log4j.version>
        <logback.version>1.2.3</logback.version>
        <mysql.version>5.1.6</mysql.version>
        <mybatis-plus-boot-starter.version>3.0-RC3</mybatis-plus-boot-starter.version>
        <jetty.version>6.1.25</jetty.version>
        <devtools.version>2.1.14.RELEASE</devtools.version>
        <swagger.version>2.8.0</swagger.version>
        <druid.version>1.1.21</druid.version>
        <springBoot.version>2.1.4</springBoot.version>
    </properties>

    <dependencyManagement>

        <dependencies>
            <!-- 1.先導入springCloud依賴 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${springCloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- 2.springCloud是基於很多個springBoot服務的，必須導入springBoot依賴-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${springboot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- 3.MySql數據庫連接依賴 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>

            <!-- 4.數據源-->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.20</version>
                <scope>import</scope>
            </dependency>

            <!-- 5.junit-->
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.verison}</version>
                <scope>import</scope>
            </dependency>

            <!-- 6.lombok -->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>

            <!-- 7.log4j -->
            <dependency>
                <groupId>org.apache.logging.log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>

            <dependency>
                <groupId>ch.qos.logback</groupId>
                <artifactId>logback-core</artifactId>
                <version>${logback.version}</version>
            </dependency>

            <!-- 8.我的項目用到了mybatis-plus,沒用到的可以不用導入 -->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatis-plus-boot-starter.version}</version>
            </dependency>
         
            <dependency>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>jetty</artifactId>
                <version>${jetty.version}</version>
            </dependency>

            <!-- 9.Swagger依賴包，Swagger用於做接口測試，用於生成、描述、調用和可視化 RESTful 風格的 Web 服務 -->
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger2</artifactId>
                <version>${swagger.version}</version>
            </dependency>

            <!-- 10. swagger配置-->
            <dependency>
                <groupId>io.springfox</groupId>
                <artifactId>springfox-swagger-ui</artifactId>
                <version>${swagger.version}</version>
            </dependency>

            <!-- 11.熱部署 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-devtools</artifactId>
                <version>${devtools.version}</version>
            </dependency>
        </dependencies>

    </dependencyManagement>

</project>

 

 

二.創建子工程:springCloud-api

1.右鍵項目,New-->Module

 

2.同樣，不勾選，點擊Next

 

3.子項目名字為springCloud-api，點擊Finish(不同版本IDEA這一步可能不同)

 

4.可以看到，創建子模塊后，在springCloud父模塊下有個springCloud-api子模塊，子模塊pom.xml的parent指向父類

 

5.引入子工程依賴

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.shiwangeweishenme</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springCloud-api</artifactId>

    <dependencies>

        <!--假如父工程配置了版本信息，子工程就不需要配置版本信息了-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

 

6.項目上必然會涉及到連接數據庫，先創建數據庫(我用的是Navicat for MySQL)和數據庫表

 

運行下面的SQL

CREATE TABLE `dept` (
  `deptNum` int(11) NOT NULL AUTO_INCREMENT COMMENT '部門編碼',
  `name` varchar(255) NOT NULL COMMENT '部門名字',
  PRIMARY KEY (`deptNum`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

NSERT INTO `dept` VALUES ('1', 'java一部');
INSERT INTO `dept` VALUES ('2', 'Java二部');

 

7.IDEA連接MySQL

 

接着，填寫前三個紅框內的內容，Database是數據庫的名字，填完后點擊Test Connection“”測試連接

在這里，可能會提示時區錯誤的報紅，解決方法見https://www.cnblogs.com/cnsdhzzl/p/13563648.html

 

8.在子工程的src里面創建包和實體類，如圖：

 

 上述代碼

package com.feng.springCloud.pojo;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;

/**
 * @author shiwangeweishenme
 * @date 2021/2/24
 * @since JDK1.8
 */

@Data
@Accessors(chain = true)  //啟用鏈式結構
@NoArgsConstructor  //給類提供一個無參構造函數
@TableName("dept")
public class Dept implements Serializable {

    /**
     *  部門編號
     */
    private int deptNum;

    /**
     *  部門名稱
     */
    private String name;

}

 

9.該服務只提供一個功能，就是提供pojo，接下來將寫第二個子工程--服務提供者

 

三.創建另一個子工程：springCloud-provider(服務提供者)

1.創建子工程的步驟和"二"中的1、2、3步驟相同，這里不反復闡述了，只不過第3步把工程名字改為springCloud-provider即可

 

2.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">
    <!--博客園:拾萬個為什么 -->
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.shiwangeweishenme</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springCloud-provider</artifactId>

    <dependencies>
        <!-- 這里我需要用到api的實體類，所以必須導入api工程的依賴 -->
        <dependency>
            <groupId>com.shiwangeweishenme</groupId>
            <artifactId>springCloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!-- junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- 數據庫連接 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!-- 數據源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>

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

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

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

        <!-- 熱部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>

    </dependencies>
</project>

 

3.找到src-main目錄，在resource下創建mybatis.mapper目錄,同時，創建mybatis-config.xml(mybati配置文件)

    new--->Directory--->寫入“mybatis.mapper”

    右鍵new resource--->XML File

mybatis-config.xml的配置信息如下：(具體見：https://mybatis.org/mybatis-3/zh/getting-started.html)

<?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>   
</configuration>

 

4.配置application.yml

  在resource下new--->FIle

 

配置代碼

#配置端口號
server:
  port: 8001

#配置mybatis-plus
mybatis-plus:
  #配置別名
  type-aliases-package: com.feng.springCloud.pojo
#  #mybatis-plus配置路徑
#  config-location: classpath:mybatis/mybatis-config.xml
  #mapper配置路徑
  mapper-locations: classpath:mybatis/mapper/*.xml

#配置spring
spring:
  application:
    #給這個工程起個名字，一定要見字知義
    name: springCloud-provider-8001
  #配置數據源
  datasource:
    #配置數據源
    type: com.alibaba.druid.pool.DruidDataSource
    name: datasource
    #驅動
    driver-class-name: org.gjt.mm.mysql.Driver
    #數據庫url，數據庫名稱根據自己的定
    url: jdbc:mysql://localhost:3306/shiwangeweishenme?useUnicode=true&characterEncoding=UTF-8
    username: root
    password: root
    #通過別名的方式配置擴展插件,stat日志用的filter
    filters: stat
    #最大連接池數量
    maxActive: 20
    #初始化時建立物理連接的個數
    initialSize: 5
    #獲取連接時最大等待時間，單位毫秒
    maxWait: 60000
    #最小連接池數量，已經不再使用了
    minIdle: 1
    #每60秒運行一次空閑連接回收器
    timeBetweenEvictionRunsMillis: 60000
    #池中的連接空閑30分鍾后被回收,默認值就是30分鍾
    minEvictableIdleTimeMillis: 1800000
    #驗證連接是否可用，使用的SQL語句
    validationQuery: select 1 from dual
    #指明連接是否被空閑連接回收器(如果有)進行檢驗.如果檢測失敗,則連接將被從池中去除
    testWhileIdle: true
    #借出連接時不要測試，否則很影響性能
    testOnBorrow: false
    #歸還連接時執行validationQuery檢測連接是否有效，做了這個配置會降低性能
    testOnReturn: false
    #是否緩存preparedStatement，也就是PSCache;PSCache對支持游標的數據庫性能提升巨大，比如說oracle。在mysql下建議關閉
    poolPreparedStatements: true
    #要啟用PSCache，必須配置大於0，當大於0時，poolPreparedStatements自動觸發修改為true
    maxOpenPreparedStatements: -1

如果你使用的是springBoot1.4以前的版本，那么之后的運行不會出現“testWhileIdle is true, validationQuery not set”的報紅信息，如果是1.4以及之后的版本，可能會出現這個報紅信息,解決方法：

  1.把springBoot的版本更換為1.4之前的；(下策)

  2.不用管，不影響使用；(下策，由於能力因素，我使用了這個辦法)

  3.參考這篇博客：http://www.voidcn.com/article/p-dequqelc-bqr.html.

 

5.寫接口

1)創建com.feng.springCloud包，在這個包下創建controller包、service包和mapper包

 

2）依據一般的開發步驟，寫mapper接口和實現類、寫service層的接口和實現類，如圖

 

mapper層接口

package com.feng.springCloud.mapper;

import com.feng.springCloud.pojo.Dept;
import org.apache.ibatis.annotations.Mapper;

/**
 * @author shiwangeweishenme
 * @date 2021/2/24
 * @since JDK1.8
 */
@Mapper
public interface DeptMapper {

    /**
     * 添加部門
     * @return bloolean
     */
    public boolean addDept(Dept dept);

    /**
     *  查詢部門
     * @return Dept
     */
    public Dept slel(int id);
}

 

   在mybatis.mapper的目錄下創建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.feng.springCloud.mapper.DeptMapper">

    <!-- 博客園:拾萬個為什么-->

  <insert id="addDept" parameterType="com.feng.springCloud.pojo.Dept">
     insert into shiwangeweishenme (name) values (#{name})
  </insert>

  <select id="slel" parameterType="int" resultType="com.feng.springCloud.pojo.Dept">
      select * from dept where deptNum = #{id}
  </select>
</mapper>

 

  service層接口代碼

package com.feng.springCloud.service;

import com.feng.springCloud.pojo.Dept;
import org.springframework.stereotype.Service;

/**
 * @author 拾萬個為什么
 * @date 2021/2/24
 * @since JDK1.8
 */public interface DeptService {

    /**
     * 添加部門
     * @return bloolean
     */
    public boolean addDept(Dept dept);

    /**
     *  查詢部門
     * @return Dept
     */
    public Dept selectDeptById(int id);
}

 

service層接口實現類代碼

package com.feng.springCloud.service.Impl;

import com.feng.springCloud.mapper.DeptMapper;
import com.feng.springCloud.pojo.Dept;
import com.feng.springCloud.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @author 拾萬個為什么
 * @date 2021/2/24
 * @since JDK1.8
 */
@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    private DeptMapper deptMapper;

    public boolean addDept(Dept dept) {
        return deptMapper.addDept(dept);
    }

    public Dept selectDeptById(int id) {
        return deptMapper.slel(id);
    }
}

 

 controller層的代碼

package com.feng.springCloud.controller;

import com.feng.springCloud.pojo.Dept;
import com.feng.springCloud.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 拾萬個為什么
 * @date 2021/2/24
 * @since JDK1.8
 */
@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;

    @PostMapping(value = "/dept/add")
    public boolean addDept(Dept dept){
        return deptService.addDept(dept);
    }

    @GetMapping(value = "/dept/get/{id}")
    public Dept selectDeptById(@PathVariable("id") int id){
        return deptService.selectDeptById(id);
    }

}

 

最后，寫啟動類(啟動類的創建必須和controller、service、mapper同級)

package com.feng.springCloud;

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

/**
 * @author 拾萬個為什么
 * @date 2021/2/24
 * @since JDK1.8
 */
@SpringBootApplication
public class DeptProvider {

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

 

3）運行

寫完后運行，試一下服務提供者可以運行不

 

四.創建消費者子工程

 1.創建子工程的步驟和"二"中的1、2、3步驟相同，這里不反復闡述了，工程名字改為springCloud-client即可

 

 2.在這個工程的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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.shiwangeweishenme</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springCloud-client</artifactId>

    <dependencies>
        <!-- 實體類 -->
        <dependency>
            <groupId>com.shiwangeweishenme</groupId>
            <artifactId>springCloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

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

        <!-- 熱部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

</project>

 

3.在application.yml配置

在resource下new--->File--->application.yml

server:
  port: 80

 

4.寫代碼,在這里(消費者)需要去調用服務提供者的接口

  src-main-java下新建包com.feng.springCloud，在這個目錄下新建controller包和config包。

  值得注意的是，消費者是不需要寫servicr層的，就好像我們使用的手機、電腦不需要自己生產，而是調用服務提供者(生產者)提供給我們的接口即可。

   config配置

package com.feng.springCloud.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

/**
 * @author 拾萬個為什么
 * @date 2021/2/28
 * @since JDK1.8
 */
@Configuration
public class ShiWanGeWeiShenMeConfigBean {

    //配置config，用於發現服務
    
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }
}

 

  controller代碼

package com.feng.springCloud.controller;

import com.feng.springCloud.pojo.Dept;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
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;

/**
 * @author 拾萬個為什么
 * @date 2021/2/28
 * @since JDK1.8
 */
@RestController
public class ShiWanGeWeiShenMeController {

    /**
     *  使用這個模板來調用服務
     */
    @Autowired
    private RestTemplate restTemplate;

    /**
     *  你的服務提供者配置的是什么port，你就按照你的你來
     */
    private static final String PREFIX = "http://localhost:8001";

    @RequestMapping("/client/dept/get/{id}")
    public Dept get(@PathVariable("id") int id){
        //第一個參數是你service需要調用的url，第二個參數是返回值類型
        return restTemplate.getForObject(PREFIX + "/dept/get/" + id , Dept.class);
    }

    @RequestMapping("/client/dept/add")
    public ResponseEntity<Boolean> addDept(Dept dept){
        //第一個參數是你service需要調用的url，第二個參數是需要傳遞的對象，第三個參數是返回值類型
        return restTemplate.postForEntity(PREFIX + "/dept/add" , dept , Boolean.class);
    }
}

 

  啟動類代碼

package com.feng.springCloud;

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

/**
 * @author 拾萬個為什么
 * @date 2021/2/28
 * @since JDK1.8
 */
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)//排除自動配置
public class DeptClient {

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

 

 運行，先運行服務者啟動類，再運行消費者啟動類

 

 運行成功，至此，一個普通的微服務項目已經搭建完成。

 接下來就行進入更深入的學習！

 

五.創建服務注冊中心

  springCloud使用Eureka作為其服務發現的框架。Eurka是Netfilx開發的符合AP原則的服務發現框架。

  下面我們來創建我們這個系統的服務發現和注冊中心。

  1.創建子工程的步驟和"二"中的1、2、3步驟相同，工程名字改為springCloud-eureka即可

 

2.在該工程下的pom.xml導入依賴文件(https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka)

<?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">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.shiwangeweishenme</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <!-- 博客園：拾萬個為什么-->
    <artifactId>springCloud-eureka</artifactId>

    <dependencies>
        <!-- 服務注冊和發現-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>

        <!-- 熱部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>
</project>

 

3.配置application.yml

  在resource目錄下新建文件application.yml

server:
  port: 8002

#配置Eureka
eureka:
  instance:
    #Eureka服務端的名字
    hostname: localhost
  client:
    #因為微服務每個服務都是可以作為一個服務提供者，這里設置是否向Eureka注冊自己
    register-with-eureka: false
    #固定寫法，false表示自己是個注冊中心
    fetch-registry: false
    #其他服務需要來到這個服務注冊或發現，其它服務依靠下面這個url可以連接到Eureka
    service-url:
      #訪問的url，使用動態拼接，可以訪問下面的地址監控到微服務的運行
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

 

4.寫啟動類

package com.shiwangeweishenme.cn;

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

/**
 * @author 拾萬個為什么
 * @date 2021/3/4
 * @since JDK1.8
 */
@SpringBootApplication
//表示這個服務可以接受別人注冊
@EnableEurekaServer
public class EurekaApplication {

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

項目結構

 

5.啟動並訪問這個url,驗證子工程能正常運行

 在瀏覽器輸入http://localhost:8002/，成功訪問

  稍微解釋下，Ds Replicas是集群，它下面的Instances currently registered with Eureka表示已經注冊的服務。

 

6.接下來，就是把其他服務注冊到這里

 

六.服務注冊

 服務提供者提供的服務必須注冊到Eureka中，以方便消費者讀取，步驟是什么呢？

1.在服務提供者的pom.xml文件里加入Eureka依賴(https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-starter-eureka/1.4.7.RELEASE)

在它的pom.xml里加入以下代碼

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

 

2.到服務提供者(springCloud-provider)的application.yml文件里配置(把自己 注冊進Eureka)

#配置端口號
server:
  port: 8001

#配置mybatis-plus
mybatis-plus:
  #配置別名
  type-aliases-package: com.feng.springCloud.pojo
#  #mybatis-plus配置路徑
#  config-location: classpath:mybatis/mybatis-config.xml
  #mapper配置路徑
  mapper-locations: classpath:mybatis/mapper/*.xml

#配置spring
spring:
  application:
    #給這個工程起個名字，一定要見字知義
    name: springCloud-provider-8001
  #配置數據源
  datasource:
    #配置數據源
    type: com.alibaba.druid.pool.DruidDataSource
    name: datasource
    #驅動
    driver-class-name: org.gjt.mm.mysql.Driver
    #數據庫url，數據庫名稱根據自己的定
    url: jdbc:mysql://localhost:3306/shiwangeweishenme?useUnicode=true&characterEncoding=UTF-8
    username: root
    password: root
    #通過別名的方式配置擴展插件,stat日志用的filter
    filters: stat
    #最大連接池數量
    maxActive: 20
    #初始化時建立物理連接的個數
    initialSize: 5
    #獲取連接時最大等待時間，單位毫秒
    maxWait: 60000
    #最小連接池數量，已經不再使用了
    minIdle: 1
    #每60秒運行一次空閑連接回收器
    timeBetweenEvictionRunsMillis: 60000
    #池中的連接空閑30分鍾后被回收,默認值就是30分鍾
    minEvictableIdleTimeMillis: 1800000
    #驗證連接是否可用，使用的SQL語句
    validationQuery: select 1 from dual
    #指明連接是否被空閑連接回收器(如果有)進行檢驗.如果檢測失敗,則連接將被從池中去除
    testWhileIdle: true
    #借出連接時不要測試，否則很影響性能
    testOnBorrow: false
    #歸還連接時執行validationQuery檢測連接是否有效，做了這個配置會降低性能
    testOnReturn: false
    #是否緩存preparedStatement，也就是PSCache;PSCache對支持游標的數據庫性能提升巨大，比如說oracle。在mysql下建議關閉
    poolPreparedStatements: true
    #要啟用PSCache，必須配置大於0，當大於0時，poolPreparedStatements自動觸發修改為true
    maxOpenPreparedStatements: -1

#配置Eureka,我們的服務注冊到哪里eu
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8002/eureka/

    defaultZone這里，localhost是eureka剛剛給起的名，8002是eureka設置的端口號，合理更改。

 

3.在該服務的啟動類上加上注解@EnableEurekaClient

package com.feng.springCloud;


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

/**
 * @author 拾萬個為什么
 * @date 2021/2/24
 * @since JDK1.8
 */
@SpringBootApplication
@EnableEurekaClient
public class DeptProvider {

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

 

4.先啟動springCloud-eureka(運行它的啟動類),再啟動springCloud-provider，訪問http://localhost:8002/

 

至此，一個簡單的springCloud項目啟動完成。