Spring 全家桶学习笔记#

1
// Record 类型（简洁的数据载体）
2
public record User(Long id, String name, String email) {}
3

4
// Pattern Matching for switch
5
String result = switch (obj) {
6
    case Integer i -> "Integer: " + i;
7
    case String s -> "String: " + s;
8
    case null -> "Null value";
9
    default -> "Unknown type";
10
};
11

12
// Virtual Threads（虚拟线程）
13
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
14
    executor.submit(() -> {
15
        // 高并发任务处理，数百万线程轻松应对
16
    });
17
}

1
// RESTful API 开发
2
@RestController
3
@RequestMapping("/api/users")
4
public class UserController {
5

6
    private final UserService userService;
7

8
    public UserController(UserService userService) {
9
        this.userService = userService;
10
    }
11

12
    @GetMapping
13
    public List<User> getAllUsers() {
14
        return userService.findAll();
15
    }
16

17
    @GetMapping("/{id}")
18
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
19
        return userService.findById(id)
20
            .map(ResponseEntity::ok)
21
            .orElse(ResponseEntity.notFound().build());
22
    }
23

24
    @PostMapping
25
    public ResponseEntity<User> createUser(@RequestBody @Valid UserDTO dto) {
26
        User user = userService.create(dto);
27
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
28
    }
29

30
    @PutMapping("/{id}")
31
    public ResponseEntity<User> updateUser(
32
        @PathVariable Long id,
33
        @RequestBody @Valid UserDTO dto
34
    ) {
35
        return userService.update(id, dto)
36
            .map(ResponseEntity::ok)
37
            .orElse(ResponseEntity.notFound().build());
38
    }
39

40
    @DeleteMapping("/{id}")
41
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
42
        userService.deleteById(id);
43
        return ResponseEntity.noContent().build();
44
    }
45

46
    // 查询参数
47
    @GetMapping("/search")
48
    public List<User> searchUsers(
49
        @RequestParam(required = false) String name,
50
        @RequestParam(defaultValue = "0") int page,
51
        @RequestParam(defaultValue = "10") int size
52
    ) {
53
        return userService.search(name, page, size);
54
    }
55
}

1
// DTO 类
2
public class UserDTO {
3

4
    @NotBlank(message = "用户名不能为空")
5
    @Size(min = 3, max = 20, message = "用户名长度必须在 3-20 之间")
6
    private String username;
7

8
    @NotBlank(message = "密码不能为空")
9
    @Size(min = 6, message = "密码长度至少为 6")
10
    private String password;
11

12
    @Email(message = "邮箱格式不正确")
13
    @NotBlank(message = "邮箱不能为空")
14
    private String email;
15

16
    @Min(value = 0, message = "年龄不能小于 0")
17
    @Max(value = 150, message = "年龄不能大于 150")
18
    private Integer age;
19

20
    @Pattern(regexp = "^1[3-9]\\d{9}$", message = "手机号格式不正确")
21
    private String phone;
22

23
    // Getters and Setters
24
}
25

26
// Controller 使用 @Valid
27
@PostMapping
28
public ResponseEntity<User> createUser(@RequestBody @Valid UserDTO dto) {
29
    // 如果校验失败，会抛出 MethodArgumentNotValidException
30
    User user = userService.create(dto);
31
    return ResponseEntity.ok(user);
32
}
33

34
// 全局异常处理
35
@RestControllerAdvice
36
public class GlobalExceptionHandler {
37

38
    @ExceptionHandler(MethodArgumentNotValidException.class)
39
    public ResponseEntity<ErrorResponse> handleValidationException(
40
        MethodArgumentNotValidException ex
41
    ) {
42
        Map<String, String> errors = new HashMap<>();
43
        ex.getBindingResult().getFieldErrors().forEach(error ->
44
            errors.put(error.getField(), error.getDefaultMessage())
45
        );
46

47
        ErrorResponse response = new ErrorResponse(
48
            HttpStatus.BAD_REQUEST.value(),
49
            "Validation failed",
50
            errors
51
        );
52

53
        return ResponseEntity.badRequest().body(response);
54
    }
55

56
    @ExceptionHandler(Exception.class)
57
    public ResponseEntity<ErrorResponse> handleException(Exception ex) {
58
        ErrorResponse response = new ErrorResponse(
59
            HttpStatus.INTERNAL_SERVER_ERROR.value(),
60
            ex.getMessage()
61
        );
62
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
63
    }
64
}

1
@Data
2
@AllArgsConstructor
3
@NoArgsConstructor
4
public class ApiResponse<T> {
5
    private int code;
6
    private String message;
7
    private T data;
8

9
    public static <T> ApiResponse<T> success(T data) {
10
        return new ApiResponse<>(200, "Success", data);
11
    }
12

13
    public static <T> ApiResponse<T> error(String message) {
14
        return new ApiResponse<>(500, message, null);
15
    }
16
}
17

18
// 使用
19
@GetMapping("/{id}")
20
public ApiResponse<User> getUser(@PathVariable Long id) {
21
    return userService.findById(id)
22
        .map(ApiResponse::success)
23
        .orElse(ApiResponse.error("User not found"));
24
}

1
@Configuration
2
@EnableScheduling
3
public class SchedulingConfig {
4
}
5

6
@Component
7
public class ScheduledTasks {
8

9
    // 每 5 秒执行一次
10
    @Scheduled(fixedRate = 5000)
11
    public void reportCurrentTime() {
12
        System.out.println("Current time: " + LocalDateTime.now());
13
    }
14

15
    // Cron 表达式：每天凌晨 2 点执行
16
    @Scheduled(cron = "0 0 2 * * ?")
17
    public void performNightlyCleanup() {
18
        System.out.println("Performing nightly cleanup...");
19
    }
20

21
    // 上次执行完成后，延迟 10 秒再执行
22
    @Scheduled(fixedDelay = 10000)
23
    public void scheduleWithFixedDelay() {
24
        System.out.println("Fixed delay task: " + LocalDateTime.now());
25
    }
26
}

1
@Configuration
2
@EnableAsync
3
public class AsyncConfig {
4

5
    @Bean(name = "taskExecutor")
6
    public Executor taskExecutor() {
7
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
8
        executor.setCorePoolSize(5);
9
        executor.setMaxPoolSize(10);
10
        executor.setQueueCapacity(100);
11
        executor.setThreadNamePrefix("async-");
12
        executor.initialize();
13
        return executor;
14
    }
15
}
16

17
@Service
18
public class EmailService {
19

20
    @Async("taskExecutor")
21
    public CompletableFuture<String> sendEmail(String to, String subject) {
22
        // 模拟耗时操作
23
        try {
24
            Thread.sleep(3000);
25
        } catch (InterruptedException e) {
26
            Thread.currentThread().interrupt();
27
        }
28

29
        System.out.println("Email sent to: " + to);
30
        return CompletableFuture.completedFuture("Email sent successfully");
31
    }
32
}

1
@Entity
2
@Table(name = "users")
3
@Data
4
@NoArgsConstructor
5
@AllArgsConstructor
6
public class User {
7

8
    @Id
9
    @GeneratedValue(strategy = GenerationType.IDENTITY)
10
    private Long id;
11

12
    @Column(nullable = false, unique = true, length = 50)
13
    private String username;
14

15
    @Column(nullable = false)
16
    private String password;
17

18
    @Column(unique = true)
19
    private String email;
20

21
    private Integer age;
22

23
    @Enumerated(EnumType.STRING)
24
    private UserStatus status;
25

26
    @CreatedDate
27
    @Column(updatable = false)
28
    private LocalDateTime createdAt;
29

30
    @LastModifiedDate
31
    private LocalDateTime updatedAt;
32

33
    // 一对多关系
34
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
35
    private List<Order> orders = new ArrayList<>();
36

37
    // 多对多关系
38
    @ManyToMany
39
    @JoinTable(
40
        name = "user_roles",
41
        joinColumns = @JoinColumn(name = "user_id"),
42
        inverseJoinColumns = @JoinColumn(name = "role_id")
43
    )
44
    private Set<Role> roles = new HashSet<>();
45
}
46

47
@Entity
48
@Table(name = "orders")
49
@Data
50
public class Order {
51

52
    @Id
53
    @GeneratedValue(strategy = GenerationType.IDENTITY)
54
    private Long id;
55

56
    private String orderNumber;
57

58
    private BigDecimal totalAmount;
59

60
    @ManyToOne(fetch = FetchType.LAZY)
61
    @JoinColumn(name = "user_id")
62
    private User user;
63

64
    @CreatedDate
65
    private LocalDateTime createdAt;
66
}
67

68
@Entity
69
@Table(name = "roles")
70
@Data
71
public class Role {
72

73
    @Id
74
    @GeneratedValue(strategy = GenerationType.IDENTITY)
75
    private Long id;
76

77
    @Column(unique = true)
78
    private String name;
79

80
    @ManyToMany(mappedBy = "roles")
81
    private Set<User> users = new HashSet<>();
82
}

1
public interface UserRepository extends JpaRepository<User, Long> {
2

3
    // 方法名查询（自动生成 SQL）
4
    Optional<User> findByUsername(String username);
5

6
    Optional<User> findByEmail(String email);
7

8
    List<User> findByAgeGreaterThan(Integer age);
9

10
    List<User> findByUsernameContainingIgnoreCase(String keyword);
11

12
    List<User> findByAgeGreaterThanAndStatus(Integer age, UserStatus status);
13

14
    // @Query 注解（JPQL）
15
    @Query("SELECT u FROM User u WHERE u.username = ?1 AND u.status = ?2")
16
    Optional<User> findByUsernameAndStatus(String username, UserStatus status);
17

18
    // 命名参数
19
    @Query("SELECT u FROM User u WHERE u.email = :email")
20
    Optional<User> findByEmailAddress(@Param("email") String email);
21

22
    // 原生 SQL
23
    @Query(value = "SELECT * FROM users WHERE age > ?1", nativeQuery = true)
24
    List<User> findUsersOlderThan(Integer age);
25

26
    // 更新操作
27
    @Modifying
28
    @Query("UPDATE User u SET u.status = :status WHERE u.id = :id")
29
    int updateUserStatus(@Param("id") Long id, @Param("status") UserStatus status);
30

31
    // 删除操作
32
    @Modifying
33
    @Query("DELETE FROM User u WHERE u.status = :status")
34
    int deleteByStatus(@Param("status") UserStatus status);
35

36
    // 分页查询
37
    Page<User> findByStatus(UserStatus status, Pageable pageable);
38

39
    // 排序查询
40
    List<User> findByStatus(UserStatus status, Sort sort);
41

42
    // 投影（只查询部分字段）
43
    @Query("SELECT new com.example.dto.UserDTO(u.id, u.username, u.email) FROM User u")
44
    List<UserDTO> findAllUserDTOs();
45
}

1
@Service
2
@Transactional(readOnly = true)
3
public class UserService {
4

5
    private final UserRepository userRepository;
6

7
    public UserService(UserRepository userRepository) {
8
        this.userRepository = userRepository;
9
    }
10

11
    public List<User> findAll() {
12
        return userRepository.findAll();
13
    }
14

15
    public Optional<User> findById(Long id) {
16
        return userRepository.findById(id);
17
    }
18

19
    public Page<User> findAll(int page, int size, String sortBy) {
20
        Pageable pageable = PageRequest.of(page, size, Sort.by(sortBy).descending());
21
        return userRepository.findAll(pageable);
22
    }
23

24
    @Transactional
25
    public User create(UserDTO dto) {
26
        User user = new User();
27
        user.setUsername(dto.getUsername());
28
        user.setPassword(passwordEncoder.encode(dto.getPassword()));
29
        user.setEmail(dto.getEmail());
30
        user.setStatus(UserStatus.ACTIVE);
31

32
        return userRepository.save(user);
33
    }
34

35
    @Transactional
36
    public Optional<User> update(Long id, UserDTO dto) {
37
        return userRepository.findById(id)
38
            .map(user -> {
39
                user.setEmail(dto.getEmail());
40
                user.setAge(dto.getAge());
41
                return userRepository.save(user);
42
            });
43
    }
44

45
    @Transactional
46
    public void deleteById(Long id) {
47
        userRepository.deleteById(id);
48
    }
49
}

1
public class UserSpecifications {
2

3
    public static Specification<User> hasUsername(String username) {
4
        return (root, query, cb) ->
5
            username == null ? null : cb.equal(root.get("username"), username);
6
    }
7

8
    public static Specification<User> hasStatus(UserStatus status) {
9
        return (root, query, cb) ->
10
            status == null ? null : cb.equal(root.get("status"), status);
11
    }
12

13
    public static Specification<User> ageGreaterThan(Integer age) {
14
        return (root, query, cb) ->
15
            age == null ? null : cb.greaterThan(root.get("age"), age);
16
    }
17
}
18

19
// Repository 继承 JpaSpecificationExecutor
20
public interface UserRepository extends JpaRepository<User, Long>,
21
                                        JpaSpecificationExecutor<User> {
22
}
23

24
// Service 使用
25
public List<User> searchUsers(String username, UserStatus status, Integer minAge) {
26
    Specification<User> spec = Specification
27
        .where(UserSpecifications.hasUsername(username))
28
        .and(UserSpecifications.hasStatus(status))
29
        .and(UserSpecifications.ageGreaterThan(minAge));
30

31
    return userRepository.findAll(spec);
32
}

1
@Configuration
2
@EnableWebSecurity
3
@EnableMethodSecurity  // 启用方法级别的安全注解
4
public class SecurityConfig {
5

6
    @Bean
7
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
8
        http
9
            .csrf(csrf -> csrf.disable())  // 禁用 CSRF（API 场景）
10
            .authorizeHttpRequests(auth -> auth
11
                .requestMatchers("/api/auth/**", "/api/public/**").permitAll()
12
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
13
                .requestMatchers("/api/user/**").hasAnyRole("USER", "ADMIN")
14
                .anyRequest().authenticated()
15
            )
16
            .sessionManagement(session -> session
17
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)  // 无状态（JWT）
18
            )
19
            .addFilterBefore(
20
                jwtAuthenticationFilter(),
21
                UsernamePasswordAuthenticationFilter.class
22
            );
23

24
        return http.build();
25
    }
26

27
    @Bean
28
    public PasswordEncoder passwordEncoder() {
29
        return new BCryptPasswordEncoder();
30
    }
31

32
    @Bean
33
    public AuthenticationManager authenticationManager(
34
        AuthenticationConfiguration config
35
    ) throws Exception {
36
        return config.getAuthenticationManager();
37
    }
38
}