Springboot——基础入门

SpringBoot 基础知识汇总 (史上最全) SpringBoot常用注解,起步依赖starter,配置文件格式,yml优先级,SpringBoot打包运行,starter和parent的区别,Restful接口请求风格。 阅读详情

源码地址

# 一、Spring与SpringBoot

1. Spring生态

Springboot+Spring Framework+Spring Data+Spring Cloud+Spring Security…

覆盖了:

  • web开发、数据访问、安全控制、分布式、消息服务、移动开发、批处理…

Spring5重大升级:

  • 响应式编程:占用少量资源来处理大规模并发

在这里插入图片描述

  • 内部源码设计改变

适配器设计模式:A接口有(1,2,3,4,5方法),B适配器实现A。C类继承B(重写1,2,3方法),D类继承B重写(4,5方法)

​ 基于Java8的一些新特性,如:提供了接口默认实现。Spring5重新设计源码架构。

2. SpringBoot特点

特点:能快速创建出生产级别的Spring应用,整合Spring其他框架

2.1 优点

  • 创建独立Spring应用

  • Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)

  • Provide opinionated ‘starter’ dependencies to simplify your build configuration

    • 自动starter依赖,简化构建配置
  • Automatically configure Spring and 3rd party libraries whenever possible

    • 自动配置Spring以及第三方功能
  • 提供生产级别的监控、健康检查及外部化配置

  • 无代码生成、无需编写XML

  • SpringBoot是整合Spring技术栈的一站式框架

  • SpringBoot是简化Spring技术栈的快速开发脚手架

2.2 缺点

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

3. SpringBoot时代背景

3.1 微服务

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

3.2 分布式

分布式的困难:

  • 远程调用:各个服务之间通过http交互
  • 服务发现:相同服务被部署在不同机器上,需要发现正常运行服务
  • 负载均衡:相同服务被部署在不同机器上,选择调用哪个
  • 服务容错:服务出现异常时处理
  • 配置管理:所有服务配置放在配置中心中,只需修改一处
  • 服务监控:监控服务健康状况,cpu占用等
  • 链路追踪:追踪服务间互相调用
  • 日志管理:分布式日志管理
  • 任务调度:并行还是串行,或者某一个先触发
  • …

分布式的解决:

  • SpringBoot(开发各种微服务应用)+ SpringCloud(整合)

在这里插入图片描述

3.3 云原生

​ 即原生应用如何上云。 Cloud Native

上云的困难:

  • 服务自愈:C服务部署两台服务器,有一天一台炸了后,在其他服务器拉起一份C
  • 弹性伸缩:流量高峰时,C服务能自动扩充几台;高峰过后自动下线
  • 服务隔离:同台服务器上部署C、D、E服务,互不影响
  • 自动化部署:将微服务部署到云平台
  • 灰度发布:B服务更新2.0后,将某几台机子换成新版本,经过长时间迭代后发现没问题再把老版本逐一下线
  • 流量治理:限制每台服务器的流量
  • …

上云的解决:

在这里插入图片描述

4. SpringBoot官方文档

二、Springboot2入门

  • 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>

需求:浏览发送/hello请求,响应 “Hello,Spring Boot 2”

1.创建maven工程

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>

3.创建主程序

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MainApplication {

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

4.编写业务

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(){
        return "Hello, Spring Boot 2!";
    }
}

5.运行&测试

  • 运行MainApplication类
  • 浏览器输入http://localhost:8080/hello,将会输出Hello, Spring Boot 2!
  • 打印日志
    • @slf4j注解类
    • log.info(“要检测的内容:username={}”,username);

设置配置:

maven工程的resource文件夹中创建application.properties文件。

# 设置端口号
server.port=8888

更多配置信息

6.打包部署

​ 在pom.xml添加:

<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build>
  • 在IDEA的Maven插件上点击运行 clean 、package,把helloworld工程项目的打包成jar包,

打包好的jar包被生成在helloworld工程项目的target文件夹内。

  • 用cmd运行java -jar boot-01-helloworld-1.0-SNAPSHOT.jar,既可以运行helloworld工程项目。

  • 将jar包直接在目标服务器执行即可。

三、了解自动配置原理

1. 依赖管理

a> 父项目做依赖管理,后续引入依赖时不需要加版本号

依赖管理:
<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>

它几乎声明了所有开发中常用的依赖的默认版本号,自动版本仲裁机制

b> 开发导入 spring-boot-starter-场景启动器

  1. 只要引入starter,这个场景的所有常规需要的依赖我们都自动引入,如spring-boot-starter-web
  2. 更多SpringBoot所有支持的场景;见到的 *-spring-boot-starter: 第三方为我们提供的简化开发的场景启动器。
所有场景启动器最底层的依赖
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter</artifactId>
	<version>2.3.4.RELEASE</version>
	<scope>compile</scope>
</dependency>

c> 导入依赖时无需关注版本号,自动版本仲裁

  1. 引入依赖默认都可以不写版本
  2. 引入非版本仲裁的jar,要写版本号。
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

d> 可以修改默认版本号

  1. 查看spring-boot-dependencies里面规定当前依赖的版本用的 key。
  2. 在当前项目里面重写配置pom.xml,如下面的代码。
<properties>
	<mysql.version>8.0.26</mysql.version>
</properties>

2. 自动配置

组件在容器中有,就会生效:

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);
    }
}
  • 自动配好Tomcat (由spring-boot-starter-web引入)
    • 引入Tomcat依赖。
    • 配置Tomcat
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-tomcat</artifactId>
	<version>2.3.4.RELEASE</version>
	<scope>compile</scope>
</dependency>
  • 自动配好SpringMVC(由spring-boot-starter-web引入)

    • 引入SpringMVC全套组件
    • 自动配好SpringMVC常用组件(DispatcherServlet,ViewResolver, multipartResolver)
  • 自动配好Web常见功能,如:字符编码问题

    • SpringBoot帮我们配置好了所有web开发的常见场景
  • 默认的包结构

    • 无需以前的包扫描配置,主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
    • 想要改变扫描路径
      • @SpringBootApplication(scanBasePackages=“com.zju”)
      • @ComponentScan 指定扫描路径
@SpringBootApplication
	==等同于==
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.zju.boot")
  • 各种配置拥有默认值
    • 配置文件application.properties的值最终会绑定每个类上,如:MultipartProperties这个类会在容器中创建对象
    • 想要修改配置只需要在配置文件中设置
  • 按需加载所有自动配置项
    • SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面
    • 有非常多的starter,引入了哪些场景这个场景的自动配置才会开启
  • …

3. 容器功能

3.1 组件添加

@Configuration

组件的循环依赖特性,必须是单实例

  • 配置类本身也是组件

  • 配置类里面使用@Bean标注在方法上给容器注册组件,默认也是单实例的

  • Full模式(proxyBeanMethods = true):保证每个@Bean方法被调用多少次返回的组件都是单实例的

    • 配置 类组件之间有依赖关系,方法会被调用得到之前单实例组件,用Full模式(默认)
  • Lite模式(proxyBeanMethods = false):每个@Bean方法被调用多少次返回的组件都是新创建的

    • 配置 类组件之间无依赖关系用Lite模式加速容器启动过程,减少判断
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值,就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean("tom")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}

//Tomcat中组件为
Spring中基本标签

它们是Spring的基本标签,在Spring Boot中并未改变它们原来的功能

  • @Bean:表示方法返回对象,然后对象交给IOC管理

  • @Component:普通的注解

  • @Controller:web层

  • @Service:业务逻辑层以及Service层

  • @Repository:dao层即持久层

  • @ComponentScan:扫描包

@Import

​ @Import({User.class, DBHelper.class,…})自动从类中的无参构造函数创建一个实例注册到IOC容器中

​ 【注意】IOC容器中默认组件的名字id就是全类名,如 User 类就是:com.zju.boot.bean.User

@Import({User.class, DBHelper.class})
public class MyConfig {
}
@Conditional

​ 条件装配:满足Conditional指定的条件,则进行组件注入

在这里插入图片描述

用@ConditionalOnMissingBean举例说明:

@Configuration(proxyBeanMethods = false)
@ConditionalOnMissingBean(name = "tom")//没有tom名字的Bean时,MyConfig类的Bean才能生效。
public class MyConfig {

    @Bean
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean("tom22")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}

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

    boolean tom = run.containsBean("tom");
    System.out.println("容器中Tom组件:"+tom);//false

    boolean user01 = run.containsBean("user01");
    System.out.println("容器中user01组件:"+user01);//true

    boolean tom22 = run.containsBean("tom22");
    System.out.println("容器中tom22组件:"+tom22);//true
}

3.2 原生配置文件引入

@ImportResource导入Spring配置文件

使用场景:比如,公司使用bean.xml文件生成配置bean,然而你为了省事,想继续复用bean.xml,@ImportResource粉墨登场。

beans.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans ...">

    <bean id="haha" class="com.lun.boot.bean.User">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="18"></property>
    </bean>

    <bean id="hehe" class="com.lun.boot.bean.Pet">
        <property name="name" value="tomcat"></property>
    </bean>
</beans>

使用方法:将注解加到配置类中

@ImportResource("classpath:beans.xml")
public class MyConfig {
	...
}
  • classpath:

spring.banner.image.location=classpath:banner.jpg

classpath:只会到你的class路径中查找文件

在这里插入图片描述

3.3 属性值绑定

​ 读取properties文件中的内容,并且把它封装到JavaBean中,以供随时使用

方法一:

@ConfigurationProperties + @Component

在实体类中配置@ConfigurationProperties

配置文件application.properties中

mycar.brand=BYD
mycar.price=100000
//只有在容器中的组件,才会拥有SpringBoot提供的强大功能
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
	private String brand;
    private Integer price;
    ...
}
@RestController
public class HelloController {
 	@Autowired
    Car car;//根据类型属性注入
    
    @RequestMapping("/car")
    public Car car(){
        return car;
    }
}

方法二:

@EnableConfigurationProperties + @ConfigurationProperties

应用场景,引用第三方包中类没有配置@Component注解

  • 开启Car属性配置绑定功能

  • 把这个Car这个组件自动注册到容器中

@EnableConfigurationProperties(Car.class)
public class MyConfig {
...
}
@ConfigurationProperties(prefix = "mycar")
public class Car {
...
}

4. 自动装配原理入门

4.1 引导加载自动配置类

Spring Boot应用启动类:@SpringBootApplication= @SpringBootConfiguration + @EnableAutoConfiguration +@ComponentScan

@SpringBootConfiguration

@Configuration代表当前是一个配置类。

@ComponentScan

指定要扫描哪些包

@EnableAutoConfiguration
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    ...
}
  • @AutoConfigurationPackage自动包规则原理

自动配置包?指定了默认的包规则,即mainApplication所在包路径

@Import(AutoConfigurationPackages.Registrar.class)//给容器中导入一个组件
public @interface AutoConfigurationPackage {
    ...
}
  1. 利用Registrar给容器中批量导入一系列组件
  2. 将指定的一个包下的所有组件导入进MainApplication所在包下,解释了SpringBoot在mainApplication所在包下类中注解能被识别

在这里插入图片描述

  • @Import(AutoConfigurationImportSelector.class)初始加载自动配置类
  1. 利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
  2. 调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
  3. 利用工厂加载 Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader);得到所有的组件
  4. 从META-INF/spring.factories位置来加载一个文件。
    • 默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
    • spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories
# 文件里面写死了spring-boot一启动就要给容器中加载的所有配置类127个
# spring-boot-autoconfigure-2.3.4.RELEASE.jar/META-INF/spring.factories
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
...

4.2 按需开启自动配置项

虽然我们127个场景的所有自动配置类启动的时候默认全部加载,

但是xxxxAutoConfiguration 按照条件装配规则(@Conditional),最终会按需配置

如AopAutoConfiguration类:

@Configuration(
    proxyBeanMethods = false
)
@ConditionalOnProperty(
    prefix = "spring.aop",
    name = "auto",
    havingValue = "true",
    matchIfMissing = true
)
public class AopAutoConfiguration {
    public AopAutoConfiguration() {
    }
	...
}

4.3 定制化修改自动配置

以autoconfigure—web—servlet—DispatcherServletAutoConfiguration—multipartResolver为例

//文件上传解析器自动配置
@Bean
@ConditionalOnBean(MultipartResolver.class)  //容器中有这个类型组件
@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME) //容器中没有这个名字 multipartResolver 的组件
public MultipartResolver multipartResolver(MultipartResolver resolver) {
	//给@Bean标注的方法传入了对象参数,这个参数的值就会从容器中找。此时容器中有MultipartResolver但命名不规范。
	//SpringMVC中命名为multipartResolver。防止有些用户配置的文件上传解析器命名不符合规范。
	// Detect if the user has created a MultipartResolver but named it incorrectly
	return resolver;//给容器中加入了文件上传解析器;
}
  • SpringBoot默认会在底层配好所有的组件,但是如果用户自己配置了以用户的优先

以ChracterEncoding为例

在这里插入图片描述

4.4 总结自动装配流程

  • SpringBoot先加载所有的自动配置类 xxxAutoConfiguration
  • 每个自动配置类按照条件进行生效,默认都会绑定配置文件指定的值(xxxProperties里面读取,xxxProperties和配置文件进行了绑定)
  • 生效的配置类就会给容器中装配很多组件(@Bean)
  • 只要容器中有这些组件,相当于这些功能就有了
  • 定制化配置(以用户自己配置优先)
    • 用户直接自己==@Bean替换底层的组件==
    • 用户去看这个组件是获取的配置文件什么值就去application.properties修改配置文件

xxxAutoConfiguration加载自动配置类 —> 装配组件 —> xxxProperties里面拿值属性值 ----> application.properties自定义属性值

因此,修改配置文件即为修改整合场景的配置,配置文档或者查看底层源码

4.5 Springboot开发最佳实践

a> 应用如何编写
  • 引入场景依赖
  • 查看自动配置了哪些(选做)
    • 配置文件中debug=true开启自动配置报告,可以查看生效配置
      • Negative matches(不生效)
      • Positive matches(生效)
  • 是否需要修改配置,改变默认行为
    • 参照文档修改配置项
    • 自定义加入或者替换组件
      • @Bean、@Component…
    • 自定义器 XXXXXCustomizer
b> Lombok简化开发

Lombok用标签方式代替构造器、getter/setter、toString()等鸡肋代码。

  • 安装Lombok插件

  • spring boot已经管理Lombok,引入依赖:

<dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
</dependency>
  • 在实体类加上注解
@NoArgsConstructor
//@AllArgsConstructor
@Data
@ToString
@EqualsAndHashCode
public class User {

    private String name;
    private Integer age;

    private Pet pet;

    public User(String name,Integer age){
        this.name = name;
        this.age = age;
    }
}

  • 简化日志开发,可以相当于sout使用
@Slf4j
@RestController
public class HelloController {
    
    @RequestMapping("/Hello/{username}")
    public String HelloMapping(@PathVariable("username") String username){
        log.info("请求进来了");
        return "Hello, wz "+username;
    }
}
c> dev-tools

实现热部署,自动重启

  • 添加依赖:
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

在IDEA中,项目或者页面修改以后:Build project(Ctrl+F9)。

d> Spring Initailizr

Spring Initailizr是创建Spring Boot工程向导,搭建好基础架构

在IDEA中,菜单栏New -> Project -> Spring Initailizr

在这里插入图片描述

四、配置文件

1. properties

application.properties中写配置文件

2. yaml

一种标记语言,非常适合用来做以数据为中心的配置文件,替代xml

基本语法

  • key: value;kv之间有空格
  • 大小写敏感
  • 使用缩进表示层级关系
  • 缩进不允许使用tab,只允许空格
  • 缩进的空格数不重要,只要相同层级的元素左对齐即可
  • '#'表示注释
  • 字符串无需加引号,如果要加,单引号’'、双引号""表示字符串内容会被 转义、不转义

数据类型

  • 字面量:单个的、不可再分的值。date、boolean、string、number、null
k: v
  • 对象:键值对的集合。map、hash、object
#行内写法:类似于json

k: {k1: v1,k2: v2,k3: v3}

#或

k: 
  k1: v1
  k2: v2
  k3: v3
  • 数组:一组按次序排列的值。array、list、queue、set
#行内写法:类似于json

k: [v1,v2,v3]

#或者

k:
 - v1
 - v2
 - v3

实例

@Data
public class Person {
    private String userName;
    private Boolean boss;
    private Date birth;
    private Integer age;
    private Pet pet;
    private String[] interests;
    private List<String> animal;
    private Map<String, Object> score;
    private Set<Double> salarys;
    private Map<String, List<Pet>> allPets;
}

@Data
public class Pet {
    private String name;
    private Double weight;
}
  • 用yaml表示以上对象(properties>yml>yaml),配置一般是为了初始化使用的
person:
  username: fkd
  boss: true
  birth: 2022/4/21 21:55:00
  age: 23
  pet: {name: wz,weight: 23}
  interests: [篮球,足球]
  animal: [猫,够,兔子]
  score: {math: 80, English: 90}
  salaries: [32000,43000,31000]
  allPets: {sick: [{name: wz,weight: 20},{name: fkd,weight: 22}],healthy:[{name: sk,weight: 30}]}

3. 配置提示

自定义的类和配置文件绑定一般没有提示。若要提示,添加如下依赖:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>
SpringBoot --- 基础篇 一、快速上手SpringBoot 1.1、概述 SpringBoot开发团队认为原始的Spring程序初始搭建的时候可能有些繁琐,这个过程是可以简化的,那原始的Spring程序初始搭建过程都包含哪些东西了呢?为什么觉得繁琐呢?最基本的Spring程序至少有一个配置文件或配置类,用来描述Spring的配置信息,此外现在企业级开发使用Spring大部分情况下是做web开发,如果做web开发的话,还要在加载web环境时加载时加载指定的spring配置,这都是最基本的需求了。 SpringBoot开发团队认为原始的 阅读详情

相关推荐

Chromatix 7实战:从零开始调优ISP模块的完整流程(附常见报错解决方案)

本文提供了高通平台Camera调试工具Chromatix 7的完整实战指南。详细阐述了从环境准备、项目初始化、基础校正(如LSC、BPC)到核心ISP管线(Demosaic、CCM、HDR)及后处理(CAC、ANR)的调优全流程,并附带了常见报错(如“未初始化实例”)的解决方案,旨在帮助工程师建立系统性的调试方法论。

weixin_29290863的博客 630

springboot基础篇(快速入门+要点总结)

本文详细的介绍了springboot的来源以及和spring的关系,和为什么使用springboot,然后介绍了两种搭建springboot项目的方法,以及热部署,properties配置文件的使用,在最后对于日志做出了详细的说明和用法。

zhaolk的博客 6万+

C# 读取图片和扫描PDF中的文本

本博客将探讨如何使用C#和OCR库实现从图片和扫描的 PDF 中提取文本。Spire.OCR for .NET 是一个OCR文字识别库,专为在 .NET 应用程序中识别图片的文本而设计。首先,使用 Spire.PDF 将扫描的 PDF 转换为图片,然后利用 Spire.OCR 从这些图片中提取文本。由于该OCR库并不支持直接处理PDF,因此要从扫描的 PDF 中提取文本,我们首先需要将 PDF 文档转换为图片。转换完成后,再利用 Spire.OCR 从生成的图片中提取文本。方法来识别图片中的文本。

nuclear2011的博客 5405

01-SpringBoot技术快速入门

文章目录简介背景分析解决什么问题有哪些核心特性SpringBoot 项目创建及运行创建项目启动运行项目启动过程概要分析SpringBoot 快速入门实践业务描述API设计分析Bean对象定义及获取运行过程中的BUG分析SpringBoot中的对象特性分析准备工作对象延迟加载对象作用域分析对象生命周期方法SpringBoot 工程依赖注入分析准备工作案例设计及分析代码编写及测试分析测试过程中的BUG分析总结(Summary) 简介 背景分析 JAVAEE应用体系中繁重的配置、低下的开发效率、高难度的三方集成,

雨田说码 6509

华为AC外置Portal认证方案配置步骤指南

华为AC外置Portal认证方案配置步骤指南

m0_46129105的博客 7700

2024阅读AOSP源码的正确打开姿势

在Android系统开发中,阅读AOSP(Android Open Source Project)源码是非常重要的环节。然而,如何构建一个优雅的阅读环境却是一个不容忽视的问题。本文将介绍不同工具和方法下阅读AOSP源码的正确姿势,并对比其优缺点。

虎哥LoveDroid 2714

SpringBoot-基础篇

SpringBoot-基础篇 学习目标 章节 学习目标 基础篇 能够创建SpringBoot工程 基于SpringBoot实现ssm/ssmp整合 前置知识 章节 前置知识 要求 基础篇 Java基础语法 面向对象,封装,继承,多态,类与接口,集合,IO,网络编程等 基础篇 Spring与SpringMVC 知道Spring是用来管理bean,能够基于Restful实现页面请求交互功能 基础篇 Mybatis与Mybatis-Plus 基于Mybatis和

yiwanbin 3064

第二节:Vben Admin 最新 v5.0 (vben5) + Python Flask 快速入门 - Python Flask 后端开发详解(附源码)

大家好,我是cuiwin!本节内容,我们从零开始开发基于Python(Flask)的后端项目,对接Vue Vben Admin(vben5)。登录mysql数据库执行: 创建数据库。

cuiwin的专栏 2271

SpringBoot学习指南:从入门到精通,全网最详尽的SpringBoot学习指南(基础篇)

​ 入门案例做完了,这个时候回忆一下咱们之前说的SpringBoot的功能是什么还记得吗?加速Spring程序的开发,现在是否深有体会?再来看SpringBoot技术的设计初衷就很容易理解了。​ SpringBoot是由Pivotal团队提供的全新框架,其设计目的是用来简化Spring应用的初始搭建以及开发过程。​ 都简化了了哪些东西呢?Spring程序缺点依赖设置繁琐。

weixin_69912448的博客 4802

Adams Car——Adams car与Simulink联合仿真

Adams与simulink悬架联合仿真

Mr.邹的博客 2127

PCL 均匀采样【2026最新版】

根据输入点云数据创建一个微小的三维立方体集合,然后计算每个三维立方体的重心;由于该重心点不一定是原始点云中的点,直接用该点来表示立方体内所有的点会丢失原始点云的细小特征;所以使用k最近邻搜索寻找距离重心点最近的原始点来代替重心点。

点云侠的博客 41万+

SpringBoot基础入门 01

一、SpringBoot基础 1.1 原有Spring优缺点分析 1.1.1 Spring的优点分析 Spring是Java企业版(Java Enterprise Edition,JEE,也称J2EE)的轻量级代替品。无需开发重量级的Enterprise JavaBean(EJB),Spring为企业级Java开发提供了一种相对简单的方法,通过依赖注入和面向切面编程,用简单的Java对象(Plain Old Java Object,POJO)实现了EJB的功能。 1.1.2 Spring的缺点分析 虽然S

z398514470的博客 154

电容放电测试解析

电子设备断电后滤波电容残留电荷存在触电风险,需符合IEC等安全标准对放电时间的要求。放电测试需测量电容电压下降至安全值的时间,设计可采用主动放电电路或被动放电电阻。常见问题包括电阻选择不当或电路设计缺陷,建议预留放电时间裕度并采用组合放电方案。合规的放电设计是确保产品安全性和可靠性的关键环节。

硬核科技 806

从头开始学SpringBoot—01入门&基础配置

SpringBoot系列01部分——从0创建boot工程和基础配置的使用

青春无问西东 岁月自成芳华 1012

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

SpringBoot——基础入门

一、SpringBoot2核心技术-基础入门 二、SpringBoot2入门 异常:This application has no explicit mapping for /error, so you are seeing this as a fallback. 三、了解自动配置原理 4、开发小技巧 1、Lombok 2、dev-tools 3、Spring Initailizr(项目初始化向导)

ouyangkq666的博客 831

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

SpringBoot基础入门篇

SpringBoot快速入门

qq_53263107的博客 1981

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

SpringBoot基础入门

Spring Boot扫盲,是使用者对其有一个十分简单的认知

weixin_42509509的博客 451

【SpringBoot】SpringBoot2核心技术-基础入门

一、参考资料 第一季:SpringBoot2核心技术-基础入门

后端研发工程师Marion的博客 250

SpringBoot基础入门【小妙招】

SpringBoot基础入门及整合MyBatis、PageHelper等

weixin_45565886的博客 293

第一章 SpringBoot基础入门笔记

一、SpringBoot简介 1、SpringBoot基础介绍 Spring Boot使开发独立的,产品级别的基于Spring的应用变得非常简单,你只需"just run"。我们为Spring平台及第三方库提供开箱即用的设置,这样你就可以有条不紊地开始。多数Spring Boot应用需要很少的Spring配置。你可以使用Spring Boot创建Java应用,并使用java -jar启动它...

hankin的博客 734

SpringBoot入门基础知识

SpringBoot对Spring的缺点进行的改善和优化,基于约定优于配置的思想,可以让开发人员不必在配置与逻辑业务之间进行思维的切换,全身心的投入到逻辑业务的代码编写中,从而大大提高了开发的效率,一定程度上缩短了项目周期。

奋斗的青春 1952

SpringBoot 入门基础

简化Spring应用开发的框架:Spring Boot是一个用于简化Spring应用开发的框架,它提供了快速构建、开箱即用的特性,使得开发人员可以更快速地搭建和部署应用程序。整个Spring技术栈的一个大整合:Spring Boot整合了Spring各项功能,提供了默认配置,使得开发者无需定义样板化的配置,简化了Spring应用的初始搭建以及开发过程。J2EE开发的一站式解决方案。

m0_74977981的博客 1306

SpringBoot2基础入门

SpringBoot2基础入门

QiuYuSy的博客 528

boot入门思想 spring_SpringBoot基础入门

一个微服务应该都是单一职责的,这才是“微”的体现,一个微服务解决一个业务问题(注意是一个业务问题而不是一个接口)。将自己的业务能力封装并对外提供服务,这是继承SOA的核心思想,一个微服务本身也可能使用到其它微服务的能力。在微服务架构之前还有一个概念:SOA(Service-Oriented Architecture)-面向服务的体系架构,学过SOA的人都知道这个这里就不做介绍了一:SpringBo...

weixin_39731586的博客 86

一、SpringBoot基础入门

SpringBoot基础入门一、SpringBoot基础入门1、SpringBoot 入门1)、系统要求1.1 Maven设置2)、HelloWord2.1、创建maven工程2.2、引入依赖2.3、创建主程序2.4 、编写业务逻辑2.5、测试2.6、简化配置2.7、简化部署2、SpringBoot自动配置原理1)、SpringBoot的特点1.1、依赖管理1.2、自动配置2)、容器功能2.1、组件添加2.2、原生配置文件引入2.3、配置绑定(例:绑定properties配置文件与JavaBean对象属性)

Welcome,Everyone. 183
上一篇: MyBatis笔记
下一篇: Springboot——Web开发
Curry_Java
博客等级 码龄5年 20粉丝 16原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值