Spring Boot学习的总结

最新推荐文章于 2022-02-13 22:12:19 发布

'小手冰凉

最新推荐文章于 2022-02-13 22:12:19 发布

阅读量317

点赞数

分类专栏：笔记文章标签： spring boot

本文链接：https://blog.csdn.net/m0_49585228/article/details/107791867

版权

笔记专栏收录该内容

34 篇文章 0 订阅

订阅专栏

Spring Boot
1.什么是SpringBoot?
SpringBoot是Spring团队在2014年，伴随Spring4.0版本推出的一个新的框架。
https://spring.io/
在这里插入图片描述

SpringBoot使创建独立的、生产级的、基于Spring的应用程序变得容易，您可以“只运行”。
就是帮助我们快速的创建出基于Spring的应用程序。
想一想在你没有SpringBoot的时候我们使用Spring创建应用程序，或者是整合SpringMVC、MyBatyis,往往都需要先导入很多的依赖包，然后编写大量的配置文件，然后开发业务逻辑，最后测试，接下来就是打war包，部署到服务器，部署之前还得配置好服务器环境，这样才完成工作。所以在有以前没有SpringBoot的时候，我们对java EE程序的开发都是比较笨重的开发,需要繁多的配置，带来低下的开发效率和复杂的部署流程,还有第三方技术集成难度大。因此上SpringBoot的出现实际上就是用来简化我们对java EE程序的开发，帮助我们快速的创建出基于Spring的应用程序。
SpringBoot的底层实际上还是使用的Spring技术，他其实就是通过整合Spring提供的针对不同领域的开发框架来达到简化Java EE 程序的开发步骤的
Spring提供的针对不同领域的开发框架：
Spring Framework：提供IOC容器
Spring Cloud：分布式框架
Spring Data：数据库访问框架
Spring Security：安全校验框架
等等…
在这里插入图片描述

2.SpringBoot的优点
2.1快速创建独立运行的Spring项目以及与主流框架集成
2.2使用嵌入式的Servlet容器，应用无需打成WAR包
2.3 starters自动依赖与版本控制
2.4大量的自动配置，简化开发，也可修改默认值
2.5无需配置XML，无代码生成，开箱即用
2.6准生产环境的运行时应用监控
2.7 与云计算的天然集成
3.什么是微服务？
2014年美国著名的面向对象分析设计、UML、模式等方面的专家，敏捷开发方法的创始人之一，martin fowler【马丁.福勒】，现为ThoughtWorks公司的首席科学家。在自己的博客中写了一篇关于微服务的博客，生动的阐述了微服务，后来微服务这个词语才被大家所熟知。
在这里插入图片描述
https://martinfowler.com/ martin fowler【马丁.福勒】个人主页
微服务其实是一种架构风格，提倡一个应用应该是一组小型服务组成；可以通过HTTP的方式进行互通。
在没有微服务之前我们软件架构方式称为单体应用：ALL IN ONE。就是所有的内容统一集中在一个应用程序中。
在这里插入图片描述
这种单体应用的优点：开发测试简单，不会涉及多个应用之间的互联互调，应用部署也简单，只需要一个war包就OK,不会对运维造成太大负担，还有就是应用程序的水平扩展也简单，就是新增模块简单。当并发量高的时候，我们可以将这个单体应用多复制几份部署在多个服务器上，通过负载均衡机制控制运行，可以提高并发访问。
他的缺点也很明显，那就是到我们需要对程序进行修改的时候就需要重新打包，重新部署，重新运行，这就是一个牵一发动全身的情况，当然更大的挑战是来自于日益增长的软件需求。

目前我们随便做一个软件都需要提供很多更能，不管这些功能有用没有都得实现，这个一个小应用就都成一个大型应用。而大型应用我们不可能将所有功能全部都写在一个应用中，因为分工合作麻烦，维护量大，而且这个应用到时候可能谁都不知道这个应用会有多大。所以我们才要学习使用微服务开发，来避免这样的问题。
在这里插入图片描述
可以这样理解：单体应用就是雕版印刷
微服务就是活字印刷
微服务：每一个功能元素最终都是一个可独立替换和独立升级的软件单元；

那么利用微服务搭建起来的项目长什么样？
在这里插入图片描述
这种类似于神经网络一样的结构就是最终微服务构建起来的项目，每一个圆圈就是服务，服务于服务之间通过http协议访问连接。
那么这种庞大微服务应用程序如何构建和部署整合呢，这时我们的SPringBoot就有用武之地。
在这里插入图片描述
通过SpringBoot快速构建微服务应用，通过SpringCloud进行分布式互联互调，形成分布式结构，通过SpringCloudDataFlow进行流式数据运算和批处理操作。
4.通过SpringBoot快速创建Spring项目
环境准备
在学习使用的SpringBoot之前我们需要我一下的一些基本内容：
1.熟练使用Spring框架
2.熟练使用Maven进行项目的构建和依赖包的管理
3.熟练使用Eclipse或者IDEA
约束环境
1.jdk1.8
2.maven3.x
3.IntelliJ IDEA 2017
4.Spring Boot 1.5.9.RELEASE

4.1安装 Maven并进行设置
1.设置Maven的本地仓库
2.给maven 的settings.xml配置文件的profiles标签添加

<profile> 
 <id>jdk‐1.8</id> 
 <activation> 
 <activeByDefault>true</activeByDefault> 
 <jdk>1.8</jdk> 
 </activation> 
 <properties> 
 <maven.compiler.source>1.8</maven.compiler.source> 
<maven.compiler.target>1.8</maven.compiler.target> 
 <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion> 
 </properties> 
</profile>

这段配置的含义就是使用jdk1.8来编译java程序。

IDEA设置整合maven
在这里插入图片描述

以上就是在IDEA中设置Mavne的Settings文件和本地仓库的位置。
5.Spring Boot HelloWorld
需求:浏览器发送hello请求，服务器接受请求并处理，响应Hello World字符串。
1、创建一个maven工程；（jar）
创建一个新工程
在这里插入图片描述

项目创建成功！
启用自动导入，好处在于以后我们在项目pom.xml文件中每配置一个依赖的话，那么IDEA就会帮我们自动导入依赖到项目中。

2、导入spring boot相关的依赖

  在pom.xml文件中导入：
<!-- 导入父项目 -->
<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>1.5.9.RELEASE</version>
   <relativePath/> <!-- lookup parent from repository -->
</parent>

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

3、编写一个主程序；启动Spring Boot应用
在src/main/java下创建一个java类【注意创建包】

/** 
 * @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用 
 */ 
 @SpringBootApplication 
 public class HelloWorldMainApplication { 
 public static void main(String[] args) { 
 // Spring应用启动起来 
 SpringApplication.run(HelloWorldMainApplication.class,args); 
 } 
 } 
 
4、创建控制器类
在src/main/java下创建一个控制器类【注意创建包】
@Controller 
 public class HelloController { 
 @ResponseBody 
 @RequestMapping("/hello") 
 public String hello(){ 
 return "Hello World!"; 
 } 
 }

5、运行主程序测试
来到主程序HelloWorldMainApplication ,启动运行
在这里插入图片描述
控制台打印已经启动Tomcat服务器

6、浏览器运行测试

在上面的这个简单的例子中我们没有进行过任何配置，没有配置包扫描，没有配置视图解析器…这些都被简化掉了。

7、简化部署
将下面的这个插件配置到pom.xml文件中

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

这个插件，可以将应用打包成一个可执行的jar包；将这个应用打成jar包，直接使用java -jar的命令进行执行；
运行打jar包
在这里插入图片描述
打好的jar包早traget目录下

将这个jar复制出来通过jar命令就可以直接运行。
5.SpringBoot中的启动器【常见的启动器】
6.Spring Boot HelloWorld深入分析

Spring Boot将所有的功能都抽取出来，做成一个个的starters（启动器），只需要在项目里面引入这些starter 那么相关功能的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器。
Spring Boot应用启动器基本的一共有44种，具体如下：
1）spring-boot-starter:这是Spring Boot的核心启动器，包含了自动配置、日志和YAML。
2）spring-boot-starter-actuator:帮助监控和管理应用。
3）spring-boot-starter-amqp:通过spring-rabbit来支持AMQP协议（Advanced Message Queuing Protocol）。
4）spring-boot-starter-aop:支持面向方面的编程即AOP，包括spring-aop和AspectJ。
5）spring-boot-starter-artemis:通过Apache Artemis支持JMS的API（Java Message Service API）。
6）spring-boot-starter-batch:支持Spring Batch，包括HSQLDB数据库。
7）spring-boot-starter-cache:支持Spring的Cache抽象。
8）spring-boot-starter-cloud-connectors:支持Spring Cloud Connectors，简化了在像Cloud Foundry或Heroku这样的云平台上连接服务。
9）spring-boot-starter-data-elasticsearch:支持ElasticSearch搜索和分析引擎，包括spring-data-elasticsearch。
10）spring-boot-starter-data-gemfire:支持GemFire分布式数据存储，包括spring-data-gemfire。
11）spring-boot-starter-data-jpa:支持JPA（Java Persistence API），包括spring-data-jpa、spring-orm、Hibernate。
12）spring-boot-starter-data-mongodb:支持MongoDB数据，包括spring-data-mongodb。
13）spring-boot-starter-data-rest:通过spring-data-rest-webmvc，支持通过REST暴露Spring Data数据仓库。
14）spring-boot-starter-data-solr:支持Apache Solr搜索平台，包括spring-data-solr。
15）spring-boot-starter-freemarker:支持FreeMarker模板引擎。
16）spring-boot-starter-groovy-templates:支持Groovy模板引擎。
17）spring-boot-starter-hateoas:通过spring-hateoas支持基于HATEOAS的RESTful Web服务。
18）spring-boot-starter-hornetq:通过HornetQ支持JMS。
19）spring-boot-starter-integration:支持通用的spring-integration模块。
20）spring-boot-starter-jdbc:支持JDBC数据库。
21）spring-boot-starter-jersey:支持Jersey RESTful Web服务框架。
22）spring-boot-starter-jta-atomikos:通过Atomikos支持JTA分布式事务处理。
23）spring-boot-starter-jta-bitronix:通过Bitronix支持JTA分布式事务处理。
24）spring-boot-starter-mail:支持javax.mail模块。
25）spring-boot-starter-mobile:支持spring-mobile。
26）spring-boot-starter-mustache:支持Mustache模板引擎。
27）spring-boot-starter-redis:支持Redis键值存储数据库，包括spring-redis。
28）spring-boot-starter-security:支持spring-security。
29）spring-boot-starter-social-facebook:支持spring-social-facebook
30）spring-boot-starter-social-linkedin:支持pring-social-linkedin
31）spring-boot-starter-social-twitter:支持pring-social-twitter
32）spring-boot-starter-test:支持常规的测试依赖，包括JUnit、Hamcrest、Mockito以及spring-test模块。
33）spring-boot-starter-thymeleaf:支持Thymeleaf模板引擎，包括与Spring的集成。
34）spring-boot-starter-velocity:支持Velocity模板引擎。
35）spring-boot-starter-web:支持全栈式Web开发，包括Tomcat和spring-webmvc。
36）spring-boot-starter-websocket:支持WebSocket开发。
37）spring-boot-starter-ws:支持Spring Web Services。
Spring Boot应用启动器面向生产环境的还有2种，具体如下：
1）spring-boot-starter-actuator:增加了面向产品上线相关的功能，比如测量和监控。
2）spring-boot-starter-remote-shell:增加了远程ssh shell的支持。
最后，Spring Boot应用启动器还有一些替换技术的启动器，具体如下：
1）spring-boot-starter-jetty:引入了Jetty HTTP引擎（用于替换Tomcat）。
2）spring-boot-starter-log4j:支持Log4J日志框架。
3）spring-boot-starter-logging:引入了Spring Boot默认的日志框架Logback。
4）spring-boot-starter-tomcat:引入了Spring Boot默认的HTTP引擎Tomcat。
5）spring-boot-starter-undertow:引入了Undertow HTTP引擎（用于替换Tomc
6.SpringBoot的自动配置自动导入的原理
6.1POM文件

<parent> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring‐boot‐starter‐parent</artifactId> 
<version>1.5.9.RELEASE</version> 
</parent>

上面的配置是我们自己项目需要依赖的父项目【spring‐boot‐starter‐parent】，这个父项目本身还依赖于另一个父项目【spring‐boot‐dependencies】

<parent> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring‐boot‐dependencies</artifactId> 
<version>1.5.9.RELEASE</version> 
<relativePath>../../spring‐boot‐dependencies</relativePath> 
</parent>

这个一个父项目【spring‐boot‐dependencies】实际是用来真正管理Spring Boot应用里面的所有依赖版本。有了他以后我们导入依赖默认是不需要写版本。

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

spring-boot-starter：【spring-boot启动器】用来帮我们导入springboot基础依赖包。

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

er-web：帮我们导入了web模块正常运行所依赖包。
7.SpringBoot的全局配置文件，表现形式
@SpringBootApplication: Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot 就应该运行这个类的main方法来启动SpringBoot应用；
在这里插入图片描述
@SpringBootConfifiguration:Spring Boot的配置类；
标注在某个类上，表示这是一个Spring Boot的配置类；

@Confifiguration:配置类上来标注这个注解； 
配置类-----配置文件；配置类也是容器中的一个组件；@Component

@EnableAutoConfifiguration：开启自动配置功能； 
以前我们需要配置的东西，Spring Boot帮我们自动配置；@EnableAutoConfifiguration告诉SpringBoot开启自动配置功能，这样自动配置才能生效；
 
@AutoConfigurationPackage 
@Import(EnableAutoConfigurationImportSelector.class) 
public @interface EnableAutoConfiguration { 

@AutoConfifigurationPackage：自动配置包 
@Import(AutoConfifigurationPackages.Registrar.class)： 
Spring的底层注解@Import，给容器中导入
一个组件；导入的组件由 
AutoConfifigurationPackages.Registrar.class； 
将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring容器； 
@Import(EnableAutoConfifigurationImportSelector.class)；

8.SpringBoot对静态资源配置
SpringBoot使用一个全局的配置文件，配置文件名是固定的；
•application.properties
•application.yml
配置文件放在src/main/resources目录或者类路径/config下
配置文件的作用：SpringBoot在底层都给我们自动配置好应用程序需要的所有配置内容，如果我们觉得不满意可以修改SpringBoot自动配置的默认值。

YAML（YAML Ain’t Markup Language）
YAML A Markup Language：是一个标记语言
YAML isn’t Markup Language：不是一个标记语言；
标记语言：
以前的配置文件；大多都使用的是 xxxx.xml文件；
YAML：以数据为中心，比json、xml等更适合做配置文件；
YAML：配置例子
server:
port: 9090
XML：配置列子

8081

YAML语法：
1、基本语法
k:(空格)v：表示一对键值对（空格必须有）；
以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的
例如：
server:
port: 8081
path: /hello
属性和值也是大小写敏感。
2.属性值得写法
2.1普通的值（数字，字符串，布尔）
字符串默认不用加上单引号或者双引号；
“”：双引号；不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思
name: “zhangsan \n lisi” ——>输出；zhangsan 换行 lisi
‘’:单引号；会转义特殊字符，特殊字符最终只是一个普通的字符串数据
name: ‘zhangsan \n lisi’ ——>输出；zhangsan \n lisi
2.2对象、Map（属性和值）（键值对）：
k: v：在下一行来写对象的属性和值的关系,注意缩进,对象还是k: v的方式
friends:
lastName: zhangsan
age: 20
行内写法：
friends: {lastName: zhangsan,age: 18}
2.3数组（List、Set）：
用”- 空格” 值表示数组中的一个元素
pets:
‐ cat
‐ dog
‐ pig
行内写法
pets: [cat,dog,pig]

3.测试YAML语法
1.创建一个javabean

public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
    @Override
    public String toString() {
        return "Person{" +
                "lastName='" + lastName + '\'' +
                ", age=" + age +
                ", boss=" + boss +
                ", birth=" + birth +
                ", maps=" + maps +
                ", lists=" + lists +
                ", dog=" + dog +
                '}';
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public Boolean getBoss() {
        return boss;
    }
    public void setBoss(Boolean boss) {
        this.boss = boss;
    }
    public Date getBirth() {
        return birth;
    }
    public void setBirth(Date birth) {
        this.birth = birth;
    }
    public Map<String, Object> getMaps() {
        return maps;
    }
    public void setMaps(Map<String, Object> maps) {
        this.maps = maps;
    }
    public List<Object> getLists() {
        return lists;
    }
    public void setLists(List<Object> lists) {
        this.lists = lists;
    }
    public Dog getDog() {
        return dog;
    }
    public void setDog(Dog dog) {
        this.dog = dog;
    }
}

public class Dog {
    private String name;
    private Integer age;
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
}

2.创建YAML语法文件

person: 
lastName: hello 
age: 18 
boss: false 
birth: 2017/12/12 
maps: {k1: v1,k2: 12} 
lists: 
‐ lisi 
‐ zhaoliu 
dog:
name: 小狗 
age: 12

3.将YAML文件中的数据值绑定到javabean上
通过@ConfigurationProperties：这个注解就是告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；
这个注解有一个属性
prefix = “配置文件中的对象名”：配置文件中哪个下面的所有属性进行一一映射

<!‐‐导入配置文件处理器，配置文件进行绑定就会有提示‐‐>

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

给pom文件中导入上面的依赖配置以后，我们在编写YAML配置文件的时候就会有提示了。

注意：只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；意思就是需要添加@Component
例如：

@Component 
@ConfigurationProperties(prefix = "person") 
public class Person {

4.properties配置文件的写法
通过@ConfigurationProperties(prefix = “person”) 将properties配置文件中的值绑定到javabean上

application.properties文件

person.last-name=张三
person.age=18
person.birth=2017/12/15
person.boss=false
person.maps.k1=v1
person.maps.k2=14
person.lists=a,b,c
person.dog.name=dog
person.dog.age=15

由于properties配置文件在idea中默认utf-8可能会有中文乱码，所以需要设置修改转码；
在这里插入图片描述

9.基于SpringBoot的SSM

'小手冰凉

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Spring Boot学习的总结

Spring Boot1.什么是SpringBoot?SpringBoot是Spring团队在2014年，伴随Spring4.0版本推出的一个新的框架。https://spring.io/SpringBoot使创建独立的、生产级的、基于Spring的应用程序变得容易，您可以“只运行”。就是帮助我们快速的创建出基于Spring的应用程序。想一想在你没有SpringBoot的时候我们使用Spring创建应用程序，或者是整合SpringMVC、MyBatyis,往往都需要先导入很多的依赖包，然后编
复制链接

扫一扫