如何启动一个SpringCloud项目

时间  2021-03-04
标签 html java mysql web spring sql 数据库 apache api 缓存 栏目 HTML 繁體版
原文   原文链接

  做为一个刚刚步入职场的小白，刚进公司就接触到springCloud，公司全部的项目构建都是基于springCloud部署的，在学校学过相关的概念可是没实际操做过这种东西，因此想由浅入深学习下。该随笔会记录springCoud的构建过程。html

 

一.首先，建立父工程

 1.选择 new projectjava

 

2.选择Maven，不要勾选提示的内容，Nextmysql

 

3.写项目名和选择存放地址（IDEA版本不一样此处会有差别，可是基本的步骤都是同样的）,Finishweb

 

4.建立完父工程后，能够看到这样的项目构造，右键src，delete删除掉spring

 

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

<?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.一样，不勾选，点击Nextapache

 

3.子项目名字为springCloud-api，点击Finish(不一样版本IDEA这一步可能不一样)api

 

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.建立子工程的步骤和"二"中的一、二、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&amp;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
 */
@Service
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
 */
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.建立子工程的步骤和"二"中的一、二、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);
    }
}

 

 运行，先运行服务者启动类，再运行消费者启动类

 

 运行成功，至此，一个普通的微服务项目已经搭建完成，可是在实际的工做中，微服务开发很是繁杂，咱们这样一个小小的项目每每是其中的冰山一角，你们共同努力好了。

 接下来就行进入更深刻的学习！

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程