SpringBoot

发表于 分类于 本文字数： 5.7k
SpringBoot入门

搭建方式

idea脚手架

然后勾选Spring Web

官网搭建

  1. 访问start.spring.io
  2. 生成SpringBoot项目
  3. 下载项目，解压并导入idea

手动搭建

添加依赖

创建一个maven项目，在pom.xml文件中添加SpringBoot的起步依赖

SpringBoot项目必须继承spring-boot-starter-parent，spring-boot-starter-parent中定义了常用配置、插件等信息

1
2
3
4
5
6
7
<!-- 父工程 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.4.4</version>
    <relativePath/>
</parent>

起步依赖中包含了其他依赖，如spring-boot-starter、spring-boot-starter-tomcat、spring-web

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!-- SpringBoot起步依赖 -->
<dependencies>
    <!-- 引入SpringBoot web开发依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>3.4.4</version>
    </dependency>
    <!-- 引入SpringBoot 测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <version>3.4.4</version>
        <scope>test</scope>
    </dependency>
</dependencies>

插件的作用是将SpringBoot项目打包成可执行的jar包

1
2
3
4
5
6
7
8
9
<!-- 插件 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

编写启动类

@SpringBootApplication是一个组合注解，包含了@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解，用于标识一个类是一个SpringBoot应用程序的启动类

  • @Configuration：标识该类是一个配置类，用于定义Bean的配置信息
  • @EnableAutoConfiguration：启用自动配置机制，自动配置Spring所需的依赖项和配置
  • @ComponentScan：扫描当前包及其子包中@Component、@Service、@Repository和@Controller注解的类，为它们注册Bean
1
2
3
4
5
6
@SpringBootApplication
public class SpringBootApp {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootApp.class, args);
    }
}

编写配置文件

在src/main/resources目录下创建application.properties文件，用于配置SpringBoot应用程序的各种属性，如数据库连接、端口号、日志级别等

1
2
3
spring.application.name=test
# 端口号
server.port=8080

编写控制类

  • @Controller：用于定义控制器类，负责处理HTTP请求
  • @RequestMapping：用于定义请求映射，将HTTP请求映射到指定的方法上，该注解也可以用在类上。@GetMapping、@PostMapping、@PutMapping、@DeleteMapping等注解是@RequestMapping的简化版，分别用于处理GET、POST、PUT、DELETE请求
  • @ResponseBody：将Controller方法的返回值直接写入HTTP响应体，如果是对象，则会自动转换为JSON格式。SpringBoot默认使用Jackson库进行对象的序列化和反序列化
1
2
3
4
5
6
7
8
9
@Controller
public class TestController {
    
    @RequestMapping("/test")
    @ResponseBody
    public String test() {
        return "test";
    }
}
  • @RestController：是@Controller和@ResponseBody的组合注解
1
2
3
4
5
6
7
8
@RestController
public class TestController {
    
    @RequestMapping("/test")
    public String test() {
        return "test";
    }
}

带参数的请求，如下代码发送请求时可以附带name和age参数，附带的参数必须与方法的参数名一致

1
2
3
4
@RequestMapping("/test")
public String test(String name, int age) {
    return "{name: \"" + name + "\", age: " + age + "}";
}

常用注解

@RequestParam

通过@RequestParam注解，如下代码发送请求时可以附带name和age参数，附带的参数可以与方法的参数名不一致

1
2
3
4
@RequestMapping("/test")
public String test(@RequestParam("name") String s1, @RequestParam("age") int i1) {
    return "{name: \"" + s1 + "\", age: " + i1 + "}";
}

@PathVariable

@PathVariable用于获取路径参数，将路径中的参数绑定到方法的参数上

如下代码，在路径中附带的id参数会绑定到方法的userId参数上，发送请求时的路径为/user/123，则userId的值为123

1
2
3
4
@RequestMapping("user/{id}")
public String user(@PathVariable("id") int userId) {
    return "User id is " + userId;
}

如下代码，路径中的id参数会绑定到方法的userId参数上，附带的name参数会绑定到方法的name参数上，发送请求时的路径为/user/123?name=Tom，则userId的值为123，name的值为Tom

1
2
3
4
@RequestMapping("user/{id}")
public String user(@PathVariable("id") int userId, @RequestParam("name") String name) {
    return "User id is " + userId + ", name is " + name;
}

@RequestBody

当@RequestBody注解方法的参数时，SpringBoot会将请求体中的数据反序列化为注解的对象，假设发送Post请求时的请求体为

1
2
3
4
{
    "name": "Tom",
    "id": 10
}

UserBean类

1
2
3
4
public class UserBean {
    private String name;
    private int id;
}

如下方法，SpringBoot会将请求体中的数据反序列化为UserBean对象，然后绑定到方法的参数上

1
2
3
4
@PostMapping("/user")
public String user(@RequestBody UserBean userBean) {
    return "User = " + userBean;
}

IOC与DI

IOC

控制反转：IOC（Inversion of Control）。传统的面向对象编程中，对象的创建和管理通常由程序员来完成，这称为主动控制。而在IOC中，对象的创建和管理交给了外部容器来完成，称为控制反转

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Component // 标记为组件，让Spring管理
public class UserDaoImpl implements UserDao{
    @Override
    public List<String> getUserList() throws IOException {
        // 读取resources下，data/users.txt中的数据
        InputStream inputStream = getClass().getClassLoader().getResourceAsStream("./data/users.txt");
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
        
        // 存储数据的集合
        List<String> userList = new ArrayList<>();
        
        String line;
        while ((line = reader.readLine()) != null) {
            userList.add(line);
        }
        return userList;
    }
}

此外，为了更好的实现三层架构，SpringBoot提供了@Repository、@Service和@Controller，用于标识数据访问层、服务层和控制层的组件，@Repository、@Service和@Controller底层都是对@Component的封装，作用与@Component相同

DI

依赖注入：DI（Dependency Injection）。IOC的一种实现方式，通过DI，自动将依赖的对象注入到需要依赖的对象中

直接注入方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Autowired
private UserDao userDao;

@Override
public List<String> getUserList() throws IOException {
    // 可以直接使用userDao的方法获取数据，然后进行处理
    List<String> userList = userDao.getUserList();
    
    return userList.stream().map(new Function<String, String>() {
        @Override
        public String apply(String user) {
            String[] split = user.split(",");
            
            return "{\"name\": \"" + split[0] + "\", \"age\": " + split[1] + "}";
        }
    }).collect(Collectors.toList());
}

构造器注入方式

1
2
3
4
5
private UserDao userDao;
@Autowired
public UserServiceImpl(UserDao userDao) {
    this.userDao = userDao;
}

Set注入方式

1
2
3
4
5
private UserDao userDao;
@Autowired
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}