SpringBoot入门基础
Posted Aaron
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了SpringBoot入门基础相关的知识，希望对你有一定的参考价值。
目录
SpringBoot入门 (一) HelloWorld. 2
一 什么是springboot 1
二 入门实例... 1
一 自定义属性... 15
二 自定义属性配置文件... 18
日志格式及内容... 21
日志输出... 22
输出文件... 22
集成log4j 23
SpringBoot入门 (四) 数据库访问之JdbcTemplate. 29
一 JDBC回顾... 28
二 JdbcTemplate使用示例... 29
三 测试，使用Junit Test 34
四 连接池配置... 36
SpringBoot入门 (五) 数据库访问之spring data jpa. 39
一 什么是Spring Data JPA.. 38
二 简单示例... 38
三 测试... 42
SpringBoot入门 (六) 数据库访问之Mybatis. 46
一 什么是Mybatis. 46
二 SpringBoot集成Mybatis. 47
三 测试... 51
SpringBoot入门 (七) Redis访问操作... 53
一 什么是Redis. 53
二 SpringBoot集成Redis. 54
三 测试... 55
SpringBoot入门 (八) Cache使用... 60
一 为什么要使用缓存... 59
二 使用Cache. 60
1 @Cacheable. 61
2 @CachePut 62
3 CacheEvict 63
一 什么是MQ.. 64
二 SpringBoot集成Active MQ.. 65
一 邮件发送过程... 72
二 发送邮件示例... 73
一 什么是数据校验... 80
二 使用示例... 82
一 SpringBoot 提供的定时任务... 87
二 SpringBoot集成Quartz. 90
SpringBoot入门 (一) HelloWorld
一 什么是springboot
springboot是一个全新的框架，它设计的目的简化spring项目的初始环境的搭建和开发，主要有以下几个特点：
1、简化初始配置 ，可与主流框架集成；
2、内置Servlet容器，无需在打War包；
3、使用了Starter（启动器）管理依赖并版本控制；
4、大量的自动配置，简化开发，方便集成第三方；
5、提供准生产环境运行时的监控，如指标，健康，外部配置等；
6、无需XML配置，减少冗余代码 。
未使用springboot时，如果我们要搭建一个springweb项目环境，我们需要配置web.xml及各种xml的配置文件来集成其他第三方的框架，而这些springboot已经帮我们做了集成，我们不再需要去配置。
二 入门实例
创建springboot项目有2中方式，1种是通过ide来创建，一种是官方网站创建(https://start.spring.io创建完成后会将工程下载到本地)然后导入ide即可，本文我们通过idea创建项目。
1 在idea的工具栏 file-->new project 如下图
会弹出选择工程类型的框，如下图
这个时候我们有2种选择，一种是使用Spring Initializr创建，一种是使用Maven或者Gradle创建。这两种方式的不同的地方是使用方法二创建的是空项目，我们需要自己去修改添加所需要的依赖，方式一在创建的过程中，我们可以在ide中直接选择需要的依赖且会生成一个项目的根启动类。本文我们使用Spring Initializr来创建项目。点击上图的Next
输入Group、Artifact、Package的对应的信息，再点击next
这是我们可以选择我们的项目要运行的springboot的版本和需要的依赖包(本文我们只选择依赖web)，然后点击Next
这是弹框会显示我们项目的名称及项目的路径，点击Finish。初始时会下载springboot默认依赖的一些jar包，需要一会时间，我们等待它下载完成。之后我们可以看到项目的结构
pom.xml内容如下，2.0.8版本不是一个发布版本，在我们的实际项目中，最好还是要引用release版本的。
<?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>
<groupId>org.allen.demo</groupId>
<artifactId>springboot-helloworld</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>springboot-helloworld</name>
<description>Demo project for Spring Boot</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.8</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
生成的启动类，一个可执行的main方法。
package org.wl.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class HelloWorldApplication {
public static void main(String[] args) {
SpringApplication.run(HelloWorldApplication.class, args);
}
}
默认在类上边使用了@SpringBootApplication注解，这个注解是一个符合注解，相当于同时使用
@SpringBootConfiguration 指定类为配置类
@EnableAutoConfiguration 开启自动配置
@ComponentScan 指定扫描路径
下来创建一个可以访问的控制器，使用@RestController注解，它是一个复合注解，相当于同时使用了@Controller和@ResponseBody注解
package org.wl.demo.web;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@RequestMapping("/hello")
public String hello(){
return "hello world";
}
}
执行main方法，启动项目，在控台可可以看到启动的日志信息
[ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8080 (http) with context path \'\'
[ main] org.wl.demo.HelloWorldApplication : Started HelloWorldApplication in 3.591 seconds (JVM running for 4.784)
内嵌的tomcat服务器已经启动，启动端口是8080，更路径是\'\'，我们访问控制器的hello方法
这样一个web项目环境就搭建成功了，使用起来还是很简单方便的。
在上边的日志信息中，默认启动端口是8080，访问根路径是‘’，如果我们希望修改的话也是可以的，只需要在application.properties中修改
修改端口，从默认的8080修改为8090
server.port=8090
修改根路径 修改前是‘’，修改后为‘/helloworld’
server.servlet.context-path=/helloWorld
SpringBoot入门 (二) 属性文件读取
在上一篇中介绍了在idea中创建springboot工程及使用web工程输出“helloworld”到前端页面，本文学习在springboot工程中读取属性文件中的属性值。
一 自定义属性
在application.properties文件中添加属性配置项
myapp.name=helloworld
可以使用@Value 注解来读取，在之前的helloworld工程的控制器中添加属性并读取，如下
@RestController
public class HelloController {
@Value("${myapp.name}")
private String name;
@RequestMapping("/hello")
public String hello(){
System.out.println("myapp name :" + name);
return "helloworld";
}
}
@Value 注解会去application.properties文件中配置属性为myapp.name的属性，并将值赋值给name属性。访问hello方法，可以看到控制台上打印出来的信息
自定义的属性比较少时使用@Value读取还是比较方便的，如果我们的属性比较多的时候，比如我们要读取数据库连接池配置的很多的属性值，再这样读取的话，就显得不是很美观了。这种情况我们一般定义一个对象，把属性字段作为对象的属性来接收，在属性文件中在增加一个属性
myapp.age=2
我们定义一个对象MyAppProperties来接收属性值
@Component
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
private String name;
private int age;
@Override
public String toString() {
return "MyAppProperties{" +
"name=\'" + name + \'\\\'\' +
", age=" + age +
\'}\';
}
//省略getter和setter方法
}
@Component 表示指定当前类为实例，以便可以在spring中使用
@ConfigurationProperties(prefix = "myapp") 表示把application中的myapp开头的属性自动赋值给当前对象的属性，比如把myapp.name的值赋值给name属性，访问hello方法可以看到。
二 自定义属性配置文件
有的时候，我们需要把自己的属性配置信息写在自己的配置文件中，以便和系统的application.properties分开，我们可以在resources目录下新建自己的属性文件my.properties,并添加属性
my.name=helloworld2
my.age=22
定义读取属性的对象类，使用 @PropertySource("classpath:my.properties") 来指定我们当前类要读取的属性文件
@Component
@PropertySource("classpath:my.properties")
@ConfigurationProperties(prefix = "my")
public class MyAppProperties2 {
private String name;
private int age;
@Override
public String toString() {
return "MyAppProperties2{" +
"name=\'" + name + \'\\\'\' +
", age=" + age +
\'}\';
}
// 省略getter和setter方法
}
修改控制器hello方法测试
@RestController
public class HelloController {
@Resource
private MyAppProperties myAppProperties;
@Resource
private MyAppProperties2 myAppProperties2;
@RequestMapping("/hello")
public String hello(){
System.out.println(myAppProperties.toString());
System.out.println(myAppProperties2.toString());
return "helloworld";
}
}
访问hello方法，可以看到控制台输出的打印信息
SpringBoot入门 (三) 日志配置
上一篇博文记录了再springboot项目中读取属性文件中配置的属性，本文学习在springboot项目中记录日志。
日志记录在项目中是很常见的一个功能了，对排查问题有很大帮助，也可以做分类分析及统计。SpringBoot内部使用的是Commons Logging做日志的记录，但是对其他的日志框架也提供了默认的配置，如：Java util Logging，Log4j2，Logback，每一种情况下日志记录器都预先配置为使用控制台输出和可选的文件输出。
日志格式及内容
如果我们的SpringBoot项目使用的是Starters启动器，默认使用LogBack做日志记录。如我们启动项目时在控制台上看到的
输出的信息有以下几点
日期和时间：精确到毫秒，如 2019-01-24 14:03:14.260
日志级别：日志级别有ERROR,WARN,INFO,DEBUG,TRACE，如上边的INFO
进程号：如上边的 10348
分割线：如上边的 ---
线程名：如上边用[]括起来的
日志名：一般使用的是代码的类名
日志信息：我们在代码中要输出的内容
日志输出
Spring Boot中默认配置了ERROR、WARN和INFO级别的日志输出到控制台，我们也是可以修改的日志级别的，比如我们修改为debug级别，有两种方式
1 使用命令 $ java -jar myapp.jar --debug
2 在application.properties中添加配置debug=true 开启debug，此配置只会对核心Logger（如内嵌的tomcat容器、hibernate、spring）有效，但是我们自己应用的日志并不会输出为DEBUG级别，需要自己配置，如 logger.level.root=debug
日志级别
可以通过logger.level.*=LEVEL来改变对应日志级别，如
|
1 2 3 4 5 6 7 8 |
logging.level.root=warn logging.level.org.springframework.web=info logging.level.org.hibernate=error
######修改mubatis日志级别 logging.level.org.mybatis=info #mapper接口为debug级别 logging.level.mybatis mapper接口所在包=debug |
输出文件
SpringBoot默认只在控制台输出日志信息，如果想把日志信息写入文件中记录，需要在application.properties中配置，如
|
1 2 3 4 5 6 7 8 |
##文件存放路径 logging.path=/usr/local/log ##写入的文件 logging.file=myapp.log ##日志文件大小，超过大小时会在新的文件中记录 logging.file.max-size=10Mb ##日志保存时间 天 logging.file.max-history=15 |
集成log4j
SpringBoot在高版本中已经不支持log4j了，支持的是log4j2。在pom.xml中引入需要的log4j2的jar包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>
由于web依赖包中已经有了log的依赖，所以我们选去掉web中的log依赖，避免jar包冲突。
然后配置log4j2的属性，在官方文档中可以看到集成的日志文件的命名如下
在resources目录下创建一个log4j2-spring.xml文件
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<properties>
<!-- 文件输出格式 -->
<property name="PATTERN">%d{yyyy-MM-dd HH:mm:ss,SSS} |-%-5level [%thread] %c [%L] -| %msg%n</property>
</properties>
<appenders>
<!--添加一个控制台追加器-->
<Console name="Console" target="system_out">
<PatternLayout pattern="${PATTERN}" />
</Console>
<!--添加一个文本追加器，文件位于E:\\\\logs目录下，名为HelloWorld.log-->
<File name="File" fileName="E:\\\\logs\\\\HelloWorld.log">
<PatternLayout>
<pattern>${PATTERN}</pattern>
</PatternLayout>
<Policies>
<SizeBasedTriggeringPolicy size="10 MB" />
</Policies>
</File>
</appenders>
<loggers>
<root level="info">
<appenderref
ref="File" />
<!--为了直观，在控制天中也输出info级别的日志-->
<appenderref ref="Console" />
</root>
<!--把org.springframework包下的所有日志输出到log文件，additivity="false"表示不输出到控制台-->
<Logger name="org.springframework" level="debug" additivity="true">
<appenderRef ref="File" />
</Logger>
</loggers>
</configuration>
正式项目中，我们需要对上述xml文件中的配置信息做些修改。写一个控制器访问，看看输出的信息
@RestController
public class HelloController {
private static final Logger logger = LoggerFactory.getLogger(HelloController.class);
@RequestMapping("/hello")
public String hello(){
logger.info("使用log4j输出日志！");
return "helloworld";
}
}
控制台和生成的log文件中输出的信息一致
SpringBoot入门 (四) 数据库访问之JdbcTemplate
一 JDBC回顾
最早是在上学时接触的使用JDBC访问数据库，主要有以下几个步骤：
1 加载驱动 Class.forName(Driver)
2 获取数据库连接 conn = DriverManager.getConnection(url, user,password)
3 创建一个statement对象来访问操作数据库 statement = conn.createStatement();
4 执行SQL，访问操作数据库 rs = statement.execute(sql)
5 得到结果集，业务处理
6 关闭连接，释放资源 statement.close(); conn.close();
使用jdbc访问并操作数据库时比较麻烦，后来也做了一定的封装，主要是对statement的创建前和sql执行后进行的封装。
二 JdbcTemplate使用示例
目前我们使用的主流的开源的数据库访问框架主要有Hibernate，Mybatis，SpringJdbc。SpringJdbc时spring对JDBC封装后的一个ORM框架，JdbcTemplate就是SpringJdbc对外提供的一个访问数据库的接口类，我们通过它可以很容易的实现数据库的访问操作。但是需要我们自己根据业务手写相关的SQl，然后执行。
在spring boot项目中引入依赖，本文练习中使用的时mysql数据库
|
1 2 3 4 5 6 7 8 9 |
|
|
|
|
在application.properties中配置数据库连接相关信息
|
1 2 3 4 5 6 7 8 9 |
|
完成以上配后，在启动springboot项目时，会自动把数据源信息注入到JdbcTemplate中，我们只需要在使用的地方注入JdbcTemplate就可以了
定义要操作数据库的相关方法接口
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
|
|
1 |
|
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
以上是关于SpringBoot入门基础的主要内容，如果未能解决你的问题，请参考以下文章 小D课堂 - 零基础入门SpringBoot2.X到实战_汇总 2021版SpringBoot2零基础入门SpringBoot全套完整版 |