在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系统架构能力具有重要意义。通过合理运用设计模式,我们可以使系统更加模块化、可扩展、可维护。在实际项目中,根据需求选择合适的设计模式,将有助于我们轻松应对复杂的项目挑战。
