Java学习第9天 - Spring Boot基础与Web开发入门

学习时间： 4-5小时
学习目标： 掌握Spring Boot基础，创建第一个Web应用，理解RESTful API设计

---

详细学习清单

✅ 第一部分：Spring Boot概念理解（60分钟）

1. Spring Boot与前端开发对比

Vue.js (你熟悉的现代前端开发)

// Vue CLI 项目结构
my-vue-app/
├── src/
│   ├── components/     // 组件
│   ├── views/         // 页面
│   ├── router/        // 路由
│   ├── store/         // 状态管理
│   ├── assets/        // 静态资源
│   └── main.js        // 入口文件
├── public/
├── package.json       // 依赖管理
└── vue.config.js      // 配置文件

// package.json - 依赖管理
{
  "dependencies": {
    "vue": "^3.3.0",
    "vue-router": "^4.0.0",
    "vuex": "^4.0.0",
    "axios": "^1.0.0"
  },
  "devDependencies": {
    "@vue/cli-service": "^5.0.0"
  },
  "scripts": {
    "serve": "vue-cli-service serve",
    "build": "vue-cli-service build"
  }
}

Spring Boot (今天学习的后端框架)

// Spring Boot 项目结构
my-spring-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   │       ├── controller/    // 控制器
│   │   │       ├── service/       // 服务层
│   │   │       ├── repository/    // 数据访问层
│   │   │       ├── model/         // 实体类
│   │   │       └── DemoApplication.java
│   │   └── resources/
│   │       ├── application.yml    // 配置文件
│   │       ├── static/           // 静态资源
│   │       └── templates/        // 模板文件
│   └── test/
└── pom.xml                       // Maven依赖管理

// pom.xml - 依赖管理
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
</dependencies>

2. Spring Boot核心特性

自动配置（Auto-Configuration）

// 传统Spring需要大量配置
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        return resolver;
    }
}

// Spring Boot自动配置 - 零配置启动
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

起步依赖（Starter Dependencies）

<!-- 只需要添加一个依赖，自动包含所有Web开发需要的库 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!-- 包含的内容：
- Spring MVC
- Tomcat服务器
- Jackson JSON处理
- 日志框架
- 等等...
-->

---

✅ 第二部分：创建第一个Spring Boot项目（90分钟）

1. 项目初始化

方法一：使用Spring Initializr

# 访问 https://start.spring.io/
# 选择：
# - Project: Maven
# - Language: Java
# - Spring Boot: 3.2.x
# - Group: com.example
# - Artifact: demo
# - Dependencies: Spring Web, Spring Data JPA, H2 Database

方法二：使用IDE创建

// IntelliJ IDEA: File → New → Project → Spring Initializr
// 选择依赖：
// - Spring Web
// - Spring Data JPA
// - H2 Database
// - Spring Boot DevTools

2. 项目结构分析

// DemoApplication.java - 启动类
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

// application.yml - 配置文件
server:
  port: 8080

spring:
  application:
    name: demo-app
  
  # 数据库配置
  datasource:
    url: jdbc:h2:mem:testdb
    driver-class-name: org.h2.Driver
    username: sa
    password: 
  
  # JPA配置
  jpa:
    hibernate:
      ddl-auto: create-drop
    show-sql: true
    properties:
      hibernate:
        format_sql: true
  
  # H2控制台
  h2:
    console:
      enabled: true
      path: /h2-console

3. 创建第一个REST API

// UserController.java
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
    
    @GetMapping("/info")
    public Map<String, Object> getUserInfo() {
        Map<String, Object> userInfo = new HashMap<>();
        userInfo.put("name", "张三");
        userInfo.put("age", 25);
        userInfo.put("email", "zhangsan@example.com");
        return userInfo;
    }
    
    @PostMapping("/create")
    public ResponseEntity<Map<String, Object>> createUser(@RequestBody Map<String, String> userData) {
        // 模拟创建用户
        Map<String, Object> response = new HashMap<>();
        response.put("message", "用户创建成功");
        response.put("userId", "U" + System.currentTimeMillis());
        response.put("userData", userData);
        
        return ResponseEntity.status(HttpStatus.CREATED).body(response);
    }
}

---

✅ 第三部分：RESTful API设计（90分钟）

1. RESTful API概念

REST vs 传统API对比

// 传统API设计（不推荐）
@RestController
public class UserController {
    @GetMapping("/getUserById")
    public User getUserById(@RequestParam Long id) { }
    
    @PostMapping("/createNewUser")
    public User createNewUser(@RequestBody User user) { }
    
    @PostMapping("/updateUserInfo")
    public User updateUserInfo(@RequestBody User user) { }
    
    @PostMapping("/deleteUserById")
    public void deleteUserById(@RequestParam Long id) { }
}

// RESTful API设计（推荐）
@RestController
@RequestMapping("/api/users")
public class UserController {
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) { }
    
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) { }
    
    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) { }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) { }
}

2. HTTP状态码使用

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        
        if (user == null) {
            return ResponseEntity.notFound().build(); // 404
        }
        
        return ResponseEntity.ok(user); // 200
    }
    
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User savedUser = userService.save(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(savedUser); // 201
    }
    
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        try {
            User updatedUser = userService.update(id, user);
            return ResponseEntity.ok(updatedUser); // 200
        } catch (UserNotFoundException e) {
            return ResponseEntity.notFound().build(); // 404
        }
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        try {
            userService.delete(id);
            return ResponseEntity.noContent().build(); // 204
        } catch (UserNotFoundException e) {
            return ResponseEntity.notFound().build(); // 404
        }
    }
}

3. 统一响应格式

// ApiResponse.java - 统一响应格式
public class ApiResponse<T> {
    private boolean success;
    private String message;
    private T data;
    private long timestamp;
    
    public ApiResponse() {
        this.timestamp = System.currentTimeMillis();
    }
    
    public static <T> ApiResponse<T> success(T data) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setSuccess(true);
        response.setMessage("操作成功");
        response.setData(data);
        return response;
    }
    
    public static <T> ApiResponse<T> success(String message, T data) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setSuccess(true);
        response.setMessage(message);
        response.setData(data);
        return response;
    }
    
    public static <T> ApiResponse<T> error(String message) {
        ApiResponse<T> response = new ApiResponse<>();
        response.setSuccess(false);
        response.setMessage(message);
        return response;
    }
    
    // getters and setters...
}

// 使用统一响应格式
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @GetMapping("/{id}")
    public ApiResponse<User> getUser(@PathVariable Long id) {
        User user = userService.findById(id);
        
        if (user == null) {
            return ApiResponse.error("用户不存在");
        }
        
        return ApiResponse.success(user);
    }
    
    @PostMapping
    public ApiResponse<User> createUser(@RequestBody User user) {
        try {
            User savedUser = userService.save(user);
            return ApiResponse.success("用户创建成功", savedUser);
        } catch (Exception e) {
            return ApiResponse.error("用户创建失败: " + e.getMessage());
        }
    }
}

---

✅ 第四部分：实战练习（90分钟）

1. 创建完整的用户管理API

// User.java - 实体类
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(nullable = false, unique = true)
    private String username;
    
    @Column(nullable = false)
    private String email;
    
    @Column(nullable = false)
    private String password;
    
    private String fullName;
    private String phone;
    
    @Enumerated(EnumType.STRING)
    private UserStatus status = UserStatus.ACTIVE;
    
    @CreatedDate
    private LocalDateTime createdAt;
    
    @LastModifiedDate
    private LocalDateTime updatedAt;
    
    // getters and setters...
}

// UserStatus.java - 枚举
public enum UserStatus {
    ACTIVE, INACTIVE, SUSPENDED
}

// UserRepository.java - 数据访问层
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
    Optional<User> findByEmail(String email);
    List<User> findByStatus(UserStatus status);
    boolean existsByUsername(String username);
    boolean existsByEmail(String email);
}

// UserService.java - 服务层
@Service
@Transactional
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
    
    public User getUserById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new UserNotFoundException("用户不存在: " + id));
    }
    
    public User createUser(User user) {
        // 验证用户名和邮箱唯一性
        if (userRepository.existsByUsername(user.getUsername())) {
            throw new IllegalArgumentException("用户名已存在");
        }
        
        if (userRepository.existsByEmail(user.getEmail())) {
            throw new IllegalArgumentException("邮箱已存在");
        }
        
        // 加密密码（实际项目中应该使用BCrypt）
        user.setPassword(encryptPassword(user.getPassword()));
        
        return userRepository.save(user);
    }
    
    public User updateUser(Long id, User userDetails) {
        User user = getUserById(id);
        
        user.setFullName(userDetails.getFullName());
        user.setEmail(userDetails.getEmail());
        user.setPhone(userDetails.getPhone());
        user.setStatus(userDetails.getStatus());
        
        return userRepository.save(user);
    }
    
    public void deleteUser(Long id) {
        User user = getUserById(id);
        userRepository.delete(user);
    }
    
    private String encryptPassword(String password) {
        // 简单加密，实际项目使用BCrypt
        return Base64.getEncoder().encodeToString(password.getBytes());
    }
}

// UserController.java - 控制器
@RestController
@RequestMapping("/api/users")
@CrossOrigin(origins = "*")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping
    public ApiResponse<List<User>> getAllUsers() {
        List<User> users = userService.getAllUsers();
        return ApiResponse.success("获取用户列表成功", users);
    }
    
    @GetMapping("/{id}")
    public ApiResponse<User> getUserById(@PathVariable Long id) {
        try {
            User user = userService.getUserById(id);
            return ApiResponse.success(user);
        } catch (UserNotFoundException e) {
            return ApiResponse.error(e.getMessage());
        }
    }
    
    @PostMapping
    public ApiResponse<User> createUser(@RequestBody User user) {
        try {
            User savedUser = userService.createUser(user);
            return ApiResponse.success("用户创建成功", savedUser);
        } catch (IllegalArgumentException e) {
            return ApiResponse.error(e.getMessage());
        }
    }
    
    @PutMapping("/{id}")
    public ApiResponse<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        try {
            User updatedUser = userService.updateUser(id, user);
            return ApiResponse.success("用户更新成功", updatedUser);
        } catch (UserNotFoundException e) {
            return ApiResponse.error(e.getMessage());
        }
    }
    
    @DeleteMapping("/{id}")
    public ApiResponse<Void> deleteUser(@PathVariable Long id) {
        try {
            userService.deleteUser(id);
            return ApiResponse.success("用户删除成功", null);
        } catch (UserNotFoundException e) {
            return ApiResponse.error(e.getMessage());
        }
    }
}

2. 测试API接口

使用Postman或curl测试：

# 1. 创建用户
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{
    "username": "zhangsan",
    "email": "zhangsan@example.com",
    "password": "123456",
    "fullName": "张三",
    "phone": "13800138000"
  }'

# 2. 获取所有用户
curl -X GET http://localhost:8080/api/users

# 3. 获取特定用户
curl -X GET http://localhost:8080/api/users/1

# 4. 更新用户
curl -X PUT http://localhost:8080/api/users/1 \
  -H "Content-Type: application/json" \
  -d '{
    "fullName": "张三丰",
    "phone": "13900139000"
  }'

# 5. 删除用户
curl -X DELETE http://localhost:8080/api/users/1

---

✅ 第五部分：学习总结与练习（30分钟）

1. 今日重点回顾

Spring Boot核心概念：

• ✅ 自动配置：减少配置工作
• ✅ 起步依赖：简化依赖管理
• ✅ 内嵌服务器：快速启动
• ✅ 生产就绪：监控、健康检查

RESTful API设计原则：

• ✅ 使用HTTP动词表示操作
• ✅ 使用名词表示资源
• ✅ 使用HTTP状态码表示结果
• ✅ 统一响应格式

2. 实战练习

练习1：扩展用户管理功能

// 添加分页查询
@GetMapping
public ApiResponse<Page<User>> getUsers(
        @RequestParam(defaultValue = "0") int page,
        @RequestParam(defaultValue = "10") int size) {
    Page<User> users = userService.getUsersWithPagination(page, size);
    return ApiResponse.success(users);
}

// 添加搜索功能
@GetMapping("/search")
public ApiResponse<List<User>> searchUsers(@RequestParam String keyword) {
    List<User> users = userService.searchUsers(keyword);
    return ApiResponse.success(users);
}

练习2：添加数据验证

// User.java - 添加验证注解
@Entity
public class User {
    @NotBlank(message = "用户名不能为空")
    @Size(min = 3, max = 20, message = "用户名长度必须在3-20之间")
    private String username;
    
    @NotBlank(message = "邮箱不能为空")
    @Email(message = "邮箱格式不正确")
    private String email;
    
    @NotBlank(message = "密码不能为空")
    @Size(min = 6, message = "密码长度不能少于6位")
    private String password;
    
    // ...
}

// UserController.java - 添加验证
@PostMapping
public ApiResponse<User> createUser(@Valid @RequestBody User user, BindingResult result) {
    if (result.hasErrors()) {
        String errorMessage = result.getFieldErrors().stream()
                .map(FieldError::getDefaultMessage)
                .collect(Collectors.joining(", "));
        return ApiResponse.error(errorMessage);
    }
    
    try {
        User savedUser = userService.createUser(user);
        return ApiResponse.success("用户创建成功", savedUser);
    } catch (IllegalArgumentException e) {
        return ApiResponse.error(e.getMessage());
    }
}

3. 明日预告

第10天学习内容：

• Spring Boot数据库集成（JPA + MySQL）
• 事务管理
• 数据验证与异常处理
• 日志配置

---

今日学习目标达成检查

• ✅ 理解Spring Boot核心概念和优势
• ✅ 创建第一个Spring Boot项目
• ✅ 设计RESTful API
• ✅ 实现完整的CRUD操作
• ✅ 使用统一响应格式
• ✅ 测试API接口