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 没有使用属性，默认对象名称是方法名
  */

@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

 
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属性文件
@PropertySourc服务器托管网e(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: "Springtbootnlesson"

（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.bootgroupId> 
    artifactId>spring-boot-configuration-processorartifactId> 
    optional>trueoptional> 
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"); // 
        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>
   resource>
      directory>src/main/resourcesdirectory>
      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>mybootfinalName>
build>

（2）指定jsp编译目录

resources>
   resource>
      directory>src/main/webappdirectory>
      targetPath>META-INF/resourcestargetPath>
      includes>
         include>**/*.*include>
      includes>
   resource>

   
   resource>
      directory>src/main/javadirectory>
      includes>
         include>**/*.xmlinclude>
      includes>
   resource>

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

（3）指定打包方式是war

packaging>warpackaging>

（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>mybootfinalName>
build>

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

plugins>
   plugin>
      groupId>org.springframework.bootgroupId>
      artifactId>spring-boot-maven-pluginartifactId>
      
      version>1.4.2.RELEASEversion>
   plugin>
plugins>

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

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

相关推荐: W5100S-EVB-PICO进行UDP组播数据回环测试（九）前言什么是UDP组播？IPv4组播地址连接方式
测试工具
UDP组播数据回环测试相关链接： 

前言 上一章我们用我们的开发板作为UDP客户端连接服务器进行数据回环测试，那么本章我们进行UDP组播数据回环测试。 什么是UDP组播？ 组播是主机间一对多的通讯模式， 组播是一种允许一个或多个组播源发送同一报文到多个接收者的技术。组播源将一份报文发送到特定的组…