简介：在现代Web应用开发中，jQuery、Servlet和JDK是核心技术组件。本文通过《Thinking in Java》的思路，深入探讨了这三个技术点及其在Web开发中的应用。jQuery简化了前端开发，实现了高效的DOM操作和动态页面更新；Servlet作为Java EE标准组件处理HTTP请求，优化Web应用交互；JDK提供了Java编程的环境和丰富的API，是构建复杂系统的基础。同时，面向对象的设计原则和模式也是提升代码质量的关键。本篇旨在帮助开发者通过理论和实践相结合的方式，熟练掌握这些技术，并理解它们在实际项目中的作用。
1. jQuery基础与高级操作
1.1 jQuery选择器与DOM操作
1.1.1 理解jQuery选择器
jQuery选择器是jQuery的核心之一，它允许开发者通过特定的模式来选择页面上的一个或多个DOM元素。它支持CSS选择器，并扩展了更多功能，如ID选择器（ #id ）、类选择器（ .class ）、属性选择器（ [attribute=value] ）等。使用jQuery选择器可以简洁高效地进行DOM操作。
1.1.2 DOM元素的获取与修改
通过jQuery选择器获取到的元素集可以使用 .html() , .text() , .val() 等方法进行内容的获取与修改。例如，获取一个段落的文本内容可以使用 $("p").text() ，修改段落内容则使用 $("p").text("新的文本内容") 。此外，还可以通过 .attr() 方法来获取和设置元素的属性值，如 $("img").attr("src", "image.jpg") 改变图片源地址。
// 示例代码
var paragraphText = $("p").text(); // 获取段落文本
$("p").text("Hello, jQuery!"); // 修改段落文本为"Hello, jQuery!"
var imageSrc = $("img").attr("src"); // 获取图片的src属性
$("img").attr("src", "new-image.jpg"); // 修改图片的src属性
通过这些基础操作，开发者能够灵活地控制页面上的元素，为创建动态网页提供了极大的便利。在后续章节中，我们将进一步探讨jQuery的事件处理机制、动画和特效，以及如何与Ajax技术相结合，实现更为丰富的网页交互功能。
2. Servlet在Web开发中的应用
2.1 Servlet概述与生命周期
2.1.1 Servlet技术核心概念
Servlet是Java EE技术中用于处理Web请求的核心组件。一个Servlet本质上是一个遵循特定接口的Java类。当Web服务器接收到一个HTTP请求后，它会创建一个Servlet实例来处理请求，并返回一个HTTP响应。Servlet的生命周期包括三个基本阶段：加载与实例化、初始化、服务和销毁。
// 一个简单的Servlet示例代码
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html><body>");
out.println("<h1>Hello, Servlet!</h1>");
out.println("</body></html>");
}
}
上述代码中， HelloServlet 类继承自 HttpServlet ，并重写了 doGet 方法用于处理GET请求。这个简单的Servlet仅仅返回了一个HTML页面。
2.1.2 Servlet生命周期的三个阶段
- 加载与实例化 ：Web服务器通过类加载器加载Servlet类，并创建其实例。
- 初始化 ：通过调用
init方法完成初始化。在初始化阶段，Servlet容器通常会传递一个ServletConfig对象给Servlet，其中包含了Servlet配置的初始化参数。 - 服务 ：这是Servlet生命周期中的核心部分。每次对Servlet发出请求时，服务方法（
service方法）都会被调用，并根据请求类型（GET、POST、PUT等）调用相应的处理方法（如doGet、doPost等）。 - 销毁 ：当Web应用卸载或服务器关闭时，Servlet容器会调用Servlet的
destroy方法，这允许Servlet执行任何必要的清理工作。
// Servlet的初始化方法
public void init(ServletConfig config) throws ServletException {
super(config);
// 可以在这里获取初始化参数
String welcomeMessage = config.getInitParameter("welcomeMessage");
// 进行其他初始化工作
}
在Servlet的 init 方法中，可以进行诸如初始化数据库连接、加载资源文件等操作。初始化完成之后，Servlet就可以响应用户的请求了。
2.2 Servlet与HTTP协议
2.2.1 HTTP请求和响应的处理
当客户端通过HTTP协议发送请求时，Web服务器接收请求并封装成一个 HttpServletRequest 对象传递给Servlet。同样，Servlet通过 HttpServletResponse 对象生成响应。
// 处理HTTP请求并返回响应
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
out.println("<h1>HTTP GET Request</h1>");
// 可以获取请求参数
String parameter = request.getParameter("param");
out.println("Received Parameter: " + parameter);
}
在上述代码中， doGet 方法处理了一个HTTP GET请求，并从请求中获取了一个名为"param"的参数。
2.2.2 Session与Cookie的管理
Servlet提供了管理用户会话的机制。使用 HttpSession 对象，可以跟踪用户的状态，如存储用户登录信息、购物车内容等。
// 设置会话属性
HttpSession session = request.getSession();
session.setAttribute("username", "user1");
// 获取会话属性
String username = (String) session.getAttribute("username");
在Web应用中，服务器通过发送包含会话标识的Cookie来识别不同的浏览器会话。服务器通过 HttpServletResponse 对象的 addCookie 方法设置Cookie。
// 设置Cookie
Cookie cookie = new Cookie("userLanguage", "en");
response.addCookie(cookie);
// 获取Cookie
Cookie[] cookies = request.getCookies();
if (cookies != null) {
for (Cookie c : cookies) {
if ("userLanguage".equals(c.getName())) {
String userLanguage = c.getValue();
break;
}
}
}
通过这种方式，Servlet管理用户的会话状态和偏好设置。
2.3 Servlet的高级特性
2.3.1 Filter和Listener的使用
Servlet过滤器（Filter）是一种用于对Servlet容器处理的请求和响应进行预处理和后处理的组件。过滤器可以帮助我们执行如日志记录、过滤请求或添加响应头等任务。
// Servlet过滤器示例
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class LoggingFilter implements Filter {
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest httpRequest = (HttpServletRequest) request;
HttpServletResponse httpResponse = (HttpServletResponse) response;
System.out.println("Logging Filter: " + httpRequest.getMethod() + " " + httpRequest.getRequestURI());
chain.doFilter(request, response);
}
}
监听器（Listener）是Servlet API中的组件，可以监听Web应用中发生的特定事件。例如， ServletContextListener 可以用来监听Web应用的生命周期事件，如应用启动和关闭。
// Servlet上下文监听器示例
import javax.servlet.*;
import javax.servlet.http.*;
public class MyServletContextListener implements ServletContextListener {
public void contextInitialized(ServletContextEvent sce) {
System.out.println("Web application initialized.");
}
public void contextDestroyed(ServletContextEvent sce) {
System.out.println("Web application destroyed.");
}
}
2.3.2 异步处理和文件上传处理
Servlet异步处理允许长时间运行的任务在后台线程上运行，而不阻塞Servlet容器线程。这样可以提高服务器处理请求的效率。
// 异步处理示例
public class AsyncServlet extends HttpServlet {
protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
final AsyncContext ctx = req.startAsync();
new Thread(new Runnable() {
public void run() {
// 进行业务处理
String result = longRunningTask();
// 将处理结果写入响应
PrintWriter out = ctx.getResponse().getWriter();
out.println(result);
// 结束异步处理
***plete();
}
}).start();
}
private String longRunningTask() {
// 模拟长时间操作
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Async result";
}
}
文件上传处理通常是通过集成第三方库（如Apache Commons FileUpload）来实现的，以便于处理多部分请求数据。
// 使用Apache Commons FileUpload库处理文件上传
FileItemFactory factory = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(factory);
List<FileItem> items = upload.parseRequest(request);
for (FileItem item : items) {
if (item.isFormField()) {
// 处理表单字段
} else {
// 上传文件处理
String fileName = item.getName();
File storeFile = new File(uploadDir, fileName);
item.write(storeFile);
}
}
2.4 Servlet安全实践
2.4.1 防止常见网络攻击
Servlet应用在Web开发中非常普遍，因此，了解和防范常见的网络攻击是必要的。包括XSS（跨站脚本攻击）、CSRF（跨站请求伪造）和SQL注入等。
- XSS攻击防范 ：在输出用户数据到HTML页面之前，应用必须进行适当的转义。
- CSRF攻击防范 ：确保对所有用户请求进行验证，比如使用令牌（token）机制。
- SQL注入防范 ：使用预编译语句（Prepared Statements）或存储过程来执行SQL语句。
2.4.2 安全配置的最佳实践
除了编码层面的防护，合理配置Web应用的安全性也很关键。这包括但不限于：
- 过滤不必要的HTTP方法 ：如果Web应用不使用某些HTTP方法，如PUT或DELETE，应当在服务器配置中禁用这些方法。
- 限制文件上传大小和类型 ：确保服务器配置限制了上传文件的大小和类型，防止恶意文件上传。
- 使用HTTPS ：始终使用SSL/TLS加密Web应用的通信，保障数据传输的安全。
<security-constraint>
<web-resource-collection>
<web-resource-name>Protected Area</web-resource-name>
<url-pattern>/*</url-pattern>
<http-method>PUT</http-method>
<http-method>DELETE</http-method>
</web-resource-collection>
<auth-constraint/>
</security-constraint>
上述XML配置片段展示了如何在web.xml文件中配置Web资源集合以限制HTTP方法的访问。这是一个基本的示例，实际部署时应根据应用的特定需求进行相应的安全配置。
Servlet作为Java EE的核心组件，在Web开发中占据着举足轻重的地位。通过学习Servlet的生命周期、处理HTTP协议的机制、高级特性和安全实践，开发者可以更好地构建健壮和安全的Web应用。
3. Java开发环境与核心API
3.1 JDK的安装与配置
Java开发离不开一个稳定且高效的开发环境。JDK（Java Development Kit）是进行Java编程的必需工具包，它包含了一系列的工具，比如编译器、Java运行时环境（JRE）、类库等。选择和配置正确的JDK版本对于项目的成功至关重要。
3.1.1 JDK版本的选择与安装
在选择JDK版本时，应该考虑到项目的兼容性、稳定性以及开发工具链的支持。对于新项目，通常推荐使用最新的稳定版JDK。例如，截至知识截止日期，JDK 11和JDK 17被认为是企业级开发的可靠选择。
安装步骤
- 下载JDK安装包：前往Oracle官网或其他JDK提供商网站下载所需版本的JDK。
- 运行安装程序：根据操作系统，运行下载的安装文件。
- 配置环境变量：安装完成后，需要配置Java的环境变量，如
JAVA_HOME、PATH和CLASSPATH。
# 对于Linux/Unix/Mac系统
export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH
# 对于Windows系统
set JAVA_HOME=C:\path\to\jdk
set PATH=%JAVA_HOME%\bin;%PATH%
3.1.2 环境变量的配置方法
环境变量的配置是确保JDK安装正确并能被系统识别的关键步骤。这一步骤会告诉操作系统在哪里可以找到JDK及其相关工具。
配置指南
-
JAVA_HOME是JDK安装的根目录。 -
PATH变量确保在任何目录下都可以通过命令行调用Java命令，比如java、javac。 -
CLASSPATH变量用于指定Java类加载器搜索类路径的位置。
# 示例环境变量配置，以Linux为例
export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
export PATH=$JAVA_HOME/bin:$PATH
export CLASSPATH=.:$JAVA_HOME/lib/*
-
.代表当前目录，*代表所有子目录，$JAVA_HOME/lib/*是Java类库的位置。
3.2 Java核心API概述
Java的核心API提供了一整套丰富的类和接口，使得开发人员能够更高效地进行编程。核心API分为不同的包，如 java.lang 、 java.util 、 java.io 等，覆盖了语言基础、集合框架、输入输出处理等多个方面。
3.2.1 Java集合框架
Java集合框架提供了数据结构的实现，用于存储和操作对象集合。它主要包括 List 、 Set 、 Map 等接口。
集合框架的组成
-
List是一个有序集合，可以包含重复的元素，如ArrayList和LinkedList。 -
Set是一个不允许重复元素的集合，如HashSet和TreeSet。 -
Map是一个存储键值对的集合，如HashMap和TreeMap。
使用集合的示例代码
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class CollectionExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("apple");
list.add("banana");
Map<String, Integer> map = new HashMap<>();
map.put("apple", 1);
map.put("banana", 2);
// 使用循环遍历List和Map
for (String fruit : list) {
System.out.println(fruit);
}
for (Map.Entry<String, Integer> entry : map.entrySet()) {
System.out.println("Fruit: " + entry.getKey() + ", Count: " + entry.getValue());
}
}
}
3.2.2 Java I/O流的使用
Java的输入输出（I/O）流用于读取和写入数据。它提供了丰富的类来处理不同类型的I/O操作。
I/O流的分类
-
InputStream和Reader用于从源读取数据。 -
OutputStream和Writer用于向目标写入数据。 -
FileInputStream、FileOutputStream等用于文件的读写。 -
BufferedReader和BufferedWriter提供了缓冲处理，提高效率。
I/O流的使用示例代码
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class IOTest {
public static void main(String[] args) {
String inputFilePath = "input.txt";
String outputFilePath = "output.txt";
try (BufferedReader reader = new BufferedReader(new FileReader(inputFilePath));
BufferedWriter writer = new BufferedWriter(new FileWriter(outputFilePath))) {
String line;
while ((line = reader.readLine()) != null) {
writer.write(line.toUpperCase());
writer.newLine();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
- 使用
BufferedReader读取输入文件，并使用BufferedWriter将内容转换为大写后写入输出文件。 -
try-with-resources语句确保在操作完成后释放资源。
3.3 Java工具的高效应用
Java不仅是一种编程语言，它还提供了一整套工具来辅助开发，包括编译器、打包工具和调试工具。
3.3.1 Java编译器与打包工具
javac 是Java的编译器，用于将 .java 文件编译成 .class 字节码文件。Java的打包工具如 jar 命令，可以将多个 .class 文件打包成一个可执行的JAR文件。
编译和打包示例
# 编译Java源文件
javac Main.java
# 创建包含所有编译后的类文件的JAR文件
jar cf app.jar *.class
3.3.2 Java调试工具的使用技巧
jdb 是Java的命令行调试器，能够帮助开发者检查程序中的错误。使用 jdb 可以设置断点、单步执行代码、查看变量值等。
调试技巧
- 使用
-sourcepath设置源代码路径。 - 使用
-classpath设置类路径。 - 使用
break设置断点。 - 使用
run启动程序。 - 使用
next、step进行单步调试。
# 使用jdb进行调试
jdb -sourcepath src -classpath bin -attach 1234
-
1234是运行中的Java进程的ID。
以上章节内容通过展示安装、配置、核心API使用以及Java工具应用的实际操作，为Java开发者提供了一个全面的参考，以确保在日常开发工作中能够高效运用Java开发环境。
4. 面向对象设计原则及模式实践
4.1 面向对象基础
4.1.1 类、对象与继承
面向对象编程（OOP）是软件开发中的一种编程范式，它使用“对象”来设计软件。对象可以包含数据，以字段（通常称为属性或成员变量）的形式，以及代码，以方法（函数）的形式。面向对象的程序由对象之间的相互作用构成。
类 是创建对象的蓝图或模板。它定义了对象将拥有哪些字段和方法，但并不实际创建对象。对象是类的实例。例如，如果我们有一个 Car 类，那么具体的每辆车，如 myCar ，都是 Car 类的一个实例。
继承 是面向对象编程中代码复用的一种机制。通过继承，新的类（称为子类）可以继承一个已存在的类（称为父类或超类）的字段和方法。这样，子类就可以在父类的基础上添加新的功能或重写某些方法。
class Vehicle {
private String color;
public void start() {
System.out.println("Vehicle is starting.");
}
}
class Car extends Vehicle {
private int numberOfDoors;
public void start() {
System.out.println("Car is starting with " + numberOfDoors + " doors.");
}
}
public class InheritanceExample {
public static void main(String[] args) {
Car myCar = new Car();
myCar.start(); // 输出: Car is starting with 0 doors.
myCar.numberOfDoors = 4;
myCar.start(); // 输出: Car is starting with 4 doors.
}
}
4.1.2 封装、多态与抽象类
封装 是OOP的一个核心原则，它指的是将对象的状态（数据）以及行为（方法）捆绑在一起，隐藏对象的内部实现细节，并通过定义公共接口来暴露有限的操作。
多态 是同一个行为具有多个不同表现形式或形态的能力。在面向对象编程中，多态指的是允许不同类的对象对同一消息做出响应。Java通过方法重载和方法重写实现多态。
抽象类 是不能实例化的类，它们通常作为其他类的超类，并提供一些通用的属性和方法。抽象类可以包含抽象方法，这些方法没有具体实现（即没有方法体），必须由子类来实现。
abstract class Animal {
abstract void makeSound();
}
class Dog extends Animal {
void makeSound() {
System.out.println("Bark!");
}
}
class Cat extends Animal {
void makeSound() {
System.out.println("Meow!");
}
}
public class PolymorphismExample {
public static void makeAnimalSound(Animal animal) {
animal.makeSound();
}
public static void main(String[] args) {
Dog dog = new Dog();
Cat cat = new Cat();
makeAnimalSound(dog); // 输出: Bark!
makeAnimalSound(cat); // 输出: Meow!
}
}
4.2 设计原则深入
4.2.1 单一职责原则与开闭原则
单一职责原则 （SRP）指出一个类应该仅有一个引起它变化的原因。也就是说，一个类应该只有一个职责或任务。如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。
开闭原则 （OCP）指出软件实体（类、模块、函数等）应该是可扩展的，但是不可修改的。这意味着，当应用的需求变化时，在不修改现有代码的基础上扩展软件的行为，以满足新的需求。
class PaymentProcessor {
public void processPayment(String type, double amount) {
if ("credit".equals(type)) {
// 处理信用卡支付
} else if ("debit".equals(type)) {
// 处理借记卡支付
}
// 可以增加更多的支付方式，但不需要修改现有的代码
}
}
// 假设在未来我们引入了新的支付方式，我们可以扩展PaymentProcessor类而不是修改它
4.2.2 依赖倒置与接口隔离原则
依赖倒置原则 （DIP）提倡高层模块不应该依赖于低层模块，它们都应该依赖于抽象。这表示抽象不应该依赖于细节，而细节应该依赖于抽象。通过依赖倒置，可以减少模块间的耦合，使系统更加灵活易变。
接口隔离原则 （ISP）建议不要强迫客户依赖于它们不用的方法。换句话说，一个类对另一个类的依赖应该建立在最小的接口上。这有助于减少客户所需实现的方法数量。
// ISP 示例
interface IMobilePhone {
void makeCall();
void sendTextMessage();
// 该接口提供了所有手机共有的方法
}
interface ICameraPhone extends IMobilePhone {
void takePhoto();
// 只有带有相机功能的手机才实现这个接口
}
class BasicPhone implements IMobilePhone {
// ...
}
class CameraPhone implements ICameraPhone {
// ...
}
// 只需要拍照功能的手机只需要实现ICameraPhone接口，而不需要实现不需要的IMobilePhone方法
4.3 设计模式应用
4.3.1 创建型模式的实例解析
创建型模式涉及对象的创建机制，它们帮助系统独立于如何创建、组合和表示它们的对象。常见的创建型模式包括单例模式、工厂方法模式、抽象工厂模式、建造者模式和原型模式。
单例模式 确保一个类只有一个实例，并提供一个全局访问点。这个模式用于全局的访问点以及贯穿整个应用程序的配置信息。
class Singleton {
private static Singleton uniqueInstance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return uniqueInstance;
}
}
工厂方法模式 定义了一个创建对象的接口，但让子类决定实例化哪一个类。工厂方法把类的实例化推迟到子类中进行。
interface IProduct {
void operation();
}
class ConcreteProduct implements IProduct {
public void operation() {
// ...
}
}
abstract class Creator {
public abstract IProduct factoryMethod();
}
class ConcreteCreator extends Creator {
public IProduct factoryMethod() {
return new ConcreteProduct();
}
}
4.3.2 结构型与行为型模式的运用
结构型模式涉及如何组合类和对象以获得更大的结构，常见的结构型模式包括适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式和代理模式。
行为型模式涉及算法和对象间职责的分配。行为型模式包括模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、访问者模式和责任链模式。
观察者模式 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
interface Observer {
void update(float temp, float humidity, float pressure);
}
interface Subject {
void registerObserver(Observer o);
void removeObserver(Observer o);
void notifyObservers();
}
class WeatherData implements Subject {
private List<Observer> observers;
private float temp;
private float humidity;
private float pressure;
public WeatherData() {
observers = new ArrayList<Observer>();
}
public void registerObserver(Observer o) {
observers.add(o);
}
public void removeObserver(Observer o) {
int i = observers.indexOf(o);
if (i >= 0) {
observers.remove(i);
}
}
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(temp, humidity, pressure);
}
}
public void measurementsChanged() {
notifyObservers();
}
public void setMeasurements(float temp, float humidity, float pressure) {
this.temp = temp;
this.humidity = humidity;
this.pressure = pressure;
measurementsChanged();
}
}
class CurrentConditionsDisplay implements Observer {
private float temp;
private float humidity;
private Subject weatherData;
public CurrentConditionsDisplay(Subject weatherData) {
this.weatherData = weatherData;
weatherData.registerObserver(this);
}
public void update(float temp, float humidity, float pressure) {
this.temp = temp;
this.humidity = humidity;
display();
}
public void display() {
System.out.println("Current conditions: " + temp + "F degrees and " + humidity + "% humidity");
}
}
在上面的观察者模式示例中， WeatherData 类实现了 Subject 接口，它允许注册、移除和通知观察者。 CurrentConditionsDisplay 类实现了 Observer 接口，并通过 update 方法接收来自 WeatherData 的更新。当 WeatherData 对象的测量值改变时，它会调用 measurementsChanged 方法，该方法又通知所有注册的观察者，包括当前条件显示更新其显示。这种设计允许 WeatherData 对象与 CurrentConditionsDisplay 对象解耦，提高了系统的可维护性和灵活性。
5. 前端与后端的交互实现
5.1 jQuery与Servlet交互基础
5.1.1 jQuery的Ajax请求细节
在Web开发中，前端与后端的通信是构建动态网页不可或缺的部分。使用jQuery，开发者可以轻松地发出Ajax请求来与后端Servlet进行交互。了解这些细节是构建现代Web应用的重要一步。
请求细节的构建 ： - 首先，需要使用jQuery的 $.ajax() 方法发起Ajax请求。该方法有多种参数可以配置，其中 url 是请求的地址， type 是请求的类型（如GET或POST）， data 是发送的数据， dataType 是预期的服务器响应数据类型。
$.ajax({
url: "someServlet", // 请求的目标地址
type: "POST", // 请求类型
data: { key1: "value1", key2: "value2" }, // 发送的数据
dataType: "json", // 期望的服务器响应数据类型
success: function(response) {
console.log(response); // 请求成功后的回调函数
},
error: function(xhr, status, error) {
console.error("Error: " + error); // 请求失败的回调函数
}
});
- 参数说明：
url指向后端Servlet的路径，type设置为POST表示以POST方法发送数据，data是一个对象，其中包含了要发送的数据，dataType设置为json意味着服务器返回的数据将被解析为JSON格式。success和error函数分别定义了请求成功和失败后的回调。
参数配置详解 ： - url ：此参数是请求发送到的服务器地址。通常，这将是Servlet的路径，可以是相对路径或绝对路径。 - type ：此参数指定了请求的HTTP方法（GET, POST, PUT, DELETE等）。选择哪种方法取决于你的需求，例如，GET用于从服务器检索信息，而POST用于提交数据到服务器。 - data ：这是一个可选参数，用于发送数据到服务器。它应是一个键值对格式的对象，jQuery会自动将它序列化为请求体。 - dataType ：这个参数告知jQuery我们期望服务器返回的数据类型。常用的有 json 、 xml 、 text 、 html 等。如果服务器正确地设置了 Content-Type 响应头，jQuery通常能自动处理响应类型。
5.1.2 Servlet处理Ajax请求的响应
在Servlet端，需要对Ajax请求进行接收和响应。处理Ajax请求与处理常规HTTP请求在本质上是相同的，但Servlet需要特别注意响应的内容类型和数据格式。
请求的接收 ： - 使用 request.getParameter() 方法获取GET请求参数，使用 request.getParameterMap() 获取所有的GET参数。 - 对于POST请求，如果发送的数据是表单数据，可以使用 request.getParameter() 方法获取，如果发送的数据是JSON或XML等格式，通常需要使用输入流读取数据，然后进行相应的解析。
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("application/json"); // 设置响应的内容类型为JSON
PrintWriter out = response.getWriter();
// 假设发送的数据是JSON格式
StringBuilder jsonInput = new StringBuilder();
String line;
while ((line = request.getReader().readLine()) != null) {
jsonInput.append(line);
}
// 进行JSON解析...
// 响应数据
out.print("{\"status\":\"success\", \"message\":\"Request processed\"}");
out.flush();
}
- 代码逻辑：首先设置了响应的内容类型为JSON，然后获取了
PrintWriter用于写入响应数据。通过输入流读取了整个请求体，并假设其内容是JSON格式。在实际应用中，可能需要使用专门的JSON解析库如Jackson或Gson来解析请求体。 - 参数说明：在Servlet中设置
response.setContentType("application/json")是为了告诉客户端我们返回的数据类型是JSON，这样客户端（如浏览器中的jQuery）就能正确地解析返回的数据。
响应的发送 ： - 使用 PrintWriter 对象的 print 和 println 方法来发送响应数据。在本例中，返回了一个简单的JSON对象来表示操作成功和一条消息。 - Servlet还应该处理异常和错误，确保返回合适的HTTP状态码（如200 OK、404 Not Found、500 Internal Server Error等）。
5.2 数据交互格式的处理
5.2.1 JSON数据的序列化与反序列化
在Web应用中，数据交换格式的选择对前后端交互的灵活性和易用性至关重要。JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，因其易于阅读和编写，以及跨平台特性被广泛使用。
序列化（数据转换为JSON格式） ： - Java对象需要转换为JSON格式字符串，以便在前端使用。可以使用 org.json 库的 JSONObject 类或使用更加强大的第三方库如Jackson或Gson进行序列化。
import org.json.JSONObject;
import com.google.gson.Gson;
// 假设有一个Java对象
Person person = new Person("John", 25);
// 使用org.json库进行序列化
JSONObject json = new JSONObject();
json.put("name", person.getName());
json.put("age", person.getAge());
String jsonString = json.toString();
// 使用Gson库进行序列化
Gson gson = new Gson();
String jsonString = gson.toJson(person);
-
org.json库的JSONObject类能够手动构建JSON对象并将其转换为字符串。而使用Gson库则可以更直接地将整个对象转换为JSON字符串。Gson在处理复杂对象和嵌套结构时通常更为方便和强大。
反序列化（JSON格式转换为数据对象） ： - 当需要将JSON字符串解析回Java对象时，同样可以使用上述两种方法。
// 使用org.json库进行反序列化
JSONObject json = new JSONObject(jsonString);
String name = json.getString("name");
int age = json.getInt("age");
Person person = new Person(name, age);
// 使用Gson库进行反序列化
Gson gson = new Gson();
Person person = gson.fromJson(jsonString, Person.class);
-
org.json库通过getString和getInt等方法读取值，而Gson库通过fromJson方法直接将JSON字符串转换为指定类型的对象。Gson在处理反序列化时也具有类型安全的优势，可以自动匹配字段名并转换数据类型。
JSON处理工具的选择 ： - 根据项目需求和开发者的偏好，可以选择合适的JSON处理工具。对于简单的应用场景， org.json 库足够使用。对于需要处理复杂对象或需要更多定制化的场景，Gson或Jackson等库提供了更多的功能和灵活性。
5.2.2 XML数据处理的方法
XML（eXtensible Markup Language）是另一种广泛使用的数据交换格式。虽然JSON由于其简洁性在Web开发中占据了主导地位，但在某些领域和企业级应用中，XML仍然是首选的数据格式。
XML序列化 ： - Java对象到XML的转换通常涉及使用如JAXB（Java Architecture for XML Binding）这样的库，它能够将Java类绑定到XML表示。
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;
@XmlRootElement(name = "person")
class Person {
private String name;
private int age;
// getters and setters
}
public void convertObjectToXML(Person person) throws Exception {
JAXBContext context = JAXBContext.newInstance(Person.class);
Marshaller marshaller = context.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
marshaller.marshal(person, System.out);
}
-
@XmlRootElement注解用于标记这个类的实例可以被序列化为XML文档的根元素。JAXBContext是JAXB API的入口点，用于创建Marshaller实例，它负责完成Java对象到XML的转换。 - 注意，JAXB能够将Java对象的属性自动转换为XML元素，包括处理复杂的数据类型转换。
XML反序列化 ： - 将XML文档解析回Java对象通常使用同样的库JAXB。
import java.io.StringReader;
public Person convertXMLToObject(String xml) throws Exception {
JAXBContext context = JAXBContext.newInstance(Person.class);
Unmarshaller unmarshaller = context.createUnmarshaller();
return (Person) unmarshaller.unmarshal(new StringReader(xml));
}
-
Unmarshaller对象用于将XML文档解析回Java对象。在此示例中，使用了StringReader来提供XML文档的内容。
XML与JSON的比较 ： - 从易用性角度来看，JSON的语法更为简洁明了，对开发者更为友好。而XML格式更为严格和规范，适用于需要更复杂结构的应用场景。 - 从处理复杂性和灵活性角度来看，XML提供了更多的标签和属性控制，而JSON更依赖于数据结构的一致性。 - 根据实际需求选择合适的格式，如果数据交换需要更严格的规范和层次结构，XML可能是更好的选择；反之，如果需要高效和简洁的数据交换，JSON是更佳的选择。
5.3 实战案例分析
5.3.1 简单CRUD操作的前后端交互
在Web开发中，CRUD（创建(Create)、读取(Read)、更新(Update)、删除(Delete)）操作是最基本的功能。本节将通过一个简单的CRUD操作案例，展示前后端如何通过jQuery和Servlet进行交互。
案例概述 ： - 假设我们正在开发一个用户管理系统，需要实现用户的增加、查询、更新和删除功能。前端使用jQuery通过Ajax请求与Servlet进行交互，后端Servlet处理这些请求并操作数据库。
后端Servlet的实现 ：
@WebServlet("/user")
public class UserServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 获取操作类型
String action = request.getParameter("action");
if ("create".equals(action)) {
// 处理创建用户
// ...
} else if ("read".equals(action)) {
// 处理读取用户
// ...
} else if ("update".equals(action)) {
// 处理更新用户
// ...
} else if ("delete".equals(action)) {
// 处理删除用户
// ...
}
}
// GET方法的处理
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doPost(request, response);
}
}
- Servlet通过
request.getParameter("action")获取前端发送的操作类型，根据操作类型执行对应的数据库操作。
前端jQuery的实现 ：
// 创建用户
function createUser() {
$.ajax({
url: "user?action=create",
// 其他参数省略
});
}
// 读取用户
function readUser() {
$.ajax({
url: "user?action=read",
// 其他参数省略
});
}
// 更新用户
function updateUser() {
$.ajax({
url: "user?action=update",
// 其他参数省略
});
}
// 删除用户
function deleteUser() {
$.ajax({
url: "user?action=delete",
// 其他参数省略
});
}
- 每个函数通过改变
action参数的值来调用不同的CRUD操作。
5.3.2 异步文件上传与下载的实现
Web应用中另一个常见的交互是文件上传和下载。在本案例中，我们将介绍如何使用jQuery和Servlet实现异步文件上传和下载。
异步文件上传的实现 ：
<form id="uploadForm" enctype="multipart/form-data">
<input type="file" name="file" />
<input type="button" value="Upload" onclick="uploadFile()" />
</form>
function uploadFile() {
var formData = new FormData(document.getElementById("uploadForm")[0]);
$.ajax({
url: "uploadServlet",
type: "POST",
data: formData,
contentType: false,
processData: false,
success: function(response) {
alert("上传成功");
},
error: function(xhr, status, error) {
alert("上传失败: " + error);
}
});
}
-
FormData对象用于构建表单数据，以便进行文件上传。 -
processData和contentType设置为false，以确保数据正确地以multipart/form-data格式发送。 -
uploadServlet是一个处理文件上传的Servlet，它需要解析multipart/form-data类型的请求，并将上传的文件保存到服务器。
异步文件下载的实现 ：
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 设置响应头以指示下载
response.setContentType("application/octet-stream");
response.setHeader("Content-Disposition", "attachment; filename=\"filename.ext\"");
// 获取文件名
String fileName = request.getParameter("filename");
// 假设有一个方法用于获取文件的输入流
InputStream is = getFileInputStream(fileName);
// 将文件内容复制到响应输出流
IOUtils.copy(is, response.getOutputStream());
// 关闭输入流和输出流
is.close();
response.flushBuffer();
}
- 在Servlet中，通过设置
Content-Disposition响应头的值为attachment，可以指示浏览器这是一个需要下载的文件。 - 使用
getFileInputStream方法获取要下载文件的输入流，然后使用IOUtils.copy方法将输入流的内容复制到响应输出流中。 - 最后，关闭输入流和输出流，并调用
response.flushBuffer()确保所有数据都被发送到客户端。
通过这些操作，我们能够实现前后端之间文件的上传和下载。对于用户来说，整个过程是透明的，用户体验得到了极大的提升。
6. JDK API在Web开发中的应用
6.1 Java API在Servlet中的应用
6.1.1 JDBC数据库操作
在Web开发中，数据库操作是不可或缺的一环。JDBC（Java Database Connectivity）是一个Java API，可以用来连接和执行查询到多种数据库。在Servlet中，我们可以利用JDBC进行数据的CRUD操作，即创建(Create)、读取(Read)、更新(Update)和删除(Delete)操作。
首先，我们需要添加JDBC驱动到项目的依赖中，例如对于MySQL数据库，我们通常需要添加如下依赖：
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.23</version>
</dependency>
接下来，通过以下步骤实现JDBC数据库操作：
- 加载数据库驱动。
- 建立与数据库的连接。
- 创建一个
Statement或者PreparedStatement对象来执行SQL语句。 - 处理执行结果，例如通过
ResultSet获取查询结果。 - 关闭连接和释放资源。
下面是一个简单的示例，演示如何使用JDBC API查询MySQL数据库：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class JDBCDemo {
static final String JDBC_DRIVER = "com.mysql.cj.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC";
static final String USER = "yourUsername";
static final String PASS = "yourPassword";
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
// Step 1: Register JDBC driver
Class.forName(JDBC_DRIVER);
// Step 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
// Step 3: Execute a query
System.out.println("Creating statement...");
stmt = conn.createStatement();
String sql;
sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql);
// Step 4: Extract data from result set
while (rs.next()) {
// Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");
// Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First Name: " + first);
System.out.println(", Last Name: " + last);
}
// Step 5: Clean-up environment
rs.close();
stmt.close();
conn.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
// finally block used to close resources
try {
if (stmt != null) stmt.close();
} catch (SQLException se2) {
} // nothing we can do
try {
if (conn != null) conn.close();
} catch (SQLException se) {
se.printStackTrace();
}
}
System.out.println("Goodbye!");
}
}
6.1.2 JavaMail发送邮件
在Web应用程序中，发送邮件是一个常见的需求。JavaMail API提供了一系列的类和接口用于发送电子邮件。要使用JavaMail，首先需要将相关依赖添加到项目中：
<dependency>
<groupId>com.sun.mail</groupId>
<artifactId>javax.mail</artifactId>
<version>1.6.2</version>
</dependency>
以下是使用JavaMail API发送邮件的一个简单示例：
import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
public class SendEmail {
public static void main(String[] args) {
// Get system properties
Properties properties = System.getProperties();
// Setup mail server
properties.setProperty("mail.smtp.host", "***");
properties.setProperty("mail.smtp.port", "465");
properties.setProperty("mail.smtp.ssl.enable", "true");
properties.setProperty("mail.smtp.auth", "true");
// Get session object
Session session = Session.getInstance(properties,
new javax.mail.Authenticator() {
protected javax.mail.PasswordAuthentication getPasswordAuthentication() {
return new javax.mail.PasswordAuthentication("***", "password");
}
});
try {
// Create a default MimeMessage object
MimeMessage message = new MimeMessage(session);
// Set From: header field of the header.
message.setFrom(new InternetAddress("***"));
// Set To: header field of the header.
message.addRecipient(Message.RecipientType.TO, new InternetAddress("***"));
// Set Subject: header field
message.setSubject("This is the Subject Line!");
// Now set the actual message
message.setText("This is actual message");
// Send message
Transport.send(message);
System.out.println("Sent message successfully....");
} catch (MessagingException mex) {
mex.printStackTrace();
}
}
}
在实际的Servlet中，邮件发送通常是在后端进行，例如在用户注册完成、忘记密码等业务场景中。由于邮件发送可能会耗费较长时间，并且可能失败，通常会采用异步方式或消息队列来处理。
6.2 网络编程与多线程处理
6.2.1 Java网络编程基础
网络编程使得两个运行在网络上的程序能够进行通信。Java提供了 *** 包来支持网络编程，主要类和接口包括 Socket 、 ServerSocket 、 URL 、 URLConnection 等。下面的示例展示了如何使用 Socket 建立一个简单的客户端连接到服务器：
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
***.Socket;
public class Client {
public static void main(String[] args) {
String host = "localhost";
int port = 1234;
try (Socket socket = new Socket(host, port);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in))) {
String userInput;
while ((userInput = stdIn.readLine()) != null) {
out.println(userInput);
System.out.println("SERVER: " + in.readLine());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
对于服务器端，需要使用 ServerSocket 来监听客户端的连接请求：
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
***.ServerSocket;
***.Socket;
public class Server {
public static void main(String[] args) {
int port = 1234;
try (ServerSocket serverSocket = new ServerSocket(port);
Socket clientSocket = serverSocket.accept();
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in))) {
String userInput;
out.println("Hello! You are connected to the server.");
out.flush();
while ((userInput = in.readLine()) != null) {
System.out.println("Client: " + userInput);
out.println("Server: " + stdIn.readLine());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
6.2.2 多线程在Servlet中的应用
由于Web服务器需要同时处理来自多个用户的请求，多线程编程在Web开发中就显得十分重要。Servlet API提供了 SingleThreadModel 接口来控制Servlet的并发执行，但这种方式已被弃用，因为它会导致性能问题。更常用的方式是直接在Servlet中管理线程，如使用 Thread 或 ExecutorService 。
下面的代码片段展示了如何在Servlet中使用线程来异步处理请求：
protected void doGet(HttpServletRequest request, HttpServletResponse response) {
new Thread(new Runnable() {
public void run() {
try {
// 处理请求的业务逻辑
// ...
} finally {
// 清理工作
// ...
}
}
}).start();
}
然而，使用裸线程手动管理异步处理可能会导致代码难以维护。为此，可以使用 @Async 注解和Spring的 AsyncTaskExecutor 来简化异步处理，使***t保持简洁。
6.3 安全机制与性能优化
6.3.1 Java加密技术的应用
为了保证Web应用程序的安全，Java提供了多种加密技术，比如使用 MessageDigest 、 Cipher 、 Mac 等类实现数据的加密与解密。在Servlet中，我们通常会在需要安全通讯的情况下使用这些技术，比如在用户登录时加密密码，或者使用HTTPS来保护数据传输。
以下是一个简单的加密和解密过程示例：
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
public class EncryptionDemo {
public static void main(String[] args) throws Exception {
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(128);
SecretKey secretKey = keyGen.generateKey();
byte[] keyBytes = secretKey.getEncoded();
// 使用密钥加密数据
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] encryptedData = cipher.doFinal("This is a secret message".getBytes());
System.out.println("Encrypted data: " + bytesToHex(encryptedData));
// 使用密钥解密数据
cipher.init(Cipher.DECRYPT_MODE, secretKey);
byte[] decryptedData = cipher.doFinal(encryptedData);
System.out.println("Decrypted data: " + new String(decryptedData));
}
public static String bytesToHex(byte[] bytes) {
StringBuilder hexString = new StringBuilder(2 * bytes.length);
for (int i = 0; i < bytes.length; i++) {
String hex = Integer.toHexString(0xff & bytes[i]);
if (hex.length() == 1) {
hexString.append('0');
}
hexString.append(hex);
}
return hexString.toString();
}
}
6.3.2 Servlet性能调优技巧
Servlet性能优化是提高Web应用响应速度和处理能力的重要手段。性能调优可以从多个方面进行：
- 使用连接池来提高数据库连接的效率。
- 使用缓存来减少数据库查询次数，比如使用
@Cacheable注解。 - 优化Servlet线程模型，例如设置合理的线程池。
- 使用异步处理技术来避免阻塞IO操作。
- 对静态资源使用专门的Web服务器或CDN进行服务。
- 对页面进行压缩，减少数据传输量。
除此之外，还有许多其他可选策略，比如对数据库查询进行优化，使用全文搜索等高级技术，以及监控应用性能来识别瓶颈并进行调整。
总结
在本章节中，我们深入探讨了JDK API在Web开发中的实际应用，包括数据库操作、邮件发送、网络编程、多线程处理以及加密技术和性能优化。这些技能对于构建高效、安全且具有高度可维护性的Web应用至关重要。通过理解和实践这些技术，开发者将能够在Web开发的道路上走得更远、更快。
7. 综合项目实战演练
7.1 需求分析与设计规划
7.1.1 项目背景与目标
在当今快速发展的IT行业，一个成功的项目往往需要清晰的背景认知和明确的目标导向。以开发一款在线购物商城为例，项目背景可能涉及当前电子商务的蓬勃发展和消费者对网络购物便捷性的需求。项目的目标是实现一个用户友好、响应迅速、功能齐全的在线购物平台，能够处理商品浏览、搜索、下单、支付和用户管理等基本功能，并在后续版本中考虑增加推荐系统、用户评论和社交媒体集成等高级功能。
7.1.2 系统架构设计与技术选型
为了确保项目的技术路线可行性和系统的可扩展性，系统架构设计需要采用模块化、分层和微服务等设计理念。本项目中，前端采用React或Vue框架，以提高用户界面的交互体验。后端则选择Spring Boot框架，因其具备快速开发、独立运行的特点，适合构建微服务架构。数据库采用MySQL或PostgreSQL，其稳定性和高性能能够满足商城系统的需求。
7.2 功能模块划分与开发
7.2.1 前端界面设计与实现
前端界面的设计需要考虑用户体验和界面美观。商城首页应包含导航栏、搜索栏、商品展示区、促销信息等。商品详情页则需要展示商品图片、描述、价格、用户评价以及购买按钮。在实现过程中，开发者需要编写React或Vue组件，通过与后端API的交互来动态获取和展示数据。CSS和JavaScript用于页面样式的定制和交互逻辑的实现。
7.2.2 后端逻辑开发与数据库设计
后端开发者需要处理的核心业务逻辑包括用户认证、商品管理、订单处理和支付接口等。在逻辑开发过程中，采用RESTful API设计原则，确保系统的前后端分离。数据库设计则需要创建清晰的ER模型，确保数据的一致性和完整性。例如，设计用户表、商品表、订单表和购物车表，并通过外键来关联这些表。
7.3 测试、部署与维护
7.3.* 单元测试与集成测试
项目开发完成后，测试成为了保证软件质量和稳定性的关键步骤。单元测试针对单个模块或组件进行，确保其按照预期工作。而集成测试则是检查不同模块协同工作时的整体表现。单元测试可以使用JUnit或TestNG框架来完成，集成测试则可能涉及Selenium或Postman。测试覆盖率应当达到预定的目标，以减少潜在的bug和漏洞。
7.3.2 应用部署与运维监控
应用部署通常采用容器化技术，例如Docker和Kubernetes，这有助于实现快速部署和扩展。运维监控包括日志分析、性能监控和故障恢复。常见的监控工具包括ELK Stack、Prometheus和Grafana。通过持续集成/持续部署(CI/CD)流水线，自动化测试和部署可以显著提高运维效率。
在实施监控策略时，应当设置合理的告警阈值，并确保监控系统的可靠性，以便在系统出现问题时能够及时响应。这些监控机制能够帮助团队快速定位问题，持续优化应用性能，确保平台的高可用性和良好的用户体验。
简介：在现代Web应用开发中，jQuery、Servlet和JDK是核心技术组件。本文通过《Thinking in Java》的思路，深入探讨了这三个技术点及其在Web开发中的应用。jQuery简化了前端开发，实现了高效的DOM操作和动态页面更新；Servlet作为Java EE标准组件处理HTTP请求，优化Web应用交互；JDK提供了Java编程的环境和丰富的API，是构建复杂系统的基础。同时，面向对象的设计原则和模式也是提升代码质量的关键。本篇旨在帮助开发者通过理论和实践相结合的方式，熟练掌握这些技术，并理解它们在实际项目中的作用。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
