Spring Boot学习笔记

SpringBoot特征

特征

创建独立的 Spring 应用程序
直接嵌入 Tomcat、Jetty 或 Undertow（无需部署 WAR 文件）
提供“入门”依赖项以简化构建配置
尽可能自动配置 Spring 和第三方库
提供生产就绪功能，例如指标、健康检查和外部化配置
完全无需代码生成，无需 XML 配置

创建SpringBoo项目

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

1.IEDA创建一个空项目

2.新建一个Module

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

4.选择依赖项

7.配置好的SpringBoot目录结构

@Controller：后端控制器

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

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

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 {

    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        //创建拦截器对象
        HandlerInterceptor interceptor = new Interceptor();

        //指定拦截的请求url
        String[] 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 {

    @Bean
    public ServletRegistrationBean servletRegistrationBean(){
        ServletRegistrationBean bean = new ServletRegistrationBean(new Myservlet(),"/myservlet");

        return bean;
    }



    /*配置字符集过滤器*/

    @Bean
    public 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 {
    @Resource
    private 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初始化器创建一个模块，