Springboot

Springboot的HelloWrold案例

  • 一. 前言
  • 二. Helloworld案例
    • 2.1 创建maven工程(jar工程不是,不是war)
    • 2.2 导入SpringBoot相关依赖
    • 2.3 编写主程序,用以启动SpringBoot应用
    • 2.4 编写Controller,Service
    • 2.5 SpringBoot简化部署
    • 2.6 简要分析POM文件
      • 2.6.1 父项目
      • 2.6.2 启动器
      • 2.6.3 主程序类
    • 2.7 使用Spring Initializer(IDEA)快速创建Spring Boot项目
  • 三. 配置文件
    • 3.1 YAML语法
      • 3.1.1 基本语法
      • 3.1.2 值的写法
        • 字面量:普通的值(数字,字符串,布尔)
        • 对象、Map(属性和值)(键值对):
        • 数组(List、Set):
    • 3.2 配置文件值注入
    • 3.3 @Value获取值和@ConfigurationProperties获取值比较
    • 3.4 @PropertySource&@ImportResource&@Bean
    • 3.5 配置文件占位符
      • 3.5.1 随机数
      • 3.5.2 占位符获取之前配置的值,如果没有可以是用:指定默认值
    • 3.6 Profile
      • 3.6.1 多Profile文件
      • 3.6.2 yml支持多文档块方式
      • 3.6.3 激活指定profile
      • 3.6.4 配置文件加载位置
      • 3.6.5 外部配置加载顺序

一. 前言

SpringBoot是简化Spring应用开发的一个框架,是Spring技术栈的整合,是J2EE开发的一站式解决方案。
环境约束

– jdk1.8:Spring Boot 推荐jdk1.7及以上;

– maven3.x:maven 3.3以上版本;

– IntelliJIDEA2019

二. Helloworld案例

实现功能:
浏览器发送hello请求,服务器接受请求并处理,响应Hello World字符串;

2.1 创建maven工程(jar工程不是,不是war)

2.2 导入SpringBoot相关依赖

	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
 	</parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

2.3 编写主程序,用以启动SpringBoot应用

/**
 *  @SpringBootApplication 来标注一个主程序类,说明这是一个Spring Boot应用
 */
@SpringBootApplication
public class HelloWorldMainApplication {
     

    public static void main(String[] args) {
     

        // Spring应用启动起来
        SpringApplication.run(HelloWorldMainApplication.class,args);
    }
}

2.4 编写Controller,Service

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

2.5 SpringBoot简化部署

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

将这个应用打成jar包,直接使用java -jar的命令进行执行;

2.6 简要分析POM文件

2.6.1 父项目

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

他的父项目是
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>1.5.9.RELEASE</version>
  <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

Spring Boot的版本仲裁中心,管理Spring Boot应用里面的所有依赖版本;

2.6.2 启动器

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

spring-boot-starter:spring-boot场景启动器;帮我们导入了模块正常运行所依赖的组件;Spring Boot将所有的功能场景都抽取出来,做成一个个的starters(启动器),只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器

2.6.3 主程序类

/**
 *  @SpringBootApplication 来标注一个主程序类,说明这是一个Spring Boot应用
 */
@SpringBootApplication
public class HelloWorldMainApplication {
     

    public static void main(String[] args) {
     

        // Spring应用启动起来
        SpringApplication.run(HelloWorldMainApplication.class,args);
    }
}

@SpringBootApplication: Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类,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:Spring Boot的配置类;标注在某个类上,表示这是一个Spring Boot的配置类;
@EnableAutoConfiguration:开启自动配置功能;以前我们需要配置的东西,Spring Boot帮我们自动配置;
@EnableAutoConfiguration告诉SpringBoot开启自动配置功能;这样自动配置才能生效;

@AutoConfigurationPackage
@Import(EnableAutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
     

@AutoConfigurationPackage:自动配置包
@Import(EnableAutoConfigurationImportSelector.class);给容器中导入组件。
EnableAutoConfigurationImportSelector:导入哪些组件的选择器;

2.7 使用Spring Initializer(IDEA)快速创建Spring Boot项目

IDE都支持使用Spring的项目创建向导快速创建一个Spring Boot项目;选择我们需要的模块;向导会联网创建Spring Boot项目;
默认生成的Spring Boot项目;

  • 主程序已经生成好了,我们只需要我们自己的逻辑
  • resources文件夹中目录结构
    • static:保存所有的静态资源; js css images;
    • templates:保存所有的模板页面;(Spring Boot默认jar包使用嵌入式的Tomcat,默认不支持JSP页面);可以使用模板引擎(freemarker、thymeleaf);
    • application.properties:Spring Boot应用的配置文件;可以修改一些默认设置;

Springboot_第1张图片
Springboot_第2张图片
此处编辑项目结构,并且选择JAVA版本
Springboot_第3张图片
选择自己项目所需的场景

三. 配置文件

SpringBoot使用一个全局的配置文件,配置文件名是固定的;

•application.properties

•application.yml

配置文件的作用:修改SpringBoot自动配置的默认值;
以前的配置文件大多都使用的是 xxxx.xml文件;
YAML:以数据为中心,比json、xml等更适合做配置文件;
YAML:配置例子

server:
  port: 8081

XML:

<server>
	<port>8081</port>
</server>

3.1 YAML语法

3.1.1 基本语法

k:(空格)v:表示一个键值对(空格必须有);以空格的缩进来控制层级关系;只要是左对齐的一列数据,都是同一个层级的

server:
    port: 8081
    path: /hello

属性和值大小写敏感;

3.1.2 值的写法

字面量:普通的值(数字,字符串,布尔)

​ k: v:字面直接来写;

​ 字符串默认不用加上单引号或者双引号;

​ “”:双引号;不会转义字符串里面的特殊字符;特殊字符会作为本身想表示的意思

​ name: “zhangsan \n lisi”:输出;zhangsan 换行 lisi

​ ‘’:单引号;会转义特殊字符,特殊字符最终只是一个普通的字符串数据

​ name: ‘zhangsan \n lisi’:输出;zhangsan \n lisi

对象、Map(属性和值)(键值对):

​ k: v:在下一行来写对象的属性和值的关系;注意缩进。对象也是k: v的方式

friends:
		lastName: zhangsan
		age: 20

行内写法

friends: {
     lastName: zhangsan,age: 18}

数组(List、Set):

用- 值表示数组中的一个元素

pets:
 - cat
 - dog
 - pig

行内写法

pets: [cat,dog,pig]

3.2 配置文件值注入

person:
    lastName: hello
    age: 18
    boss: false
    birth: 2017/12/12
    maps: {
     k1: v1,k2: 12}
    lists:
      - lisi
      - zhaoliu
    dog:
      name: 小狗
      age: 12
/**
 * 将配置文件中配置的每一个属性的值,映射到这个组件中
 * @ConfigurationProperties:告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定;
 *      prefix = "person":配置文件中哪个下面的所有属性进行一一映射
 *
 * 只有这个组件是容器中的组件,才能使用容器提供的@ConfigurationProperties功能;
 *
 */
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
     

    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birth;

    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;

<!--导入配置文件处理器,配置文件进行绑定就会有提示-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-configuration-processor</artifactId>
			<optional>true</optional>
		</dependency>

3.3 @Value获取值和@ConfigurationProperties获取值比较

Springboot_第4张图片
松散绑定:last-name与latName可以相互代替就称之为松散绑定。但是@Value并不能满足last-name到lastName的映射
复杂类型封装:对Map等复杂数据类型,@value并不能获取
如果是ConfigurationPropertites注入配置文件的值,可以进行数据校验

@Component
@ConfigurationProperties(prefix = "person")
@Validated
public class Person {
     

    /**
     * 
     *      
     * 
     */

   //lastName必须是邮箱格式
    @Email
    //@Value("${person.last-name}")
    private String lastName;
    //@Value("#{11*2}")
    private Integer age;
    //@Value("true")
    private Boolean boss;

    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;

配置文件yml还是properties他们都能获取到值;如果说,我们只是在某个业务逻辑中需要获取一下配置文件中的某项值,使用@Value;如果说,我们专门编写了一个javaBean来和配置文件进行映射,我们就直接使用@ConfigurationProperties;

3.4 @PropertySource&@ImportResource&@Bean

@PropertySource:加载指定的配置文件;
Springboot_第5张图片

@ImportResource:导入Spring的配置文件,让配置文件里面的内容生效;Spring Boot里面没有Spring的配置文件,我们自己编写的配置文件,也不能自动识别;想让Spring的配置文件生效,加载进来;@ImportResource标注在一个配置类上

@ImportResource(locations = {
     "classpath:beans.xml"})
导入Spring的配置文件让其生效

但是在SpringBoot中,推荐给容器中添加组件的方式是使用全注解
1、配置类**@Configuration用以代替Spring配置文件
2、使用
@Bean**给容器中添加组件

/**
 * @Configuration:指明当前类是一个配置类;就是来替代之前的Spring配置文件
 *
 * 在配置文件中用标签添加组件
 *
 */
@Configuration
public class MyAppConfig {
     

    //将方法的返回值添加到容器中;容器中这个组件默认的id就是方法名
    @Bean
    public HelloService helloService02(){
     
        System.out.println("配置类@Bean给容器中添加组件了...");
        return new HelloService();
    }
}

3.5 配置文件占位符

3.5.1 随机数

${
     random.value}、${
     random.int}、${
     random.long}
${
     random.int(10)}、${
     random.int[1024,65536]}

3.5.2 占位符获取之前配置的值,如果没有可以是用:指定默认值

person.last-name=张三${
     random.uuid}
person.age=${
     random.int}
person.birth=2017/12/15
person.boss=false
person.maps.k1=v1
person.maps.k2=14
person.lists=a,b,c
person.dog.name=${
     person.hello:hello}_dog
person.dog.age=15

3.6 Profile

3.6.1 多Profile文件

我们在主配置文件编写的时候,文件名可以是 application-{profile}.properties/yml。默认使用application.properties的配置;
Springboot_第6张图片

3.6.2 yml支持多文档块方式

server:
  port: 8081
spring:
  profiles:
    active: prod

---
server:
  port: 8083
spring:
  profiles: dev


---

server:
  port: 8084
spring:
  profiles: prod  #指定属于哪个环境

3.6.3 激活指定profile

1、在配置文件中指定 spring.profiles.active=dev

​2、命令行:

​ java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev;

​ 可以直接在测试的时候,配置传入命令行参数

​3、虚拟机参数;

​ -Dspring.profiles.active=dev

3.6.4 配置文件加载位置

springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文件

–file:./config/

–file:./

–classpath:/config/

–classpath:/

优先级由高到底,高优先级的配置会覆盖低优先级的配置;SpringBoot会从这四个位置全部加载主配置文件;互补配置
Springboot_第7张图片

3.6.5 外部配置加载顺序

SpringBoot也可以从以下位置加载配置; 优先级从高到低;高优先级的配置覆盖低优先级的配置,所有的配置会形成互补配置

1.命令行参数
所有的配置都可以在命令行上进行指定
java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc多个配置用空格分开; --配置项=值
2.来自java:comp/env的JNDI属性
3.Java系统属性(System.getProperties())
4.操作系统环境变量
5.RandomValuePropertySource配置的random.*属性值
由jar包外向jar包内进行寻找;
优先加载带profile
6.jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
7.jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
再来加载不带profile
8.jar包外部的application.properties或application.yml(不带spring.profile)配置文件
9.jar包内部的application.properties或application.yml(不带spring.profile)配置文件
10.@Configuration注解类上的@PropertySource
11.通过SpringApplication.setDefaultProperties指定的默认属性

你可能感兴趣的:(spring,boot,java)