spring boot后端开发基础

Spring Boot

一、开发步骤

• 创建项目

• 添加依赖

• 项目结构

• 添加请求处理类

我们在这个类中处理前端发送过来的请求，例如，我们可以创建一个HelloController类来处理前端发送过来的请求

package com.example.controller;

import org.springframework.web.bind.annotation.*;

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello() {
        System.out.println("Hello World ~");
        return "Hello World ~";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

二、Web分析

浏览器：

• 输入网址：http://192.168.100.11:8080/hello

  • 通过IP地址192.168.100.11定位到网络上的一台计算机

    我们之前在浏览器中输入的localhost，就是127.0.0.1（本机）

  • 通过端口号8080找到计算机上运行的程序

    localhost:8080 , 意思是在本地计算机中找到正在运行的8080端口的程序

  • /hello是请求资源位置

    • 资源：对计算机而言资源就是数据
      • web资源：通过网络可以访问到的资源（通常是指存放在服务器上的数据）

    localhost:8080/hello ，意思是向本地计算机中的8080端口程序，获取资源位置是/hello的数据

    • 8080端口程序，在服务器找/hello位置的资源数据，发给浏览器

服务器：（可以理解为ServerSocket）

• 接收到浏览器发送的信息（如：/hello）
• 在服务器上找到/hello的资源
• 把资源发送给浏览器

网络三要素：

• IP ：网络中计算机的唯一标识
• 端口 ：计算机中运行程序的唯一标识
• 协议 ：网络中计算机之间交互的规则

问题：浏览器和服务器两端进行数据交互，使用什么协议？

答案：http协议

• 流程

浏览器向服务器进行请求时：

• 服务器按照固定的格式进行解析

服务器向浏览器进行响应时：

• 浏览器按照固定的格式进行解析

所以，我们学习HTTP主要就是学习请求和响应数据的具体格式内容。

三、跨域问题

跨域问题出现的原因：浏览器的同源策略（要求请求与服务器满足同源条件）

同源：协议，域名，端口三个都相同才是同源（不存在跨域问题），否则就是不同源（存在跨域问题），不能读取服务器返回回来的资源

例如：

​ vue项目：http://localhost:8080

​ springboot项目：http://localhost:8081/list

分析：

• 协议都是http
• 地址都是localhost
• 端口不同，vue是8080，springboot是8081,不同源，存在跨域问题

• 解决方案：

法一：创建一个configuration包，创建CorsConfig类重写WebMvcConfigurer接口

@Configuration
public class CorsConfig implements WebMvcConfigurer {
    
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")// 应用CORS策略到所有的路径
                .allowedOriginPatterns("*")// 允许所有域名进行跨域请求，使用通配符"*"，不推荐在生产环境
                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD")// 允许的HTTP方法
                .allowCredentials(true)// 允许请求带有验证信息，如HTTP认证或cookie
                .maxAge(3600)// 预检请求的结果能够被缓存多长时间（以秒为单位）
                .allowedHeaders("*");// 允许所有头信息，通配符"*"表示接受任何请求头
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

法二： Cors过滤

@Configuration
public class CorsConfig {
    @Bean
    public CorsFilter corsFilter() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.addAllowedOrigin("*"); // 允许任何域名使用
        corsConfiguration.addAllowedHeader("*"); // 允许任何头
        corsConfiguration.addAllowedMethod("*"); // 允许任何方法（POST、GET等）

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", corsConfiguration); // 对所有路径应用配置

        return new CorsFilter(source); // 传递配置源到CorsFilter
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

@Configuration: 用来标识该类为配置类。Spring容器会在启动时加载这个类的配置。

@Bean:让Spring容器管理,@Bean 注解标记在一个方法上，表明该方法将返回一个对象,通常与@Configuration一起使用

四、HTTP协议

浏览器和服务器是按照HTTP协议进行数据通信的。

HTTP协议又分为：请求协议和响应协议

• 请求协议：浏览器将数据以请求格式发送到服务器
  • 包括：请求行、请求头 、请求体
• 响应协议：服务器将数据以响应格式返回给浏览器
  • 包括：响应行 、响应头 、响应体

• GET请求和POST请求的区别：

• 响应状态码

  状态码类别	状态码	状态码说明
  1xx 信息性	100	Continue: 客户端应继续其请求
  2xx 成功	200	OK: 请求成功
  	201	Created: 请求已经被实现，而且有一个新的资源已经依据请求的需要而建立
  3xx 重定向	301	Moved Permanently: 请求的资源已永久移动到新位置
  	302	Found: 请求的资源临时移动到其他URI
  4xx 客户端错误	400	Bad Request: 服务器不理解请求的语法
  	404	Not Found: 服务器找不到请求的资源
  5xx 服务器错误	500	Internal Server Error: 服务器遇到错误，无法完成请求
  	503	Service Unavailable: 服务器目前无法使用（由于超载或停机维护）

五、Web服务器

Tomcat，因为springboot自带了一个web服务器，所以就不写了

六、响应前端请求

一、创建一个名为mapper的包用于处理数据库操作

package com.example.mapper;

import com.example.pojo.User;
import org.apache.ibatis.annotations.*;

import java.util.List;

@Mapper
public interface UserMapper {
    @Select("select * from resume")
    List<User> list();

    @Insert("insert into resume(name,age,job,email,phone,education,major,school,experience,project) " +
            "values(#{name},#{age},#{job},#{email},#{phone},#{education},#{major},#{school}," +
            "#{experience},#{project})")
    void insertUser(User user);

    @Select("select * from resume where name = #{name}")
    List<User> selectUserByName(String name);

    @Delete("delete from resume where name = #{name}")
    int deleteUserByName(String user);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

使用#{name}参数的方式，#–> 预处理sql,防止sql注入，提高效率

• mybatis常用注释

统一回复格式 Result类

package com.itheima.pojo;

/**
 * 统一响应结果封装类
 */
public class Result {
    private Integer code ;//1 成功 , 0 失败
    private String msg; //提示信息
    private Object data; //数据 date

    public Result() {
    }
    public Result(Integer code, String msg, Object data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
    public Integer getCode() {
        return code;
    }
    public void setCode(Integer code) {
        this.code = code;
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }

    public static Result success(Object data){
        return new Result(1, "success", data);
    }
    public static Result success(){
        return new Result(1, "success", null);
    }
    public static Result error(String msg){
        return new Result(0, msg, null);
    }

    @Override
    public String toString() {
        return "Result{" +
                "code=" + code +
                ", msg='" + msg + '\'' +
                ", data=" + data +
                '}';
    }
}

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56

使用示例

package com.itheima.controller;

import com.itheima.pojo.Address;
import com.itheima.pojo.Result;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;

/**
 * 测试响应数据
 */
@RestController
public class ResponseController {
    @RequestMapping("/hello")
    public Result hello(){
        System.out.println("Hello World ~");
        //return new Result(1,"success","Hello World ~");
        return Result.success("Hello World ~");
    }

    @RequestMapping("/getAddr")
    public Result getAddr(){
        Address addr = new Address();
        addr.setProvince("广东");
        addr.setCity("深圳");
        return Result.success(addr);
    }

    @RequestMapping("/listAddr")
    public Result listAddr(){
        List<Address> list = new ArrayList<>();

        Address addr = new Address();
        addr.setProvince("广东");
        addr.setCity("深圳");

        Address addr2 = new Address();
        addr2.setProvince("陕西");
        addr2.setCity("西安");

        list.add(addr);
        list.add(addr2);
        return Result.success(list);
    }
}
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
43
44
45
46

@RestController包含两个注解，@Controller 和 @ResponsBody,

被@RestController注释的函数的返回值都会以响应体的方式返回

七、springboot常用注解

• 创建一个简单的RESTful API

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class MyApp {

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

    @GetMapping("/hello")
    public String sayHello(@RequestParam(value = "name", defaultValue = "World") String name) {
        return String.format("Hello %s!", name);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在这个例子中，@SpringBootApplication 注解用于主类，启用自动配置、组件扫描和配置属性的支持。@RestController 表明该类处理HTTP请求。@GetMapping 指定一个方法来处理对/hello路径的GET请求。

• 服务层和数据访问层

  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  import org.springframework.stereotype.Repository;
  
  @Service
  public class UserService {
  
      private final UserRepository userRepository;
  
      @Autowired
      public UserService(UserRepository userRepository) {
          this.userRepository = userRepository;
      }
  
      public User getUserById(Long id) {
          return userRepository.findById(id).orElse(null);
      }
  }
  
  @Repository
  interface UserRepository extends JpaRepository<User, Long> {
      // Spring Data JPA 会自动实现常见的数据库操作
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24

  这个例子中，@Service 注解标记了一个服务类，表明它执行业务逻辑。@Repository 注解标记了数据访问接口，Spring Data JPA将自动实现此接口。@Autowired 用于构造函数，实现依赖注入。

• 配置类和Bean定义

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class AppConfig {
    
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

@Configuration 告诉Spring该类包含一个或多个@Bean定义。@Bean 注解在方法上表明该方法生成一个由Spring容器管理的bean。

• 响应体和路径变量

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @PostMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        return userService.updateUser(user);  // 假设有一个 userService 处理用户更新
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

@RestController 标记了一个类为控制器，@PostMapping 指定方法响应POST请求。@PathVariable 和 @RequestBody 分别用来绑定URL路径中的变量和HTTP请求体到方法的参数。