第十六站：Java珊瑚红——Web开发的活力之源

Java在Web开发领域扮演着极其重要的角色，其生态系统提供了多种技术来构建高效、可维护的Web应用程序。下面我们将通过源代码示例，来探讨Servlet、JSP、Spring MVC和RESTful API在Java Web开发中的应用。

Servlet

Servlet是Java EE规范的一部分，它提供了一种运行在服务器端的Java程序，可以处理客户端请求并生成动态响应。以下是一个简单的Servlet示例，它返回一个简单的HTTP响应：

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.IOException;

public class HelloWorldServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.setCharacterEncoding("UTF-8");
        response.getWriter().write("<h1>Hello, World!</h1>");
    }
}

在这个例子中，HelloWorldServlet继承了HttpServlet类，并覆盖了doGet方法来处理GET请求。

JSP

JSP（JavaServer Pages）允许将Java代码嵌入到HTML页面中，使得页面能够根据Java代码的执行结果动态生成内容。以下是一个简单的JSP页面示例：

<!DOCTYPE html>
<html>
<head>
    <title>JSP Example</title>
</head>
<body>
    <h1>Hello, JSP!</h1>
    <% 
        String message = "Welcome to JSP!";
        out.println(message);
    %>
</body>
</html>

在这个JSP页面中，我们使用<% %>标签包裹Java代码，这段代码将在服务器端执行，并将结果输出到客户端浏览器。

Spring MVC

Spring MVC是一个用于构建Web应用程序的框架，它提供了一种模型-视图-控制器（MVC）的实现。以下是一个Spring MVC控制器的示例：

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class MyController {

    @GetMapping("/greeting")
    public String greeting(Model model) {
        model.addAttribute("message", "Hello, Spring MVC!");
        return "greeting";
    }
}

在这个控制器中，我们定义了一个处理/greeting路径GET请求的方法。它向模型添加一个属性，然后返回视图名称。

对应的视图（HTML页面）可能如下所示：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Greeting Page</title>
</head>
<body>
    <h1 th:text="${message}">Hello, World!</h1>
</body>
</html>

这里使用了Thymeleaf模板引擎来动态插入模型中的message属性。

RESTful API

RESTful API是一种设计风格，它使用标准的HTTP方法来执行CRUD操作。以下是一个使用Spring Boot创建的RESTful控制器示例：

import org.springframework.web.bind.annotation.*;
import java.util.concurrent.atomic.AtomicLong;

@RestController
public class GreetingController {

    private static final String template = "Hello, %s!";
    private final AtomicLong counter = new AtomicLong();

    @GetMapping("/greeting")
    public Greeting greeting(@RequestParam(value = "name", defaultValue = "World") String name) {
        return new Greeting(counter.incrementAndGet(), String.format(template, name));
    }

    static class Greeting {
        private final long id;
        private final String content;

        public Greeting(long id, String content) {
            this.id = id;
            this.content = content;
        }

        // Getters and Setters
    }
}

在这个控制器中，我们定义了一个处理/greeting路径GET请求的方法，它接受一个name参数，并返回一个包含问候语的JSON对象。

这些示例展示了Java在Web开发中的多样性和灵活性。Servlet和JSP为传统的服务器端Web应用程序提供了基础，而Spring MVC和RESTful API则为构建现代Web应用程序提供了强大的支持。通过这些技术，Java开发者可以构建出高效、可维护、易于扩展的Web服务。

让我们通过一个更具体的案例来进一步阐释Java在Web开发中的应用，特别是结合Spring MVC和RESTful API来构建一个实际的Web服务。

案例：在线图书商店

案例背景

假设我们正在开发一个在线图书商店的Web应用程序，它允许用户浏览图书、查看详情、添加到购物车以及进行购买。

Spring MVC应用

1. 图书列表页面控制器

首先，我们创建一个Spring MVC控制器来处理对图书列表页面的请求：

@Controller
public class BookController {

    @GetMapping("/books")
    public String listBooks(Model model, @RequestParam(value = "category", required = false) String category) {
        List<Book> books = bookService.findBooksByCategory(category); // 假设bookService已实现
        model.addAttribute("books", books);
        model.addAttribute("category", category);
        return "booksList";
    }
}

在这个控制器中，listBooks方法根据请求的分类参数来获取图书列表，并将其添加到模型中，然后返回视图名称booksList。

2. 图书详情页面控制器

接下来，我们创建另一个控制器方法来显示单个图书的详细信息：

@GetMapping("/books/{id}")
public String bookDetails(@PathVariable Long id, Model model) {
    Book book = bookService.findBookById(id); // 假设bookService已实现
    if (book != null) {
        model.addAttribute("book", book);
        return "bookDetails";
    } else {
        return "bookNotFound"; // 未找到图书时的视图
    }
}

这个方法使用@PathVariable来获取URL中的图书ID，并根据ID获取图书详情。

3. 视图页面

对于booksList视图，我们可能会有一个Thymeleaf模板，如下所示：

<html>
<head><title>Book List</title></head>
<body>
    <h1>Book List</h1>
    <form action="/books" method="get">
        <input type="text" name="category" placeholder="Search by category">
        <button type="submit">Search</button>
    </form>
    <div th:each="book : ${books}">
        <h2 th:text="${book.title}"></h2>
        <p th:text="${book.author}"></p>
        <!-- 其他图书信息 -->
    </div>
</body>
</html>

RESTful API应用

1. 图书资源控制器

现在，让我们创建一个RESTful API控制器来提供图书的RESTful服务：

@RestController
@RequestMapping("/api/books")
public class BookApiController {

    @GetMapping
    public ResponseEntity<List<Book>> getAllBooks(@RequestParam(value = "category", required = false) String category) {
        List<Book> books = bookService.findBooksByCategory(category); // 假设bookService已实现
        return ResponseEntity.ok(books);
    }

    @GetMapping("/{id}")
    public ResponseEntity<Book> getBookById(@PathVariable Long id) {
        Book book = bookService.findBookById(id); // 假设bookService已实现
        if (book != null) {
            return ResponseEntity.ok(book);
        } else {
            return ResponseEntity.notFound().build();
        }
    }
}

这个控制器提供了两个方法：一个用于获取所有图书的列表，另一个用于通过ID获取单个图书的详细信息。返回类型是ResponseEntity，它允许我们自定义响应的状态。

2. 请求和响应示例

客户端可以使用HTTP GET请求来获取图书列表：

GET /api/books?category=fiction

服务器响应可能是：

[
    {
        "id": 1,
        "title": "Fiction Book One",
        "author": "Author A"
    },
    {
        "id": 2,
        "title": "Fiction Book Two",
        "author": "Author B"
    }
]

对于单个图书的详细信息，客户端请求可能是：

GET /api/books/1

服务器响应可能是：

{
    "id": 1,
    "title": "Fiction Book One",
    "author": "Author A",
    "description": "A thrilling fiction novel...",
    "price": 19.99
}

如果没有找到图书，服务器将返回404状态码。

结论

通过这个案例，我们展示了如何使用Spring MVC和RESTful API来构建一个在线图书商店的Web应用程序。Spring MVC控制器用于生成服务器端渲染的页面，而RESTful API控制器提供了轻量级的、易于消费的数据接口，适合于各种客户端，包括Web页面、移动应用和第三方服务。这种分离的架构不仅提高了应用程序的灵活性和可维护性，而且也适应了现代Web开发的需要。

让我们继续扩展在线图书商店的案例，这次我们将添加购物车和订单处理的功能，以及相应的RESTful API。

购物车和订单处理

1. 购物车控制器

首先，我们创建一个控制器来管理用户的购物车：

@Controller
public class ShoppingCartController {

    @GetMapping("/cart")
    public String showCart(Model model, @AuthenticationPrincipal Customer customer) {
        List<Book> cartItems = customer.getShoppingCart().getBooks();
        model.addAttribute("cartItems", cartItems);
        return "cart";
    }

    @PostMapping("/cart/add")
    public String addToCart(@RequestParam("bookId") Long bookId, 
                            @AuthenticationPrincipal Customer customer) {
        Book book = bookService.findBookById(bookId); // 假设bookService已实现
        if (book != null) {
            customer.getShoppingCart().addBook(book);
        }
        return "redirect:/cart";
    }
}

在这个控制器中，showCart方法显示购物车中的书籍，而addToCart方法允许用户将书籍添加到购物车中。

2. 购物车RESTful API控制器

接下来，我们创建一个RESTful API控制器来提供购物车的操作：

@RestController
@RequestMapping("/api/cart")
public class ShoppingCartApiController {

    @PostMapping("/add/{bookId}")
    public ResponseEntity<?> addToCart(@PathVariable Long bookId, 
                                        @AuthenticationPrincipal Customer customer) {
        Book book = bookService.findBookById(bookId); // 假设bookService已实现
        if (book != null) {
            customer.getShoppingCart().addBook(book);
            return ResponseEntity.ok().build();
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @GetMapping
    public ResponseEntity<List<Book>> getCartItems(@AuthenticationPrincipal Customer customer) {
        List<Book> cartItems = customer.getShoppingCart().getBooks();
        return ResponseEntity.ok(cartItems);
    }
}

这个控制器提供了添加书籍到购物车和获取购物车中所有书籍的API。

3. 订单控制器

然后，我们创建一个控制器来处理订单：

@Controller
public class OrderController {

    @PostMapping("/order")
    public String placeOrder(@AuthenticationPrincipal Customer customer, Model model) {
        List<Book> cartItems = customer.getShoppingCart().getBooks();
        Order order = orderService.createOrder(customer, cartItems); // 假设orderService已实现
        model.addAttribute("order", order);
        customer.getShoppingCart().clear(); // 清空购物车
        return "orderConfirmation";
    }
}

placeOrder方法创建一个订单并清空用户的购物车。

4. 订单RESTful API控制器

最后，我们创建一个RESTful API控制器来处理订单：

@RestController
@RequestMapping("/api/order")
public class OrderApiController {

    @PostMapping
    public ResponseEntity<Order> placeOrder(@AuthenticationPrincipal Customer customer) {
        List<Book> cartItems = customer.getShoppingCart().getBooks();
        Order order = orderService.createOrder(customer, cartItems); // 假设orderService已实现
        customer.getShoppingCart().clear(); // 清空购物车
        return ResponseEntity.ok(order);
    }
}

这个控制器提供了创建订单的API。

5. 视图页面

对于购物车视图，我们可能会有一个Thymeleaf模板，如下所示：

<html>
<head><title>Shopping Cart</title></head>
<body>
    <h1>Shopping Cart</h1>
    <div th:each="item : ${cartItems}">
        <h2 th:text="${item.title}"></h2>
        <p th:text="'Price: ' + ${item.price}"></p>
        <!-- 其他图书信息 -->
    </div>
    <form method="post" th:action="@{/order}">
        <button type="submit">Place Order</button>
    </form>
</body>
</html>

结论

通过这个案例，我们展示了如何在在线图书商店的Web应用程序中添加购物车和订单处理功能。我们使用了Spring MVC控制器来生成用户界面，并使用RESTful API控制器来提供与前端应用交互的接口。这种设计允许我们构建一个既适用于传统服务器端渲染页面，也适用于现代单页应用（SPA）或移动应用的Web服务。通过这种方式，我们可以为用户提供丰富且一致的购物体验。

让我们继续以在线图书商店的案例为基础，深入探讨购物车和订单处理的实现，包括后端服务的伪代码示例。

购物车服务

首先，我们定义一个简单的ShoppingCart类，用于存储购物车中的书籍和用户信息：

public class ShoppingCart {
    private List<Book> books;
    private Customer customer;

    public ShoppingCart(Customer customer) {
        this.customer = customer;
        this.books = new ArrayList<>();
    }

    public void addBook(Book book) {
        books.add(book);
    }

    public List<Book> getBooks() {
        return books;
    }

    public void clear() {
        books.clear();
    }

    // 可能还有其他方法，例如计算总价等
}

然后，我们创建一个Customer类，代表用户，并包含购物车：

public class Customer {
    private String id;
    private String name;
    private ShoppingCart shoppingCart;

    public Customer(String id, String name) {
        this.id = id;
        this.name = name;
        this.shoppingCart = new ShoppingCart(this);
    }

    public ShoppingCart getShoppingCart() {
        return shoppingCart;
    }

    // 省略其他属性和方法
}

订单服务

接下来，我们定义一个Order类，用于表示用户的订单：

public class Order {
    private Long orderId;
    private Customer customer;
    private List<Book> books;
    private Date orderDate;
    private double totalAmount;

    public Order(Customer customer, List<Book> books) {
        this.orderId = generateOrderId(); // 假设这个方法生成唯一的订单ID
        this.customer = customer;
        this.books = new ArrayList<>(books);
        this.orderDate = new Date();
        this.totalAmount = calculateTotalAmount();
    }

    private double calculateTotalAmount() {
        return books.stream().mapToDouble(Book::getPrice).sum();
    }

    // 省略其他属性和方法
}

然后，我们创建一个OrderService类，用于处理订单逻辑：

@Service
public class OrderService {

    // 假设bookService已注入并实现
    @Autowired
    private BookService bookService;

    public Order createOrder(Customer customer, List<Long> bookIds) {
        List<Book> books = bookService.findBooksByIds(bookIds);
        return new Order(customer, books);
    }
}

书籍服务

我们还需要一个BookService类来处理与书籍相关的逻辑：

@Service
public class BookService {

    // 假设有一个repository来访问数据库
    @Autowired
    private BookRepository bookRepository;

    public List<Book> findBooksByCategory(String category) {
        // 根据分类查询书籍
        return bookRepository.findByCategory(category);
    }

    public Book findBookById(Long id) {
        // 根据ID查询书籍
        return bookRepository.findById(id);
    }

    public List<Book> findBooksByIds(List<Long> ids) {
        // 根据ID列表查询书籍
        return bookRepository.findByIds(ids);
    }
}

数据访问层

最后，我们定义一个BookRepository接口，用于访问数据库：

public interface BookRepository extends JpaRepository<Book, Long> {
    List<Book> findByCategory(String category);
    // 其他可能的查询方法
}

请注意，上述代码示例中的服务和存储库方法都是伪代码，实际实现将依赖于具体的技术栈和业务需求。例如，JpaRepository是Spring Data JPA的一部分，它提供了一种声明式的方式来处理数据库操作。

通过这些服务和类，我们的在线图书商店应用程序能够处理用户的购物车和订单。用户可以浏览书籍，将书籍添加到购物车，查看购物车内容，然后下单购买。这些操作可以通过Spring MVC控制器和RESTful API控制器来触发，从而为不同的客户端提供服务。