项目开发笔记-5

// 没有Spring IoC容器的情况，紧耦合
public class Car {
    private Engine engine;

    public Car() {
        // Car 自己负责创建 Engine，它们紧密耦合在一起
        this.engine = new Engine();
    }

    public void start() {
        engine.ignite();
        System.out.println("Car started!");
    }
}

// (1)使用Spring IoC容器，第一步先通过注解定义Bean

@Component // 告诉 Spring，请把此类作为一个 Bean 管理起来
public class Engine {
    public void ignite() {
        System.out.println("Engine ignited.");
    }
}

@Component // 告诉 Spring，请把此类作为一个 Bean 管理起来
public class Car {
    private Engine engine;

    // 构造器注入：Spring 会自动将 Engine 注入进来
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.ignite();
        System.out.println("Car started!");
    }
}

//======================
// (2) 使用Spring IoC容器

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        // 1. 启动 Spring 容器，它会扫描 @Component 等注解，创建并管理所有 Bean
        ApplicationContext context = SpringApplication.run(MyApplication.class, args);

        // 2. 从容器中“获取”Car，而不是自己 new Car()
        Car myCar = context.getBean(Car.class);

        // 3. 使用 Car，此时 Car 内部的 Engine 已经被容器自动装配好了
        myCar.start(); // 输出: Engine ignited. Car started!
    }
}

// 完整的主启动类示例
package com.example.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);
    }
}

@Controller // 传统的控制器注解
public class MyOldRestApiController {

    @ResponseBody // 需要这个注解来表明返回的是数据，不是视图名
    @GetMapping("/api/user")
    public User getUser() {
        return new User("John", 30); // 希望返回 JSON: {"name": "John", "age": 30}
    }

    @ResponseBody // 每个方法都需要加，很麻烦
    @PostMapping("/api/user")
    public User createUser(...) { ... }
}

@RestController
public class UserController {

    @PostMapping("/users")
    // 关键在这里：@RequestBody 将请求体中的 JSON 自动转换为 User 对象
    public ResponseEntity<String> createUser(@RequestBody User user) {
        System.out.println("收到的用户姓名：" + user.getName());
        System.out.println("收到的用户年龄：" + user.getAge());
        // ... 这里可以执行保存到数据库等操作
        return ResponseEntity.ok("用户创建成功");
    }
}

@Controller
public class MyController {
    
    // 将这个方法映射到 /home 路径的 GET 请求
    @RequestMapping(value = "/home", method = RequestMethod.GET)
    public String home() {
        return "home-page"; // 返回视图名
    }
    
    // 映射到 /submit 路径的 POST 请求
    @RequestMapping(value = "/submit", method = RequestMethod.POST)
    public String submit() {
        return "result-page";
    }
}

// 1. 方法参数名与URL参数名不同
// GET /api/users?userName=张三
@GetMapping("/api/users")
public User findUser(@RequestParam("userName") String name) {
    // URL 参数是 userName，但方法参数是 name
    return userService.findByName(name);
}

// 2. 指定参数是否必须
// 可以接收：GET /api/users?type=VIP 或 GET /api/users
@GetMapping("/api/users")
public List<User> getUsers(@RequestParam(required = false) String type) {
    // 如果请求中没有 type 参数，type 的值会是 null
    return userService.getUsersByType(type);
}


// 3. 分页查询带有默认值
// GET /api/products 或 GET /api/products?page=3&size=50
@GetMapping("/api/products")
public List<Product> getProducts(
        @RequestParam(defaultValue = "1") int page,
        @RequestParam(defaultValue = "20") int size) {
    // 如果没有提供 page 参数，默认为 1
    // 如果没有提供 size 参数，默认为 20
    return productService.getProducts(page, size);
}

// GET /api/users/123/orders/456
@GetMapping("/api/users/{userId}/orders/{orderId}")
public Order getOrder(@PathVariable Long userId, 
                     @PathVariable Long orderId) {
    // userId = 123, orderId = 456
    return orderService.findUserOrder(userId, orderId);
}

// URL路径变量名与方法参数变量名不匹配时可以明确指定
// GET /api/users/123
@GetMapping("/api/users/{id}")
public User getUser(@PathVariable("id") Long userId) {
    // URL 模板中是 {id}，但方法参数名是 userId
    // 需要使用 @PathVariable("id") 明确指定
    return userService.findById(userId);
}

// 字段注入
@Service
public class UserService {
    
    @Autowired // 直接注入到字段
    private UserRepository userRepository;
    
    @Autowired
    private EmailService emailService;
    
    public User findUser(Long id) {
        return userRepository.findById(id);
    }
}

// Setter方法注入
@Service
public class UserService {
    
    private UserRepository userRepository;
    private EmailService emailService;
    
    @Autowired
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    
    @Autowired
    public void setEmailService(EmailService emailService) {
        this.emailService = emailService;
    }
}


// 构造器注入
@Service
public class UserService {
    
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    // Spring 会自动寻找合适的 Bean 注入到构造器参数中
    @Autowired
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
}

// 自定义 Bean 名称
@Component("creditCardService")
public class CreditCardPaymentService implements PaymentService {
    // ...
}

@Component("payPalService")  
public class PayPalPaymentService implements PaymentService {
    // ...
}

@Service
public class OrderService {
    
    @Autowired
    @Qualifier("creditCardService") // 使用自定义名称
    private PaymentService primaryPaymentService;
    
    @Autowired
    @Qualifier("payPalService")
    private PaymentService secondaryPaymentService;
}

// MySQL 数据源作为默认选择
@Component
@Primary // 标记为首选 Bean
public class MySQLDataSource implements DataSource {
    public Connection getConnection() {
        return new MySQLConnection();
    }
}

// H2 数据源作为备选
@Component
public class H2DataSource implements DataSource {
    public Connection getConnection() {
        return new H2Connection();
    }
}

@Repository
public class UserRepository {
    
    @Autowired
    private DataSource dataSource; // 会自动注入 MySQLDataSource
    
    public void saveUser(User user) {
        // 使用默认的 MySQL 数据源
    }
}

import javax.persistence.*;

@Entity // 标记这个类是一个 JPA 实体
@Table(name = "users") // 可选：指定表名，默认使用类名
public class User {
    
    @Id // 标记为主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 主键生成策略
    private Long id;
    
    @Column(name = "username") // 可选：指定列名，默认使用字段名
    private String username;
    
    private String email; // 默认映射到 email 列
    private Integer age;  // 默认映射到 age 列
    
    // 必须有无参构造函数
    public User() {
    }
    
    // 有参构造函数
    public User(String username, String email, Integer age) {
        this.username = username;
        this.email = email;
        this.age = age;
    }
    
    // Getter 和 Setter 方法
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
}

public interface UserRepository extends JpaRepository<User, Long> {
    
    // 使用原生 SQL 查询
    @Query(value = "SELECT * FROM users u WHERE u.email = ?1", nativeQuery = true)
    User findByEmailNative(String email);
    
    // 复杂的原生 SQL 查询
    @Query(value = "SELECT u.* FROM users u " +
                   "WHERE u.age > ?1 AND u.status = ?2 " +
                   "ORDER BY u.created_date DESC " +
                   "LIMIT ?3", nativeQuery = true)
    List<User> findActiveUsersOlderThan(Integer age, String status, Integer limit);
}