SpringBoot详解

1. Xml 和 JavaConfig

Spring 使用 Xml 作为容器配置文件， 在 3.0 以后加入了 JavaConfig. 使用 java 类做配 置文件使用。

1.1 什么是 JavaConfig

（1）JavaConfig: 是 Spring 提供的使用 java 类配置容器。 配置 Spring IOC 容器的纯 Java 方法。
（2）优点：
①可以使用面像对象的方式， 一个配置类可以继承配置类，可以重写方法
②避免繁琐的 xml 配置

1.2 JavaConfig 配置容器

（1）JavaConfig 主要使用的注解
①@Configuration:放在类的上面， 这个类相当于 xml 配置文件，可以在其中声明 bean
②@Bean:放在方法的上面， 方法的返回值是对象类型，将这个对象注入到 spring ioc 容器
（2）创建配置类（等同于 xml 配置文件）
/**

• @Configuration：表示当前类是 xml 配置文件的作用
• 在这个类中有很多方法， 方法的返回值是对象。
• 在这个方法的上面加入@Bean， 表示方法返回值的对象放入到容器中。
• @Bean == <bean></bean>
• @Bean 没有使用属性，默认对象名称是方法名
  */

@Configuration 
public class SpringConfig { 
    @Bean 
    public Student createStudent(){ 
        Student student = new Student(); 
        student.setId(1002); 
        student.setName("周仓"); 
        student.setAge(29); 
        return student; 
    } 
    // name ：指定对象的名称 
    @Bean(name = "myStudent2") 
    public Student makeStudent(){ 
        Student student = new Student(); 
        student.setId(1003); 
        student.setName("诸葛亮"); 
        student.setAge(30); 
        return student; 
    } 

（3）测试方法：

//使用 JavaConfig 
@Test 
public void test02(){ 
    //没有 xml 配置文件，使用 java 类代替 xml 配置文件 的作用 
    ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class); 
    Student student = (Student) ctx.getBean("createStudent"); 
    System.out.println("student==="+student); 
} 
@Test 
public void test03(){ 
    //没有 xml 配置文件，使用 java 类代替 xml 配置文件 的作用 
    ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class); 
    Student student = (Student) ctx.getBean("myStudent2"); 
    System.out.println("myStudent2==="+student); 
    Object myDate = ctx.getBean("myDate"); 
    System.out.println("myDate = " + myDate); 
} 

1.3 @ImportResource

@ImportResource 是导入 xml 配置，等同于 xml 文件的 resources
（1）创建数据类：

public class Cat { 
    private String cardId; 
    private String name; 
    private Integer age; 
    // set、get  
} 

（2）创建配置文件 beans.xml

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> 
    <bean id="myCat" class="com.bjpowernode.vo.Cat"> 
        <property name="cardId" value="XSET29001" /> 
        <property name="name" value="tom 猫"/> 
        <property name="age" value="3" /> 
    </bean> 
</beans> 

（3）创建配置类：

@Configuration 
@ImportResource(value = {"classpath:beans.xml","classpath:applicationContext.xml"})
 public class SystemConfig { 
    //使用@Bean 声明 bean 
} 

（4）创建测试方法：

@Test 	
public void test04(){ 
    //没有 xml 配置文件，使用 java 类代替 xml 配置文件 的作用 
    ApplicationContext ctx = new AnnotationConfigApplicationContext(SystemConfig.class); 
    Cat cat = (Cat) ctx.getBean("myCat"); 
    System.out.println("cat==="+cat); 
} 

1.4 @PropertyResource

@PropertyResource 作用是读取 properties 属性配置文件 ，使用属性配置文件可以外部化配置，在程序代码之外提供数据

<context:property-placeholder location="classpath:jdbc.properties"/>

（1）在 resources 目录下创建 config.properties

tiger.name=东北老虎 
tiger.age=6 

（2）修改 SystemConfig 文件

@Configuration 
// @PropertySource注解相当于在xm中引入外部properties属性文件
@PropertySource(value = "classpath:config.properties") 
@ComponentScan(value = "com.bjpowernode.vo")
 public class SystemConfig { 
    //使用@Bean 声明 bean 
} 

（3）创建数据类 Tiger

@Component("tiger") 
public class Tiger { 
    @Value("${tiger.name}") 
    private String name; 
    @Value("${tiger.age}") 
    private Integer age; 
    @Override 
    public String toString() { 
        return "Tiger{" + 
                "name='" + name + '\'' + 
                ", age=" + age + 
                '}'; 
    } 
} 
    

2. 注解@SpringBootApplication

@SpringBootApplication 是 一 个 复 合 注 解，是 由@SpringBootConfiguration+@EnableAutoConfiguration +@ComponentScan 联合在一起组成的。
（1）@SpringBootConfiguration：就是@Configuration 这个注解的功能，使用@SpringBootConfiguration
这个注解的类就是配置文件的作用。
（2）@EnableAutoConfiguration：开启自动配置， 把一些对象加入到 spring 容器中。
（3）@ComponentScan：组件扫描器， 扫描注解，根据注解的功能，创建 java bean，给属性赋值 等等。组件扫描器默认扫描的是 @ComponentScan 注解所在的类， 类所在的包和子包。

3.Spring Boot 核心配置文件

（1）Spring Boot 的核心配置文件用于配置 Spring Boot 程序，名字必须以 application 开始；SpringBoot提供了多种属性配置方式，默认采用.properties 文件

（2）SpringBoot配置文件加载顺序
application.properties > application.yml(常用) > application.yaml
（3）自动提示功能消失解决方案

（4）yml 是一种 yaml 格式的配置文件，主要采用一定的空格、换行等格式排版进行配置。 yaml 是一种直观的能够被计算机识别的的数据序列化格式，容易被人类阅读，yaml 类 似于 xml，但是语法比 xml 简洁很多，值与前面的冒号配置项必须要有一个空格， yml 缀也可以使用 yaml 后缀

3.1 yaml格式

YAML（YAML Ain’t Markup Language）， 一种数据序列化格式
（1）优点：
①容易阅读
②容易与脚本语言交互
③以数据为核心，重数据轻格式
（2）YAML文件扩展名
①.yml（主流）
②.yaml
（3）yaml语法规则
①大小写敏感
②属性层级关系使用多行描述，每行结尾使用冒号结束
③使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键）
④属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）
⑤# 表示注释
⑥核心规则： 数据前面要加空格与冒号隔开
（4）字面值表示方式

（5）数组表示方式：在属性名书写位置的下方使用减号作为数据开始符号，每行书写一个数据，减号与数据间空格分隔

（6）使用@Value读取单个数据，属性名引用方式： ${一级属性名.二级属性名……}

（7）在配置文件中可以使用属性名引用方式引用属性

（8）属性值中如果出现转移字符，需要使用双引号包裹

lesson: "Spring\tboot\nlesson"

（9）封装全部数据到Environment对象

（10）自定义对象封装指定数据
①使用@ConfigurationProperties注解绑定配置信息到封装类中
②封装类需要定义为Spring管理的bean，否则无法进行属性注入

3.2 .yml 文件

（1）yml 是一种 yaml 格式的配置文件，主要采用一定的空格、换行等格式排版进行配置。 yaml 是一种直观的能够被计算机识别的的数据序列化格式，容易被人类阅读，yaml 类 似于 xml，但是语法比 xml 简洁很多，值与前面的冒号配置项必须要有一个空格， yml 缀也可以使用 yaml 后缀
（2）注意 ： 当两种格式配置文件同时存在 ，在 SpringBoot2.4 开始， 使用的是 yml 配置文件，推荐使用 yml 格式配置文件

3.3 多环境配置

在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段的配置也会不同，例如：端口、上下
文根、数据库等，那么这个时候为了方便在不同的环境 之间切换，SpringBoot 提供了多环境配置，具体步骤如下
（1）为每个环境创建一个配置文件，命名必须以 application-环境标识.properties|yml。例如：
①开发环境：application-dev.properties
②生产环境：application-product.properties
③测试环境：application-test.properties

（2）在application.properties中 指定使用的环境文件

#指定使用的环境文件 
#spring.profiles.active=dev
spring.profiles.active=test 

3.4 Spring Boot 自定义配置

SpringBoot 的核心配置文件中，除了使用内置的配置项之外，我们还可以在自定义配置，然后采用如下注解去读取配置
的属性值

3.4.1 @Value 注解

（1）@Value(“${key}”) ， key 来自 application.properties(yml)
（2）application.properties：
添加两个自定义配置项 school.name和school.address。

school.name=XXX
school.address=XXX 

（3）读取配置文件数据

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

3.5 注解@ConfigurationProperties

（1）ConfigurationProperties注解将整个配置文件映射成一个对象，用于自定义配置项比较多的情况;
（2）prefix 的作用可以区分同名配置；prefix 可以不指定，如果不指定，那么会去配置文件中寻找与该类的属性名一致
的配置
（3）创建 SchoolController

@Component 
@ConfigurationProperties(prefix = "school")
 public class SchoolInfo {  
    private String name; // 会去配置文件中找school.name的值
}

（4）警告解决
①在 SchoolInfo 类中使用了 ConfigurationProperties 注解，IDEA 会出现一个警告，不影响程序的执行

②点击 open documentnation 跳转到网页，在网页中提示需要加一个依赖，我们将这个依赖拷贝，粘贴到pom.xml文件中

③解决使用@ConfigurationProperties注解出现警告问题

<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-configuration-processor</artifactId> 
    <optional>true</optional> 
</dependency> 

3.6 中文乱码

（1）如果在 SpringBoot 核心配置文件中有中文信息，会出现乱码：
①一般在配置文件中，不建议出现中文（注释除外）
②如果有，可以先转化为 ASCII 码

（2）注意：大家如果是从其它地方拷贝的配置文件，一定要将里面的空格删干净

4.Spring Boot 中使用容器

通过SpringApplication.run(Application.class, args); 返回值获取容器

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        return run(new Class[]{primarySource}, args);
}

// ConfigurableApplicationContext接口，是ApplicationContext的子接口
public interface ConfigurableApplicationContext extends ApplicationContext

5. ComnandLineRunner接口,ApplcationRunner接口

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

@SpringBootApplication 
public class Application implements CommandLineRunner { 
   public static void main(String[] args) { 
      //run 方法返回值是容器对象 
      //1.创建容器对象 
      ConfigurableApplicationContext ctx = SpringApplication.run(Application.class, args); 
      SomeService service = (SomeService) ctx.getBean("someService"); 
      service.sayHello("李四"); 
   } 
   @Override 
    public void run(String... args) throws Exception { 
      //2. 容器对象创建好，执行 run 
      System.out.println("输出， 在容器对象创建好后执行的代码"); 
   } 
} 

6.Spring Boot 和 web 组件

6.1 SpringBoot 中拦截器

拦截器是SpringMVC中一种对象，能拦截器对Controller的请求。拦截器框架中有系统的拦截器， 还可以自定义
拦截器。 实现对请求预先处理。
（1）实现自定义拦截器：创建类实现SpringMVC框架的HandlerInterceptor接口
①HandlerInterceptor接口源码如下：

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 {
 }
}

②创建类实现 HandlerInterceptor 接口

public class LoginInterceptor implements HandlerInterceptor { 

    @Override 
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
        System.out.println("执行了 LoginInterceptor，preHandle()"); 
        return true; 

    } 

} 

（2）SpringBoot中注册拦截器：

//相当于 springmvc 配置文件 
@Configuration
public class MyAppConfig implements WebMvcConfigurer {
    //添加拦截器对象， 注入到容器中
    @Override 
    public void addInterceptors(InterceptorRegistry registry) {
       
        // 指定拦截的地址 
        String path [] = {"/user/**"}; 
        //指定不拦截的地址
        String excludePath [] = {"/user/login"}; 
        registry.addInterceptor(new LoginInterceptor()) //创建拦截器对象
                .addPathPatterns(path)
                .excludePathPatterns(excludePath); 
    } 
} 

6.2 Spring Boot 中使用Servlet

（1）创建Servlet类。 自定义类继承HttpServlet

//创建Servlet类
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       //使用HttpServletResponse输出数据，应答结果
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter out  = resp.getWriter();
        out.println("===执行的是Servlet==");
        out.flush();
        out.close();
    }
}

（2）注册Servlet ，让框架能找到Servlet

@Configuration
public class WebApplictionConfig {

    //定义方法， 注册Servlet对象
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){

        //public ServletRegistrationBean(T servlet, String... urlMappings)
        //第一个参数是 Servlet对象， 第二个是url地址

        //ServletRegistrationBean bean =
                //new ServletRegistrationBean( new MyServlet(),"/myservlet");


        ServletRegistrationBean bean = new ServletRegistrationBean();
        bean.setServlet( new MyServlet());
        bean.addUrlMappings("/login","/test"); // <url-pattern>
        return bean;
    }
}

6.3 Spring Boot 中使用 Filter

Filter是Servlet规范中的过滤器，可以处理请求， 对请求的参数， 属性进行调整。 常常在过滤器中处理字符编码
（1）创建自定义过滤器类

// 自定义过滤器
public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("执行了MyFilter，doFilter ");
        filterChain.doFilter(servletRequest,servletResponse);
    }
}

（2）注册 Filter

@Configuration
public class WebApplicationConfig {
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean bean  = new FilterRegistrationBean();
        bean.setFilter( new MyFilter());
        bean.addUrlPatterns("/user/*");
        return bean;
    }
}

6.3.1 字符集过滤器的应用

CharacterEncodingFilter : 解决post请求中乱码的问题
在SpringMVC框架， 在web.xml 注册过滤器。 配置他的属性。

• 方式一：

（1）配置字符集过滤器

@Configuration
public class WebSystemConfig {

    //注册Servlet
    @Bean
    public ServletRegistrationBean servletRegistrationBean(){
        MyServlet myServlet = new MyServlet();
        ServletRegistrationBean reg = new ServletRegistrationBean(myServlet,"/myservlet");
        return reg;
    }


    //注册Filter
    @Bean
    public FilterRegistrationBean filterRegistrationBean(){
        FilterRegistrationBean reg = new FilterRegistrationBean();

        //使用框架中的过滤器类
        CharacterEncodingFilter filter  = new CharacterEncodingFilter();
        //指定使用的编码方式
        filter.setEncoding("utf-8");
        //指定request ， response都使用encoding的值
        filter.setForceEncoding(true);

        reg.setFilter(filter);
        //指定 过滤的url地址
        reg.addUrlPatterns("/*");


        return reg;
    }
}

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

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

• 方式二：修改application.properties文件

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

#让系统的CharacterEncdoingFilter生效
server.servlet.encoding.enabled=true
#指定使用的编码方式
server.servlet.encoding.charset=utf-8
#强制request，response都使用charset属性的值
server.servlet.encoding.force=true

7. ORM 操作 MySQL

使用MyBatis框架操作数据， 在SpringBoot框架集成MyBatis

• 第一种方式 ：@Mapper

@Mapper：放在dao接口的上面， 每个接口都需要使用这个注解。

/**
 * @Mapper：告诉MyBatis这是dao接口，创建此接口的代理对象。
 *     位置：在类的上面
 */
@Mapper
public interface StudentDao { 
    Student selectById(@Param("stuId") Integer id);
}

• 第二种方式 @MapperScan
  在 Dao 接口上面加入@Mapper，需要在每个接口都加入注解。 当 Dao 接口多的时候不方便。可以使用如下的方式解决。 主类上添加注解包扫描：@MapperScan(“com.bjpowernode.dao”)

/** 
 * @MapperScan： 扫描所有的 mybatis 的 dao 接口 
 * 位置：在主类的上面 
 *  属性：basePackages：指定 dao 接口的所在的包名。 
 *     dao 接口和 mapper文件依然在同一目录 
 */ 

@SpringBootApplication 
@MapperScan(basePackages = "com.bjpowernode.dao") 
public class MyBatisApplication2 { 
    public static void main(String[] args) { 
        SpringApplication.run(MyBatisApplication2.class,args); 
    } 
} 

• 第三种方式：Mapper文件和Dao接口分开管理

现在把Mapper文件放在resources目录下
1）在resources目录中创建子目录 （自定义的） ， 例如mapper
2）把mapper文件放到 mapper目录中
3）在application.properties文件中，指定mapper文件的目录

#指定mapper文件的位置
mybatis.mapper-locations=classpath:mapper/*.xml
#指定mybatis的日志
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

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

<!--resources插件-->
<resources>
   <resource>
      <directory>src/main/resources</directory>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>
</resources>

8.接口架构风格—RESTful

8.1 认识 REST

（1）接口： API（Application Programming Interface，应用程序接口）是一些预先定义的接口（如函数、HTTP接口），或指[软件系统]不同组成部分衔接的约定。 用来提供[应用程序]与开发人员基于某[软件]或硬件得以访问的一组[例程]，而又无需访问源码，或理解内部[工作机制]的细节。
接口（API）： 可以指访问servlet， controller的url， 调用其他程序的 函数

（2）REST（英文：Representational State Transfer，简称 REST）
一种互联网软件架构设计的风格，但它并不是标准，它只是提出了一组客户端和服务器交 互时的架构理念和设计原则，基于这种理念和原则设计的接口可以更简洁，更有层次，REST 这个词，是 Roy Thomas Fielding 在他 2000 年的博士论文中提出的。
（3）任何的技术都可以实现这种理念，如果一个架构符合 REST 原则，就称它为 RESTFul 架构
（4）比如我们要访问一个 http 接口：http://localhost:8080/boot/order?id=1021&status=1 采用 RESTFul 风格
则 http 地址为：http://localhost:8080/boot/order/1021/1

8.2 RESTful 的注解

Spring Boot 开发 RESTful 主要是几个注解实现
（1）@PathVariable：获取 url 中的数据
（2）@PostMapping：接收和处理 Post 方式的请求
（3）@DeleteMapping：接收 delete 方式的请求，可以使用 GetMapping 代替
（4） @PutMapping：接收 put 方式的请求，可以用 PostMapping 代替
（5） @GetMapping：接收 get 方式的请求
（6） @RestController: 符合注解， 是@Controller 和@ResponseBody组合。
​ 在类的上面使用@RestController ， 表示当前类者的所有方法都加入了 @ResponseBody

8.3 RESTful 优点

（1）轻量，直接基于 http，不再需要任何别的诸如消息协议 get/post/put/delete 为 CRUD 操作
（2）面向资源，一目了然，具有自解释性。
（3）数据描述简单，一般以 xml，json 做数据交换。
（4）无状态，在调用一个接口（访问、操作资源）的时候，可以不用考虑上下文，不用考虑当前状态， 极大的降低了复杂度。
（5）简单、低耦合

9.Spring Boot 打包

Spring Boot 可以打包为 war 或 jar 文件。 以两种方式发布应用

9.1 Spring Boot 打包为 war

创建 Spring Boot web 项目: 024-springboot-war
（1）指定打包后的文件名称

<build>
   <!--打包后的文件名称-->
   <finalName>myboot</finalName>
</build>

（2）指定jsp编译目录

<!--resources插件， 把jsp编译到指定的目录-->
<resources>
   <resource>
      <directory>src/main/webapp</directory>
      <targetPath>META-INF/resources</targetPath>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>

   <!--使用了mybatis ，而且mapper文件放在src/main/java目录-->
   <resource>
      <directory>src/main/java</directory>
      <includes>
         <include>**/*.xml</include>
      </includes>
   </resource>

   <!--把src/main/resources下面的所有文件，都包含到classes目录-->
   <resource>
      <directory>src/main/resources</directory>
      <includes>
         <include>**/*.*</include>
      </includes>
   </resource>
</resources>

（3）指定打包方式是war

<!--打包类型-->
<packaging>war</packaging>

（4）主启动类继承SpringBootServletInitializer

/**
 * SpringBootServletInitializer: 继承这个类， 才能使用独立tomcat服务器
 */
@SpringBootApplication
public class JspApplication  extends SpringBootServletInitializer  {

   public static void main(String[] args) {
      SpringApplication.run(JspApplication.class, args);
   }

   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
      return builder.sources(JspApplication.class);
   }
}

（5）部署war
把war放到tomcat等服务器的发布目录中。 tomcat为例， myboot.war放到tomcat/webapps目录。启动tomcat后就会自动生成war包对应的webapp目录

9.2打包为jar

创建了一个包含了jsp的项目，修改pom.xml文件
​（1）指定打包后的文件名称

<build>
   <!--打包后的文件名称-->
   <finalName>myboot</finalName>
</build>

（2）指定springboot-maven-plugin版本

<plugins>
   <plugin>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-maven-plugin</artifactId>
      <!--打包jar， 有jsp文件时，必须指定maven-plugin插件的版本是 1.4.2.RELEASE-->
      <version>1.4.2.RELEASE</version>
   </plugin>
</plugins>

（3）执行独立的springboot项目 在cmd中 java -jar myboot.jar
​ 在target目录中，生成jar 文件， 例子是myboot.jar