Spring Boot学习笔记

SpringBoot特征

特征

• 创建独立的 Spring 应用程序

• 直接嵌入 Tomcat、Jetty 或 Undertow（无需部署 WAR 文件）

• 提供“入门”依赖项以简化构建配置

• 尽可能自动配置 Spring 和 第三方库

• 提供生产就绪功能，例如指标、健康检查和外部化配置

• 完全无需代码生成，无需 XML 配置

创建SpringBoo项目

第一种方式，使用Spring提供的初始化器，就是向导创建SpringBoot应用

1.IEDA创建一个空项目

2.新建一个Module

还可以使用国内地址（镜像)  ​ https://start.springboot.io

 3.

4.选择依赖项

 5.

 6.

 7.配置好的SpringBoot目录结构

 8.

@Controller：后端控制器

@RequestMapping("/hello")：访问路径

@ResponseBody：将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据

 9.

10.去浏览器访问 @RequestMapping("/hello")地址

 多环境配置

        在实际开发过程中，项目会经历很多阶段（开发->测试->上线）,每个阶段的配置也会不同，例如，端口，上下文跟，数据库，那么这个时候为了方便不同环境之间的切换，SpringBoot提供了多环境配置，具体步骤如下

项目名:006-SpringBoot-multi-asdn

为每个环境创建一个配置文件，命名必须以application-环境标识.yml

注解

一、@controller：   controller控制器层（注入服务）
二、@service ：      service服务层（注入dao）
三、@repository ：  dao持久层（实现dao访问）
四、@component：  标注一个类为Spring容器的Bean，（把普通pojo实例化到spring容器中，至关于配置文件中的<bean id="" class=""/>）spring

@ConfigurationProperties

在SpringBoot中，当需要获取到配置文件数据时，除了可以用Spring自带的@Value注解外，
SpringBoot提供了一种更加方便的方式：@ConfigurationProperties。
只要在bean上添加上这个注解，指定好配置文件的前缀，那么对应的配置文件数据就会自动填充到bean中。
举个栗子，现在有如下配置：
1 myconfig.name=test
2 myconfig.age=22
3 myconfig.desc=这是我的测试描述添加对应的配置类，并添加上注解@ConfigurationProperties，指定前缀为myconfig
1 @Component
2 @ConfigurationProperties(prefix = "myconfig")
3 public class MyConfig {
4 private String name; //属性名要和配置文件中的名字一样
5 private Integer age; //属性名要和配置文件中的名字一样
6 private String desc; //属性名要和配置文件中的名字一样
7     //get//set 略
8 @Override
9 public String toString() {
10  return "MyConfig [name=" + name + ", age=" + age + ", desc=" + desc + "]";
11 }
12}

使用容器

获取容器中的对象

CommandLineRunner 接口

在开发中会有这样的情景，需要在容器启动后执行一些内容，比如读取配置文件，数据库连接之类的，SpringBoot给提供了两个接口帮我们实现这种需求，这两个接口分别为CommandLineRunner和ApplicationRunner。他们的执行时机为容器启动完成的时候，这两个接口中有一个run方法，只需要实现这个方法即可。这两个接口的不同之处在于：ApplicationRunner中run方法的参数为ApplicationArguments，而CommandLineRunner接口中run方法的参数为String数组

 Web组件

拦截器

拦截器是SpringMVC中的一种对象，能拦截对COntroller的请求

拦截器框架中有系统的拦截器，还可以自定义拦截器，实现对请求的拦截

实现自定义拦截器：创建类去实现HandlerInterceptor接口重写方法

package org.springframework.web.servlet;import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.lang.Nullable;public interface HandlerInterceptor {default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {return true;}default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {}default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {}
}

需要在SpringMVC的配置文件中，声明拦截器

<mvc:interceptors><mvc:interceptor><mvc:path="url"/><bean class="拦截器类全限定名称"/></mvc:interceptor>
</mvc:interceptors>

SpringBoot中拦截器

1.创建一个类去实现HandlerInterceptor接口重写preHandle方法

 2.通过WebMvcConfigurer接口实现一个配置类,再通过@Configuration 注解注入到容器

/*** 拦截器注入到容器中*/
@Configuration
public class MyappConfig implements WebMvcConfigurer {@Overridepublic void addInterceptors(InterceptorRegistry registry) {//创建拦截器对象HandlerInterceptor interceptor = new Interceptor();//指定拦截的请求urlString[] url = {"/user/**"};//不拦截的url请求地址String[] path ={"/user/login"};registry.addInterceptor(interceptor).addPathPatterns(url).excludePathPatterns(path);}
}

3.创建controller去实验一下

 4.运行程序访问/user/acc和/user/login

访问/user/acc地址，拦截器中的preHandle方法执行了，说明该请求被拦截器拦截

 

SpringBoot 中Servlet

1.自定义一个servlet类

 2.注册servlet

 SpringBoot中使用Filter

实现步骤：

1.创建Filter对象

 2.FilterRegistrationBean用来注册Filter对象

 字符集过滤器

CharacterEncodingFilter:解决post请求中乱码的问题

实现步骤：

1.配置字符集过滤器

@Configuration
public class WebApplicationConfig {@Beanpublic ServletRegistrationBean servletRegistrationBean(){ServletRegistrationBean bean = new ServletRegistrationBean(new Myservlet(),"/myservlet");return bean;}/*配置字符集过滤器*/@Beanpublic FilterRegistrationBean filterRegistrationBean(){FilterRegistrationBean filter = new FilterRegistrationBean();//使用框架中的过滤器CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();//指定编码的格式characterEncodingFilter.setEncoding("utf-8");//指定request，response都使用utf-8编码characterEncodingFilter.setForceEncoding(true);filter.setFilter(characterEncodingFilter);filter.addUrlPatterns("/*");return filter;}
}

2.修改application.properties文件，让自定义过滤器起作用

#springboot中默认是配置了CharacterEncodingFilter。默认编码ISO-8859-1
#设置为false，关闭默认配置使用自定义字符过滤器
server.servlet.encoding.enabled=false

第二种修改字符集方式：

 ORM操作MySQL

在SpringBoot框架中集成MyBatis

使用步骤：

1.添加mybatis起步依赖

2.pom.xml指定把src/main/java目录中的xml文件包含classpath中

3.创建实体类

4.创建Dao接口，创建查询方法

 5.创建Dao接口对应的Mapper文件

6.创建servlice接口和实现类，去调Dao接口中的方法

7.创建Controller层，去调用service中的方法

8.写application.properties文件

 9.在启动类上添加@MapperScan(basePackages = "com.demo.dao")

 10.启动springboot测试就ok

        第二种方式：Mapper文件和dao接口分开管理（推荐使用）

        1.在resources目录中创建子目录（自定义），例如，mapper

        2.把mapper.xml文件放到mapper目录中

        3.在application.properties文件中，指定mapper.xml文件的位置 

mybatis.mapper-locations=classpath:mapper/*.xml

        4.在pom.xml中指定把resources目录中的文件，编译到目标目录中

<resources><resource><directory>src/main/resources</directory><includes><include>**/*.*</include></includes></resource>
</resources>

事务

spring框架中的事务

1.管理事务的对象：事务管理器（接口，接口有很多实现类）

        例如，使用jdbc和mybatis访问数据库，使用的事务管理器：DataSourceTransactionManager

2.声明事务：在xml配置文件或使用注解方式说明事务控制的内容

        控制事务：隔离级别、传播行为、超时时间

3.事务处理方式

        Spring框架中注解@Transactional

        aspecJ框架可以在xml配置文件中，声明事务控制的内容

SpringBoot中使用事务：以上两种方式都可以，这里使用注解方式

1.在业务方法上面加入@Transactional，加入注解方法就有事务功能了

2.在主启动类上面加入，@EnableTransactionManager

SpringBoot中使用Redis数据库

1.启动Redis服务，客户端连接redis服务

2.IEDA中新建模块，依赖项选择Web 和 NoSQL

3.在application.properties配置文件中添加连接redis数据库ip和端口

4.写个测试类访问redis数据库

@RestController
public class RedisController {@Resourceprivate RedisTemplate redisTemplate;@GetMapping("/redis/set")public String addredis(String name,String value){/*通过RedisTemplate类中的opsForValue()方法可以操控redis数据库中String类型的数据*/ValueOperations redis = redisTemplate.opsForValue();redis.set("myname","lisi");return "向redis数据库添加String类型数据";}@GetMapping("/redis/get")public String getredis(String key){ValueOperations redis = redisTemplate.opsForValue();String v = (String) redis.get(key);return key+":::"+v;}
}

以上两个方法执行结果都会被序列化成二进制数据，第一个方法写入redis数据库中的数据被序列化，我们查看很不方便，如下图

 这时候就要使用序列化和反序列化技术

Redis序列化

 序列化：把对象转化为可以传输的字节序列过程称为序列化

反序列化：把字节序列还原为对象的过程称为反序列化

Q为什么要序列化？

序列化最终的目的是为了对象可以跨平台存储，和进行网络传输。跨平台存储和网络传输的方式就是IO，而IO支持的数据格式就是字节数据，再把对象转成字节数组的时候制定一种规则(序列化)，我们从IO流里读取数据的时候再以制定的规则把对象还原回来(反序列化)

序列化的方式？

常见的序列化方式有：jdk(不支持跨语言)、JSON、XML、Hessian等。

java的序列化：把java对象转换为byte[]，二进制数据。

json序列化：是将java对象转换成字符串：{"name":"李四"，"age":"22"}，反序列化是将

{"name":"李四"，"age":"22"}转换成java对象，对象属性是name，值是李四。

设置RredisTemplate序列化

可以设置key的序列化、也可以只设置value的序列化，也可以同时都设置

使用json序列化，把java对象转换为json字符串存储

1.创建一个student类实现Serializable接口，并添加序列化版本号

 2.使用json序列化把一个java对象存储到redis数据库

 3.使用json反序列化从redis中取出刚才存储的java对象显示在页面上

         输出结果

springBoot集成Dubbo

1.创建接口

创建一个接口项目，该项目只定义接口和实体类，此项目就是一个普通的maven项目

2.服务提供者

新建一个项目使用Spring 初始化器创建，不用选择依赖项，实现接口项目里的接口

在pom.xml文件中添加依赖

        <!--接口依赖--><dependency><groupId>com.song</groupId><artifactId>014-interface-api</artifactId><version>1.0.0</version></dependency><!--dubbo依赖--><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>2.7.8</version></dependency><!--zookeeper注册中心依赖--><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-dependencies-zookeeper</artifactId><version>2.7.8</version><type>pom</type><exclusions><exclusion><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId></exclusion></exclusions></dependency></dependencies>

创建一个StudentServiceImpl类实现StudentService接口，并在类上添加暴露接口的注解

 在application.properties文件中添加配置

#配置服务名称
spring.application.name=studentservice-provider#配置扫描包，扫描的@DubboService
dubbo.scan.base-packages=com.song.service#配置dubbo协议,使用注册中心，不用配置协议
#dubbo.protocol.name=dubbo
#dubbo.protocol.port=8081#注册中心
dubbo.registry.address=zookeeper://localhost:2181

在启动类上方添加@EnableDubbo注解

@EnableDubbo注解含义是启用Dubbo，下包含两个注解：

        @EnableDubboConfig

        @DubboComponentScan：扫描Dubbo注解

3.创建消费者

新建一个项目使用Spring 初始化器创建，不选择依赖，创建好后，把以下依赖添加到pom文件中

<!--web起步依赖--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--接口依赖--><dependency><groupId>com.song</groupId><artifactId>014-interface-api</artifactId><version>1.0.0</version></dependency><!--dubbo依赖--><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>2.7.8</version></dependency><!--zookeeper注册中心依赖--><dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-dependencies-zookeeper</artifactId><version>2.7.8</version><type>pom</type><exclusions><exclusion><groupId>org.slf4j</groupId><artifactId>slf4j-log4j12</artifactId></exclusion></exclusions></dependency>

创建Controller类

 在启动类上面添加@EnableDubbo注解

 在application.properties文件中添加一下内容

#指定服务名称
spring.application.name=consumer-application#指定注册中心
dubbo.registry.address=zookeeper://localhost:2181

SpringBoot 打 war包

1.在pom.xml文件中修改打包格式，默认是打jar包

 2.修改打包后的名字

 3.启动类继承SpringBootServletInitializer类，重写configure方法

 4.开始打包，IDEA工具栏Build->Build Artifact->选中要打包的项目->Build

 SpringBoot打jar包

1.在pom.xml文件中指定maven-plugin插件的版本号

 2.下面步骤跟打war包的步骤2和4一样

Thymeleaf模板引擎

SpringBoot集成了Thymeleaf模板技术，并且SpringBoot官方也推荐使用Thymeleaf来代替JSP技术，Thymeleaf是另外的一张模板技术，它本身不属于SpringBoot，SpringBoot只是很好地集成这种模板技术，作为前端页面的数据展示，在过去的 java web开发中，我们往往会使用jsp去完成页面的动态渲染，但是jsp需要翻译编译运行，效率低。

第一个例子

1.使用spring初始化器创建一个模块，

 2.勾选依赖，如下图

 3.写controller

 4.在templates文件夹中新建一个html文件

5.启动类运行访问controller的地址/acc

 Thymeleaf表达式

表达式是在页面获取数据的一种thymeleaf语法，类似${key}

标准变量表达式

        注意：th:text=""是Thymeleaf的一个属性，用于文件的显示

说明：标准变量表达式用于访问容器tomcat上下文环境中的变量，Thymeleaf中的变量表达式使用${变量名}的方式获取Controller中model其中的数据，也就是request作用域中的数据

 选择变量表达式

星号变量表达式

语法：*{key}

作用：获取这个key对应的数据，*{key}需要和th:object这个属性一起使用。

目的：简化获取对象的属性值。

链接表达式

语法：@{url}

作用：表示连接