SpringBoot从入门到放弃，第一章

时间  2019-11-12
标签 springboot 入门 放弃 第一章 栏目 Spring 繁體版
原文   原文链接

SpringBoot从入门到放弃，第一章

1、简单概述

先谈一下什么是Springjava

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著做《Expert One-On-One J2EE Development and Design》。Spring是为了解决企业级应用开发的复杂性而建立的，使用Spring可让简单的JavaBean实现以前只有EJB才能完成的事情。可是Spring不只仅局限于服务器端开发，任何Java应用都能在简单性、可测试性和松耦合性等方面从Spring中获益。

为了下降Java开发的复杂性，Spring采用了如下4种关键策略：web

一、基于POJO的轻量级和最小侵入性编程；

二、经过依赖注入（DI）和面向接口实现松耦合；

三、基于切面（AOP）和惯例进行声明式编程；

四、经过切面和模版减小样式代码；

什么是SpringBootredis

Spring Boot 是全部基于 Spring 开发的项目的起点。Spring Boot 的设计是为了让你尽量快的跑起来 Spring 应用程序而且尽量减小你的配置文件。简单来讲就是SpringBoot其实不是什么新的框架，它默认配置了不少框架的使用方式，就像maven整合了全部的jar包，spring boot整合了全部的框架（不知道这样比喻是否合适）。

SpringBoot的四大特性spring

一、SpringBoot Starter：他将经常使用的依赖分组进行了整合，将其合并到一个依赖中，这样就能够一次性添加到项目的Maven或Gradle构建中；

二、自动配置：SpringBoot的自动配置特性利用了Spring4对条件化配置的支持，合理地推测应用所需的bean并自动化配置他们；

三、命令行接口：（Command-line-interface, CLI）：SpringBoot的CLI发挥了Groovy编程语言的优点，并结合自动配置进一步简化Spring应用的开发；

四、Actuatir：它为SpringBoot应用的全部特性构建一个小型的应用程序。但首先，咱们快速了解每项特性，更好的体验他们如何简化Spring编程模型。

2、SpringBoot的场景启动器

什么是场景启动器数据库

Spring boot将全部的功能场景都抽取出来,作成一个个独立的starters启动器

只有在项目里引入了starters,这些场景的依赖就会导入到工程中

开发中须要什么样的功能，就引入什么场景启动器
若是想使用Spring和JPA进行数据库访问，只需spring-boot-starter-data-jpa在项目中包含依赖项便可。

spring-boot-starter-parent编程

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

这是Spring Boot的父级依赖，这样当前的项目就是Spring Boot项目了。
spring-boot-starter-parent 是一个特殊的starter，它用来提供相关的Maven默认依赖。使用它以后，经常使用的包依赖能够省去version标签。

先来看 parent 的基本功能有哪些？

一、定义了 Java 编译版本为 1.8 。
二、使用 UTF-8 格式编码。
三、继承自 spring-boot-dependencies，这个里边定义了依赖的版本，也正是由于继承了这个依赖，因此咱们在写依赖时才不须要写版本号。
四、执行打包操做的配置。
五、自动化的资源过滤。
六、自动化的插件配置。
七、针对 application.properties 和 application.yml 的资源过滤，包括经过 profile 定义的不一样环境的配置文件，例如 application-dev.properties 和 application-dev.yml。

下面列举一下经常使用的starter数组

spring-boot-starter-web
spring-boot-starter-thymeleaf
spring-boot-starter-test
spring-boot-starter-security
spring-boot-starter-jdbc
spring-boot-starter-freemarker
spring-boot-starter-data-redis
spring-boot-starter-data-solr
spring-boot-starter-data-jpa
spring-boot-starter-aop
spring-boot-starter-batch
spring-boot-starter-amqp
spring-boot-starter-activemq
。。。

3、SpringBoot的启动类

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

@SpringBootApplication表示这是一个SpringBoot应用

SpringBootApplicationspringboot

@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的配置类服务器

​ 标注在某个类上，表示这是一个SpringBoot的配置类app

​ 其中**@Configuration**：配置类上来标注这个注解

​ 配置类---配置文件：配置类也是容器中的一个组件，其底层是**@Component**

@Configuration
public @interface SpringBootConfiguration {
	...
}

@Component
public @interface Configuration {
	...
}

**二、@EnableAutoConfiguration：**开启自动配置功能

​ 之前须要配置的东西，Spring Boot帮助咱们自动配置；@EnableAutoConfiguration告诉

​ SpringBoot开启自动配置功能.

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    ...
}

**2.1）、@AutoConfigurationPackage：**自动配置包

​ 底层：@Import(AutoConfigurationPackages.Registrar.class)

​ spring的底层注解@Import，给容器中导入一个组件；

​ 导入的组件由Registrar.class

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

    	//AnnotationMetadata扫描到的类上有注解的类
    	//PackageImport(metadata).getPackageName()获取该类的包名
    	//register注册
		@Override
		public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
			register(registry, new PackageImport(metadata).getPackageName());
		}

    	...
	}

以上：将主配置类（@SpringBootApplication标注的类）的所在包及下面全部包里面的全部组件注册到Spring容器。

2.2）、@Import(AutoConfigurationImportSelector.class)：

给容器注入组件：AutoConfigurationImportSelector

@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
				.loadMetadata(this.beanClassLoader);
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
				annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}

将全部须要导入的组件以全类名的方式返回；这些组件就会被添加到容器中

会给容器中导入很是多的自动配置类（xxxAutoConfiguration）,这些配置类的左右是给容器中导入这个场景须要的全部的组件，并配置好这些组件

有了自动配置类，就免去了咱们手动编写配置和注入功能组件等工做。

从META-INF/spring.factories里导入EnableAutoConfiguration场景所制定的配置类

4、YAML配置文件

4.1）、全局配置文件

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

application.properties
application.yml

配置文件放在src/main/resources目录或者类路径/config下

全局配置文件能够对一个springboot的默认配置值进行修改

4.2）、默认语法：

server:
  port: 8080

key和value中间有空格，大小写敏感

k:v 字符串默认不用加单引号或者双引号；

​ ""：双引号；不会转义字符串里面的特殊字符

​ name: "zhangsan \n lisi" 输出：zhangsan 换行 lisi

​ ‘’：单引号，会转义特殊字符，只会将其当作一个普通的字符串输出

​ name: "zhangsan \n lisi" 输出：zhangsan \n lisi

对象表达;

friends:
	lastname: zhangsan 
	age: 25
##或者
friends: {lastname: zhangsan,age: 25}

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

pets:
	- cat
	- dog
	- rabbit
##或者
pets: [cat,dog,rabbit]

MAP;

maps: {k1: v1,k2: v2}

4.3）、yaml文件值获取

@ConfigurationProperties告诉SpringBoot本类中全部属性和配置文件中相关的配置进行绑定

且只有这个组件是容器中的组件，才能使用容器提供的@ConfigurationProperties功能

person:
  name: lee
  age: 28
  map: {k1: v1,k2: v2}
  pets:
    - dog
    - cat
    - rabbit

实体类：

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

    private String name;

    private Integer age;

    private Map<String,Object> map;

    private List<String> pets;
}

一样的配置在application.properties中怎样配置呢：

person.name=lee
person.age=28
person.map.k1=v1
person.map.k2=v2
person.map.pets=dog,cat,rabbit

5、@ConfigurationProperties和@Value

@ConfigurationProperties是springboot中的注解

@Value是spring中的注解

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

import org.springframework.beans.factory.annotation.Value;
@Data
@ToString
@Component
//@ConfigurationProperties(prefix = "person")
public class Person {

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

    @Value("${person.age}")
    private Integer age;

	//map
    @Value("#{${person.map}}")
    private Map<String,String> map;

	//list
    @Value("#{'${person.pets}'.split(',')}")
    private List<String> pets;
}

不过yml要写成一下格式

person:
  name: lee
  age: 28
  map: "{key1: 'value1', key2: 'value2'}"
  pets: topic1,topic2,topic3
  
##不能写成

person:
  name: lee
  age: 28
  map: {k1: v1,k2: v2}
  pets:
    - dog
    - cat
    - rabbit

测试：

@RunWith(SpringRunner.class)
@org.springframework.boot.test.context.SpringBootTest
public class SpringBootTest {

    @Autowired
    private Person person;

    @Test
    public void contextLoader(){
        System.out.println(person);
    }
}

6、@PropertySource和@ImportResource

@ConfigurationProperties：是默认加载全局配置文件中的值

@PropertySource：加载指定的配置文件

@ImportResource：导入spring的配置文件，让配置文件里面的内容生效

6.1）、@PropertySource

加载指定的配置文件

pet.properties

pet.name=dog
pet.age=5
pet.color=yellow

Pet

@Data
@ToString
@Component
@PropertySource(value = {"classpath:pet.properties"})
public class Pet {

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

    @Value("${pet.age}")
    private Integer age;

    @Value("${pet.color}")
    private String color;

}

6.2）、ImportResource

导入spring的配置文件，让配置文件里面的内容生效

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="helloService" class="com.lee.boot.service.HelloService"></bean>

</beans>

HelloService

package com.lee.boot.service;

public class HelloService {

}

测试：

@RunWith(SpringRunner.class)
@org.springframework.boot.test.context.SpringBootTest
public class SpringBootTest {

    @Autowired
    private ApplicationContext context;

    @Test
    public void containBeans(){
        boolean res = context.containsBean("helloService");
        System.out.println(res);
    }
}

结果：false

SpringBoot里面没有spring的配置文件，咱们本身编写的配置文件，也不能自动识别；想让spring的配置文件生效，加载进来；就须要将**@ImportResource**标注在一个配置类上

@ImportResource(value = {"classpath:beans.xml"})
@SpringBootApplication
public class BootApplication {

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

}

//标注在启动类上也是能够的，由于启动类自己也是一个配置类，其底层也
//注解了@Configuration

结果：true

其实springboot不推荐使用配置文件的方式添加组件，而是推荐使用全注解的方式。

//configuration指明当前类是一个配置类，就是来替代以前的
//spring配置文件
@Configuration
public class MyAppConfig {
	
	//使用@Bean给容器添加组件
	//将方法的返回值添加到容器中
	//容器中这个组件默认的ID就是方法名
    @Bean
    public HelloService helloService(){
        return new HelloService();
    }
}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程