常用设计模式

最新推荐文章于 2025-05-19 20:25:11 发布

余冰涛

最新推荐文章于 2025-05-19 20:25:11 发布

阅读量228

点赞数

一、Singleton（单例模式）

一句话总结：一个类在Java虚拟机中只有一个对象。
项目里：JobQueue等queue，以及生成id的mapper，统计节点状态的mapper等。
分为饿汉式和懒汉式；
饿汉式：

public class HurgrySingleton {  
	private static HurgrySingleton hurgry=new HurgrySingleton();  
	private HurgrySingleton(){};  
    public static HurgrySingleton getSinletonHurgry(){  
         return hurgry;  
     }  
}

懒汉式：（考虑并发的话使用volatile + 双重检测机制）

public class LarzySingleton {  
   private static LarzySingleton larzy=null;  
   private LarzySingleton(){};  
   public static LarzySingleton getSinletonLarzy(){  
        if(larzy==null){  
              larzy=new LarzySingleton();  
        }  
        return larzy;  
    }  
}

注意的点：
1、使用懒汉模式时注意线程安全问题
2、单例模式构造方法都是私有的，是不能被继承的
3、实例和方法都是静态的。

二、Factory（简单的工厂模式）

一句话总结：用一个方法来代替new关键字
解决什么问题：对象产生过多，或者产生不同的子类。
spring的核心就是工厂模式。

public class FruitFactory {  
     public static Fruit createFruit(String name){    
         if(name.equals("apple"))
             return new Apple();  
          else if(name.equals("orange"))  
          	return new Orange();
          else
          	return new Fruit();
     }  
}

三、装饰模式

实际场景：https://www.cnblogs.com/jzb-blog/p/6717349.html
装饰器模式，顾名思义，就是对已经存在的某些类进行装饰，以此来扩展一些功能。结构图如下：
在这里插入图片描述

//基础接口
public interface Component {
    
    public void biu();
}
//具体实现类
public class ConcretComponent implements Component {

    public void biu() {
        
        System.out.println("biubiubiu");
    }
}
//装饰类
public class Decorator implements Component {

    public Component component;
    
    public Decorator(Component component) {
        
        this.component = component;
    }
    
    public void biu() {
        
        this.component.biu();
    }
}
//具体装饰类
public class ConcreteDecorator extends Decorator {

    public ConcreteDecorator(Component component) {

        super(component);
    }

    public void biu() {
        
        System.out.println("ready?go!");
        this.component.biu();
    }
}

四、Proxy（代理模式）

一句话总结：为其他对象提供一个代理，以控制对当前对象的访问。
解决什么问题：不能直接访问该对象，需要使用中介。
项目里面怎么用：访问权限问题。
spring里aop用的就是代理模式
代码：由接口+被代理类+代理类组成

//接口
public interface UserDao {
    void save();
}
//被代理类
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("----已经保存数据!----");
    }
}
 //代理类
public class UserDaoProxy implements UserDao {
    //接收保存目标对象
    private UserDao target;
    public UserDaoProxy(UserDao target){
        this.target=target;
    }

    public void save() {
        System.out.println("开始事务...");
        target.save();//执行目标对象的方法
        System.out.println("提交事务...");
    }
}

装饰模式和代理模式的关系：
1、两者的代码非常像，甚至都拿组件/被代理对象作为成员变量
2、区别在于两者的目的不同，装饰模式是为了增强某些功能，而代理模式是为了获得被代理对象的控制权

五、适配器模式Adapter（了解即可）

一句话总结：将两个原来不兼容的类兼容起来一起工作。
在这里插入图片描述
整个流程就是通过Adapter把Adaptee转换为目标（Target）的子类。

//投影仪支持的大口
public interface BigPort {
    
    public void userBigPort();//使用的大口
}
//小口
public interface SmallPort {
    public void userSmallPort();//使用小口
}
//适配器
public class SmallToBig implements BigPort{

    private SmallPort smallPort;//小口
    
    public SmallToBig(SmallPort smallPort){//获得小口
        this.smallPort=smallPort;
    }

    public void userBigPort() {
        this.smallPort.userSmallPort();    //使用小口
    }
            
}

六、观察者模式

个人理解：其实就是activemq中的topic-subject订阅，发布一个通知，所有订阅者能收到通知并做出响应。

七、Strategy（策略模式）

一句话总结：定义一个接口，然后很多实现类制定各种策略。
解决什么问题：做一件事情有很多种方法。

public interface Person {  
    void eat();  
}  
public class India implements Person {  
    @Override  
    public void eat() {  
        System.out.println("非洲人用手吃饭");  
    }  
} 
public class America implements Person {  
    @Override  
    public void eat() {  
        System.out.println("美国人用刀叉吃饭");  
    }  
}   
public class Chinese implements Person {  
    @Override  
    public void eat() {  
        System.out.println("中国人用筷子吃饭");  
    }  
}