正文

Java系统架构：掌握这些设计模式，轻松应对复杂项目挑战

/0 浏览量
0402

在Java编程领域，系统架构是确保项目稳定、高效运行的关键。而设计模式，作为系统架构的重要组成部分，能够帮助我们更好地应对复杂的项目挑战。本文将详细介绍几种常用的Java设计模式，帮助你提升系统架构能力。

1. 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。在Java中，实现单例模式有以下几种方式：

1.1 懒汉式单例

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

1.2 饿汉式单例

public class Singleton {
    private static final Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

1.3 双重校验锁单例

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2. 工厂模式（Factory Method）

工厂模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

public interface Car {
    void drive();
}

public class Audi implements Car {
    public void drive() {
        System.out.println("驾驶奥迪");
    }
}

public class Benz implements Car {
    public void drive() {
        System.out.println("驾驶奔驰");
    }
}

public class CarFactory {
    public static Car createCar(String type) {
        if ("Audi".equals(type)) {
            return new Audi();
        } else if ("Benz".equals(type)) {
            return new Benz();
        }
        return null;
    }
}

3. 代理模式（Proxy）

代理模式为其他对象提供一种代理以控制对这个对象的访问。在Java中，实现代理模式有以下几种方式：

3.1 静态代理

public interface Subject {
    void request();
}

public class RealSubject implements Subject {
    public void request() {
        System.out.println("请求处理");
    }
}

public class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    public void request() {
        beforeRequest();
        realSubject.request();
        afterRequest();
    }

    private void beforeRequest() {
        System.out.println("预处理");
    }

    private void afterRequest() {
        System.out.println("后处理");
    }
}

3.2 动态代理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxy implements InvocationHandler {
    private Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }

    public Object bind() {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this
        );
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        beforeRequest();
        Object result = method.invoke(target, args);
        afterRequest();
        return result;
    }

    private void beforeRequest() {
        System.out.println("预处理");
    }

    private void afterRequest() {
        System.out.println("后处理");
    }
}

4. 观察者模式（Observer）

观察者模式定义了对象之间的一对多依赖关系，当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。

public interface Observer {
    void update();
}

public class ConcreteObserver implements Observer {
    public void update() {
        System.out.println("观察者接收到通知");
    }
}

public class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

总结

掌握这些设计模式对于提升Java系统架构能力具有重要意义。通过合理运用设计模式，我们可以使系统更加模块化、可扩展、可维护。在实际项目中，根据需求选择合适的设计模式，将有助于我们轻松应对复杂的项目挑战。

-- 展开阅读全文 --