设计模式在经典框架源码中的体现

工厂模式：

• 在Spring框架中，Bean工厂是一个典型的工厂模式的应用。Spring容器负责管理Bean对象的生命周期，并通过工厂方法来创建Bean对象。
• 示例代码：

 

public interface Vehicle {
    void drive();
}

public class Car implements Vehicle {
    @Override
    public void drive() {
        System.out.println("Driving a car");
    }
}

public class Bike implements Vehicle {
    @Override
    public void drive() {
        System.out.println("Riding a bike");
    }
}

public class VehicleFactory {
    public static Vehicle createVehicle(String type) {
        if ("car".equalsIgnoreCase(type)) {
            return new Car();
        } else if ("bike".equalsIgnoreCase(type)) {
            return new Bike();
        }
        return null;
    }
}

public class Main {
    public static void main(String[] args) {
        Vehicle car = VehicleFactory.createVehicle("car");
        car.drive(); // Driving a car

        Vehicle bike = VehicleFactory.createVehicle("bike");
        bike.drive(); // Riding a bike
    }
}
 

单例模式：

• 在Java中，Logger类通常被设计为单例模式，确保应用中只有一个全局的Logger实例。
• 示例代码

public class Logger {
    private static Logger instance;

    private Logger() {
        // 私有构造方法，防止外部实例化
    }

    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }

    public void log(String message) {
        System.out.println("Logging: " + message);
    }
}

public class Main {
    public static void main(String[] args) {
        Logger logger1 = Logger.getInstance();
        logger1.log("Message 1");

        Logger logger2 = Logger.getInstance();
        logger2.log("Message 2");

        System.out.println(logger1 == logger2); // true，同一个实例
    }
}

观察者模式：

• 在Swing框架中，事件处理机制就是观察者模式的一个典型应用。组件通常充当主题，当发生某些事件时，会通知已注册的监听器。
• 示例代码：

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;

public class ButtonFrame extends JFrame {
    private JButton button;

    public ButtonFrame() {
        button = new JButton("Click me");
        button.addActionListener(new ClickListener()); // 注册监听器
        add(button);
        setSize(200, 100);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    private class ClickListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            System.out.println("Button clicked!");
        }
    }

    public static void main(String[] args) {
        new ButtonFrame();
    }
}
 

适配器模式：

• 在Java I/O中，InputStream和Reader、OutputStream和Writer之间的适配器就是适配器模式的应用。比如，InputStreamReader将字节流转换成字符流。

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = new FileInputStream("input.txt");
        Reader reader = new InputStreamReader(inputStream);

        int data = reader.read();
        while (data != -1) {
            System.out.print((char) data);
            data = reader.read();
        }

        reader.close();
    }
}
 

策略模式：

• 在Java集合框架中，Comparator接口就是策略模式的一个典型应用。它定义了一组算法，用于比较对象，并通过传入不同的Comparator实现来选择不同的比较策略。
• 示例代码

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");

        // 使用策略模式，传入Comparator实现
        Collections.sort(list, new LengthComparator());

        System.out.println(list); // [Apple, Banana, Orange]
    }
}

class LengthComparator implements Comparator<String> {
    @Override
    public int compare(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
}
 

模板方法模式：

• 在Servlet框架中，HttpServlet类就是模板方法模式的应用。它定义了一组处理HTTP请求的模板方法，并在具体子类中实现了具体的处理逻辑。
• 示例代码（伪代码）

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public abstract class BaseServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
        // 模板方法
        processRequest(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) {
        // 模板方法
        processRequest(request, response);
    }

    protected abstract void processRequest(HttpServletRequest request, HttpServletResponse response);
}

public class MyServlet extends BaseServlet {
    @Override
    protected void processRequest(HttpServletRequest request, HttpServletResponse response) {
        // 具体处理逻辑
    }
}