SpringBoot学习笔记（一）基础入门

最新推荐文章于 2024-07-15 21:21:12 发布
最新推荐文章于 2024-07-15 21:21:12 发布
阅读量158 收藏
点赞数
文章标签： spring boot 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43174141/article/details/129663473
版权

SpringBoot学习笔记（一）

一、SpringBoot与Spring

1、 Spring能做什么

1.1 Spring的能力

Spring：IOC容器、AOP切片
SpringMVC：Web应用开发
在这里插入图片描述
Microservice：微服务，把应用中的功能拆封成一个个微小的功能模块，每个功能模块称为微服务
Reactive：响应式编程，基于异步非阻塞的方式，通过整个应用之间建立一个异步数据流的方式，异步数据流允许我们占用服务器少量的线程资源，帮助我们构建一个高吞吐量的应用
Cloud：分布式云开发
Web开发：SpringMVC发送请求，响应页面
Serverless：无服务开发，函数式服务，无需购买服务器
Event Driven：事件驱动，将整个分布式系统构建一个实时数据流，通过响应式的方式让系统占用少量的资源完成高吞吐量的业务。
Batch：批处理

1.2 Spring生态

覆盖了：
web开发
数据访问
安全控制
分布式
消息服务
移动开发
批处理

1.3 Spring5重大升级

  1. 响应式编程
    在这里插入图片描述
  2. 内部源码设计
    基于Java8的一些新特性，如：接口默认实现。重新设计源码架构。

2、 为什么用SpringBoot

能快速创建出生产级别的Spring应用

2.1 SpringBoot优点

  • Create stand-alone Spring applications
    • 创建独立Spring应用
  • Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)
    • 内嵌web服务器
  • Provide opinionated ‘starter’ dependencies to simplify your build configuration
    • 自动starter依赖，简化构建配置
  • Automatically configure Spring and 3rd party libraries whenever possible
    • 自动配置Spring以及第三方功能
  • Provide production-ready features such as metrics, health checks, and externalized configuration
    • 提供生产级别的监控、健康检查及外部化配置
  • Absolutely no code generation and no requirement for XML configuration
    • 无代码生成、无需编写XML

SpringBoot是整合Spring技术栈的一站式框架
SpringBoot是简化Spring技术栈的快速开发脚手架

2.2 SpringBoot缺点

  • 人称版本帝，迭代快，需要时刻关注变化
  • 封装太深，内部原理复杂，不容易精通

3、时代背景

3.1 微服务

  • 微服务是一种架构风格
  • 一个应用拆分为一组小型服务
  • 每个服务运行在自己的进程内，也就是可独立部署和升级
  • 服务之间使用轻量级HTTP交互
  • 服务围绕业务功能拆分
  • 可以由全自动部署机制独立部署
  • 去中心化，服务自治。服务可以使用不同的语言、不同的存储技术

3.2 分布式

分布式的困难
  • 远程调用
  • 服务发现
  • 负载均衡
  • 服务容错
  • 配置管理
  • 服务监控
  • 链路追踪
  • 日志管理
  • 任务调度
  • …
分布式的解决

SpringBoot + SpringCloud

3.3 云原生

原生应用如何上云。 Cloud Native

上云的困难
  • 服务自愈
  • 弹性伸缩
  • 服务隔离
  • 自动化部署
  • 灰度发布
  • 流量治理
  • …

4、如何学习SpringBoot

4.1 官网文档架构

在这里插入图片描述
在这里插入图片描述

二、SpringBoot2入门

1、系统要求

1.1 maven设置

<mirrors>
      <mirror>
        <id>nexus-aliyun</id>
        <mirrorOf>central</mirrorOf>
        <name>Nexus aliyun</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
      </mirror>
  </mirrors>
 
  <profiles>
         <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>

2、HelloWorld

需求：浏览发送/hello请求，响应 Hello，Spring Boot 2

2.1 创建maven工程

2.2 引入依赖

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

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

2.3 创建主程序

/**
 * 主程序类
 * @SpringBootApplication：这是一个SpringBoot应用
 */
@SpringBootApplication
public class MainApplication {

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

2.4 编写业务

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String handle01(){
        return "Hello, SpringBoot 2";
    }
}

2.5 测试

直接运行main方法
在这里插入图片描述

2.6 简化配置

在src/main/resources下创建application.properties文件

server.port=8888

2.7 简化部署

 <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

打开cmd页面，进入打包后的文件夹/target包下，使用java -jar (文件名)命令，即已部署

注意点：

  • 取消掉cmd的快速编辑模式

三、了解自动配置原理

1、SpringBoot特点

1.1 依赖管理

  • 父项目做依赖管理
依赖管理    
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
</parent>

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

几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制
  • 开发导入starter场景启动器
1、见到很多 spring-boot-starter-* ： *就代表某种场景
2、只要引入starter，这个场景的所有常规需要的依赖我们都自动引入
3、SpringBoot所有支持的场景
https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
4、见到的  *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。
5、所有场景启动器最底层的依赖
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
  <version>2.3.4.RELEASE</version>
  <scope>compile</scope>
</dependency>
  • 无需关注版本号，自动版本仲裁
1、引入依赖默认都可以不写版本
2、引入非版本仲裁的jar，要写版本号。
  • 可以修改默认版本号
1、查看spring-boot-dependencies里面规定当前依赖的版本用的 key。
2、在当前项目里面重写配置
    <properties>
        <mysql.version>5.1.43</mysql.version>
    </properties>

1.2 自动配置

  • 自动配好Tomcat
    • 引入Tomcat依赖
    • 配置Tomcat
<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.3.4.RELEASE</version>
      <scope>compile</scope>
    </dependency>

@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for(String name : names){
            System.out.println(name);
        }
    }
}
  • 自动配好SpringMVC
    • 引入SpringMVC全套组件
    • 自动配好SpringMVC常用组件（功能）
  • 自动配好Web常见功能，如：字符编码问题
    • SpringBoot帮我们配置好了所有web开发的常见场景
  • 默认的包结构
    • 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
    • 无需以前的包扫描配置
    • 想要改变扫描路径，@SpringBootApplication(scanBasePackages="com.atguigu")， 或者@ComponentScan指定扫描路径
@SpringBootApplication
等同于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.atguigu.boot")

  • 各种配置拥有默认值
    在这里插入图片描述

    • 默认配置最终都是映射到某个类上，如：MultipartProperties
    • 配置文件的值最终会绑定到每个类上，这个类会在容器中创建对象

  • 按需加载所有自动配置项

    • 非常多的starter
    • 引入了哪些场景，这些场景的自动配置才会开启
    • SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

2、容器功能

2.1 组件添加

2.1.1 @Configuration

基本使用
在Spring中获取组件，需要在xml文件中进行配置后获取；而在SpringBoot中只需要@Configuration标签即可代表一个xml配置文件。

a>创建实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private String id;

    private String userName;
}
b>创建Config类

（1）@Configuration注解：告诉SpringBoot这是一个配置类 == 配置文件
（2）@Bean注解：给容器添加组件，以方法名作为组件的id，返回类型就是组件类型，返回的值就是组件在容器中的实例。
（3）配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的，外部无论对配置类中的这个组件注册方法调用多少次，获取的都是之前注册容器中的单实例对象。
（4）配置类本身也是组件
（5）proxyBeanMethods：代理bean的方法
                Full(proxyBeanMethods = true)：保证每一个@Bean方法被调用多少次返回的组件都是单实例的
                Lite(proxyBeanMethods = false)：每一个@Bean方法被调用多少次返回的组件都是新创建的

@Configuration
public class MyConfig {
    @Bean
    public User user01(){
        return new User("1001","张三");
    }
}
c>测试
@SpringBootApplication
public class MainApplication {
    public static void main(String[] args) {
        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //2、从容器中获取组件
        User bean1 = run.getBean("user01", User.class);
        User bean2 = run.getBean("user01", User.class);
        //结果：true
        System.out.println("组件：" + (bean1 == bean2));
        
        //3、com.yuuto148.boot.config.MyConfig$$EnhancerBySpringCGLIB$$111dc970@8dfe921
        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        //如果@Configuration(proxyBeanMethods = true)，代理对象调用方法，SpringBoot总会检查这个组件是否在容器中已存在。
        //保持组件单实例
        User user01 = bean.user01();
        User user = bean.user01();
        System.out.println("直接调用方法是否相等:" + (user == user01));
        
        User user01 = run.getBean("user01", User.class);
        Pet tom = run.getBean("tom", Pet.class);

        System.out.println("用户的宠物："+(user01.getPet() == tom));
    }
}

Full模式与Lite模式
Full模式会自动被代理，代理过后的类调用获取实例的方法时会先先在容器中查找是否已经存在，查找容器和项目启动时都会花更多时间，花时间省空间；Lite模式则不会被代理，直接创建新实例，花空间省时间。

  • 最佳实战
    • 配置类之间无依赖关系，用Lite模式加速容器启动过程，减少判断
    • 配置类组件之间有依赖关系，方法会被调用得到之前是单实例组件，用Full模式
2.1.2 @Bean、@Component、@Controller、@Service、@Repository
2.1.3 @ComponentScan、@Import

@Import：给容器中创建出所填的组件，默认组件名就是全类名

@Import({User.class})
@Configuration
public class MyConfig {

    @Bean
    public User user01(){
        return new User("1001","张三");
    }

}
@Conditional

条件装配：满足Conditional指定的条件，则进行组件注入
在这里插入图片描述
Config类

@Import({User.class})
@Configuration
public class MyConfig {
    @Bean
    public Pet pet(){
        return new Pet();
    }

    @ConditionalOnBean(name = "pet") 
    @Bean
    public User user01(){
        return new User("1001","张三");
    }
}

注：@ConditionalOnBean需要注意类的声明前后顺序问题，OnClass不用

测试方法

public class MainApplication {
    public static void main(String[] args) {
        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        
        
        boolean user01 = run.containsBean("user01");
        System.out.println("容器中是否存在user01组件:" + user01);

        boolean pet = run.containsBean("pet");
        System.out.println("容器中是否存在pet组件:" + pet);
    }
}

2.2 原生配置文件引入

2.2.1 @ImportResource

导入过去的Spring的xml文件注册相关组件，无需改成新的配置类

@Configuration
@ImportResource("classpath:beans.xml")
public class MyConfig {
    @Bean
    public Pet pet(){
        return new Pet();
    }

    @Bean
    public User user01(){
        return new User("1001","张三");
    }
}

2.3 配置绑定

如何使用Java读取到properties文件中的内容，并且把它封装到JavaBean中以供随时使用：
传统方式

public class getProperties {
     public static void main(String[] args) throws FileNotFoundException, IOException {
         Properties pps = new Properties();
         pps.load(new FileInputStream("a.properties"));
         Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
         while(enum1.hasMoreElements()) {
             String strKey = (String) enum1.nextElement();
             String strValue = pps.getProperty(strKey);
             System.out.println(strKey + "=" + strValue);
             //封装到JavaBean。
         }
     }
 }
2.3.1 @ConfigurationProperties

@ConfigurationProperties(prefix = “”)

  1. prefix或value的值，指定配置文件中对应的前缀
  2. 只有在容器中注册了的组件，才可以使用SpringBoot的功能
2.3.2 @ConfigurationProperties + @Conponment

配置文件

server.port=8888

mypet.name="Tom"

实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
@Component
@ConfigurationProperties(prefix = "mypet")
public class Pet {
    private String name;
}

测试方法

@RestController
public class HelloController {
    @Autowired
    private Pet pet;

    @RequestMapping("/myPet")
    public Pet handle02(){
        return pet;
    }
}

结果
在这里插入图片描述

2.3.3 @ConfigurationProperties + @EnableConfigurationProperties

@EnableConfigurationProperties(Pet.class)
1、开启Pet配置绑定功能
2、把这个Pet组件自动注册到容器中

MyConfig类

@Configuration
@EnableConfigurationProperties({Pet.class})
public class MyConfig {
}

测试
在这里插入图片描述

3、自动配置原理入门

3.1 引导加载自动配置类（暂未更新）

3.2 按需开启自动配置项（暂未更新）

3.3 修改默认配置（暂未更新）

3.4 最佳实践

如何开发一个SpringBoot应用

  1. 引入场景依赖
    在该地址下查询需要用到的依赖： https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
  2. 查看自动配置了哪些（选做）
    方法①：自己分析，引入场景对应的自动配置一般都生效了
    方法②： 配置文件中debug=true开启自动配置报告。Negative（不生效）\Positive（生效）
  3. 是否需要修改配置
  • 参照文档修改配置项
    • 文档地址：https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-application-properties.html#common-application-properties
    • 自己分析，xxxxProperties绑定了配置文件的哪些。
  • 自定义加入或替换组件 @Bean @Component
  • 自定义器 XXXXCustomizer

4、开发小技巧

4.1 lombok

简化JavaBean开发

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
idea中搜索安装lombok插件

@Data：注解在类上，提供get、set、equals、hashCode、canEqual、toString方法
@AllArgsConstructor ： 注在类上，提供类的全参构造
@NoArgsConstructor ： 注在类上，提供类的无参构造
@Setter ： 注在属性上，提供 set 方法
@Getter ： 注在属性上，提供 get 方法
@EqualsAndHashCode ： 注在类上，提供对应的 equals 和 hashCode 方法
@ToString：注解在类上，生成toString方法
@Slf4j：注解在类上，提供对应的 Logger 对象，变量名为 log（log.info(…)）

4.2 dev-tools

热更新，项目或者页面修改以后：Ctrl+F9

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

4.3 Spring Initailizr（项目初始化向导）

4.3.0 选择我们需要的开发场景

在这里插入图片描述

4.3.1 自动依赖注入

在这里插入图片描述

4.3.2 自动创建项目结构

在这里插入图片描述

4.3.3 自动编写好主配置类

在这里插入图片描述

Yuuto148
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
黑马程序员SSM-SpringBoot学习笔记
weixin_68837457的博客
07-27 1353
SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程
springboot学习笔记，适合新手
08-12
1、首先对Spring Boot做一...一、Spring Boot入门 1、spring boot 简介 2、idea和maven 3、项目构建启动 4、RESTful URL 二、Spring Boot 项目开发 1、整合Spring Data JPA 2、使用Thymeleaf模板 3、整合swagger
SpringBoot学习笔记
大枫树
07-03 1317
什么是Spring BootSpring Boot 是所有基于 Spring Framework 5.0 开发的项目。Spring Boot 的设计是为了让你尽可能快的跑起来 Spring 应用程序，并且尽可能减少你的配置文件。设计目的：用来简化 Spring 应用的初始搭建以及开发过程。从最根本上来讲，Spring Boot 就是一些库的集合，它能够被任意项目所使用，它使用 “习惯优于配置” （项目中存在大量的配置，此外还内置一个习惯性的配置）的理念让你的项目快速运行起来。
超详细的springBoot学习笔记
热门推荐
cnn0314的博客
02-27 37万+
Spring Boot 1.Spring Boot简介 Spring诞生时是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的 轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级 Java开发提供了一种相...
SpringBoot3笔记-快速入门
Ego_Ekko的博客
06-02 706
修改配置（外部放置一个application.properties文件）、监控、健康检查。①创建项目（maven项目）继承spring-boot-starter-parent。SpringBoot帮助开发者简单快速地创建一个独立的、生产级别的Spring应用。官方提供的场景：命名为spring-boot-starter-*第三方提供场景：命名为*-spring-boot-starter。简化开发、简化配置、简化整合、简化部署、简化监控、简化运维。java -jar demo.jar启动项目。
SpringBoot学习笔记—SpringBoot快速入门
cmy_top的博客
06-19 166
SpringBoot快速入门SpringBoot快速入门需求实现步骤① 创建Maven项目② 导入SpringBoot依赖③ 定义Controller类④ 编写引导类⑤ 启动测试注意事项快速构建SpringBoot工程 SpringBoot快速入门 需求 搭建SpringBoot工程，定义HelloController类，实现一个hello()方法，返回字符串"Hello SpringBoot"，即在页面上显示“Hello SpringBoot”字符串。 实现步骤 ① 创建Maven项目 ② 导入Spri
【黑马程序员】SpringBoot2学习笔记
m0_60824353的博客
02-07 1404
黑马程序员springboot 学习笔记 springboot2学习笔记
springboot学习笔记
qq_57697526的博客
08-10 991
这个是根据名字，也可以根据。
尚硅谷SpringBoot3笔记 (一) 快速入门
qq_45981086的博客
03-08 701
是 Spring Boot 提供的一个用于构建 Spring Boot 项目的父项目（Parent Project）。，你可以快速地构建基于 Spring MVC 的 Web 应用程序，无需手动管理依赖和配置。，从而简化项目的配置和构建过程。作为项目的父项目，你可以。
Springboot学习笔记（一）
weixin_45983532的博客
07-02 179
Springboot的学习笔记（一）
SpringBoot学习笔记——SpringBoot2入门
m0_56282664的博客
02-08 289
SpringBoot学习笔记——SpringBoot2入门
springboot学习笔记.docx
04-08
3. 编写主程序类，使用`@SpringBootApplication`注解标记。 4. 创建控制器，定义处理请求的方法。 5. 运行主程序，内嵌的Tomcat服务器会启动并监听端口。 6. 通过浏览器访问控制器的URL进行测试。 打包Spring Boot...
超详细的springboot学习笔记
11-27
附件是我最新学习springboot的学习笔记，里面记载了从入门到精通的超详细的一个学习资料，希望能给大家带来学习上的帮助
springboot 入门学习笔记
04-12
springboot 入门学习笔记
在 Spring Boot 中使用 WebSocket 构建在线日志系统
xiaoerbuyu1233的博客
07-15 510
感谢原作者 侵删在 Spring Boot 中使用 WebSocket 构建在线日志系统 - spring 中文网
Spring Boot实战：无缝对接OpenAI
德乐懿的博客
07-09 1258
通过本文的介绍，你应该已经了解了如何使用Spring Boot无缝对接OpenAI，并在你的应用中实现AI功能。你可以通过探索OpenAI的官方文档来了解更多关于这些功能的信息，并按照类似的方式在你的Spring Boot应用中实现它们。要使用OpenAI的API，首先需要注册一个OpenAI账号，并在Dashboard中获取你的API密钥。这个密钥将用于后续的API调用中，以验证你的身份。此外，你还可以考虑使用Spring Boot的其他特性来增强你的应用，如异步处理、安全性、数据库集成等。
Spring boot 2.0 升级到 3.3.1 的相关问题 （一）
飞一站的博客
07-15 1016
解决Spring boot 升级到3.X版本引起的Interceptor和 WebMvcConfigurer 无法使用的BUG
观察者模式实战：Spring Boot中联动更新机制的优雅实现
最新发布
心猿意码
07-15 533
观察者模式（Observer Pattern）是一种软件设计模式，它定义了对象之间的一种一对多依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知并自动更新。在Spring框架中，观察者模式通常通过事件驱动的方式实现。首先，我们需要定义一个事件类，用于表示学生年龄的更新。Java深色版本246914 }1518 }1922 }23}通过上述步骤，我们成功地实现了当学生表中的年龄字段更新时，自动同步更新学生档案表和学生成绩表的功能。
SpringBoot学习笔记：从入门到精通
"springboot课堂笔记，如果觉得好给我留言要教学视频" 在本文中，我们将深入探讨Spring Boot这一流行的Java框架，并基于提供的课堂笔记内容，分析其发展历程、核心概念以及如何进行快速入门。Spring Boot是由...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值