浅谈下SpringBoot框架基本应用做个入门级讲讲
1.SpringBoot简介
1.1 原有Spring优缺点分析
1.1.1 Spring的优点分析
Spring是Java企业版(Java Enterprise Edition,javeEE)的轻量级代替品。无需开发重量级的Enterprise JavaBean(EJB),Spring为企业级Java开发提供了一种相对简单的方法,通过依赖注入和面向切面编程,用简单的Java对象(Plain Old Java Object,POJO)实现了EJB的功能。
1.1.2 Spring的缺点分析
虽然Spring的组件代码是轻量级的,但它的配置却是重量级的。
不论是一开始的基于XML的配置,还是Spring2.5引入的基于注解的组件扫描,还是Spring 3.0引入的基于Java的配置,这些都代表了开发时的额外损耗。
因为在思考Spring配置和解决业务问题之间需要进行思维切换,甚至还带来了何种方式配置更好的无谓争论,所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样,Spring实用,但与此同时它要求的回报也不少。
除此之外,项目的依赖管理也是一件耗时耗力的事情。在环境搭建时,需要分析要导入哪些库的坐标,而且还需要分析导入与之有依赖关系的其他库的坐标,一旦选错了依赖的版本,随之而来的不兼容问题就会严重阻碍项目的开发进度。
1.2 SpringBoot的概述
SpringBoot对上述Spring的缺点进行的改善和优化,基于约定优于配置的思想,可以让开发人员不必在配置与逻辑业务之间进行思维的切换,全身心的投入到逻辑业务的代码编写中,从而大大提高了开发的效率,一定程度上缩短了项目周期。
1.2.1 SpringBoot的特点
- SpringBoot不是对Spring功能上的增强,而是提供了一种快速构建Spring的方式
- 开箱即用,没有代码生成,也无需XML配置。同时也可以修改默认值来满足特定的需求
- 提供了一些大型项目中常见的非功能性特性,如嵌入式服务器(嵌入Tomcat,无需部署WAR文件)、安全、指标,健康检测、外部配置等
1.2.2 SpringBoot的核心功能
- 起步依赖
起步依赖本质上是一个Maven项目对象模型(Project Object Model,POM),定义了对其他库的传递依赖,这些东西加在一起即支持某项功能。
简单的说,起步依赖就是将具备某种功能的坐标打包到一起,并提供一些默认的功能。 - 自动配置
Spring Boot的自动配置是一个运行时(更准确地说,是应用程序启动时)的过程,考虑了众多因素,才决定Spring配置应该用哪个,不该用哪个。该过程是Spring自动完成的。
后面会详细说明起步依赖与自动配置的原理解析。
2.SpringBoot实例
2.1.创建SpringBoot简单实例
下面使用Maven创建一个基于SpringBoot的Web工程的简单实例。
2.1.1.创建工程
111注意:虽然是创建Web工程,但由于SpringBoot内嵌了Tomcat,所以这里选择jar包形式的工程。
2.1.2.添加依赖
在pom.xml文件中添加SpringBoot的相关依赖
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.neusoft</groupId>
<artifactId>boot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!--
继承Spring Boot父级依赖,也就是:spring-boot-dependencies。
父级依赖管理了Spring Boot项目中的所有依赖版本,以后导入依赖默认不需要写版本号了。
(当前没有在dependencies里面管理的依赖自然需要声明版本号)
-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.3.RELEASE</version>
</parent>
<dependencies>
<!--
spring-boot-starter是Spring Boot的核心启动器。
只要引入官方提供的starter,就可以将此模块中的相关jar都导入进来。
官方的starter命名规范是:spring-boot-starter-模块名
所以,下面配置会将web开发相关jar都导入进来,并自动管理版本信息。
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>
2.1.3.添加工程主启动类
在类路径下创建HelloApplication.java文件
package com.neusoft.boot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class HelloApplication {
public static void main(String[] args) {
SpringApplication.run(HelloApplication.class, args);
}
}
注意:
- @SpringBootApplication注解指定该类为SpringBoot的程序入口类。
- SpringBoot项目的Bean默认装配规则是:根据入口类所在包位置从上往下扫描。
例如:如果DemoApplication类所在的包为:com.neusoft.demo;那么就会自动扫描com.neusoft.demo 包及其所有子包,否则不会被扫描!
所以,应将SpringBoot的程序入口类放到mapper、service所在包的上级。
- SpringApplication类中的run方法会对当前SpringBoot工程进程初始化创建。
2.1.4.创建Controller
在 HelloApplication.java 所在包下创建controller包,然后创建Controller。
package com.neusoft.boot.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloController {
@RequestMapping("/hello")
public String say(){ //可以直接返回对象或集合,客户端将接收到json数据
return "hello...";
}
}
@RestController 注解标识当前类为Controller组件,并且直接响应json数据。
2.1.5.测试
执行HelloApplication类的入口方法,SpringApplication类中的run方法就会启动当前的SpringBoot工程。
Tomcat started on port(s): 8080 (http) with context path ''
Started DemoApplication in 4.292 seconds (JVM running for 5.15)
当控制台输出上述内容时,表示SpringBoot工程启动成功。 在地址栏中输入url进行访问测试:
111注意:SpringBoot内嵌了Tomcat,所以只需要运行SpringBoot工程的主启动类即可。
2.1.6.工程目录结构
1112.2.使用Spring Initializr创建工程
上面案例中,我们自己手动搭建了一个SpringBoot框架。实际上,为了实现快速开发,SpringBoot官方给我们提供了一个初始化器,可以引导我们快速构建一个SpringBoot工程。
2.2.1.使用官方工具生成工程
打开 SpringBoot 官网:https://spring.io/projects/spring-boot/; 在网站的下部有 Spring Initializr 的链接。
111点击此链接,进入到工程引导页面:
111注意:
- 引导页面的左部,设置工程属性及版本信息等内容。右部设置工程所添加的依赖jar包。
- Packaging 处选择 Jar 形式。(因为SpringBoot 内置服务器,不需要打成 war 包)
- 因为我们想要创建web工程,所以添加 Spring Web 依赖模块。
- 最后,点击 “GENERATE” 按钮,生成整个工程。
2.2.2.工程目录结构
先使用IDE导入工程(这里使用STS导入此Maven工程)。
111注意: mvnw是一个maven wrapper script(Maven包装脚本),它可以让你在没有安装maven或者maven版本不兼容的条件下运行maven的命令。
2.2.3.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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<!-- pom模型版本 -->
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.3.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<!-- 项目信息 -->
<groupId>com.neusoft</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>demo</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
<!-- 配置工程字符编码集 -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</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>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<!-- 配置SpringBoot的Maven插件 -->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
2.2.4.工程主启动类
package com.neusoft.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
2.2.5.创建Controller
在 DemoApplication.java 所在包下创建controller包,然后创建Controller。
package com.neusoft.demo.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
@RequestMapping("/hello")
public String say() {
return "hello...";
}
}
2.2.6.测试
执行 DemoApplication类的入口方法,然后在地址栏中输入url进行访问测试。
2.3.使用STS创建工程
2.3.1.创建Spring Starter Project工程
11112.3.2.添加工程信息
111注意:这里添加Maven工程需要的一些信息
2.3.3.添加版本及依赖信息
111注意:这里添加SpringBoot版本信息、添加的依赖信息。然后点击 “Finish” 。
2.3.4.生成SpringBoot工程
工程创建完成后,我们会发现:创建的工程与使用 Spring Initializr 创建的工程是完全一样的。
2.4.SpringBoot热部署
我们在开发中反复修改类、页面等资源,每次修改后都是需要重新启动才生效,这样每次启动都很麻烦,浪费了大量的时间,我们可以在修改代码后不重启就能生效,在 pom.xml 中添加如下配置就可以实现这样的功能,我们称之为热部署。
<!--热部署配置-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
2.5.SpringBoot的跨域处理
除了使用传统的过滤器来设置跨域处理配置之外,SpringBoot还给我们提供了两种跨域处理方式:
- 使用 @CrossOrigin 注解配置某一个 Controller 允许跨域。
//只要在此Controller上使用@CrossOrigin注解就可实现跨域访问,并可配置允许跨域的url
@CrossOrigin("*")
@RestController
public class DeptController { //... }
- 实现 WebMvcConfigurer 接口中的 addCorsMappings 方法,在此方法中配置全局跨域处理。
在工程中添加 WebMvcConfig 类。此类配置了 @Configuration 注解,就成为一个 Spring 容器类,工程启动时会自动加载此类中的配置。
package com.neusoft.demo;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
/*
* addMapping:配置可以被跨域的路径,可以任意配置,可以具体到直接请求路径。
* allowCredentials:是否开启Cookie
* allowedMethods:允许的请求方式,如:POST、GET、PUT、DELETE等。
* allowedOrigins:允许访问的url,可以固定单条或者多条内容
* allowedHeaders:允许的请求header,可以自定义设置任意请求头信息。
* maxAge:配置预检请求的有效时间
*/
registry.addMapping("/**")
.allowedOrigins("*")
.allowCredentials(true)
.allowedMethods("*")
.allowedHeaders("*")
.maxAge(36000);
}
}
2.6.@RequestBody实现参数序列化
前端使用 AJAX 的 post 方式请求时,需要对请求参数做序列化处理,否则 SpringMVC 无法接收提交参数。
//使用qs模块中的stringify方法实现post提交时的参数序列化
this.$axios.post('http://localhost:8080/hello', this.$qs.stringify(user))...
在 SpringBoot 中,可以使用 @RequestBody 注解,在服务器端实现 post 提交时的参数序列化处理。这样,前端的 post 请求就可以直接提交 json 对象了。
@RequestMapping("/hello")
//在参数前使用@RequestBody注解
public String say(@RequestBody User user) {
System.out.println(user);
return "hello...";
}
let user = {
userId: 1,
userName: 'zhangsan',
password: '123'
};
axios.post('http://localhost:8080/elm/hello',user)
.then(response => {
console.log(response.data);
}).catch(error => {
console.log(error);
});
@RequestBody 注解很强大,它甚至于可以直接接收 json 数组。
@RequestMapping("/hello")
//使用集合接收json数组
public String say(@RequestBody List<User> list) {
for(User user : list) {
System.out.println(user);
}
return "hello...";
}
let userArr = [{
userId: 1,
userName: '张三',
password: '123'
}, {
userId: 2,
userName: '李四',
password: '888'
}, {
userId: 3,
userName: '王五',
password: '999'
}]
axios.post('http://localhost:8080/elm/hello', userArr)
.then(response => {
console.log(response.data);
}).catch(error => {
console.log(error);
});
注意:@RequestBody 注解不支持get方式请求
3.SpringBoot原理分析
3.1.起步依赖原理解析
3.1.1.分析spring-boot-starter-parent
按住Ctrl键,然后点击pom.xml中的spring-boot-starter-parent,跳转到了spring-boot-starter-parent的pom.xml,xml配置如下(只摘抄了部分重点配置):
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.3.3.RELEASE</version>
<relativePath>../../spring-boot-dependencies</relativePath>
</parent>
按住Ctrll键,然后点击pom.xml中的spring-boot-starter-dependencies,跳转到了spring-boot-starter-dependencies的pom.xml,xml配置如下(只摘抄了部分重点配置):
<properties>
<activemq.version>5.15.3</activemq.version>
<antlr2.version>2.7.7</antlr2.version>
<appengine-sdk.version>1.9.63</appengine-sdk.version>
<artemis.version>2.4.0</artemis.version>
<aspectj.version>1.8.13</aspectj.version>
<assertj.version>3.9.1</assertj.version>
<atomikos.version>4.0.6</atomikos.version>
<bitronix.version>2.1.4</bitronix.version>
<build-helper-maven-plugin.version>3.0.0</build-helper-maven-plugin.version>
<byte-buddy.version>1.7.11</byte-buddy.version>
... ... ...
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot</artifactId>
<version>2.3.1.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-test</artifactId>
<version>2.3.3.RELEASE</version>
</dependency>
... ... ...
</dependencies>
</dependencyManagement>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.jetbrains.kotlin</groupId>
<artifactId>kotlin-maven-plugin</artifactId>
<version>${kotlin.version}</version>
</plugin>
<plugin>
<groupId>org.jooq</groupId>
<artifactId>jooq-codegen-maven</artifactId>
<version>${jooq.version}</version>
</plugin>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>2.3.3.RELEASE</version>
</plugin>
... ... ...
</plugins>
</pluginManagement>
</build>
从上面的spring-boot-starter-dependencies的pom.xml中我们可以发现,一部分坐标的版本、> > 依赖管理、插件管理已经定义好,所以我们的SpringBoot工程继承spring-boot-starter-parent后> > 已经具备版本锁定等配置了。所以起步依赖的作用就是进行依赖的传递。
3.1.2.分析spring-boot-starter-web
按住Ctrll键,然后点击pom.xml中的spring-boot-starter-web,跳转到了spring-boot-starter-web的pom.xml,xml配置如下(只摘抄了部分重点配置):
<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starters</artifactId>
<version>2.3.3.RELEASE</version>
</parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.3.3.RELEASE</version>
<name>Spring Boot Web Starter</name>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.3.3.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
<version>2.3.3.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<version>2.3.3.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.hibernate.validator</groupId>
<artifactId>hibernate-validator</artifactId>
<version>6.0.9.Final</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.2.8.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.8.RELEASE</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>
从上面的spring-boot-starter-web的pom.xml中我们可以发现,spring-boot-starter-web就是将> web开发要使用的spring-web、spring-webmvc等坐标进行了“打包”,这样我们的工程只要引入spring-boot-starter-web起步依赖的坐标就可以进行web开发了,同样体现了依赖传递的作用。
3.2.自动配置原理解析
按住Ctrll键,然后点击查看启动类DemoApplication上的注解@SpringBootApplication
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
注解@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 { //... }
@SpringBootConfiguration:等同与@Configuration,既标注该类是Spring的一个配置类@EnableAutoConfiguration:SpringBoot自动配置功能开启 @ComponentScan:定义扫描路径,从中找出标识了需要装配的类,并自动装配到spring容器中
3.3.处理器配置原理解析
按住Ctrll键,然后点击查看处理器类 UserController上的注解@RestController
@RestController
public class UserController { }
注解@RestController的源码
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController { //... }
可以看到:@RestController注解就相当于:@Controller+@ResponseBody
4.SpringBoot工程配置文件
SpringBoot是基于约定的,所以很多配置都有默认值,但如果想使用自己的配置替换默认配置的话,就可以使用SpringBoot配置文件进行配置。
SpringBoot配置文件有两种:properties文件形式、yml文件形式。SpringBoot默认会从Resources目录下加载application.properties或application.yml文件。
4.1.application.properties配置文件
下面是一个 application.properties 配置文件实例:
## 修改服务器启动端口
server.port=8080
## 设置应用程序访问上下文路径
server.servlet.context-path=/elm
## 设置SpringBoot日志输出级别(error、warn、info、debug)
logging.level.org.springframework=debug
4.2.application.yml配置文件
YML文件格式是YAML (YAML Aint Markup Language)编写的文件格式,YAML是一种直观的能够被电脑识别的数据序列化格式,并且容易被人类阅读,容易和脚本语言交互的,可以被支持YAML库的不同的编程语言程序导入,比如: C/C++, Ruby, Python, Java, Perl, C#, PHP等。YML文件是以数据为核心的,比传统的xml方式更加简洁。
YML文件的扩展名可以使用.yml或者.yaml。
下面是一个 application.yml 配置文件实例:
server:
port: 8080
servlet:
context-path: /elm
logging:
level:
org.springframework: debug
yml文件基本语法:
- 大小写敏感
- 使用缩进表示层级关系(缩进的空格数并不重要,只要相同层级的元素左对齐即可)
- 缩进不允许使用tab,只允许空格
- 冒号后必须要有一个空格
- 使用 # 作为注释
4.3.SpringBoot配置信息的查询
上面提及过,SpringBoot的配置文件,主要的目的就是对配置信息进行修改的,但在配置时的key从哪里去查询呢?我们可以查阅SpringBoot的官方文档文档URL: https://docs.spring.io/spring-boot/docs/2.0.1.RELEASE/reference/htmlsingle/#common-application-properties 常用的配置摘抄如下:
# QUARTZ SCHEDULER (QuartzProperties)
spring.quartz.jdbc.initialize-schema=embedded # Database schema initialization mode.
spring.quartz.jdbc.schema=classpath:org/quartz/impl/jdbcjobstore/tables_@@platform@@.sql # Path to the SQL file to use to initialize the database schema.
spring.quartz.job-store-type=memory # Quartz job store type.
spring.quartz.properties.*= # Additional Quartz Scheduler properties.
# ----------------------------------------
# WEB PROPERTIES
# ----------------------------------------
# EMBEDDED SERVER CONFIGURATION (ServerProperties)
server.port=8080 # Server HTTP port.
server.servlet.context-path= # Context path of the application.
server.servlet.path=/ # Path of the main dispatcher servlet.
# HTTP encoding (HttpEncodingProperties)
spring.http.encoding.charset=UTF-8 # Charset of HTTP requests and responses. Added to the "Content-Type" header if not set explicitly.
# JACKSON (JacksonProperties)
spring.jackson.date-format= # Date format string or a fully-qualified date format class name. For instance, `yyyy-MM-dd HH:mm:ss`.
# SPRING MVC (WebMvcProperties)
spring.mvc.servlet.load-on-startup=-1 # Load on startup priority of the dispatcher servlet.
spring.mvc.static-path-pattern=/** # Path pattern used for static resources.
spring.mvc.view.prefix= # Spring MVC view prefix.
spring.mvc.view.suffix= # Spring MVC view suffix.
# DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.driver-class-name= # Fully qualified name of the JDBC driver. Auto-detected based on the URL by default.
spring.datasource.password= # Login password of the database.
spring.datasource.url= # JDBC URL of the database.
spring.datasource.username= # Login username of the database.
4.4.@Value注解
我们可以通过@Value注解,将配置文件中的值映射到一个Spring管理的Bean的属性上。
@RestController
public class DeptController {
//server.port 就是SpringBoot配置文件中的一个值
@Value("${server.port}")
private int port;
@Autowired
private DeptService deptService;
@RequestMapping("/listDept")
public List<Dept> listDept(){
System.out.println("端口:"+port);
return deptService.listDept();
}
}
将@Value注解放置在一个属性上,就可以使用它获取SpringBoot配置文件中的值。
5.SpringBoot整合MyBatis
5.1.添加MyBatis相关依赖
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.0.1</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
<scope>runtime</scope>
</dependency>
5.2.添加MyBatis相关配置
在application.properties配置文件中配置MyBatis相关信息
server.port=8080
server.servlet.context-path=/elm
logging.level.org.springframework=debug
## 配置mapper输出日志级别
logging.level.com.neusoft.demo.mapper=debug
## 配置数据源信息
spring.datasource.username=root
spring.datasource.password=123
spring.datasource.url=jdbc:mysql://localhost:3306/elm?characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
## 配置mapper映射文件路径
mybatis.mapper-locations=classpath:mapper/*.xml
## 配置扫描实体包,给实体类设置别名
mybatis.type-aliases-package=com.neusoft.demo.po
也可以使用application.yml形式配置文件进行MyBatis相关配置:
server:
port: 8080
servlet:
context-path: /elm
logging:
level:
org.springframework: debug
com.neusoft.demo.mapper: debug
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/elm?characterEncoding=utf-8
username: root
password: 123
mybatis:
mapper-locations: classpath:mapper/*.xml
type-aliases-package: com.neusoft.demo.po
5.3.创建mapper接口
@Mapper
public interface DeptMapper {
@Select("select * from dept order by deptno")
public List<Dept> listDept();
}
注意:必须要使用 @Mapper 标识此mapper接口
5.4.创建service接口与实现类
public interface DeptService {
public List<Dept> listDept();
}
@Service
public class DeptServiceImpl implements DeptService{
@Autowired
private DeptMapper deptMapper;
@Override
public List<Dept> listDept() {
return deptMapper.listDept();
}
}
5.5.创建controller
@RestController
public class DeptController {
@Autowired
private DeptService deptService;
@RequestMapping("/listDept")
public List<Dept> listDept(){
return deptService.listDept();
}
}
5.6.测试
<script src="https://unpkg.com/axios/dist/axios.js"></script>
<script>
axios.post('http://localhost:8080/elm/listDept')
.then(response => {
console.log(response.data);
}).catch(error => {
console.log(error);
});
</script>
本章作业
- SpringBoot与SpringMVC的区别?
- 简述SpringBoot的特点?
- 简述SpringBoot的核心功能?
- 简述@RequestBody 注解的功能?
- 简述yml文件的基本语法?
- 什么是 Spring Boot Stater?
- 什么是嵌入式服务器?我们为什么要使用嵌入式服务器呢?
- 编程题:
- 使用SpringBoot+MyBatis集成框架实现一个登录案例。
- 使用前后端分离的模式实现。
- 服务器端要有数据层组件、业务层组件、控制层组件。
- 数据层组件使用MyBatis框架完成对数据库的操作。
- 控制层组件要向前端返回json数据。
- 前端使用ajax请求,并通过服务器端返回的json数据来判断是否登录成功。