技能篇：实际开发常用设计模式
Posted 潜行前行
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了技能篇：实际开发常用设计模式相关的知识，希望对你有一定的参考价值。
创建型
单例模式
单例对象能节约系统资源，一个对象的创建和消亡的开销可能很小。但是日常的服务接口，就算是一般小公司也有十几万的QPS吧。每一次的功能运转都创建新的对象来响应请求，十几万对象的创建和销毁，想想就是一笔大开销，所以 spring 管理构造的 bean 对象一般都是单例。而且单例模式可以更好的解决并发的问题，方便实现数据的同步性
- 优点
- 在内存中只有一个对象，节省内存空间
- 避免频繁的创建销毁对象，可以提高性能
- 避免对共享资源的多重占用，简化访问
- 为整个系统提供一个全局访问点
- 缺点
- 不适用于变化频繁的对象
//饿汉式
private static Singleton singleton = new Singleton();
//懒汉式
private static Singleton singleton;
public static Singleton getSingleton(){
if (singleton == null) {
singleton = new Singleton(); //被动创建，在真正需要使用时才去创建
}
return singleton;
}
//双重判断加锁机制
private volatile static Singleton instance;
//程序运行时创建一个静态只读的进程辅助对象
public static Singleton GetInstance() {
//先判断是否存在，不存在再加锁处理
if (instance == null){
synchronized (Singleton.class){
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
//静态初始化
private static readonly Singleton instance= new Singleton();
public static Singleton GetInstance(){
return instance;
}
工厂模式
使用者不关心对象的实例化过程，只关心对象的获取。工厂模式使得产品的实例化过程和消费者解耦
- 优点
- 一个调用者想创建一个对象，只需通过其名称或其他唯一键值在工厂获取
- 扩展性高，如果想增加生产一种类型对象，只要扩展工厂类就可以
- 缺点
- 工厂类不太理想，因为每增加一产品，都要在工厂类中增加相应的生产判断逻辑，这是违背开闭原则的
public interface Sender{ public void send(); }
public class MailSender implements Sender {
@Override
public void send() {
System.out.println("this is mailsender!");
}
}
public class SmsSender implements Sender {
@Override
public void send() {
System.out.println("this is sms sender!");
}
}
public class SendFactory {
public Sender produce(String type) {
if ("mail".equals(type)) {
return new MailSender();
} else if ("sms".equals(type)) {
return new SmsSender();
} else {
return null;
}
}
//若还有其他产品 则在工厂里加对应的 produce 方法
}
建造者模式
主要解决在软件系统中一个复杂对象的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定
- 优点
- 扩展性好，对象每一个属性的构建相互独立，有利于解耦。
- 建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险
- 缺点
- 如果对象建造者发生变化，则建造者也要同步修改，后期维护成本较大
- 一种建造者对应一种类型建造，一个建造者基本很难建造多种类型对象
@Data
class Product {
private String name;
private String price;
// Product 的建造者 Builder
public static class Builder{
public static Builder builder(){
Builder builder = Builder();
}
private Product product = new Product();
public Builder name(String name){ product.name = name; return this;}
public Builder price(String price){ product.price = price; return this; }
//返回产品对象
public Product build() { return product; }
}
}
结构型
适配器模式
连通上下游功能。一般是现有的功能和产品要求的接口不兼容，需要做转换适配。平时见到的 PO，BO，VO，DTO 模型对象之间的相互转换也是一种适配的过程
- 优点：提高了类的复用，灵活性好
- 缺点：过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现
//类的适配器模式
public class Source {
public void sayHello() {
System.out.println("lwl:hello!");
}
}
public interface Targetable {
/* Source方法相同 */
public void sayHello();
/* 新增的方法 */
public void hi();
}
// Source 用 Adapter 适配成 Targetable
public class Adapter extends Source implements Targetable {
@Override
public void hi() {
System.out.println("csc:hi!");
}
}
//对象的适配器模式
public class Source {
public void sayHello() {
System.out.println("lwl:hello!");
}
}
public interface Targetable {
/* Source方法相同 */
public void sayHello();
/* 新增的方法 */
public void hi();
}
// Source的对象适配成 Targetable
public class Adapter implements Targetable {
private Source source;
public Adapter(Source source){ this.source = source; }
public void sayHello(){ source.sayHello(); }
@Override
public void hi() {
System.out.println("csc:hi!");
}
}
装饰器模式
增强对象功能，动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删）
public interface Show(){ public void acting(); }
public class Artist implements Show {
public void acting(){
System.out.println("lwl 在唱歌!");
}
}
public class DecoratorArtist implements Show{
Artist artist;
DecoratorArt(Artist artist){
this.artist = artist;
}
public void acting(){
System.out.println("lwl 在弹钢琴!"); //增强的功能
this.artist.acting();
System.out.println("表演完毕!"); //增强的功能
}
}
代理模式
代理类是客户类和委托类的中介，可以通过给代理类增加额外的功能来扩展委托类的功能，这样只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则
- 和装饰器模式的区别：代理模式着重于增强类功能，且对面屏蔽原对象的创建过程；装饰器模式增强的是对象，且装饰器模式有一个动态传递原对象的步骤
- 和对象的适配器模式优点像：不过代理模式着重的是对原功能增强，适配器模式着重的是对新功能的兼容
- 优点-1、职责清晰。 2、高扩展性
public class Artist implements Show {
public void acting(){
System.out.println("lwl 在唱歌!");
}
}
public class ProxyArtist implements Show{
Artist artist;
ProxyArtist(){
this.artist = new Artist();//屏蔽了 artist 对象的创建
}
public void acting(){
System.out.println("lwl 在弹钢琴!"); //增强的功能
this.artist.acting();
System.out.println("表演完毕!"); //增强的功能
}
}
public class Demo {
public static void main(String[] arg){
Show show = new ProxyArtist();
show.acting();
}
}
桥接模式
桥接模式侧重于功能的抽象，从而基于这些抽象接口构建上层功能。一般的java 项目都会将接口和实现分离原因，就是基于桥接模式。提高了系统的扩展能力，当引用的底层逻辑有不同的设计实现时，继承抽象接口重新实现一套即可，旧的不变，符合代码设计的开闭原则
- jdbc 的驱动：常用的JDBC 和 DriverManager，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，原因就是JDBC提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接
- Unix 的文件系统：VFS（virtual File System）使得 Unix 系统可以在不同物理介质上的不同文件系统进行读写
public interface FileSystem(){
public void open(int file);
public String loading(int file);
public void store(int file, String data);
}
//网络上的文件系统
public class NetFileSystem implements FileSystem {
public void open(int file){ System.out.println(" netfile opening...."); }
public String loading(int file) {System.out.println(" net loading ...."); }
public void store(int file, String data) {System.out.println(" send to network ...."); }
}
//磁盘文件系统
public class DiskFileSystem implements FileSystem{
public void open(int file){ System.out.println(" disk opening...."); }
public String loading(int file) {System.out.println(" disk loading ...."); }
public void store(int file, String data) {System.out.println(" write back disk ...."); }
}
public class Linux {
FileSystem fileSystem;
//底层功能提供接口，桥接模式：功能和具体实现分离
//可以桥接 NetFileSystem 或者 DiskFileSystem 作为文件系统
public void set(FileSystem fileSystem){ this.fileSystem = fileSystem; }
//上层功能读数据
public String read(int file){
fileSystem.open(file);
... // Linux 自己的系统功能
fileSystem.loading(file);
...
}
//上层功能写数据
public String write(int file, String data){
fileSystem.open(file);
....
fileSystem.store(file,data);
}
}
- 可配合适配器模式使用
享元模式
多个对象共享某些属性。在创建有大量对象时，可能会造成内存溢出，把其中共同的部分抽象出来，如果有相同的请求，直接返回在内存中同一份属性，避免重新创建
- 如 jdbc 连接池的连接对象，它们会共享池对象的 url、driverClassName、username、password 等属性
public class ConnectionPool {
private Vector<Connection> pool;
/*公有属性*/
private String url = "jdbc:mysql://localhost:3306/test";
private String username = "root";
private String password = "root";
private String driverClassName = "com.mysql.jdbc.Driver";
public ConnectionPool() {
pool = new Vector<Connection>(poolSize);
for (int i = 0; i < poolSize; i++) {
Class.forName(driverClassName);
// 每一个 conn 共享了 driverClassName ，url, username, password 等属性
Connection conn = DriverManager.getConnection(url, username, password);
pool.add(conn);
}
}
....
}
外观模式
- 用多个不同的对象实现一组更复杂的功能。使得类与类之间的关系解耦。如 spring 将使用各个简单的 component、dao 实现复杂的service，就是一种外观模式
- 功能的组合，组合优于继承
public class DAO {
public void queryData(){
System.out.print(" query data ")
}
}
public class Deal {
public void dealData(){
System.out.print(" dealing data ")
}
}
public class Sender {
public void send(){
System.out.print(" send data ")
}
}
public class Service(){
private DAO dao;
private Deal deal;
private Sender sender;
//封装 DAO，Deal，Sender 的功能，统一对外提供服务
public void reponse(){
dao.queryData();
deal.dealData();
sender.send();
}
}
行为型
策略模式
策略模式侧重于不同的场景使用不同的策略。在有多种算法相似的情况下，解决 if…else 所带来的复杂和难以维护
- 和桥接模式的区别：而桥接模式是结构型模式，侧重于分离底层功能的抽象和实现，底层只有一种实现也可以
// 上学的策略
abstract class Strategy{
private static final Map<Integer,Strategy> strategyMap = new ConcurrentHashMap<>();
public Strategy(){
strategyMap.put(getType(), this);
}
public static Strategy routing(int type){
return strategyMap.get(type);
}
abstract int getType();
abstract void method(); //留待子类实现差异
}
//跑路去学校
class RunningStrategy extends Strategy{
int getType() { return 0; }
void method() { System.out.println(" Run to school "); }
}
//公交去学校
class BusStrategy extends Strategy{
int getType() { return 1; }
void method() { System.out.println(" Go to school by bus "); }
}
//飞去学校
class FlyStrategy extends Strategy{
int getType() { return 2; }
void method() { System.out.println(" Fly to school "); }
}
class Context{
//使用不同的策略
void method(int strategy){
Strategy.routing(strategy).method();
}
}
模板方法
和享元模式有一定的相似处，享元模式侧重于属性的共享，而且是结构上的引用，不一定需要继承；而模板方法是共享相同行为，一定有继承行为
- 区别于策略模式是它有能抽象出来的共同行为，每一个子类再实现有差异细节
abstract class AbstractHandler{
// handle是抽象出来的共同逻辑
void handle(String data){
System.out.println("通用逻辑1...");
stepOne(data);
System.out.println("通用逻辑2...");
stepTwo(data);
System.out.println("通用逻辑3...");
}
abstract void stepOne(String data); //留待子类实现差异
abstract void stepTwo(String data); //留待子类实现差异
技能篇：开发必备linux命令大全