目录

一、什么是springboot？

二、为什么要学springboot？

三、怎么用springboot?

JavaConfig（@Configuration）

@ImportResource

@PropertyResource

创建Spring Boot项目

1、使用国外的Spring提供的初始化器， 就是向导创建SpringBoot应用

2、使用国内的Spring提供的初始化器， 就是向导创建SpringBoot应用

3、第三种方式 使用 maven 向导创建项目

@SpringBootApplication注解

SpringBoot的核心配置文件

SpringBoot应用的多环境配置

@Value 注解

@ConfigurationProperties

在SpringBoot中使用jsp

使用SpringBoot中的容器

ComnandLineRunner 接口 , ApplcationRunner接口

SpringBoot中的拦截器

SpringBoot中使用Servlet

SpringBoot中使用Filter过滤器

在SpringBoot中使用CharacterEncodingFilter（字符集过滤器）

SpringBoot中操作数据库

一、什么是springboot？

• SpringBoot 就相当于不需要配置文件的Spring+SpringMVC。 常用的框架和第三方库都已经配置好了。拿来就可以使用了。
• SpringBoot是Spring中的一个成员， 可以简化Spring，SpringMVC的使用。 他的核心还是IOC容器。
• SpringBoot的特点：

  • Create stand-alone Spring applications

    创建spring应用

  • Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)

    内嵌的tomcat， jetty ， Undertow服务器

  • Provide opinionated 'starter' dependencies to simplify your build configuration

    提供了starter起步依赖，简化应用的配置。

    比如使用MyBatis框架 ， 需要在Spring项目中，配置MyBatis的对象 SqlSessionFactory ， Dao的代理对象

    在SpringBoot项目中，在pom.xml里面, 加入一个 mybatis-spring-boot-starter依赖

  • Automatically configure Spring and 3rd party libraries whenever possible

    尽可能去配置spring和第三方库。叫做自动配置（就是把spring中的，第三方库中的对象都创建好，放到容器中， 开发人员可以直接使用）

  • Provide production-ready features such as metrics, health checks, and externalized configuration

    提供了健康检查， 统计，外部化配置

  • Absolutely no code generation and no requirement for XML configuration

    不用生成代码， 不用使用xml，做配置

二、为什么要学springboot？

• 因为Spring， SpringMVC 需要使用的大量的配置文件 （xml文件）比较麻烦，还需要配置各种对象，把使用的对象放入到spring容器中才能使用对象。
• 需要了解其他框架配置规则，比如在整合mybatis框架就需要配置spring整合mybatis的配置文件applicationContext_mapper.xml。
• SpringBoot开发效率高，使用方便多了.

三、怎么用springboot?

JavaConfig（@Configuration）

使用java类作为xml配置文件的替代， 是配置spring容器的纯java的方式。 在这个java类这可以创建java对象，把对象放入spring容器中（注入到容器）.

使用两个注解：

1）@Configuration ： 放在一个类的上面，指明表示这个类是作为一个配置文件使用的。

2）@Bean：声明对象，把对象注入到容器中。

// 表示以下这个类是一个配置文件，
// 相当于applicationContext.xml
@Configuration
public class SpringConfig {

    
    @Bean
    public Student getStudent(){

        return new Student("李四",25);
    }

    // 也可以指定对象的id属性
    @Bean(name = "lisiStu")
    public Student getStudent2(){

        return new Student("王五",52);
    }
}

public class MyTest1 {

    @Test
    public void test1(){
        // 创建并启动spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Student myStudent = (Student) ac.getBean("myStudent");
        System.out.println("使用xml配置文件的形式取出容器中的对象：" + myStudent);
    }

    @Test
    public void test2(){
        // 使用JavaConfig作为对象创建并启动Spring容器
        // SpringConfig.class 就等于 applicationContext.xml
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);
        Student stu = (Student) ac.getBean("getStudent");
        System.out.println("使用javaconfig对象创建的bean：" + stu);
    }

    @Test
    public void test3(){
        // 使用JavaConfig作为对象创建并启动Spring容器
        // SpringConfig.class 就等于 applicationContext.xml
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);
        Student stu = (Student) ac.getBean("lisiStu");
        System.out.println("使用javaconfig对象创建的bean：" + stu);
    }
}

@ImportResource

@ImportResource

使用在类上

作用导入其他的xml配置文件， 等于在xml配置文件中使用：

要导入的spring配置文件： 

// 表示以下这个类是一个配置文件，
// 相当于applicationContext.xml
@Configuration
// 导入其他配置文件
@ImportResource({"classpath:applicationContext.xml"})
public class SpringConfig {

    
    @Bean
    public Student getStudent(){

        return new Student("李四",25);
    }

    // 也可以指定对象的id属性
    @Bean(name = "lisiStu")
    public Student getStudent2(){

        return new Student("王五",52);
    }
}

    @Test
    public void test4(){
        // 使用JavaConfig作为对象创建并启动Spring容器
        // SpringConfig.class 就等于 applicationContext.xml
        ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfig.class);
        Student stu = (Student) ac.getBean("myStudent");
        System.out.println("取出导入的配置文件中的bean：" + stu);// 取出导入的配置文件中的bean：Student{name='张三', age=23}

    }

@PropertyResource

@PropertyResource: 用于读取properties属性配置文件，引入属性文件，就可以使用${key}的方式访问里面的值了。 使用属性配置文件可以实现外部化配置 ，在程序代码之外提供数据。

等同于之前的：

cat.properties 

cat.name=tomcat
cat.age=23

@Component("myCat") // 使用spring注解创建对象,交给spring容器管理

// 引入properties属性文件
@PropertySource("classpath:cat.properties")
public class Cat {

    // ${cat.name}使用属性文件的值
    @Value("${cat.name}")
    private String name;

    @Value("${cat.age}")
    private int age;

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

// 表示以下这个类是一个配置文件，
// 相当于applicationContext.xml
@Configuration
// 导入其他配置文件
@ImportResource({"classpath:applicationContext.xml"})

// 告诉spring要去扫描这个包下的类,看是否需要创建对象
@ComponentScan(basePackages = "com.lin.spirngboot.bean")
public class SpringConfig {

    
    @Bean
    public Student getStudent(){

        return new Student("李四",25);
    }

    // 也可以指定对象的id属性
    @Bean(name = "lisiStu")
    public Student getStudent2(){

        return new Student("王五",52);
    }
}

创建Spring Boot项目

1、使用国外的Spring提供的初始化器， 就是向导创建SpringBoot应用

地址：

https://start.spring.io

在这一步，可以自己手动选择maven需要的依赖，就不用像之前那样一个一个的在pom文件中配置了。 

目录介绍

2、使用国内的Spring提供的初始化器， 就是向导创建SpringBoot应用

国外的速度比较慢，可以使用国内的地址：

https://start.springboot.io

3、第三种方式 使用 maven 向导创建项目

@SpringBootApplication注解

@SpringBootApplication注解是一个复合注解，由以下三个注解组成

        @SpringBootConfiguration
        @EnableAutoConfiguration
        @ComponentScan

• 1、@EnableAutoConfiguration使用了这个注解的类，可以作为一个配置文件来使用，可以使用@Bean声明对象注入到Spring容器中。

• 2、@EnableAutoConfiguration注解表示开启自动配置功能，该注解是Spring Boot框架最重要的注解，也是实现自动化配置的注解。 把java对象配置好，注入到spring容器中。例如可以把mybatis的对象创建好，放入到容器中直接使用。
• 3、@ComponentScan 包扫描，有了这个注解后，就可以默认扫描@ComponentScan所在的类所在的包和子包。扫描到有创建对象的注解就创建对象，有依赖注入的注解就进行依赖注入等。

SpringBoot的核心配置文件

•  Spring Boot 的核心配置文件用于配置 Spring Boot 程序，文件名字必须以 application 开始。
• 在此配置文件中，可以配置Springboot应用的端口号，上下文访问路径等。

配置文件扩展名有两种：

        .properties

        .yml

如果两种扩展名的配置文件一样，默认使用.properties的配置文件

推荐使用 yml 格式配置文件

application.yml

#设置Springboot应用的端口号和上下文访问路径contextPath
server:
  port: 8082
  servlet:
    context-path: /myboot

 application.properties

#设置端口号
server.port=8082
#设置访问应用上下文路径， contextpath
server.servlet.context-path=/myboot

SpringBoot应用的多环境配置

在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段的配置也会不同，例如：端口、上下文路劲、数据库等，那么这个时候为了方便在不同的环境 
之间切换对应的配置，SpringBoot 提供了多环境配置。

本地程序员开发的时候所用的配置文件：application-dev.yml

#本地程序员开发的时候所用的配置
server:
  port: 8081
  servlet:
    context-path: /mydev

项目测试的时候所用的配置文件：application-test.yml

#项目测试的时候所用的配置
server:
  port: 8082
  servlet:
    context-path: /mytest

项目上线的时候所用的配置文件：application-online.yml

#项目上线的时候所用的配置
server:
  port: 8083
  servlet:
    context-path: /myonline

最后在springboot项目的主配置文件application.yml中根据环境，指定要使用的配置文件

#在主配置文件中，指定要使用的配置文件

#激活开发的时候的配置文件
#spring:
#  profiles:
#    active: dev

#激活测试的时候的配置文件
spring:
  profiles:
    active: test

@Value 注解

@Value("${key}") ， key 来自 application.properties(yml)，根据key直接取来自Spring Boot的核心配置文件中的value。

application.properties： 

server.port=9090 
server.servlet.context-path=/myboot 

#自定义的key=value 
school.name=动力节点 
school.address=北京大兴区 
school.website=www.bjpowernode.com 
 
site=www.bjpowernode.com 

 读取配置文件中的数据：

@Controller 
public class HelloController { 
 @Value("${server.port}") 
 private String port; 
 @Value("${school.name}") 
 private String name; 
 
 @Value("${site}") 
 private String site;

 @RequestMapping("/hello") 
 @ResponseBody 
 public String doHello(){ 
 return "hello, port:" + port + "学校："+name+",网站："+site; 
 } 
}

@ConfigurationProperties

在 SpringBoot 中，当想需要获取到配置文件数据时，除了可以用 Spring 自带的 @Value 注解外，SpringBoot 还提供了一种更加方便的方式：@ConfigurationProperties。

只要在 Bean 上添加上了这个注解，指定好配置文件的前缀，那么对应的配置文件中的数据就会自动填充到 Bean 中。填充规则就是找到相同名字的key和属性名进行数据注入。

#项目端口号
server:
  port: 8082
  servlet:
    context-path: /myboot

#自定义数据key-value
school:
  name: 莆田学院
  website: www.ptu.com
  address: 福建莆田

package com.lin.bean;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;


@Component// 交给Spring创建对象

// 除了@Value注解, @ConfigurationProperties注解也可以从配置文件中获取数据
// 这样这个bean中的属性就会在application.properties中找前缀为school，
// 然后找到和属性名一样的key将对应的value赋给属性
@ConfigurationProperties(prefix = "school")
public class School {
    private String name;

    private String website;

    private String address;

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + ''' +
                ", website='" + website + ''' +
                ", address='" + address + ''' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getWebsite() {
        return website;
    }

    public void setWebsite(String website) {
        this.website = website;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public School(String name, String website, String address) {
        this.name = name;
        this.website = website;
        this.address = address;
    }

    public School() {
    }
}

package com.lin.controller;

import com.lin.bean.School;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;


@Controller
public class GetDataController {

    // @Value注解可以获取application.properties(yml)中的数据
    @Value("${server.servlet.context-path}")
    private String contextPath;

    @Value("${school.name}")
    private String school;

    // @Resource注解和@Autowired注解类似，都用来声明需要自动装配的bean，
    // 区别在于@Autowired是类型驱动的注入，而@Resource是名称驱动的注入，所以前者存在多bean问题，
    // 而后者，只要保证bean命名唯一就不会出现多bean的问题。
    @Resource
    private School ptu;

    @RequestMapping("/data")
    @ResponseBody
    public String getDate(){

        return "我在"+school+"学" + contextPath + "school对象:" + ptu;
    }
}

在SpringBoot中使用jsp

使用SpringBoot中的容器

如果想要使用容器，然后获取容器中管理的对象的话，得需要先获取容器对象。

// SpringBoot项目启动的方法run()的返回值就是容器
public static ConfigurableApplicationContext run(Class primarySource, String... args) {
        return run(new Class[]{primarySource}, args);
    }

// ApplicationContext就是Spring容器
public interface ConfigurableApplicationContext extends ApplicationContext

例子: 

@Service("userService")// 交给spring创建对象,将对象放进容器中管理
public class UserServiceImpl implements UserService {
    @Override
    public void sayHello(String name) {
        System.out.println("say hello to" + name);
    }
}

@SpringBootApplication
public class Springboot007SpringcontainerApplication {

    public static void main(String[] args) {
        // 获取容器对象
        ConfigurableApplicationContext applicationContext = SpringApplication.run(Springboot007SpringcontainerApplication.class, args);

        // 从容器中取出对象
        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.sayHello("张三");
    }

}

ComnandLineRunner 接口 , ApplcationRunner接口

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

@SpringBootApplication
public class Springboot008ApplicationRunnerApplication implements ApplicationRunner {

    public static void main(String[] args) {
        System.out.println("创建启动容器之前....");

        // 创建并启动容器
        SpringApplication.run(Springboot008ApplicationRunnerApplication.class, args);

        System.out.println("创建启动容器之后");
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("读取配置文件");
    }
}

只要实现CommandLineRunner接口 或 ApplicationRunner接口，然后实现里面的run()方法，就可以在创建启动之后执行。

SpringBoot中的拦截器

以前我们在SpringMVC中使用拦截器，需要在配置文件中配置注册拦截器等，比较麻烦，接下来介绍SpringBoot中优化的拦截器。

实现步骤：

1. 创建一个类实现SpringMVC框架的HandlerInterceptor接口
2. 注册拦截器
3. 创建controller测试拦截器功能
4. 在主启动类中启动应用
5. 在浏览器上访问测试是否被拦截

1

public class LoginInterceptor implements HandlerInterceptor {

    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("拦截登录相关的请求,验证是否登录过。。。。");

        // 返回true说明登录过,放行请求
        return true;

        // 返回false说明没登录过,不放行请求
//        return false;
    }
}

 2

// 指明这是一个配置文件,相当于springmvc.xml
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    // 注册拦截器s,相当于之前在xml配置文件中配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 要拦截的请求uri
        String[] paths = {"/user
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){
        // public ServletRegistrationBean(T servlet, String... urlMappings)
        // servlet是要注册的servlet对象,urlMappings是servlet对应的请求路径
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new HelloServlet(), "/hello");

        return servletRegistrationBean;
    }
}

SpringBoot中使用Filter过滤器

我们在现实业务中，多个请求对应的不同controller，对于这多个controller来说，可能都会有一些共同的操作要做，比如：设置字符集编码等公共的代码，这时就可以在过滤器中添加过滤规则，请求先经过过滤器的处理后，才能到达下面的controller。

实现步骤：

1. 创建过滤器类，实现servlet.Filter接口
2. 注册过滤器，让框架知道

import javax.servlet.*;

public class UserFilter implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("对请求进行处理,进行字符集的设置.......");

        // 若下面没有过滤器了,则执行请求对应的controller
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

@Configuration
public class FilterConfig {

    // 注册过滤器
    @Bean
    public FilterRegistrationBean userFilterBean(){
        FilterRegistrationBean filterBean = new FilterRegistrationBean();

        // 设置过滤器类对象
        filterBean.setFilter(new UserFilter());
        
        // 添加要被过滤的请求路径,请求都被过滤一下再执行对应的controller
        filterBean.addUrlPatterns("/user/*");

        return filterBean;
    }
}

在SpringBoot中使用CharacterEncodingFilter（字符集过滤器）

CharacterEncodingFilter是spring内置的字符集过滤器，用来指定请求或者响应使用的字符集，用来解决请求和响应的乱码问题。

第一种：自定义字符集过滤器 

@Configuration
public class FilterConfig {

    // 注册Spring自带的字符集编码过滤器
    @Bean
    public FilterRegistrationBean characterFilterBean(){
        FilterRegistrationBean filterBean = new FilterRegistrationBean();

        // 创建Spring内置的字符集过滤器对象并设置相关的属性
        CharacterEncodingFilter encodingFilter = new CharacterEncodingFilter();
        encodingFilter.setEncoding("UTF-8");// 设置字符集
        encodingFilter.setForceRequestEncoding(true);// 设置请求是否强制使用设置的字符集
        encodingFilter.setForceResponseEncoding(true);

        // 设置过滤器类对象
        filterBean.setFilter(encodingFilter);

        // 所有路径都过滤一下,处理一下字符集再放行
        filterBean.addUrlPatterns("/*");

        return filterBean;
    }
}

server.servlet.context-path=/filter

#SpringBoot中默认已经配置了CharacterEncodingFilter。 编码默认ISO-8859-1
#设置enabled=false 作用是取消使用SpringBoot配置好的过滤器， 使用自定义的CharacterEncodingFilter
server.servlet.encoding.enabled=false

第二种：使用SpringBoot中默认配置好的CharacterEncodingFilter

#使用SpringBoot默认配置好的CharacterEncodingFilter
server.servlet.encoding.enabled=true

#指定CharacterEncodingFilter的字符集为UTF-8
server.servlet.encoding.charset=UTF-8

#设置请求和响应都强制使用设置的字符集
server.servlet.encoding.force=true

SpringBoot中操作数据库

MyBatis 框架操作数据库，读写 MySQL 数据。通过 SpringBoot +MyBatis 实现对数据库学生表的查询操作。