网站贴子推广怎么做,建设网站破解版,加强机关网站建设,wordpress修改导航字体目录
常见的设计模式#xff1a;
单例模式#xff1a;
工厂模式#xff1a;
策略模式#xff1a;
桥接模式#xff1a;
责任链模式#xff1a; Java架构师之路八、安全技术#xff1a;Web安全、网络安全、系统安全、数据安全等-CSDN博客Java架构师之路十、框架和工…目录
常见的设计模式
单例模式
工厂模式
策略模式
桥接模式
责任链模式 Java架构师之路八、安全技术Web安全、网络安全、系统安全、数据安全等-CSDN博客Java架构师之路十、框架和工具Spring Framework、Spring Boot、Spring Cloud、MyBatis、Hibernate、Dubbo、Zookeeper、Redis等-CSDN博客
常见的设计模式
在 Java 中设计模式是软件开发中常用的解决方案模板可以帮助开发者解决特定的设计问题并提高代码的可重用性、可维护性和灵活性。Java 中常见的设计模式包括创建型模式、结构型模式、行为型模式以及其他模式其中还包括责任链模式。 创建型模式 工厂模式Factory Pattern定义一个创建对象的接口但让子类决定实例化哪个类。单例模式Singleton Pattern确保一个类只有一个实例并提供一个全局访问点。建造者模式Builder Pattern将一个复杂对象的构建过程与其表示分离使相同的构建过程可以创建不同的表示。 结构型模式 适配器模式Adapter Pattern将一个类的接口转换成客户希望的另一个接口使原本由于接口不兼容而不能在一起工作的类可以一起工作。装饰器模式Decorator Pattern动态地给一个对象添加一些额外的职责而不影响从这个类派生的其他对象。代理模式Proxy Pattern为其他对象提供一种代理以控制对这个对象的访问。 行为型模式 观察者模式Observer Pattern定义对象间的一对多依赖关系使得当一个对象改变状态时所有依赖它的对象都会得到通知并自动更新。策略模式Strategy Pattern定义一系列算法将每个算法封装起来并使它们可以互相替换。模板方法模式Template Method Pattern定义算法的框架由子类实现具体步骤。责任链模式Chain of Responsibility Pattern为请求创建一个接收者对象的链并沿着这条链传递请求直到有对象处理请求为止。 其他模式 享元模式Flyweight Pattern通过共享技术来有效支持大量细粒度对象的复用。备忘录模式Memento Pattern在不破坏封装性的前提下捕获一个对象的内部状态并在该对象之外保存这个状态。
这些设计模式在 Java 开发中有着广泛的应用合理运用设计模式可以提高软件的质量和可维护性降低系统的耦合度使代码更加清晰易懂。责任链模式特别适用于处理请求的场景可以灵活地组织处理者链条实现请求与处理者的解耦提高代码的灵活性和可扩展性。
单例模式
单例模式是一种创建型设计模式保证一个类只有一个实例并提供一个全局访问点。在实际应用中有些对象只需要一个实例例如线程池、缓存、对话框、注册表设置等。单例模式可以确保系统中某个类只有一个实例避免了重复创建对象节省了系统资源并且方便对该实例的控制和管理。
在 Java 中单例模式通常有几种实现方式 懒汉式 延迟加载在第一次使用时创建实例。线程安全需要考虑可以通过 synchronized 加锁或者使用双重检查锁定Double-Checked Locking。可能会存在性能问题因为每次获取实例都需要进行同步操作。 饿汉式 类加载时即创建实例。线程安全但可能会浪费内存。 静态内部类 利用类加载机制保证线程安全且延迟加载。通过静态内部类持有外部类的实例当外部类被加载时静态内部类并不会被加载和初始化。 枚举 最简洁、安全的实现方式由 JVM 保证只会实例化一次。防止反射和序列化攻击。
实现单例模式时需要考虑线程安全性、延迟加载、性能等因素。在选择实现方式时可以根据具体需求和场景来决定使用哪种方式。单例模式在很多框架和库中都有广泛应用如 Spring 框架中的 Bean 默认就是单例模式保证了在应用中只有一个 Bean 实例存在。
总的来说单例模式是一种常见且重要的设计模式合理使用可以提高代码的效率和可维护性但也需要注意避免滥用单例模式导致的问题如增加代码耦合度、隐藏依赖关系等。
懒汉式单例模式
在懒汉式单例模式中实例在需要的时候才被创建。
实现步骤
将构造函数设置为私有防止外部直接实例化该类。提供一个静态方法获取实例在方法内部判断实例是否为空为空则创建实例否则直接返回实例。
Java 代码示例
public class LazySingleton {private static LazySingleton instance;private LazySingleton() {// 私有构造函数}public static LazySingleton getInstance() {if (instance null) {instance new LazySingleton();}return instance;}
}
示例代码说明
LazySingleton 类中的构造函数是私有的外部无法直接实例化。getInstance() 方法是获取实例的静态方法通过判断instance 是否为空来决定是否创建实例。
测试代码
public class Main {public static void main(String[] args) {LazySingleton singleton1 LazySingleton.getInstance();LazySingleton singleton2 LazySingleton.getInstance();System.out.println(singleton1 singleton2); // 输出 true说明是同一个实例}
}
示例说明
在上面的示例中通过调用 LazySingleton.getInstance() 方法两次获取实例得到的两个实例是相同的因为单例模式确保了只有一个实例存在。这种懒汉式单例模式虽然简单但在多线程环境下存在线程安全问题可能会创建多个实例。可以通过加锁或使用双重检查锁定等方式来解决线程安全性问题。
工厂模式
工厂模式是一种创建型设计模式它提供一种封装对象创建过程的方式。工厂模式通过定义一个共同的接口来创建对象但具体的实现由子类决定。这样可以将对象的创建与使用代码解耦提高代码的灵活性和可维护性。
工厂模式常见的几种变体包括简单工厂模式、工厂方法模式和抽象工厂模式。
下面分别详细介绍这三种工厂模式的实现方式并给出相应的代码示例
1. 简单工厂模式Simple Factory Pattern
简单工厂模式通过一个工厂类负责创建多个不同类型的对象。
实现步骤
创建一个共同的接口或抽象类用于描述所要创建的对象。创建具体的实现类实现共同的接口或抽象类。创建一个简单工厂类负责根据参数的不同返回不同的具体对象。
Java 代码示例
// 共同的接口
public interface Product {void operation();
}// 具体的实现类
public class ConcreteProductA implements Product {Overridepublic void operation() {System.out.println(ConcreteProductA operation);}
}public class ConcreteProductB implements Product {Overridepublic void operation() {System.out.println(ConcreteProductB operation);}
}// 简单工厂类
public class SimpleFactory {public static Product createProduct(String type) {if (type.equals(A)) {return new ConcreteProductA();} else if (type.equals(B)) {return new ConcreteProductB();}return null;}
}
示例代码说明
Product 是一个共同的接口描述了所要创建的对象应具有的行为。ConcreteProductA 和 ConcreteProductB 是具体的实现类实现了 Product 接口。SimpleFactory 是简单工厂类根据参数的不同返回不同的具体对象。
测试代码
public class Main {public static void main(String[] args) {Product productA SimpleFactory.createProduct(A);productA.operation(); // 输出 ConcreteProductA operationProduct productB SimpleFactory.createProduct(B);productB.operation(); // 输出 ConcreteProductB operation}
} 2. 工厂方法模式Factory Method Pattern
工厂方法模式将对象的创建延迟到子类每个子类负责创建一个具体的对象。
实现步骤
创建一个抽象工厂类声明一个抽象的工厂方法。创建具体的工厂类实现抽象工厂类中的工厂方法每个具体工厂类负责创建一个具体的对象。创建一个共同的接口或抽象类用于描述所要创建的对象。创建具体的实现类实现共同的接口或抽象类。
Java 代码示例
// 共同的接口
public interface Product {void operation();
}// 具体的实现类
public class ConcreteProductA implements Product {Overridepublic void operation() {System.out.println(ConcreteProductA operation);}
}public class ConcreteProductB implements Product {Overridepublic void operation() {System.out.println(ConcreteProductB operation);}
}// 抽象工厂类
public abstract class Factory {public abstract Product createProduct();
}// 具体的工厂类
public class ConcreteFactoryA extends Factory {Overridepublic Product createProduct() {return new ConcreteProductA();}
}public class ConcreteFactoryB extends Factory {Overridepublic Product createProduct() {return new ConcreteProductB();}
} 示例代码说明
Product 是一个共同的接口描述了所要创建的对象应具有的行为。ConcreteProductA 和 ConcreteProductB 是具体的实现类实现了 Product 接口。Factory 是抽象工厂类声明了一个抽象的工厂方法 createProduct()。ConcreteFactoryA 和 ConcreteFactoryB 是具体的工厂类分别负责创建 ConcreteProductA 和 ConcreteProductB 对象。
测试代码
public class Main {public static void main(String[] args) {Factory factoryA new ConcreteFactoryA();Product productA factoryA.createProduct();productA.operation(); // 输出 ConcreteProductA operationFactory factoryB new ConcreteFactoryB();Product productB factoryB.createProduct();productB.operation(); // 输出 ConcreteProductB operation}
} 3. 抽象工厂模式Abstract Factory Pattern
抽象工厂模式提供一个接口用于创建一系列相关或相互依赖的对象。
实现步骤
创建一组共同的接口用于描述所要创建的对象。创建多个具体的实现类实现共同的接口。创建一个抽象工厂类声明创建一组对象的抽象方法。创建具体的工厂类实现抽象工厂类中的抽象方法负责创建一组相关的对象。
Java 代码示例
// 共同的接口
public interface ProductA {void operationA();
}public interface ProductB {void operationB();
}// 具体的实现类
public class ConcreteProductA1 implements ProductA {Overridepublic void operationA() {System.out.println(ConcreteProductA1 operationA);}
}public class ConcreteProductA2 implements ProductA {Overridepublic void operationA() {System.out.println(ConcreteProductA2 operationA);}
}public class ConcreteProductB1 implements ProductB {Overridepublic void operationB() {System.out.println(ConcreteProductB1 operationB);}
}public class ConcreteProductB2 implements ProductB {Overridepublic void operationB() {System.out.println(ConcreteProductB2 operationB);}
}// 抽象工厂类
public interface AbstractFactory {ProductA createProductA();ProductB createProductB();
}// 具体的工厂类
public class ConcreteFactory1 implements AbstractFactory {Overridepublic ProductA createProductA() {return new ConcreteProductA1();}Overridepublic ProductB createProductB() {return new ConcreteProductB1();}
}public class ConcreteFactory2 implements AbstractFactory {Overridepublic ProductA createProductA() {return new ConcreteProductA2();}Overridepublic ProductB createProductB() {return new ConcreteProductB2();}
} 示例代码说明
ProductA 和 ProductB 是一组共同的接口描述了所要创建的对象应具有的行为。ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 是具体的实现类分别实现 ProductA 和 ProductB 接口。AbstractFactory 是抽象工厂类声明了创建一组对象的抽象方法 createProductA() 和 createProductB()。ConcreteFactory1 和 ConcreteFactory2 是具体的工厂类分别负责创建一组相关的对象。
测试代码
public class Main {public static void main(String[] args) {AbstractFactory factory1 new ConcreteFactory1();ProductA productA1 factory1.createProductA();productA1.operationA(); // 输出 ConcreteProductA1 operationAProductB productB1 factory1.createProductB();productB1.operationB(); // 输出 ConcreteProductB1 operationBAbstractFactory factory2 new ConcreteFactory2();ProductA productA2 factory2.createProductA();productA2.operationA(); // 输出 ConcreteProductA2 operationAProductB productB2 factory2.createProductB();productB2.operationB(); // 输出 ConcreteProductB2 operationB}
} 工厂模式通过封装对象的创建过程将对象的具体类型与使用代码解耦提供了一种灵活的方式来创建对象。它能够隐藏对象的创建细节简化了客户端的代码并且方便扩展和维护。工厂模式在实际应用中经常被使用例如在 Java 中Spring 框架的 BeanFactory 就是一个工厂模式的实现。
策略模式
策略模式Strategy Pattern是一种行为型设计模式它定义了一系列算法并将每个算法封装在独立的类中使得它们可以互相替换。策略模式使得算法可以独立于使用它的客户端而变化。
在策略模式中有三个核心角色
上下文Context上下文是客户端与策略模式之间的接口它负责调用具体的策略对象来完成任务。策略Strategy策略是定义了一组相同行为的接口或抽象类它代表了一种算法或行为。具体策略Concrete Strategy具体策略是策略接口的实现类它实现了具体的算法或行为。
策略模式的优点包括
提高代码的可扩展性由于策略模式将算法封装在独立的类中因此可以很容易地添加新的策略类来扩展系统的功能。提供了一定程度的灵活性客户端可以根据需要选择不同的策略来完成特定的任务而不需要修改客户端的代码。使代码易于理解和维护策略模式将不同的算法分离开来使得每个算法都具有清晰的目的和职责使代码更加可读和易于维护。
下面是一个简单的策略模式的示例以计算商品折扣价格为例 // 策略接口
public interface DiscountStrategy {double applyDiscount(double price);
}// 具体策略类
public class NoDiscountStrategy implements DiscountStrategy {Overridepublic double applyDiscount(double price) {return price;}
}public class FixedDiscountStrategy implements DiscountStrategy {private double discountAmount;public FixedDiscountStrategy(double discountAmount) {this.discountAmount discountAmount;}Overridepublic double applyDiscount(double price) {return price - discountAmount;}
}public class PercentageDiscountStrategy implements DiscountStrategy {private double discountPercentage;public PercentageDiscountStrategy(double discountPercentage) {this.discountPercentage discountPercentage;}Overridepublic double applyDiscount(double price) {return price * (1 - discountPercentage);}
}// 上下文类
public class Product {private String name;private double price;private DiscountStrategy discountStrategy;public Product(String name, double price, DiscountStrategy discountStrategy) {this.name name;this.price price;this.discountStrategy discountStrategy;}public double getPriceAfterDiscount() {return discountStrategy.applyDiscount(price);}
}// 客户端代码
public class Main {public static void main(String[] args) {Product product1 new Product(Product 1, 100.0, new NoDiscountStrategy());System.out.println(Price: product1.getPriceAfterDiscount()); // 输出 Price: 100.0Product product2 new Product(Product 2, 100.0, new FixedDiscountStrategy(20.0));System.out.println(Price: product2.getPriceAfterDiscount()); // 输出 Price: 80.0Product product3 new Product(Product 3, 100.0, new PercentageDiscountStrategy(0.25));System.out.println(Price: product3.getPriceAfterDiscount()); // 输出 Price: 75.0}
} 在上述示例中策略模式通过定义 DiscountStrategy 接口和具体的策略类 NoDiscountStrategy、FixedDiscountStrategy 和 PercentageDiscountStrategy 来实现不同的折扣算法。Product 类作为上下文类它包含一个折扣策略对象并通过调用 applyDiscount() 方法来计算最终的折扣价格。
通过使用策略模式客户端可以根据具体的需求选择不同的折扣策略而无需修改上下文类的代码。这样一来当需要添加新的折扣策略时只需要创建新的具体策略类并实现 DiscountStrategy 接口即可而不会对原有的代码造成影响。这提高了代码的可扩展性和灵活性。
桥接模式
桥接模式Bridge Pattern是一种结构型设计模式它将抽象部分与实现部分分离使它们可以独立变化而互不影响。桥接模式通过组合的方式将抽象和实现解耦从而可以在两者之间建立一座桥梁使它们可以独立地进行变化和扩展。
在桥接模式中有四个核心角色
抽象类Abstraction定义了抽象部分的接口维护一个指向实现类的引用。具体实现类Concrete Implementation实现了实现部分的接口并具体实现了其方法。实现类接口Implementation定义了实现部分的接口供具体实现类实现。具体抽象类Concrete Abstraction继承自抽象类实现了抽象部分的具体功能。
桥接模式的优点包括
解耦抽象和实现桥接模式通过将抽象部分和实现部分分离使得它们可以独立变化互不影响。扩展性强由于抽象部分和实现部分可以独立变化因此很容易添加新的抽象类或实现类扩展系统的功能。隐藏实现细节桥接模式可以隐藏实现部分的细节使客户端只需要关注抽象部分即可。
下面是一个简单的桥接模式的示例以形状和颜色为例
// 颜色接口
public interface Color {void applyColor();
}// 红色类
public class RedColor implements Color {Overridepublic void applyColor() {System.out.println(Applying red color);}
}// 蓝色类
public class BlueColor implements Color {Overridepublic void applyColor() {System.out.println(Applying blue color);}
}// 形状抽象类
public abstract class Shape {protected Color color;public Shape(Color color) {this.color color;}public abstract void applyColor();
}// 圆形类
public class Circle extends Shape {public Circle(Color color) {super(color);}Overridepublic void applyColor() {System.out.print(Circle filled with );color.applyColor();}
}// 正方形类
public class Square extends Shape {public Square(Color color) {super(color);}Overridepublic void applyColor() {System.out.print(Square filled with );color.applyColor();}
}// 客户端代码
public class Main {public static void main(String[] args) {Shape redCircle new Circle(new RedColor());redCircle.applyColor(); // 输出 Circle filled with Applying red colorShape blueSquare new Square(new BlueColor());blueSquare.applyColor(); // 输出 Square filled with Applying blue color}
} 在上述示例中桥接模式通过将形状类和颜色类分离使它们可以独立变化。Shape 是抽象类它包含一个颜色对象并定义了一个抽象方法 applyColor()。Circle 和 Square 是具体抽象类它们继承自 Shape并实现了 applyColor() 方法来应用颜色。
通过使用桥接模式客户端可以选择不同的颜色来填充不同的形状而不需要修改形状类的代码。这样一来当需要添加新的形状或颜色时只需要创建新的具体抽象类并传入相应的颜色对象即可而不会对原有的代码造成影响。桥接模式提高了代码的灵活性和可扩展性。
责任链模式
责任链模式Chain of Responsibility Pattern是一种行为设计模式用于解耦发送者和接收者之间的关系。在责任链模式中多个对象处理者依次处理请求直到其中一个对象能够处理该请求为止。这些对象被串成一条链请求沿着链传递直到有一个处理者处理它为止。
责任链模式通常包括以下几个角色
抽象处理者Handler定义一个处理请求的接口通常包括一个处理请求的方法和一个设置下一个处理者的方法。具体处理者ConcreteHandler实现抽象处理者接口在处理请求时可以决定是否自己处理或者将请求传递给下一个处理者。客户端Client创建责任链并向链头的处理者发送请求。
责任链模式的优点包括
解耦发送者和接收者发送者不需要知道具体的接收者只需将请求发送给第一个处理者即可。灵活性增强可以动态地修改责任链中的处理者顺序或增加新的处理者而不需要修改客户端代码。可以动态地指定处理者每个处理者都有机会处理请求客户端可以根据需要灵活地指定处理者的顺序。
然而责任链模式也存在一些缺点包括
请求可能未被处理如果责任链没有正确配置或者最终没有处理请求的处理者请求可能会被漏掉。性能问题请求需要沿着责任链传递可能导致一定的性能损失特别是在责任链较长时。
总的来说责任链模式适合于多个对象可以处理同一请求且客户端不需要明确指定处理者的情况下使用。通过合理设计责任链可以更好地管理和处理请求提高系统的灵活性和可扩展性。
假设我们有一个在线商城系统当用户下单购买商品时订单需要经过一系列的处理流程来验证和处理。这时候可以使用责任链模式来处理订单。
首先我们定义一个抽象处理者Handler接口其中包含处理请求的方法和设置下一个处理者的方法。
public interface OrderHandler {void handleOrder(Order order);void setNextHandler(OrderHandler handler);
}
然后我们创建具体的处理者类实现抽象处理者接口并在处理请求时决定是否自己处理或者将请求传递给下一个处理者。
public class StockHandler implements OrderHandler {private OrderHandler nextHandler;public void handleOrder(Order order) {if (order.getStock() order.getQuantity()) {System.out.println(库存充足可以继续处理订单。);// 处理订单逻辑...} else {System.out.println(库存不足无法处理订单将请求传递给下一个处理者。);passToNextHandler(order);}}public void setNextHandler(OrderHandler handler) {this.nextHandler handler;}private void passToNextHandler(Order order) {if (nextHandler ! null) {nextHandler.handleOrder(order);} else {System.out.println(没有合适的处理者请求无法处理。);}}
}public class PaymentHandler implements OrderHandler {private OrderHandler nextHandler;public void handleOrder(Order order) {if (order.isPaymentValid()) {System.out.println(支付有效可以继续处理订单。);// 处理订单逻辑...} else {System.out.println(支付无效无法处理订单将请求传递给下一个处理者。);passToNextHandler(order);}}public void setNextHandler(OrderHandler handler) {this.nextHandler handler;}private void passToNextHandler(Order order) {if (nextHandler ! null) {nextHandler.handleOrder(order);} else {System.out.println(没有合适的处理者请求无法处理。);}}
}
最后我们创建客户端代码创建责任链并向链头的处理者发送订单请求。
public class Client {public static void main(String[] args) {OrderHandler stockHandler new StockHandler();OrderHandler paymentHandler new PaymentHandler();stockHandler.setNextHandler(paymentHandler);Order order new Order(ABC123, 10, 100.0);stockHandler.handleOrder(order);}
}
在上述例子中订单首先会经过库存处理者StockHandler如果库存充足则订单被处理否则请求会被传递给支付处理者PaymentHandler再次进行处理。如果没有合适的处理者请求将无法被处理。
通过使用责任链模式订单处理过程被解耦每个处理者只需要关注自己的处理逻辑增加新的处理者或者调整处理者的顺序也变得灵活和简单。
