SpringBoot02 入门

一、微服务

1.什么是微服务？

是一种架构风格 , 将业务拆分成模块 , 部署在不同的主机上提供结构 , 提供服务 , 通过 http 的方式通信

2.发展历程

单体应用程序---》垂直应用架构--》分布式架构--》SOA架构--》微服务架构

单体应用程序：将一个应用的所有应用服务都封在一个应用中 , 无论什么系统 , 都把数据库访问 ,web 访问 , 各个功能放在一 个war 包内 .

好处: 

①架构简单, 项目开发成本低 .

②所有项目模块部署到一起, 对于小型项目来说 , 维护方便 .

缺点:

①所有模块耦合在一起 , 虽然对于小型项目来说 , 维护方便 . 但是 , 对于大型项目来说 , 却是不易开发
和维护的 .
②项目的各模块之前过于耦合 , 如果一旦有一个模块出现问题 , 则整个项目将不可用 .
③无法针对某个具体模块来提升性能 .
④无法对项目进行水平扩展 .

垂直应用架构：

随着企业业务的不断发展 , 发现单节点的单体应用不足以支撑业务的发展 , 于是企业会将单体应用部署多 份 , 分别放在不同的服务器上 .
但是 , 此时会发现不是所有的模块都会有比较大的访问量 . 如果想针对项目中的某些模块进行优化和性能提 升, 此时对于单体应用来说 , 是做不到的 .
于是垂直应用架构诞生了 . 垂直应用架构, 就是将原来一个项目应用进行拆分 , 将其拆分为互不想干的几个应用 , 以此来提升系统的整体性能.

我们将单体应用架构拆分为垂直应用架构之后 , 一旦访问量变大 , 我们只需要针对访问量大的业务增加服务器节点即可, 无需针对整个项目增加服务器节点了 .

好处:

①系统进行了拆分 , 可根据不同系统的访问情况 , 有针对性的进行优化 .
②能够实现应用的水平扩展 .
③各系统能够分担整体访问的流量 , 解决了并发问题 .
④一个系统发生了故障 , 不应用其他系统的运行情况 , 提高了整体的容错率

 缺点:

①拆分后的各系统之间相对比较独立 , 无法进行互相调用 .
②各系统难免存在重叠的业务 , 会存在重复开发的业务 , 后期维护比较困难

分布式架构

我们将系统演变为垂直应用架构之后 , 当垂直应用越来越多 , 重复编写的业务代码就会越来越多 . 此时 , 我们需要将重复的代码抽象出来 , 形成统一的服务供其他系统或者业务模块来进行调用 , 系统就会演变为分布式架构. 在分布式架构中, 我们会将系统整体拆分为服务层和表现层 . 服务层封装了具体的业务逻辑供表现层调用 , 表现层则负责处理与页面的交互操作.

好处:

①将重复的业务代码抽象出来 , 形成公共的访问服务 , 提高了代码的复用性 .
②可以有针对性的对系统和服务进行性能优化 , 以提升整体的访问性能 .

 缺点:

系统之间的耦合度变高 , 调用关系变得复杂 , 难以维护 .
系统之间交互需要远程通信 , 接口发开增加工作量

这里可以衍生出两个概率   集群与分布式

垂直拆分 ( 分布式 ): 就是多个子系统互相协作才能完成整个业务流程 , 系统之间需要进行通信 .
水平扩展 ( 集群 ): 就是同一个工程部署到多台服务器上 .

SOA架构

 在分布式架构下 , 当部署的服务越来越多 , 重复的代码就会越来越多 , 对于容量的评估 , 小服务资源的浪费等 问题比较严重 . 此时 , 我们就需要增加一个统一的调度中心来对集群进行实时管理 . 此时 , 系统就会演变为 SOA （面向服 务）的架构 .

好处:

使用注册中心解决了各个服务之间的服务依赖以及调用关系的自动注册与发现 .

 缺点:

服务之间的依赖与调用关系复杂 , 测试部署的困难比较大

微服务架构

随着业务的发展 , 我们在 SOA 架构的基础上进一步扩展 , 将其彻底拆分为微服务架构 . 在微服务架构下 , 我们将一个大的项目拆分为一个个小的可以独立部署的微服务 , 每个微服务都有自己的数 据库 .

好处:

①服务彻底拆分 , 各服务独立打包、独立部署和独立升级 .
②每个微服务负责的业务比较清晰 , 利于后期扩展和维护 .
③微服务之间可以采用 REST 和 RPC 协议进行通信 .

 缺点:

①涉及到各服务的容错性问题 .
②涉及到数据的一致性问题 .
③涉及到分布式事务问题 .

SOA 架构和微服务架构的区别

①SOA （ Service Oriented Architecture ） " 面向服务的架构 ": 他是一种设计方法 , 其中包含多个服务 ,
服务之间通过相互依赖最终提供一系列的功能 . 一个服务 通常以独立的形式存在与操作系统进程中 .
②各个服务之间 通过网络调用.
③MicroServices " 微服务架构 ": 其实和 SOA 架构类似 , 微服务是在 SOA
上做的升华 , 微服务架构强调的一个重点是 “ 业务需要彻底的组件化和服务化 ”, 原有的单个业务系统会拆分为多个可以独立开发、设计、运行的小应用. 这些小应用之间通过服务完成交互和集成

微服务架构 = 80%的SOA服务架构思想 + 100%的组件化架构思想 + 80%的领域建模思想 

二、构建springBoot项目

springBoot流程图

 

 第一种方式  使用IDEA

 第二种方式

1. 打开 spring,aliyun

2. 填写项目信息

3. 点击”Generate Project“按钮生成项目,下载此项目

4. 解压项目包，并用IDEA以Maven项目导入，一路下一步即可，直到项目导入完毕。

 

 url使用阿里云网站比较好

建成后的pom文件为

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.lj</groupId>
    <artifactId>SpringBoot2</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBoot2</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>

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

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>com.lj.springboot2.SpringBoot2Application</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

 

在这个文件里依赖不需要定义版本号，都是内定好了的

在spring-boot-dependencies文件中

当敲不出@RestController或者@RequestMapping时，可能是没有web依赖，此时需要在pom文件中添加web依赖

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

springBoot主启动类注解：

@SpringBootApplication 标识启动类
@ComponentScan 开启组件扫描
@Configuration 标识配置类 ( 替代 XML 配置文件 )
@SpringBootConfiguration 标识配置类 ( 是对 @Configuration 注解进行了包装，本质上依然是
@Configuration 注解 )
@EnableAutoConfiguration 开启自动配置 (
从 classpath 中搜索所有 META-INF/spring.factories 配置文件然后，将其中
org.springframework.boot.autoconfigure.EnableAutoConfiguration
key 对应的配置项加载到 spring 容器 只有 spring.boot.enableautoconfiguration 为 true （默认为
true ）的时候，才启用自动配置 )
@AutoConfigurationPackage 自动配置包 ( 将添加该注解的类所在的 package 作为自动配置
package 进行管理 )

三、基于配置文件的注入

@ConfigurationProperties() 可以通过指定 prefix 指定加载的对象的前缀

配置文件加载的优先级：

1. config/application.properties （项目根目录中 config 目录下）
2. config/application.yml
3. application.properties （项目根目录下）
4. application.yml
5. resources/config/application.properties （项目 resources 目录中 config 目录下）
6. resources/config/application.yml
7. resources/application.properties （项目的 resources 目录下）
8. resources/application.yml

由于 properties 不支持松散绑定，所以我们使用yml文件，新建yml文件命名要规范（application.yml）

新建一个student类，定义以下属性

private String name;
private String sex;
private int age;
private List<String> ah=new ArrayList<>();
private HashMap<String, String> abc = new HashMap<>();
Set<String> gexing = new HashSet<>();

在类上使用@Data注解，让其应用get/set方法以及tostring

在SjyApplicationTests类中使用注解@ExtendWith(SpringExtension.class)，并将student自动装配

package com.lj.springboot2;

import com.lj.springboot2.pojo.Student;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit.jupiter.SpringExtension;

@ExtendWith(SpringExtension.class) //集成Spring环境
@SpringBootTest
class SpringBoot2ApplicationTests {
    @Autowired
    private Student student ;

    @Test
    void contextLoads() {
        System.out.println(student);
    }

}

在yml文件中定义name属性值

在实体类中使用@Value("${name}")使其能够被赋值

 

 运行结果

但是我们一般使用第二种方法，使其更加方便

使用层级绑定数据

实体类使用@ConfigurationProperties(prefix = "student")绑定前缀（只能在yml文件中可以使用），使用后会出现未配置处理器，这时候只需要点击右边的打开，然后会自动跳到一个网页，找到3.1的依赖往pom里面复制进去，就可以了

 然后在yml文件中添加一个前缀并给属性赋值

运行结果如下

 

如果实体类中使用的驼峰命名法（userName），那么在yml文件中需要用_来隔开（user_name）

四、多环境配置  

application.yaml

application-dev.yaml

application-test.yaml

可以通过 spring.profiles.active=profile 来完成配置指定（在主yml文件中）

spring :

profiles :

active : test