工厂模式（Factory Pattern）：用于创建对象，隐藏对象的创建细节。
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
public class ShapeFactory {
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
} else if (shapeType.equalsIgnoreCase("SQUARE")) {
return new Square();
}
return null;
}
}
public class Main {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
Shape rectangle = shapeFactory.getShape("RECTANGLE");
rectangle.draw();
Shape square = shapeFactory.getShape("SQUARE");
square.draw();
}
}抽象工厂模式（Abstract Factory Pattern）：提供一个接口来创建一系列相关或相互依赖的对象，而无需指定具体类。
public interface Button {
void paint();
}
// 具体产品类A
public class WindowsButton implements Button {
@Override
public void paint() {
System.out.println("WindowsButton");
}
}
// 具体产品类B
public class LinuxButton implements Button {
@Override
public void paint() {
System.out.println("LinuxButton");
}
}
// 抽象工厂接口
public interface GUIFactory {
Button createButton();
}
// 具体工厂A
public class WindowsFactory implements GUIFactory {
@Override
public Button createButton() {
return new WindowsButton();
}
}
// 具体工厂B
public class LinuxFactory implements GUIFactory {
@Override
public Button createButton() {
return new LinuxButton();
}
}
// 客户端代码
public class Main {
public static void main(String[] args) {
// 创建具体工厂A
GUIFactory windowsFactory = new WindowsFactory();
// 创建产品A
Button windowsButton = windowsFactory.createButton();
windowsButton.paint();
// 创建具体工厂B
GUIFactory linuxFactory = new LinuxFactory();
// 创建产品B
Button linuxButton = linuxFactory.createButton();
linuxButton.paint();
}
}单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点。
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
public class Main {
public static void main(String[] args) {
Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2); // true
}
}建造者模式（Builder Pattern）：将复杂对象的构建过程与其表示分离，以便相同的构建过程可以创建不同的表示。
原型模式（Prototype Pattern）：通过复制现有对象来创建新对象，而无需通过实例化创建。
// 原型接口
public interface Prototype {
Prototype clone();
}
// 具体原型类
public class ConcretePrototype implements Prototype {
private int number;
public void setNumber(int number) {
this.number = number;
}
public int getNumber() {
return number;
}
@Override
public Prototype clone() {
ConcretePrototype clone = new ConcretePrototype();
clone.setNumber(this.number);
return clone;
}
}
// 客户端代码
public class Main {
public static void main(String[] args) {
// 创建一个原型对象
ConcretePrototype prototype = new ConcretePrototype();
prototype.setNumber(10);
// 克隆原型对象
ConcretePrototype clone = (ConcretePrototype) prototype.clone();
// 修改克隆对象的属性
clone.setNumber(20);
System.out.println("Original object: " + prototype.getNumber()); // Original object: 10
System.out.println("Cloned object: " + clone.getNumber()); // Cloned object: 20
}
}
适配器模式（Adapter Pattern）：将一个类的接口转换为客户端所期望的另一个接口。
public interface MediaPlayer {
void play(String audioType, String fileName);
}
public interface AdvancedMediaPlayer {
void playVlc(String fileName);
void playMp4(String fileName);
}
public class VlcPlayer implements AdvancedMediaPlayer {
@Override
public void playVlc(String fileName) {
System.out.println("Playing vlc file. Name: " + fileName);
}
@Override
public void playMp4(String fileName) {
// do nothing
}
}
public class Mp4Player implements AdvancedMediaPlayer {
@Override
public void playVlc(String fileName) {
// do nothing
}
@Override
public void playMp4(String fileName) {
System.out.println("Playing mp4 file. Name: " + fileName);
}
}
public class MediaAdapter implements MediaPlayer {
private AdvancedMediaPlayer advancedMediaPlayer;
public MediaAdapter(String audioType) {
if (audioType.equalsIgnoreCase("VLC")) {
advancedMediaPlayer = new VlcPlayer();
} else if (audioType.equalsIgnoreCase("MP4")) {
advancedMediaPlayer = new Mp4Player();
}
}
@Override
public void play(String audioType, String fileName) {
if (audioType.equalsIgnoreCase("VLC")) {
advancedMediaPlayer.playVlc(fileName);
} else if (audioType.equalsIgnoreCase("MP4")) {
advancedMediaPlayer.playMp4(fileName);
}
}
}
public class AudioPlayer implements MediaPlayer {
private MediaAdapter mediaAdapter;
@Override
public void play(String audioType, String fileName) {
if (audioType.equalsIgnoreCase("MP3")) {
System.out.println("Playing mp3 file. Name: " + fileName);
} else if (audioType.equalsIgnoreCase("VLC") || audioType.equalsIgnoreCase("MP4")) {
mediaAdapter = new MediaAdapter(audioType);
mediaAdapter.play(audioType, fileName);
} else {
System.out.println("Invalid media. " + audioType + " format not supported");
}
}
}
public class Main {
public static void main(String[] args) {
AudioPlayer audioPlayer = new AudioPlayer();
audioPlayer.play("MP3", "song.mp3");
audioPlayer.play("VLC", "movie.vlc");
audioPlayer.play("MP4", "video.mp4");
audioPlayer.play("AVI", "movie.avi"); // Invalid media. AVI format not supported
}
}桥接模式（Bridge Pattern）：将抽象部分与其实现部分分离，使它们可以独立变化。
装饰器模式（Decorator Pattern）：动态地将责任添加到对象上，以扩展其功能。
组合模式（Composite Pattern）：将对象组合成树形结构，以表示“部分-整体”的层次结构。
外观模式（Facade Pattern）：提供一个统一的接口，用于访问子系统的一组接口。
// 子系统A
public class SubsystemA {
public void operationA() {
System.out.println("SubsystemA operation");
}
}
// 子系统B
public class SubsystemB {
public void operationB() {
System.out.println("SubsystemB operation");
}
}
// 外观类
public class Facade {
private SubsystemA subsystemA;
private SubsystemB subsystemB;
public Facade() {
subsystemA = new SubsystemA();
subsystemB = new SubsystemB();
}
public void operation() {
subsystemA.operationA();
subsystemB.operationB();
}
}
// 客户端代码
public class Main {
public static void main(String[] args) {
Facade facade = new Facade();
facade.operation();
}
}
享元模式（Flyweight Pattern）：通过共享细粒度对象来最小化内存使用和提高性能。
代理模式（Proxy Pattern）：为其他对象提供一个代理以控制对这个对象的访问。
ps:这里采用jdk动态代理实现
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// 接口
public interface Subject {
void request();
}
// 真实主题
public class RealSubject implements Subject {
@Override
public void request() {
System.out.println("RealSubject request");
}
}
// 代理处理器
public class ProxyHandler implements InvocationHandler {
private Object target;
public ProxyHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("ProxyHandler before");
Object result = method.invoke(target, args);
System.out.println("ProxyHandler after");
return result;
}
}
// 客户端代码
public class Main {
public static void main(String[] args) {
RealSubject realSubject = new RealSubject();
ProxyHandler proxyHandler = new ProxyHandler(realSubject);
Subject proxy = (Subject) Proxy.newProxyInstance(
realSubject.getClass().getClassLoader(),
realSubject.getClass().getInterfaces(),
proxyHandler);
proxy.request();
}
}
模板方法模式（Template Method Pattern）：定义一个算法的骨架，将一些步骤延迟到子类中实现。
spring框架中有很多体现：
-
JDBC模板（JdbcTemplate）：JdbcTemplate 是 Spring 提供的对 JDBC 进行封装的模板类。它定义了一系列模板方法，如
execute()、query()、update()等，这些方法提供了一致的 JDBC 操作流程，例如获取连接、执行 SQL 语句、处理结果集等。具体的数据库操作可以通过重写回调方法来实现。 -
Hibernate模板（HibernateTemplate）：HibernateTemplate 是 Spring 对 Hibernate 框架的封装，它提供了一系列模板方法，如
execute()、find()、save()等。通过使用 HibernateTemplate，开发者无需关注底层的 SessionFactory 和事务管理等细节，可以直接使用模板方法进行数据库操作。 -
JMS模板（JmsTemplate）：JmsTemplate 是 Spring 对 Java Message Service (JMS) 的封装，它提供了一系列模板方法，如
send()、receive()、convertAndSend()等。通过使用 JmsTemplate，开发者可以简化 JMS 的使用，无需手动管理连接、会话和消息等资源，而是通过模板方法进行消息发送和接收。 -
AOP模板（AopProxy）：Spring 的 AOP 模块也使用了模板方法模式。AopProxy 是 Spring AOP 中的代理对象，它基于 JDK 动态代理或 CGLIB 创建代理对象，并提供了一致的拦截器处理流程。具体的切面逻辑可以在对应的回调方法中实现。
-
JdbcTemplateCallback：JdbcTemplateCallback 是一个回调接口，用于扩展 JdbcTemplate 的功能。开发者可以通过实现该接口并重写回调方法，将自己的逻辑插入到 JdbcTemplate 的执行流程中。
策略模式（Strategy Pattern）：定义一系列算法，将它们封装起来，并使它们可以互相替换。
命令模式（Command Pattern）：将请求封装成对象，以便可以用不同的请求对客户进行参数化。
职责链模式（Chain of Responsibility Pattern）：将请求的发送者和接收者解耦，并通过一条链传递请求，直到有对象能够处理它。
状态模式（State Pattern）：允许对象在其内部状态改变时改变其行为。
观察者模式（Observer Pattern）：定义对象之间的一对多依赖关系，当一个对象状态改变时，它的所有依赖者都会收到通知并自动更新。
中介者模式（Mediator Pattern）：用一个中介对象封装一系列对象的交互，使它们不需要显式地相互引用。
迭代器模式（Iterator Pattern）：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。
import java.util.ArrayList;
import java.util.Iterator;
public class Main {
public static void main(String[] args) {
ArrayList<String> names = new ArrayList<>();
names.add("1");
names.add("2");
names.add("3");
Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
String name = iterator.next();
System.out.println(name);
}
}
}访问者模式（Visitor Pattern）：定义了在不改变对象结构的前提下访问对象的新方法。
interface Visitor {
void visit(ConcreteElementA element);
void visit(ConcreteElementB element);
}
class ConcreteVisitor implements Visitor {
@Override
public void visit(ConcreteElementA element) {
System.out.println("Visited ConcreteElementA");
}
@Override
public void visit(ConcreteElementB element) {
System.out.println("Visited ConcreteElementB");
}
}
interface Element {
void accept(Visitor visitor);
}
class ConcreteElementA implements Element {
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
class ConcreteElementB implements Element {
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
class ObjectStructure {
private List<Element> elements = new ArrayList<>();
public void add(Element element) {
elements.add(element);
}
public void remove(Element element) {
elements.remove(element);
}
public void accept(Visitor visitor) {
for (Element element : elements) {
element.accept(visitor);
}
}
}
public class Main {
public static void main(String[] args) {
ObjectStructure objectStructure = new ObjectStructure();
objectStructure.add(new ConcreteElementA());
objectStructure.add(new ConcreteElementB());
Visitor visitor = new ConcreteVisitor();
objectStructure.accept(visitor);
}
}
备忘录模式（Memento Pattern）：在不违反封装的情况下，捕获一个对象的内部状态，并在稍后恢复它。
解释器模式（Interpreter Pattern）：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
Spring框架的设计模式
Java Spring框架是一种非常流行的开源框架，它提供了许多功能和工具，用于简化企业级应用程序的开发。Spring框架的成功离不开其使用的各种设计模式，这些设计模式有助于使Spring框架更加灵活、可重用和可扩展。以下是Java Spring框架使用的一些常见的设计模式及其应用场景。
工厂模式（Factory Pattern）
工厂模式是一种创建型模式，它提供了一个通用的接口来创建对象，但是具体的对象创建过程被封装在一个工厂类中。在Spring框架中，工厂模式被广泛应用于Bean的创建和管理。Spring框架提供了两种主要的工厂模式，分别是BeanFactory和ApplicationContext。BeanFactory是Spring框架中最基本的工厂模式，它负责创建和管理Bean对象。ApplicationContext是BeanFactory的扩展，它添加了更多的功能，例如支持国际化、自动装配和AOP等。
单例模式（Singleton Pattern）
单例模式是一种创建型模式，它确保一个类只有一个实例，并提供全局访问点。在Spring框架中，单例模式被广泛地应用于Bean的创建和管理。默认情况下，Spring框架中所有的Bean都是单例的，它们只会被创建一次，并在整个应用程序中共享。
代理模式（Proxy Pattern）
代理模式是一种结构型模式，它为其他对象提供一个代理以控制对这个对象的访问。在Spring框架中，代理模式被广泛用于实现AOP（面向切面编程）。Spring框架提供了两种主要的代理模式，分别是JDK动态代理和CGLIB代理。JDK动态代理是通过接口创建代理对象，而CGLIB代理则是通过继承来创建代理对象。在Spring框架中，使用代理模式可以将横切关注点（例如日志记录、事务管理等）与业务逻辑分离开来，使程序结构更加清晰。
装饰器模式（Decorator Pattern）
装饰器模式是一种结构型模式，它动态地将责任添加到对象上，以扩展其功能。在Spring框架中，装饰器模式被广泛用于实现AOP。Spring框架将横切关注点（例如日志记录、事务管理等）封装成切面，并使用装饰器模式将切面应用到目标对象上，从而实现对目标对象的增强。
模板方法模式（Template Method Pattern）
模板方法模式是一种行为型模式，它定义了一个算法的骨架，将一些步骤延迟到子类中实现。在Spring框架中，模板方法模式被广泛用于JdbcTemplate类中的execute方法。该方法定义了一个JDBC查询的基本流程，但将具体的查询过程留给子类去实现。
策略模式（Strategy Pattern）
策略模式是一种行为型模式，它定义了一系列算法，将它们封装起来，并使它们可以互相替换。在Spring框架中，策略模式被广泛用于实现数据访问策略。Spring框架提供了多种数据访问策略，例如使用JDBC、Hibernate、MyBatis等。这些策略可以根据需要进行替换，以适应不同的数据访问需求。
观察者模式（Observer Pattern）
观察者模式是一种行为型模式，它定义了对象之间的一对多依赖关系，当一个对象状态改变时，它的所有依赖者都会收到通知并自动更新。在Spring框架中，观察者模式被广泛用于实现事件监听机制。Spring框架提供了ApplicationEventPublisher和ApplicationListener接口，用于实现事件的发布和监听。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
