快速入门java微服务架构SpringBoot之一

Springboot概念：

Springboot提供了一种快速使用Springboot的方式，基于约定优于配置的思想。

可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编辑中，从而大大提高了开发的效率，一定程度上缩短了项目周期。2014年4月，SpringBoot1.0.0发布。Spring的顶级项目之一（https://spring.io）.

官网：spring.io.project

springboot;使用最少的配置，来启动项目。

Spring缺点

1）配置繁琐。

虽然Spring的组件代码是轻量级的，但他的配置确实重量级的。一开始，Spring用XML配置。而且是很多XML配置。Spring2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。

Spring3.0引入了基于java的配置，这是一种类型安全的可重构配置方式，可以代替XML。

所有这些配置都代表了开发时的损耗，因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的问题。和所有框架一样，Spring实用，但它要求的回报也不少。

2）依赖繁琐：

项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且换需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。

SpringBoot功能：

1）自动配置

SpringBoot的自动配置是一个运行时（更准确的说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个，该过程是SpringBoot自动完成的。

2）起步依赖

起步依赖本质上是一个Maven项目对象模型（Project Object Model,POM）,定义了对其他库的传递依赖，这些对象加在一起即支持某项功能。

简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些某认的功能。

3）辅助功能

提供了一些大型项目中常见的非功能性特性，如嵌入式服务器，安全，指标，健康监测，外部配置等。

SpringBoot并不是对Spring功能上的增强，而是提供了一种快速的使用Spring的方式。

小结

SpringBoot提供了一种快速开发Spring项目的方式，而不是对Spring功能上的增强。

Spring的缺点

*配置繁琐

*依赖繁琐

SpringBoot功能

*自动配置

*起步依赖：依赖传递

*辅助功能

SpringBoot快速入门：

案例：需求

搭建SpringBoot工程，定义HelloController。hello（）方法，返回“Hello SpringBoot”。

案例实现步骤

1）创建Maven项目

2）导入SpringBoot起步依赖

3）定义Controller

4）编写引导类

5）启动测试

.实际操作：

File-》新建-》Maven-》Next—》

进入了pom文件

添加起步依赖：

<!-- springboot工程需要继承的父工程 -->

<parent>

<groupId>org.springframework</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>2.1.8.RELEASE</version>

</parent>

<dependencies>

<!-- web开发的起步依赖 -->

<dependency>

<groupId>org.framewrok.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

</dependencies>

HelloController.java：

@RestController

public class HelloController{

@RequestMapping("/hello")

public  String hello(){

return "hello Spring Boot!";

}

}

/*引导类。springboot项目入口*/

@SpringBootApplication

public class HelloApplication{

main{

SpringApplication.run(HelloApplication.class.args);

}

}

小结：

*SpringBoot在创建项目时，使用jar的打包方式。

*SpringBoot的引导类，是项目入口，运行main方法就可以启动项目。

*使用SpringBoot和Spring构建项目，业务代码编写方式完全一样。

案例：需求

使用idea快速构建SpringBoot工程，定义HelloController。hello（）方法，返回“Hello”

“SpringBoot！”。

快速构建选Spring Initializr->选择

依赖原理分析：

1）spring-boot-starter-parent

2)spring-boot-starter-web

小结：

*在spring-boot-starter-parent中定义了各种技术的版本信息。组合了一套最优搭配的技术版本。

*在各种starter中，定义了完成该功能需要的坐标集合，其中大部分版本信息来自于父工程。

*我们的工程继承parent，引入starter后，通过依赖传递，就可以简单方便获得需要的jar包，并且不会存在版本冲突等问题。

配置文件分类：

SpringBoot是基于约定的，所以很多配置都有默认值，就可以使用application。properties或者application.yml（applicatoin.yaml）进行配置。

*properties：

server.port=8080

*yml

server：

port： 8080

小结：

*SpringBoot提供了2中配置文件类型，properteis和yml/yaml

*默认配置文件名称：application

*在同一级目录下优先级为：properties>yml>yaml

YAML

YAML全称是YAML Ain'tMarkup Language。YAML是一种直观的能够被电脑识别的数据序列化格式并容易被人类阅读，容易被脚本语言交互的。可以被支持YAML库的不同的编程语言程序导入，比如：C/C++,Ruby,Python,Java,Perl,C#,PHP等。YML文件是以数据为核心的，比传统的xml方式更加简洁。

YAML文件的扩展名可以使用。yml或者。yaml。

*properties：

server.port=8080

server.address=127.0.0.1

*xml：

<server>

<port>8080</port>

<address>127.0.0.1</address>

</server>

*yml

server:

    port: 8080

address: 127.0.0.1

简洁：以数据为中心。

YAML：基本语法：
1）大小写敏感

2）数据值前边必须有空格，作为分隔符

3）使用缩进表示层级关系

4）缩进时不允许使用Tab键，只允许使用空格（各个系统Tab对应的空格数目可能不同，导致层次混乱）。

5）缩进的空格数目不重要，只要相同层级的元素左侧对其即可。

6）#表示注解，从这个字符一直到行尾，都会被解析器忽略。

server：

port： 8080

address： 127.0.0.1

name：abc

YAML：数据格式

*对象（map）：键值对的集合。

person：

   name: zhansan

#行内写法

person: {name: zhangsan}

*数组：一组按次序排列的值。

address:

   -beijing

   -shanghai

#行内写法

address: [beijing,shanghai]

*纯量：单个的。不可再分的值

msg1: 'hello \n world'         #单引忽略转义字符

msg2: "hello \n world"        #双引识别转义字符

application.yml

server:

    port: 8080

name: abc

#对象

person：

     name: zhangsan

     age: 20

#对象行内写法

person2： {name: zhangsan,age: 20}

#数组

address：

    -  beijing

    -  shanghai

#数组的行内写法

address2：  [beijing,shanghai]

#纯量

msg1:  'hello \n world'

msg2:  "hello \n world"

YAML参数引用

name:  lisi

person:

    name:  ${name}   #引用上面定义的name值

YAML：小结

1）配置文件类型

*properties：和以前一样

*yml/yaml：注意空格

2）yaml：简洁，以数据为中心

*基本语法

*大小写敏感

*数据值前边必须有空格，作为分隔符

*使用空格缩进表示层级关系，相同缩进表示同一级。

*数据格式

*对象

*数组：使用 “- ”  表示数组每个元素

*纯量

*参数引用

*${Key}

如何读取配置文件的内容：

1）@Value

2）Environment（一个环境的对象）

3）@ConfigurationProperties（映射的一个关系）

@RestController

public class HelloController{

@Value("${name}")

private String name;

@Value("${person.name}")

private String name2;

@Value("${person.age}")

private int age;

@Value("${address[0]}")

private String address1 ;

@Value("${msg1}")

private String msg1 ;

@Value("${msg2}")

private String msg2 ;

@Autowired

private Environment env;#注入一个对象

@Autowired

private Person person;#注入一个对象

@RequestMapping("/hello2")

public class hello2(){ return "hello Spring Boot 222!"; }

P(name);

P(name2);

P(age);

P(address1);

P(msg1);

P(msg2);

P(env.getProperty("person.name"));.

P(env.getProperty("address[0]"));.

P(person);

String[] address = person.getAddress();

for(String s : address) {

P(s);

}

@RequestMapping("/hello")

public String hello(){ return "hello Spring Boot 222!";  }

}

@Componet

@ConfigurationProperties（prefix = "person"）

public class Person{

private String name;

priavte int age;

private String[] address;

public String getName(){

return name;

}

//get and set方法，并且重写toString()

}

拓展：有一个打开文档的提示：

加一个注解文档：

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-configuration-processor</artifactId>

<optional>true</optional>

</dependency>

加上之后写yml会有一些提示。比如可以。出来。

SpringBoot配置

profile

我们在开发springboot应用时，通常同一套程序会被安装到不同环境，比如：开发，测试，生产等。其中数据库地址。服务器端口等等配置都不同。如果每次打包时，都要修改配置文件，那么非常麻烦。profile功能就是来进行动态配置切换的。 

1）profile配置方式（用来完成不同环境下，配置动态切换功能的）

    *多profile文件方式

    *yml多文档方式

2）profile激活方式

     *配置文件：在配置文件中配置：spring.profiles.active=dev

     *虚拟机参数 :在VM options指定： -Dspring.profiles.active=dev

     *命令行参数  :java -jar xxx.jar  --spring.profiles.active=dev

application.properties

application-dev.properties/yml 开发环境

application-pro.properties/yml 测试环境

application-test.properties/yml 生产环境

如何激活，在application.properties主文件中

spring.profiles.active=dev/pro/test

yml多文档配置方式  --分隔不同配置

application.yml

---

server:

    port:  8081

spring:

    profiles:  dev

---

server:

    port:  8082

spring:

    profiles:  test

---

server:

    port:  8083

spring:

    profiles:  pro

---

激活：

spring:

    profiles:

        active:  pro

虚拟机

Run/Denug Configuration

VM options:   -Dspring.profiles.active-test

Program arguments:   --spring.profiles.active=pro

打包jar：

springboot-profiles->Lifecycle->package

在有jar包的位置按Shift+右键

在cmd中输入java -jar .\文件名。后缀

回车

java -jar .\文件名。后缀 --spring.profiles.active=pro

完成切换。

内部配置加载顺序

Springboot程序启动时，会从以下位置加载配置文件：

1.file:./config/:  当前项目下的/config目录下

2。file:./        :  当前项目的根目录

3。classpath:/config/: classpath的/config目录

4。classpath:/          :classpath的根目录

加载顺序为上文的排列顺序，高优先级配置的属性会生效。

Profile-小结

1）profile是用来完成不同环境下，配置动态切换功能的。

2）profile配置方式。

*多profile文件方式：提供多个配置文件，每个代表一种环境。

三种文件的配置的开发环境

*yml多文档方式：

在同一个yml中使用---分隔不同配置。

3）profile激活方式

*配置文件：在配置文件中配置：spring.profiles.active=dev

*虚拟机参数：在VM options指定： -Dspring.profiles.active-dev

*命令行参数： java -jar XXX.jar  --spring.profiles.active=dev

classpath是类路径，类路径是在   .idea那里。

#修改项目的访问路径 默认值为/

server.servlet.context-path=/hello

server.port=8081

 

 在Shift+右键的运行方式下，运行jar，上图不会执行。因为根目录下的配置不会打进jar包

 

 后边是路径。

12.13.14.15是四个默认加载位置。

Springboot整合其他框架

案例：需求

springboot整合Junit

案例：实现步骤

1）搭建Springboot工程

2）引入starter-test起步依赖

3）编写测试类

4）添加测试相关注解

*@RunWith（springRunner.class）

*@SpringBootTest(classes = 启动类。class)

5）编写测试方法

 

 

如果包名一样可以去掉哪个路径。

包名不同也不指定路径，会出现找不到异常。 

 自动快速创建的情况下，包名是相同的。

SpringBoot整合Redis

案例：实现步骤：

1）搭建springboot工程。

2）引入redis起步依赖

3）配置redis相关属性

4）注入RedisTemplate模板

5）编写测试方法，测试。

 起步依赖

快速创建时选的是NoSQL--》Spring Data Redis(Access + Driver)

 自动注入RedisTemplate

加上get和set方法

默认自带的Redis本机端口号6379。

控制台启动Redis

在启动测试

成功。

如果不是本机的Redis

用yml配置

 下面的提示是可以修改的默认的配置。

###SpringBoot整合MyBatis

案例：实现步骤：

1）搭建SpringBoot工程

2）引入mybatis起步依赖，添加mysql驱动

3）编写DataSource和MyBatis相关配置。

4）定义表和实体类。

5）编写dao和mapper文件/纯注解开发

6）测试

 添加依赖。

 起步依赖和驱动依赖。

pom文件：

runtime这个是运行时生效的mysql驱动。

接下来准备数据库的资料。

 这是做好的sql文件

打开cmd

打开mysql

命令mysql -u(账号) -p(密码)比如：mysql -uroot -proot

插入表

select * from t_user;查询表

 然后添加get方法，set方法。重写toString。

application.yml

#datasource

spring:

    datasource:

        url:  jabc:mysql:///springboot           #///省略了用户名，端口，IP

        username:    root

        password:    root

        driver-class-name:   com.mysql.jdbc.Driver

 @Repostitory注解可以去除自动注入的波浪

 写一个UserMapper

url: jabc:mysql:///springboot?serverTimezone=UTC