带你了解springboot微服务架构和装配原理

冷环渊

发布于 2021-10-19 15:34:32

6550

发布于 2021-10-19 15:34:32

文章被收录于专栏：冷环渊的全栈工程师历程冷环渊的全栈工程师历程

Springboot

从今天开始我们就开始了离开地狱的快乐生活！！！！！！芜湖学习视频链接:小狂神Springboot

我们的学习历程：

javase：oop
mysql：持久化
html+css+js+jquery+框架：视图，框架不熟练，css不好
javaweb：独立开发MVC架构的网站：原始
ssm:框架：简化了我们的开发流程
打包出来是：war：tomcat运行
Spring再简化：SpringBoot-jar:内嵌tomcat；微服务架构！
服务越来越多：SpringCloud；

SpringBoot

Spring视为了解决企业级应用开发的复杂性而创建的，简化开发，

Spring如何简化java开发

为了降低java开发的复杂性，Spring采用了四种关键策略；

基于实体类的轻量级，最小入侵性变成；
通过ioc，依赖注入和面向接口实现松耦合
基于切面(AOP)和管理进行声明式变成；
通过切面和模版减少样式代码

什么是SpringBoot？

javaweb：Servlet+tomcat，后来是Struts，再后来是SpringMVC 到了现在的SpringBoot,过一两年还会出现新的前端框架，技术快速迭代，程序员需要不断学习，

新服务架构：服务网格，可能会干掉SpringBoot来完成新的微服务架构

老师，领导，项目经理：

培训讲师：
- 面向面试培训，教你如何使用，快速上手！
做教育的
- 如何学习新东西，如何持续学习,如何关注这个行业！
- 教你历史，来龙去脉，理论；积累谈资

30，经理

30：程序猿：淘汰！

java框架的迭代

SpringBoot其实就是javaweb开发框架，于SpringMVC类似，对比其他开发框架的好处就是简化开发，约定大于配置，你只管训醒：you can just run 能够快速开发web应用，几行代码实现一个http接口

所有的技术框架的发展，都遵循这一个条主线规律，从复杂的应用场景，衍生出规范框架。人们在实际生产应用情况不断的精简，吸收设计精华，重构新的，更轻量级的框架，逐渐提升开发效率，之后开始提倡约定大于配置进而衍生一些一站式的解决方案，

j2EE --------> spring-------->springboot

随着发展，Spring涉及的领域越来越多，项目的整合开发需要配置大量的配置文件妈妈那么难的变得不那么易用简单，违背了最初的理念，甚至被人称为配置地狱，SpringBoot正是这样一个背景下被抽象出来的开发框架，目的就是为了让大家容易的使用Spring，更容易集合中间件和开源软件

Spring boot 基于Spring开发，boot本身并不提供Spring的核心特性以及拓展功能，只是用于快速的开发新一个基于SPRING框架的应用程序，也就是说，他并不是代替Spring的解决方案，而是和Spring框架紧密结合用于提升，Spring开发者的体验工具。Springboot约定大于配置的核心思想，默认帮我们进行了很多的设置，多数的SpringBoot应用很少的Spring配置，同时集成了大量常用的第三方库配置，几乎所有的第三方库都是开箱即用。

SpringBoot主要优点：

为了所有Spring开发这更快入门
开箱即用，提供各种默认配置简化项目配置
内嵌式容器简化web项目
没有冗余代码和xml的配置要求

约定大于配置：maven------>spring------->springMVC---->SpringBoot

正常的程序=数据结构+算法==》程序员—》i创造性角色

机构的程序=面向对象+框架 ==》码农–》会用别人的东西，干事

微服务

什么是微服务？

微服务是一个中架构风格，它要求我们在开发一个应用的时候，这个应用必须构建成一个系列小小服务的组合；可以通过http的方法进行互通。要说为微服务架构，先得说说我们以前的单体引用架构。

架构：MVC三层架构， MVVM ，微服务架构

业务：service：userService ===>模块！

SpringMVC，controller ===>提供接口！

单体应用架构

所谓单体引用（all in one）是指，我们将一个应用的中的所有应用的中的所有应用服务封装在一个应用中，无论是erp。crm或是其他系统，都吧数据库访问，web访问，等等功能方到一个war包内

好处是：易于开发测试，，部署起来十分方便，当需要拓展的时候，只需要将war复制多份，然后放在多个服务器上，在做负载均衡就可以
缺点是：单体应用架构的缺点是，哪怕我要修改非常小的地方，我都需要停掉整个服务，重新打包，部署这个应用war包，特别是对于一个大型应用，我们不可能吧所有的内容都放在一个应用里，我们如何维护，如何分工都是问题

微服务架构

all in one 的架构方式没我们把所有的功能单元放在一个应用里面。整个应用部署在服务器上，如果负载能力不行，我们将整个应用水平赋值，进行扩展，之后负载均衡

所谓微服务架构，就是打破之前的all in one的架构方式，把每个功能元素独立出来，把独立出来的功能元素动态组合，需要的功能元素才组合在一起，需要时间多一些，可以整合多个功能的元素。所以微服务架构是对功能元素进行复制，

好处：

节省，调用资源
每个功能元素的服务都是一个可替换的可独立升级的软件代码，

详细阐述了什么是微服务：https://www.martinfowler.com/articles/microservices.html

中文版：https://www.cnblogs.com/liuning8023/p/4493156.html

http: rpc

用户下单： controller! 1000ms

消息队列：

仓库冻结：资金冻结，验证，购买成功，仓库数量减少，仓库解冻，资金解冻 10 s

如何构建微服务

一个大型系统的微服务架构，就像一个复杂交织，神经网络，每一个神经元就像是一个功能元素，它们各自完成自己的功能，然后通过http相互请求调用。比如一个电商系统，查缓存，连数据库，浏览页面，结账，支付等服务都是一个一个独立的功能服务，都被微化了，他们作为一个个微服务共同构建了一个庞大的系统，如果修改其中的一个功能，只需要更新升级其中一个功能服务单元即可。

但是这种庞大的系统架构给部署和运维带来很大的难度。于是，spring为我们带来了构建大型分布式微服务的全套、全程产品：

构建一个个功能独立的微服务应用单元，可以使用SpringBoot，可以帮助我们快速的构建一个应用；
大型分布式网络服务的调用，这部分由Springcloud来完成，实现分布式；
在分布式中间，进行流式数据计算，批处理，我们有spring cloud data flow。
spring 为我们想清楚了整个从开始构建应用到大型分布式应用全流程方案

高内聚，低耦合，

面试：

8k-13k：软实力：聊天+举止+谈吐+见解

你主导面试官:13k:聊天30分钟

面试官主导你:8k

第一个SpringBoot程序

环境：

jdk1.8
maven 3.6.2
SpringBoot最新版
idea

官方提供了一个快速生成网站！idea集成了这个网站！

可以在官网直接下载，导入idea开发（官网在哪里）
直接使用idea创建一个SpringBoot项目（常用）

简单编写个controller类来看看如何运行的

package com.hyc.spring01helloworld.Controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
@RequestMapping("/hello")
public class helloController {

    @GetMapping("/hello")
    @ResponseBody
    public String hello(){
        return "hello";
    }

}

maven打包注意事项

utf-8报错：

	<project.build.sourceEncoding>
				UTF-8
	project.build.sourceEncoding>

原理初探

自动装配：

pom.xml:

Spring-boot-dependencies:核心依赖在父项目
我们在写或者引入一些Springboot依赖的时候，不需要指定版本，就应为这些版本仓库

启动器

主程序：

@SpringBootApplication
public class Spring01HelloworldApplication {

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

}

获取候选的配置

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

加载项目自动装配文件

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = (Map)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            HashMap result = new HashMap();

            try {
                Enumeration urls = classLoader.getResources("META-INF/spring.factories");

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        String[] var10 = factoryImplementationNames;
                        int var11 = factoryImplementationNames.length;

                        for(int var12 = 0; var12 < var11; ++var12) {
                            String factoryImplementationName = var10[var12];
                            ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                                return new ArrayList();
                            })).add(factoryImplementationName.trim());
                        }
                    }
                }

                result.replaceAll((factoryType, implementations) -> {
                    return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
                });
                cache.put(classLoader, result);
                return result;
            } catch (IOException var14) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
            }
        }
    }

自动配置的核心文件

META-INF/spring.factories

加载到properties 中：

 Properties properties = PropertiesLoaderUtils.loadProperties(resource);

判断条件成立才自动装配

@ConditionalOnClass(Advice.class)

自动装配原理流程图：

结论：springboot所有的自动配置都是在启动的时候扫描并加载：META-INF/spring.factories所有的自动配置类都在这里面，但是不一定生效，判断条件是否成立，只要导入了对应的start，就有对应的启动器，有了启动器我们自动装配就会生效，然后就配置成功了！

Springboot在启动的时候，从类路径下的META-INF/spring.factories获取指定的值；
将这些自动配置的类导入容器，自动配置类就会生效，帮我们进行自动配置
以前我们需要自动配置的东西，现在只要符合条件Springboot帮我们做了
整合javaEE的解决方案和自动配置的东西都在spring-boot-autoconfigure-2.5.1.jar这个包下
它会把所有需要导入的组件，以类名的方式返回，这些组件就会被添加到容器；
容器中也会存在非常多的XXXXautoconfiguration的文件，就是这些类容器中导入了这个场景需要的所有组件并且自动配置，@Configuration
有了自动配置类，就免去了我们手动编写配置文件的工作，远离配置地狱！！！

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2021-08-22 ，如有侵权请联系 cloudcommunity@tencent.com 删除

java

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度