SpringBoot笔记之入门教程

最新推荐文章于 2023-12-29 13:58:20 发布
最新推荐文章于 2023-12-29 13:58:20 发布
阅读量426 收藏 2
点赞数
分类专栏： java框架 文章标签： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/msyqmsyq/article/details/82017773
版权

SpringBoot入门

一、SpringBoot简介

1.SpringBoot是什么？

​ 产生背景：Spring开发变的越来越笨重，大量的XML文件，繁琐的配置，复杂的部署流程，整合第三方框架难度大等，导致开发效率低下

​ SpringBoot是一个用来简化Spring应用的初始创建和开发过程的框架，简化配置，实现快速开发

​ 整合了整个Spring技术栈，JavaEE开发的一站式解决方案

2. 为什么使用SpringBoot？

​ 优点：

  • 快速创建独立运行的Spring项目并与主流框架集成
  • 内置Servlet容器，应用无需打成war包
  • 使用starter(启动器)管理依赖并进行版本控制
  • 大量的自动配置，简化开发
  • 提供准生产环境的运行时监控，如指标、健康检查、外部配置等
  • 无需配置XML，没有冗余代码生成，开箱即用

二、第一个SpringBoot程序

1. 简介

​ 环境：

  • SpringBoot 2.0（基于Spring 5.0）
  • JDK1.8及以上
  • Maven 3.2及以上
  • Tomcat 8.5及以上
  • IDEA较新版本

2. 操作步骤

​ 步骤：

  1. 创建一个maven的java工程

    传统的web应用需要创建web工程，后期要打包war包，然后放到tomcat中，太麻烦

    而SpringBoot应用只需要创建一个java工程，后期直接打包可执行的jar包，其内置tomcat

  2. 导入SpringBoot的相关依赖

    <!-- Inherit defaults from Spring Boot -->
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.0.3.RELEASE</version>
   </parent>

   <!-- Add typical dependencies for a web application -->
   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
   </dependencies>

  3. 编写Service、Controller等

    @Controller
public class HelloController {

   @RequestMapping("/hello")
   @ResponseBody
   public String hello() {
       return "Hello World";
   }
}

  4. 编写主程序类，用来启动Spring应用

    /**
* Author：xx
* Date：2018-07-09 10:28
* Description：使用@SpringBootApplication标注主程序类，表示这是一个SpringBoot应用
*/
@ComponentScan("com.itany.controller")
@SpringBootApplication
public class MainApplication {
   public static void main(String[] args) {
       // 启用SpringBoot应用
       SpringApplication.run(MainApplication.class, args); //传入主程序类的Class对象
   }
}

    注：默认只扫描主程序类所在的包及其子包

  5. 部署打包

    添加插件，将应用打包成可执行的jar，执行java -jar springboot01-helloworld-1.0-SNAPSHOT.jar

    <!--  该插件可以将应用打成一个可执行的jar包  -->
<build>
 <plugins>
   <plugin>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-maven-plugin</artifactId>
   </plugin>
 </plugins>
</build>

3. 分析Hello World

3.1 POM文件

  • 父工程spring-boot-starter-parent

    <parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.3.RELEASE</version>
</parent>

    父工程的父工程是spring-boot-dependencies，用来管理SpringBoot应用中的依赖的版本，进行版本控制

    <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-dependencies</artifactId>
 <version>2.0.3.RELEASE</version>
 <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

  • 通过starter指定依赖

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

    SpringBoot提供了许多starter（启动器），分别对应不同的功能场景，当在项目中引入这些starter时相应场景的依赖就会被导入进来

3.2 主程序类

  • @SpringBootApplication

    标注在类上，表示这个是SpringBoot的主配置类，通过运行该类的main方法来启动SpringBoot应用

    @Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
  excludeFilters = {@Filter(
  type = FilterType.CUSTOM,
  classes = {TypeExcludeFilter.class}
), @Filter(
  type = FilterType.CUSTOM,
  classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {

  • @SpringBootConfiguration

    标注在类上，表示这个类是SpringBoot的配置类

    层级关系：@SpringBootConfiguration——>@Configuration——>@Component

    @Configuration标注在类上，表示这个类是Spring的配置类，相当于是一个xml配置文件

  • @EnableAutoConfiguration

    开启自动配置功能，SpringBoot会自动完成许多配置，简化了以前繁琐的配置

    SpringBoot在启动时会类路径下/META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类添加到容器中，这些自动配置类会帮我们完成许多配置工作。

  • @ComponentScan

    标注在类上，指定要扫描的包

三、快速创建SpringBoot项目

1. 简介

​ 使用Spring Initinalizer快速创建SpringBoot项目

2. 基本操作

  • POM文件和主程序类已经生成好了，直接写业务逻辑即可

  • resources文件夹的目录结果

    |-static   存放静态资源，如css、js、image等
|-templates  存储模板页面，可以使用模板引擎，如freemarker、thymeleaf等
|-application.properties SpringBoot应用的配置文件,可以修改一些默认设置

四、配置文件

1. 简介

​ SpringBoot的默认全局配置文件有两种：

  • application.properties
  • application.yml

​ 文件名固定，存放在classpath:/ 或 classpath:/config/ 目录下

​ 可以通过配置文件修改SpringBoot的默认配置

​ 配置项可参考：https://docs.spring.io/spring-boot/docs/2.0.3.RELEASE/reference/htmlsingle/#common-application-properties

​ 注：在SpringBoot2.0中，部分配置项与SpringBoot1.0中有所不同，有的被重命名或被删除

2. YAML用法

2.1 简介

​ YAML是”YAML Ain’t a Markup Language”的缩写，表示YAML不是一种标记语言

​ YAML是专门用来写配置文件的语言，以数据为中心，简洁和强大，比xml、properties等更合适做配置文件

​ YAML文件的后缀名为.yml或.yaml

2.2 语法规则
  • 大小写敏感
  • 使用缩进表示层级关系
  • 缩进时不允许使用Tab键，只能使用空格
  • 缩进的空格数目不重要，只要相同层级的元素左侧要对齐
  • #表示注释
server:
  port: 8881  #　写法key:value，冒号后面必须有空格
  servlet:
    context-path: /springboot03
2.3 基本用法

​ YAML支持的数据结构有三种：

  • 字面量：单个的，不可再分的值
  • 对象：键值对的集合
  • 数组：一组按次序排列的值

​ 三种数据结构的用法：

  1. 字面量：普通的值，如数字、字符串、布尔值

    number: 12.5
str: hello
name: 'tom cruise'  # 如果字符串包含空格或特殊字符，则必须使用引号引起来，单引号或双引号都可以
name: 'tom \n cruise' # 不对对特殊字符进行转义，结果：tom 换行 cruise
name: "tom \n cruise"  # 对特殊字符进行转义，会作为普通字符输出，结果为:tom \n cruise

  2. 对象：也称为映射Map，包含属性和值

    
# 写法1：换行写

user:
 name: tom
 age: 20
 sex: male

# 写法2：行内写法

user: {name: tom,age: 20,sex: male}

  3. 数组，如List、Set等

    
#　写法１：一组短横线开头的行

names:
 - tom
 - jack
 - alice

# 写法2：行内写法

name: [tom,jack,alice]

3. 为属性注入值

​ 通过加载配置文件，为类中的属性注入值

3.1 使用.yml配置文件

​ application.yml文件

user:
  username: admin
  age: 18
  status: true
  birthday: 2018/2/14
  address:
    province: 江苏省
    city: 南京市
  lists:
    - list1
    - list2
    - list3
  maps: {k1: v1,k2: v2}

​ User类

// 必须将当前类添加到容器中
@Component
// 默认读取全局配置文件获取值，将当前类中的所有属性与配置文件中的user进行绑定
@ConfigurationProperties(prefix = "user")
public class User {

    private String username;
    private Integer age;
    private Boolean status;
    private Date birthday;
    private Address address;
    private List<String> lists;
    private Map<String,Object> maps;

可以添加配置文件处理器的依赖（可选）

<!-- 配置文件处理器，自动生成元数据信息，编写配置文件会有提示 -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
  <optional>true</optional>
</dependency>
3.2 使用properties配置文件

​ application.properties文件

user.username=alice
user.age=22
user.status=false
user.birthday=2018/7/2
user.address.province=广东省
user.address.city=东莞市
user.lists=list1,list2,list3
user.maps.k1=v1
user.maps.k2=v2

​ 注：在IDEA中properties文件默认使用utf8/gbk编码，会出现中文乱码

3.3 使用@Value为属性注入值
// 必须将当前类添加到容器中
@Component
// 默认读取全局配置文件获取值，将当前类中的所有属性与配置文件中的user进行绑定
// @ConfigurationProperties(prefix = "user")
public class User {

    @Value("${user.username}")
    private String username;
    @Value("${user.age}")
    private Integer age;
    @Value("${user.status}")
    private Boolean status;
    @Value("${user.birthday}")
    private Date birthday;
    //@Value不支持复杂类型封装
    private Address address;
    @Value("${user.lists}")
    private List<String> lists;
    private Map<String,Object> maps;

@Value和@ConfigurationProperties的比较：

  • @Value只能一个个为属性注入值，而@ConfigurationProperties可以批量为属性注入值
  • @Value不支持为复杂类型封装，而@ConfigurationProperties支持

4. 多环境配置

​ 可以为不同环境提供不同的配置信息，如开发环境、测试环境、生产环境等

​ 两种方式：

  • 创建多个properties文件
  • 定义yml文档块
4.1 创建多个properties文件

​ 步骤：

  1. 创建不同环境的properties文件

    文件命名必须符合application-xxx.properties格式

    application-dev.properties

    application-test.properties

    application-prod.properties

  2. 在application.properties文件中指定要激活的配置

    
# 指定要激活的配置

spring.profiles.active=prod
4.2 定义yml文档块

​ 在yml文件中使用三个短横线定义多个文档块

​ 步骤：

  1. 在yml文件中定义多个文档块，表示不同的环境配置

    “`yaml

    spring:
    profiles: dev
    server:
    port: 9991

spring:
profiles: test
server:
port: 9992
“`

spring:
profiles: prod
server:
port: 9993

“`

  1. 在第一个文档块中指定要激活的配置

    spring:
 profiles:
   active: test

5. 加载外部配置文件

5.1 加载properties属性文件

​ 问题：@ConfigurationProperties默认是从全局配置文件中获取值，如果想从外部的自定义属性文件中获取值怎么办？

​ 解决：使用@PropertySource加载外部的属性文件

// 必须将当前类添加到容器中
@Component
// 加载外部的属性文件
@PropertySource({"classpath:user.properties"})
// 默认读取全局配置文件获取值，将当前类中的所有属性与配置文件中的user进行绑定
@ConfigurationProperties(prefix = "user")
public class User {
5.2 加载spring配置文件

​ 问题：如果确实需要将配置写在Spring的xml配置文件中，想加载xml文件怎么办？

​ 解决：使用@ImportResource加载外部的Spring配置文件

// 加载外部的Spring配置文件
@ImportResource({"classpath:spring.xml"})
@SpringBootApplication
public class Springboot03ConfigApplication {
5.3 使用注解方式添加组件

​ 推荐使用全注解方式向容器中添加组件，@Configuration和@Bean

// 标注在类上，表示这是一个配置类，相当于以前编写的Spring配置文件
@Configuration
public class SpringConfig {

    // 标注在方法上，向容器中添加一个组件，将方法的返回值添加到容器中，方法名作为组件id
    @Bean
    public Address address(){
        Address address = new Address();
        address.setProvince("山东");
        address.setCity("日照");
        return address;
    }
}

五、自动配置的原理

1. 执行流程

  1. SpringBoot启动时加载主配置类，开启了自动配置功能@EnableAutoConfiguration

  2. @EnableAutoConfiguration作用

    利用@Import({AutoConfigurationImportSelector.class})向容器中添加一些组件（自动配置类）

    查看AutoConfigurationImportSelector中的selectImports()方法

    查看List configurations = this.getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置

    查看SpringFactoriesLoader.loadFactoryNames方法

    查看loadSpringFactories()方法

    查看classLoader.getResources(“META-INF/spring.factories”)

    扫描所有Jar包类路径下的加载META-INF/spring.factories文件，获取EnableAutoConfiguration对应的值（在spring-boot-autoconfigure-2.0.3.RELEASE.jar中）

    将这些自动配置类（xxxAutoConfiguration）添加到容器中

  3. 通过这些自动配置类来完成相应的自动配置功能

2. 原理分析

​ 以HttpEncodingAutoConfiguration为例，就是以前我们在web.xml文件中配置的CharacterEncodingFilter过滤器

// 表示这是一个配置类，相当于以前我们编写的spring配置文件
@Configuration
// 启用HttpEncodingProperties类的ConfigurationProperties功能，通过配置文件为属性注入值，并将其添加到容器中
@EnableConfigurationProperties({HttpEncodingProperties.class})
// 如果当前应用是Web应用，则该配置类生效，否则不生效
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
// 如果当前应用有CharacterEncodingFilter类，则该配置类生效，否则不生效
@ConditionalOnClass({CharacterEncodingFilter.class})
// 如果配置文件中有spring.http.encoding.endabled选项，则该配置生效，否则不生效，默认已经设置为true，所以默认生产
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
    private final HttpEncodingProperties properties;

    // 将容器中的HttpEncodingProperties注入
    public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
        this.properties = properties;
    }

    // 将返回的CharacterEncodingFilter对象添加到容器中，作为一个bean
    @Bean
    // 如果容器中没有这个组件，则添加
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpEncodingProperties.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpEncodingProperties.Type.RESPONSE));
        return filter;
    }
// 从配置文件中获取指定的属性值，然后绑定到当前类中的属性
@ConfigurationProperties(
    prefix = "spring.http.encoding"
)
public class HttpEncodingProperties {
    public static final Charset DEFAULT_CHARSET;
    private Charset charset;
    private Boolean force;
    private Boolean forceRequest;
    private Boolean forceResponse;
    private Map<Locale, Charset> mapping;

​ 注意：

  • 根据当前不同的条件判断，决定自动配置类是否生产，即并不是所有的自动配置类都会生效
  • 自动配置类xxxAutoConfiguration的属性是从对应的xxxProperties类中获取的
  • xxxProperties类中的所有属性是通过配置文件注入绑定的，我们可以通过配置文件指定这些属性的值

3. 总结

  • SpringBoot启动时会加载大量的自动配置类
  • 通过这些自动配置类来向添加中添加组件
  • 通过这些组件来自动完成许多功能，简化配置

六、Web开发

1. 简介

​ 使用SpringBoot开发Web应用的步骤：

  1. 创建SpringBoot应用，选择需要的starter
  2. 在配置文件中指定必要的少量配置
  3. 编写业务代码

​ Web开发的自动配置类：WebMvcAutoConfiguration

2. 静态资源的映射

2.1 静态资源位置

​ 查看WebMvcAutoConfiguration——>addResourceHandlers()——>getStaticLocations()——>staticLocations

​ 静态资源的默认位置：

  • “classpath:/META-INF/resources/”,
  • “classpath:/resources/”
  • “classpath:/static/”
  • “classpath:/public/”
  • “classpath:/” 在SpringBoot2.0中已经被删除，在SpringBoot1.0中有效

​ 当访问静态资源时会到所有静态资源文件夹中查找

​ 可以修改静态资源的位置：

# 指定静态资源的位置
spring.resources.static-locations=classpath:/static,classpath:/public
2.2 欢迎页

​ 查看WebMvcAutoConfiguration——>welcomePageHandlerMapping()——>getWelcomePage()

​ 将index.html页面放到任意一个静态资源文件夹中即可

2.3 图标

​ 查看WebMvcAutoConfiguration——>内部类FaviconConfiguration——>faviconHandlerMapping

​ 将favicon.ico放到任意一个静态资源文件夹中即可

七、模板引擎

1. 简介

​ 目前Java Web开发推荐使用模板引擎，不建议使用JSP页面

  • JSP缺点：本质上就是Servlet，需要后台编译，耗时，效率低
  • 模板引擎：不需要编译，速度快

​ 常用的模板引擎：Freemarker、Velocity、Thymeleaf等

​ SpringBoot推荐使用Thymeleaf，且默认不支持JSP页面，因为JSP必须要打成war包

​ 补充：目前主流的Web开发更推荐采用前后端分离，前端使用MVVM框架：Vue.js、Angular、React等

2. Thymeleaf的使用

​ 步骤：

  1. 添加thymeleaf的依赖

    <!--添加thymeleaf-->
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

  2. 将HTML页面放到templates目录中

    templates目录下的HTML页面默认不能直接访问，需要通过controller来访问，由thymeleaf渲染

    查看：ThymeleafAutoConfiguration——>ThymeleafProperties——>DEFAULT_PREFIX/DEFAULT_SUFFIX

  3. 使用thymeleaf

    参考手册：usingthymeleaf.pdf

    <!DOCTYPE html>
<!-- 导入thymeleaf的命名空间 -->
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
   <meta charset="UTF-8">
   <title>Title</title>
</head>
<body>
   <h2>success</h2>
   <!-- 使用th:text属性，设置元素中的文本，表达式${}可以获取作用域中的数据 -->
   <div th:text="${name}"></div>
</body>
</html>

  4. 修改页面后，让其实时生效

    由于thymeleaf默认启用了缓存

    
# 禁用thymeleaf的缓存

spring.thymeleaf.cache=false

    ​

    补充：还需要开启IDEA的自动编译，IDEA默认保存时不会自动编译

    Setting——>搜索Compiler——>勾选Build Project automatically

    Fild——>Find Action——>搜索Registry——>勾选Compiler.automake……

3. 语法规则

3.1 常用属性

​ 参考手册：10 Attribute Precedence

  • th:text、th:utext

    设置元素中的文本内容

    th:text 对特殊字符进行转义，等价于内联方式[[${}]]

    th:utext 对特殊字符不进行转义，等价于内联方式[(${})]

  • th:html原生属性

    用来替换指定的原生属性的值

  • th:if、th:unless、th:switch、th:case

    条件判断，类似于c:if

  • th:each

    循环，类似于c:forEach

  • th:object、th:with

    定义变量，类似c:set

    需要和*{}表达式配合使用

3.2 表达式

​ 参考手册：4 Standard Expression Syntax

  • ${}

    获取对象的属性

    获取对象的方法

    调用内置的基本对象，如session、application等

    调用内置的工具对象，如#strings、#dates、#arrays、#lists等

  • *{}

    需要和th:object配合使用，简化获取对象的属性

  • @{}

    定义url

  • 运算符

4. 热部署

​ 使用SpringBoot提供devtools实现热部署

​ 原理：实时监控classpath下文件的变化，如果发生变化则自动重启

​ 配置：添加devltools依赖

<!--devtools热部署-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <!--该依赖不传递-->
  <optional>true</optional>
</dependency>

八、扩展默认的SpringMVC功能

1. 简介

​ 以前在SpringMVC中通过如下代码实现一些功能，如视图跳转、拦截器等

<mvc:view-controller path="/showLogin" view-name="login"/>
<mvc:interceptors>
  <mvc:interceptor>
    <mvc:mapping path="/hello"/>
    <bean class="com.itany.interceptor.MyInterceptor"/>
  </mvc:interceptor>  
</mvc:interceptors>

​ SpringBoot自动配置默认并没有提供以上功能配置，需要自己扩展，使用WebMvcConfigurer接口

2. 基本操作

​ 步骤：

  1. 定义一个配置类（@Configuration），实现WebMvcConfigurer接口

  2. 根据需要实现相应的方法

    /**
* Author：汤小洋
* Date：2018-07-11 10:51
* Description：扩展默认的SpringMVC功能
* 要求：
* 1.使用@Configuration标注为配置类
* 2.实现WebMvcConfigurer接口
* 3.根据需要实现相应的方法
*
* 注：这个接口中的方法都加了jdk1.8中的default方法修饰，不强制实现所有方法（jdk1.8新特性）
*     在SpringBoot1.0版本中是继承WebMvcConfigurerAdapter类，在SpringBoot2.0中该类已过时
*/
@Configuration
public class CustomMvcConfig implements WebMvcConfigurer {

   // 添加ViewController
   @Override
   public void addViewControllers(ViewControllerRegistry registry) {
       //访问/showLogin时跳转到login视图
       registry.addViewController("/showLogin").setViewName("login");
   }

   // 添加Interceptor
   @Override
   public void addInterceptors(InterceptorRegistry registry) {
       registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**").excludePathPatterns("/showLogin","/test1");
   }
}

九、全局异常处理

1. 简介

​ 当程序出现异常时要进行全局处理

​ 两种方式：

  • 定义错误码页面
  • 定义异常通知

2. 定义错误码页面

​ 创建错误状态码.html页面，放在templates/error目录中，当发生错误时会自动到该目录下查找对应的错误页面

​ 可以创建如4xx.html或5xx.html页面，用来匹配所有该类型的错误

​ 可以在错误页面获取异常相关信息：

<h3>状态码：[[${status}]]</h3>
<h3>错误提示：[[${error}]]</h3>
<h3>异常消息：[[${message}]]</h3>
<h3>时间戳：[[${timestamp}]]</h3>
<h3>异常对象：[[${exception}]]</h3>

3. 定义异常通知

/**
 * Author：汤小洋
 * Date：2018-07-11 11:18
 * Description：异常通知，处理全局异常
 */
@ControllerAdvice
public class ExceptionAdvice {

    @ExceptionHandler(ArithmeticException.class)
    public String arithmetic(Exception e){
        System.out.println("警报，程序出现异常啦，发短信："+e.getMessage());
        return "error/arithmetic";
    }

    @ExceptionHandler(Exception.class)
    public String excetion(Exception e){
        System.out.println("警报，程序出现异常啦，发短信："+e.getMessage());
        return "error/error";
    }

}

十、关于Servlet容器

1. 简介

​ SpringBoot默认内置了Servlet容器：Tomcat

​ 问题：SpringBoot默认是以jar包的方式启动内置的Servlet容器，没有web.xml文件，如何注册Servlet、Filter、Listener?

​ 解决：通过自定义Servlet配置，使用ServletRegistrationBean、FilterRegistrationBean、ServletListenerRegistrationBean

2. 注册Servlet组件

​ 步骤：

  1. 定义一个配置类（@Configuration）

  2. 自定义方法，用来注册bean

    /**
* Author：xx
* Date：2018-07-11 11:50
* Description：自定义Servlet配置，注册Servlet三大组件:Servlet、Filter、Listener
*/
@Configuration
public class CustomServletConfig {

   // 注册Servlet
   @Bean
   public ServletRegistrationBean myServlet() {
       ServletRegistrationBean<MyServlet> bean = new ServletRegistrationBean<>();
       bean.setServlet(new MyServlet());
       bean.addUrlMappings("/myServlet");
       return bean;
   }

   // 注册Filter
   @Bean
   public FilterRegistrationBean myFilter() {
       FilterRegistrationBean<MyFilter> bean = new FilterRegistrationBean<>();
       bean.setFilter(new MyFilter());
       bean.setUrlPatterns(Arrays.asList("/showLogin", "/test1"));
       return bean;
   }

   // 注册Listener
   @Bean
   public ServletListenerRegistrationBean myListener() {
       return new ServletListenerRegistrationBean<>(new MyListener());
   }

}

3. 使用外部的Servlet容器

3.1 优缺点

​ 使用内置Servlet容器：将应用打成可执行的jar包，直接运行

​ 优点：简单、方便

​ 缺点：不支持JSP、可定制性差

​ 使用外部Servlet容器：将应用打成war包，然后部署到外部的Tomcat

​ 优点：支持JSP、可定制性强

3.2 操作步骤

​ 步骤：

  1. 创建一个war工程

    有如下三个变化：

    • 打包方式为war

      <packaging>war</packaging>

    • 将内置Tomcat的scope配置为provided

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

    • 定义了一个SpringBootServletInitinalizer的子类

      /**
* 要求：
* 1.必须继承SpringBootServletInitializer类
* 2.重写configure方法
* 3.调用SpringApplicationBuilder的sources()方法，传入SpringBoot应用的主程序类
*/
public class ServletInitializer extends SpringBootServletInitializer {

 @Override
 protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
     //传入SpringBoot应用的主程序类
     return application.sources(Springboot05WarApplication.class);
 }

}

  2. 创建web目录结构

  3. 配置前缀和后缀

    spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

  4. 配置Tomcat并启动

    需要使用Tomcat 8.5及以上版本

十五、SpringBoot数据访问

1. JDBC

​ 步骤：

  1. 创建一个工程，勾选 Web、MySQL、JDBC

  2. 配置数据库连接信息

    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=

spring.datasource.type=org.apache.commons.dbcp.BasicDataSource

  3. 配置连接池参数

    
# 指定连接池信息

spring.datasource.initialSize=10
spring.datasource.maxActive=100
spring.datasource.minIdle=5
spring.datasource.maxIdle=20
spring.datasource.maxWait=50000

    问题：添加上面的连接池参数后并不会生效，因为SpringBoot默认并不支持 这些参数，即DataSourceProperties类中没有这些属性

    解决：自定义数据源配置 

    @Configuration
public class DataSourceConfig {
   @Bean
   // 从配置文件中读取spring.datasource属性，并注入给数据源的属性
   @ConfigurationProperties(prefix = "spring.datasource")
   public DataSource dataSource(){
       DruidDataSource dataSource = new DruidDataSource(); // 自己创建数据源对象
       return dataSource;
   }
}

  4. 使用JdbcTemplate操作数据库

    @RestController
public class UserController {

   @Autowired
   private JdbcTemplate jdbcTemplate;

   @RequestMapping("/findAll")
   public List<Map<String, Object>> findAll() {
       List<Map<String, Object>> list = jdbcTemplate.queryForList("select * from t_user");
       return list;
   }

}

2. MyBatis

2.1 基本用法

​ 步骤：

  1. 创建一个工程，勾选：Web、MySQL、MyBatis

  2. 配置applilcation.yml

    
# 配置DataSource:

spring:
 datasource:
   driver-class-name: com.mysql.jdbc.Driver
   url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=utf8
   username: root
   password:
   initialSize: 10
   maxActive: 100
   minIdle: 5
   maxIdle: 20
   maxWait: 50000


# 配置MyBatis

mybatis:
 type-aliases-package: com.itany.pojo
 mapper-locations: classpath:mapper/*.xml

  3. 编写Mapper、Service、Controller等

  4. 配置MyBatisConfig

    @Configuration
// 扫描MyBatis的Mapper接口所在的包
@MapperScan("com.itany.mapper")
public class MyBatisConfig {

   @Bean
   @ConfigurationProperties(prefix = "spring.datasource")
   public DataSource dataSource(){
       return new DruidDataSource();
   }

}
2.2 配置PageHelper分页插件

​ 步骤：

  1. 添加pagehelper的依赖

    <dependency>
 <groupId>com.github.pagehelper</groupId>
 <artifactId>pagehelper-spring-boot-starter</artifactId>
 <version>1.2.5</version>
</dependency>

  2. 配置PageHelper属性

    
# 配置PageHelper

pagehelper:
 helper-dialect: mysql

  3. 使用PageHelper

    public PageInfo<User> findByPage(int pageNum, int pageSize) {
  // 设置PageHelper分页
  PageHelper.startPage(pageNum,pageSize);
  List<User> list = userMapper.selectAll();
  return new PageInfo<>(list);
}

    ​

陶大海888
关注
专栏目录
108页《SpringBoot 学习笔记完整教程》PDF附下载
uuqaz的博客
05-30 1296
今天Hydra分享给大家一本108页的《SpringBoot 学习笔记完整教程》，从SpringBoot的基本入门使用，到搭建项目进行代码实战，最终研究底层实现原理，基本涵盖了各个环节，可以说是一份非常齐全的资料了，能够帮助你快速打通SpringBoot的任督二脉。 目录 大家首先可以来看一下目录，全书共108页分为33个章节： 简要浏览 集成JdbcTemplate： 实现基于Scheduled的任务调度： 拦截器Interceptor实战： 集成redis缓存： ...
毕业设计：基于SpringBoot框架的动吧旅游后台项目,
08-21
还在未毕业设计而烦恼吗？点击下载，排解你的烦恼！！！
SpringBoot内部培训资料
07-04
SpringBoot内部培训资料,仅供参考和学习。自己搜索整理的。
快速教你认识springboot application.yml(超仔细超简单)
NiJabor的博客
11-20 1545
第一步 https://start.spring.io 下载demo 点击generate project 第二步 配置日志必须要引入spring-boot-starter-web或者spring-boot-starter &lt;!-- SLF4J日志 默认不需配置 spring-boot-starter或者spring-boot-starter-web， 而这两个起步依...
Springboot ---application.yml快速学习
开发猫
11-11 1万+
application.properties   使用多环境配置 在Spring Boot中多环境配置文件名需要满足application-{profile}.properties的格式，其中{profile}对应你的环境标识，如： application-dev.properties：开发环境 application-pro.properties：生产环境 这样就可以使用多状态配置...
SpringBoot配置文件教程(YML)
weixin_45203607的博客
09-20 2648
SpringBoot配置文件教程 介绍 SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话， 就可以使用application.properties或者application.yml | application.yaml进行配置。 SpringBoot默认会从Resources目录下加载application.properties或application.yml（application.yaml）文件 文件名必须是 application.xx ,两种
SpringBoot--application.yml配置文件--用法
IT利刃出鞘的博客
09-21 1万+
原文网址： bootstrap与application 参考网址 SpringCloud入门之常用的配置文件 application.yml和 bootstrap.yml区别 - JackYang - 博客园 简介 bootstrap与application都有两种配置格式：yml格式与properties格式。 项 bootstrap application 加载顺序 先于 applicatio
SpringBoot最详细入门教程+代码+笔记+视频
01-09
SpringBoot是Java开发领域的一款热门框架，由Pivotal团队创建，旨在简化Spring应用的初始搭建以及开发...通过学习这个最详细的入门教程，你可以全面掌握SpringBoot的基础和高级用法，为你的开发工作带来极大的便利。
SpringBoot学习笔记
01-11
### SpringBoot学习笔记 #### 一、SpringBoot入门 ##### 1、SpringBoot简介 - **简化Spring应用开发**：SpringBoot是简化Spring应用开发的一个框架，它通过默认配置极大地减少了开发过程中的样板代码，使得开发者...
springBoot笔记要点PDF
最新发布
11-04
1.Spring Boot 入门 Spring Boot是Spring社区较新的一个项目。该项目的目的是帮助开发者更容易的创建基于Spring的应用程序和服务，让更多人的人更快的对Spring进行入门体验，让Java开发也能够实现Ruby on Rails那样...
三、springboot笔记（特征、入门、整合）
09-22
springboot笔记： 特征、入门、整合
SpringBoot简明教程-yml配置文件详解
热门推荐
java小白翻身
10-14 1万+
Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。以下是我个人编写的SpringBoot简明教程，方便初学者学习，如有不足，敬请指正。首先，我们需要用idea创建一个SpringBoot项目。
SpringBoot - 配置文件application.yml使用详解（附：Profile多环境配置）
weixin_46916570的博客
02-09 6170
（1）YAML是 JSON 的超集，简洁而强大，是一种专门用来书写配置文件的语言，可以替代 application.properties。（2）在创建一个 SpringBoot 项目时，引入的 spring-boot-starter-web 依赖间接地引入了 snakeyaml 依赖， snakeyaml 会实现对 YAML 配置的解析。（3）YAML 的使用非常简单，利用缩进来表示层级关系，并且大小写敏感。
【Spring Boot】Spring Boot 配置文件详解（application.yml、application-dev.yml、application-test.yml ）
代码的魅力，根本走不出来
12-29 1万+
在 Spring Boot 中，可以通过属性文件（比如 application.yml 或 application.properties）来配置应用程序的属性。除了通过属性文件来设置激活的环境外，你还可以通过命令行参数、系统属性、环境变量等方式来指定激活的环境。上述示例展示了一些常用的配置项，但根据应用程序的需求，你可以在 application.yml 中配置各种属性。这些方式都允许在应用程序中方便地访问配置文件中的属性值，开发者可以根据具体情况选择最适合的方式。外，你还可以使用其他自定义的配置文件。
springBoot学习笔记之application.yml配置文件
qq_34258956的博客
12-05 225
我创建了一个springBoot的简单demo，并实现了简单的http请求。但有些用过springBoot工程的人就会疑惑，springBoot工程中是有一个application.yml配置文件的啊，其实application.yml的功能和application.properties是一样的，不过因为yml文件是树状结构，写起来有更好的层次感，更易于理解，所以很多人都选择了yml文件。 下面来...
Spring Boot 教程3：在 Spring Boot 中使用 application.yml 与 application.properties
梦幻天空
05-26 203
Spring Boot 中的一个常见做法是使用外部配置来定义我们的属性。这允许我们在不同的环境中使用相同的应用程序代码。我们可以使用属性文件、YAML文件、环境变量和命令行参数。在这个简短的教程中，我们将探索属性和YAML文件之间的主要区别。
SpringBoot application.yml配置文件写法
qq_67832732的博客
11-30 2983
1，基本介绍（1）是 JSON 的超集，简洁而强大，是一种专门用来书写配置文件的语言，可以替代 application.properties。（2）在创建一个 SpringBoot 项目时，引入的 spring-boot-starter-web 依赖间接地引入了 snakeyaml 依赖， snakeyaml 会实现对 YAML 配置的解析。（3）YAML 的使用非常简单，利用缩进来表示层级关系，并且大小写敏感。
SpringBoot加载配置文件application.yml的过程及原理（相同属性如何加载）
wodiaonihai的博客
07-01 3062
一、前言 最近，关于SpringBoot的配置文件在不同目录下的配置文件出现了相同的配置属性，对于加载顺序有点疑惑。所以写一篇博客记录一下。 二、摘要 关于本片文章阅读后将回答下面几个问题： 1、springBoot何时加载配置文件？ 2、springBoot加载配置文件时，不同位置及不同后缀的配置文件如何加载？ 3、springBoot的{prifile}文件时是如何加载的？如:（application-dev.yml） 4、不同位置的配置文件配置了相同的属性时 将如何加载？ 5、不同位置到配置文件，设置
SpringBoot入门教程：简化J2EE开发
这份笔记涵盖了Spring Boot的入门知识，包括其核心价值、微服务概念以及开发环境的准备。通过学习这些内容，开发者可以快速上手Spring Boot，进一步探索其丰富的特性和强大的功能，如自动配置、Actuator健康检查、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值