【分享】我在阿里工作十年里接触过的Java框架设计模式(【独家揭秘】阿里十年Java框架设计模式实战经验分享)

原创

ithorizon 6个月前 (10-21) 阅读数 26 #后端开发

阿里十年Java框架设计模式实战经验分享

一、前言

在过去的十年里，我有幸在阿里巴巴集团工作，参与了多个大型Java项目的开发。在这个过程中，我深入研究了各种Java框架，并积累了丰盈的设计模式实践经验。本文将独家揭秘我在阿里工作期间接触过的Java框架设计模式，愿望能为广大Java开发者提供一些参考和启示。

二、常用的Java框架设计模式

以下是我在阿里工作期间接触过的一些常用的Java框架设计模式：

1. 代理模式（Proxy）

代理模式是一种常用的设计模式，用于在不修改原对象在出现的同时，对原对象进行扩大。在Java框架中，代理模式的应用非常广泛，如Spring AOP、MyBatis等。


public interface Subject {
    void request();
}
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject's request");
    }
}
public class ProxySubject implements Subject {
    private Subject subject;
    public ProxySubject(Subject subject) {
        this.subject = subject;
    }
    @Override
    public void request() {
        System.out.println("ProxySubject's request start");
        subject.request();
        System.out.println("ProxySubject's request end");
    }
}
public class ProxyPatternDemo {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        Subject proxySubject = new ProxySubject(realSubject);
        proxySubject.request();
    }
}

2. 工厂模式（Factory）

工厂模式用于创建对象，允许客户端创建一个类的实例，而不暴露创建逻辑。在Java框架中，工厂模式的应用也非常广泛，如Spring Bean的创建等。


public interface Product {
    void use();
}
public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("ConcreteProductA is used");
    }
}
public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("ConcreteProductB is used");
    }
}
public class Factory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}
public class FactoryPatternDemo {
    public static void main(String[] args) {
        Product productA = Factory.createProduct("A");
        productA.use();
        Product productB = Factory.createProduct("B");
        productB.use();
    }
}

3. 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。在Java框架中，单例模式的应用也非常广泛，如Spring的Bean管理等。


public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
public class SingletonPatternDemo {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2); // 输出 true
    }
}

4. 观察者模式（Observer）

观察者模式允许对象在状态变化时通知多个观察者对象。在Java框架中，观察者模式的应用也非常广泛，如Spring事件监听等。


public interface Observer {
    void update();
}
public class ConcreteObserver implements Observer {
    private int state;
    @Override
    public void update() {
        System.out.println("ConcreteObserver's state is updated to: " + state);
    }
    public void setState(int state) {
        this.state = state;
    }
}
public class ConcreteSubject {
    private int state;
    private List observers = new ArrayList<>();
    public void attach(Observer observer) {
        observers.add(observer);
    }
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }
    public int getState() {
        return state;
    }
}
public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        ConcreteObserver observer1 = new ConcreteObserver();
        ConcreteObserver observer2 = new ConcreteObserver();
        subject.attach(observer1);
        subject.attach(observer2);
        subject.setState(1);
        subject.setState(2);
    }
}

5. 策略模式（Strategy）

策略模式允许在运行时选择算法的行为。在Java框架中，策略模式的应用也非常广泛，如Spring MVC的HandlerMapping等。


public interface Strategy {
    int doOperation(int num1, int num2);
}
public class AddStrategy implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}
public class SubtractStrategy implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}
public class Context {
    private Strategy strategy;
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
}
public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new AddStrategy());
        System.out.println("Addition: " + context.executeStrategy(5, 3));
        context.setStrategy(new SubtractStrategy());
        System.out.println("Subtraction: " + context.executeStrategy(5, 3));
    }
}