SpringBoot深入简之出篇一

最新推荐文章于 2024-05-24 09:46:05 发布

朝油

最新推荐文章于 2024-05-24 09:46:05 发布

阅读量307

点赞数

分类专栏： SpringBoot

本文链接：https://blog.csdn.net/qq_41910568/article/details/90615745

版权

SpringBoot 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Spring Boot深入简出之篇一

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。（百度百科描述）
spring boot的优点：

创建独立的Spring应用程序——就是把一个大型的企业级应用拆分成许多的微服务应用组件，然后在组合起来形成一个完整的大型项目，这就是spring boot当中对于微服务的特色功能
嵌入的Tomcat，无需部署WAR文件——在IDE的开发时，我们不需要手动地为项目配置Tomcat服务器，spring boot项目会默认为我们的项目配置好服务器环境。还可以通过IDE把项目打包成jar运行包，可以直接在有jdk 环境下，直接在控制台输入“java -jar 文件名.jar”命令只可运行我们的spring boot项目。
简化Maven配置——我们采用maven作为开发环境，主要目的还是因为maven 的超强管理机制。以往我们使用maven的时候还是需要把我们项目中要用到的第三方jar 包的坐标（三位一体（groupId、artifactId和version）唯一标识）信息在pom.xml 文件下声明。但是现在由spring boot的依赖场景管理机制帮我们把用来开发J2EE 的项目场景依赖全部包含进来了，而我们需要做的就是选择自己需要的开发场景即可，剩下的就是spring boot帮我们完成所需依赖的加载工作。
自动配置Spring——以前我们采用Spring作为开发环境的时候，无论是使用xml 还是使用注解装配作为环境配置都需要我们手动地一个一个的声明出来让项目知道这些都是需要的环境配置。但是现在spring boot 推出了一套可自动装配配置注解的机制，开发者可以不用为每个环境配置做手动注解了。我们现在需要做的就是选择需要的哪一类注解，然后交给spring boot 为项目自动注入配置。
提供生产就绪型功能，如指标，健康检查和外部配置
绝对没有代码生成并且对XML也没有配置要求 [1] ——这是因为spring boot 官方都已经为我们开发者提前在spring boot 框架的底层把spring 所需的配置全部封装好了。

接下来我们采用Idea + maven 快速搭建一个spring boot 项目
在这里插入图片描述

这样就完整搭建好spring boot 项目了

设置默认本地maven（也可以使用idea 默认maven版本）
在这里插入图片描述
设置maven自动导入依赖
在本地的maven/conf/setting.xml 配置文件的profiles 标签下设置默认使用jdk1.8版本

<profile>
		<id>jdk-1.8</id>
		<activation>
			<activeByDefault>true</activeByDefault>
			<jdk>1.8</jdk>
		</activation>
		<properties>
			<maven.compiler.source>1.8</maven.compiler.source>
			<maven.compiler.target>1.8</maven.compiler.target>
			<maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
		</properties>
	</profile>
  </profiles>

设置本地jdk版本
在这里插入图片描述
不知道的可以查看

好了现在总的运行环境已经搭建好了

接下来我们来简单说明一下项目目录
在这里插入图片描述
我们简单讲解一下pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!-- 管理spring boot 的依赖版本号 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->

        <!--<parent>上面的父项目-->
        	<!-- 里面是所有spring boot 依赖场景的版本号，所以以后导入依赖坐标的时候不需要导入版本号（除了在dependencies管理里面没有的依赖） -->
            <!--<groupId>org.springframework.boot</groupId>-->
            <!-- 可以点击进去查看一下 -->
            <!--<artifactId>spring-boot-dependencies</artifactId>-->
            <!--<version>2.1.5.RELEASE</version>-->
            <!--<relativePath>../../spring-boot-dependencies</relativePath>-->
        <!--</parent>-->
    </parent>

    <!-- 本项目的坐标信息 -->
    <groupId>cn.zdxh.lcy</groupId>
    <artifactId>demo01</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo01</name>
    <description>Demo project for Spring Boot</description>

    <!-- jdk版本 -->
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <!-- 依赖唯一标识 -->
    <dependencies>
        <!-- spring boot 场景启动器 -->
        <dependency>
        <!-- 由于前面已经设置spring boot 管理依赖版本号，所以后面的场景坐标都不是设置版本号了 -->
            <groupId>org.springframework.boot</groupId>
           <!-- spring boot 场景启动器，帮我们导入了web模块正常运行的所有依赖的组件 -->
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <!-- 打包插件，可以将应用打包成一个可执行的jar包 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    
	<!-- 这部分暂不做讲解 -->
    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
        <pluginRepository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>

接下来我们来实现一个小功能：（测试一下spring boot环境搭建是否成功）
浏览器向服务器发送一个hello的请求，服务器响应一个“Hello Spring Boot”到浏览器端

编写一个spring boot 主程序
在这里插入图片描述

package cn.zdxh.lcy.demo01;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;

@RestController//@Controller + @ResponseBody
@SpringBootApplication()//spring boot 主程序标识注解，说明这是一个spring boot 主程序
public class Demo01Application {

    //主程序的入口
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Demo01Application.class);
        app.run(args);
    }

}

编写一个业务逻辑控制程序
在这里插入图片描述

package cn.zdxh.lcy.demo01.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class hello {
    @RequestMapping("/hello")
    public String hello() {
        return "Hello Spring Boot";
    }
}

把spring boot 应用启动起来
在这里插入图片描述
运行结果
运行结果图
简化部署（以jar包形式运行）
向pom.xml配置文件写入代码

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

在这里插入图片描述
把jar包复制到桌面

右击查看路径属性（C:\Users\Administrator\Desktop）

打开控制台
win + r
输入cmd

项目已经跑起来了

说说为什么不用手动配置tomcat（在spring boot为我们项目导入依赖的时候已经把嵌入式的tomcat 导入到了我们的项目中）
非官方

1. 主程序类

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})//spring boot 主程序标识注解，说明这是一个spring boot 主程序
public class Demo01Application {
    //主程序的入口
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Demo01Application.class);
        app.run(args);
    }
}

@SpringBootApplication：spring boot 应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main 方法来启动SpringBoot应用

在@SpringBootApplication 注解下的源码如下所示：

@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 {
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class<?>[] exclude() default {};

    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    String[] excludeName() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class<?>[] scanBasePackageClasses() default {};
}

**@SpringBootConfiguration：**有此注解的类就是SpringBoot 的配置类，该注解下的源码如下：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}

@Configuration：是Spring 框架下标注配置类的注解
配置类就是我们常说的“配置文件”；配置类也是容器中的一个组件（@Component）

**@EnableAutoConfiguration：**开启自动配置功能，该注解的源码如下所示
之前说过SpringBoot 的强大功能之一就是在我们项目需要配置的东西，SpringBoot 会帮我们自动配置好，@EnableAutoConfiguration 注解的作用就是告诉SpringBoot 这个项目要开启自动配置功能，这样自动配置才能生效。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

**@AutoConfigurationPackage：**自动配置包，该注解下的源码如下所示

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
}

**@Import({Registrar.class})：**spring 的底层注解，该注解下的源码如下所示
@import，给容器中导入一个组件；导入的组件由{AutoConfigurationPackage.Registrar.class} 决定

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        Registrar() {
        }

        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            AutoConfigurationPackages.register(registry, (new AutoConfigurationPackages.PackageImport(metadata)).getPackageName());//获取该注解原信息所在的包名
        }

        public Set<Object> determineImports(AnnotationMetadata metadata) {
            return Collections.singleton(new AutoConfigurationPackages.PackageImport(metadata));
        }
    }

通过上面的源码所知@AutoConfigurationPackage 注解的作用是为了把标注了@SpringBootApplication 注解的类所在的包路径下所有子类或者子包全部扫描进Spring容器中。

**@Import({AutoConfigurationImportSelector.class})：**给Spring容器导入组件
AutoConfigurationImportSelector：把项目所需的组件以去全类名的方式返回；这些组件就会被添加到Spring容器中，会给容器中导入非常多的自动配置类（XxxAutoConfiguration）；就是给容器中导入这个场景所需的所有组件，并配置好这些组件（maven管理）。如下图所示
在这里插入图片描述
SpringBoot有了自动配置类的作用，所以才免去了我们手动编写配置注入功能组件等的工作
SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, ClassLoader);
SpringBoot在启动的时候从类路径下的 META-INF/spring.factories 中获取EnableAutoConfiguration 指定的值；将这些值作为自动配置类导入到Spring容器中，自动配置类就生效了，帮我们进行自动配置工作，一起我们需要手动配置的东西，现在都是自动配置类帮我们完成了。
J2EE的整体整合解决方案和自动配置都在：spring-boot-autoconfigure-2.1.5.RELEASE.jar 包下进行自动配置；

后续请看SpringBoot篇二

朝油

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot深入简之出篇一

Spring Boot深入简出之篇一Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。（百度百科描述）sp...
复制链接

扫一扫

专栏目录