Java最常见设计模式：单例模式、工厂模式和代理模式

小鱼儿 2022-12-10 12:29 238阅读 0赞

# 一、设计模式的分类 #

总体来说**23种**设计模式分为三大类：  
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。  
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。  
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

我们主要来了解一下：  
**单例模式（Singleton）  
简单的工厂模式（Factory）  
代理模式（Proxy）**

## 1. 单例模式 ##

java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍经常被面试的经典的两种：懒汉模式、饿汉模式。

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。比如每台计算机可以有若干个打印机，但只能有一个打印机打印程序，以避免两个打印作业同时输出到打印机中

### 懒汉式单例 ###

//懒汉式单例类.在第一次调用的时候实例化自己 
    public class Singleton {
        
        private Singleton() {
        }
        private static Singleton single=null;
        //静态工厂方法 
        public static Singleton getInstance() {
        
             if (single == null) {
          
                 single = new Singleton();
             }  
            return single;
        }
    }

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问。  
（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论，姑且掩耳盗铃地认为反射机制不存在。）  
但是以上懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的

## 饿汉式单例 ##

//饿汉式单例类.在类初始化时，已经自行实例化 
    public class Singleton1 {
        
        private Singleton1() {
        }
        private static final Singleton1 single = new Singleton1();
        //静态工厂方法 
        public static Singleton1 getInstance() {
        
            return single;
        }
    }

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

## 饿汉式和懒汉式区别 ##

从名字上来说，饿汉和懒汉，  
饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，  
而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。  
另外从以下两点再区分以下这两种方式：

1.  线程安全：  
    饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，  
    懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加载和性能方面有些区别。
2.  资源加载和性能：  
    饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，  
    而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。  
    至于1、2、3这三种实现又有些区别，  
    第1种，在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的，  
    第2种，在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗  
    第3种，利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以一般我倾向于使用这一种。  
    综上大部分情况下单例模式中最好的实现方式就是静态内部类的懒汉模式。

# 2. 工厂设计模式 #

工厂模式分为工厂方法模式和抽象工厂模式。

工厂方法模式  
工厂方法模式：

1.  工厂方法模式分为三种：普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
2.  多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。
3.  静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

## 1. 普通工厂模式 ##

建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

interface Sender {
        
        void Send();
    }
    
    class MailSender implements Sender {
        
    
        @Override
        public void Send() {
        
            System.out.println("This is mail sender...");
        }
    }
    
    class SmsSender implements Sender {
        
    
        @Override
        public void Send() {
        
            System.out.println("This is sms sender...");
        }
    }
    
    public class FactoryPattern {
        
        public static void main(String[] args) {
        
            Sender sender = produce("mail");
            sender.Send();
        }
        public static Sender produce(String str) {
        
            if ("mail".equals(str)) {
        
                return new MailSender();
            } else if ("sms".equals(str)) {
        
                return new SmsSender();
            } else {
        
                System.out.println("输入错误...");
                return null;
            }
        }
    }

## 2. 多个工厂方法模式 ##

该模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

interface Sender {
        
        void Send();
    }
    
    class MailSender implements Sender {
        
    
        @Override
        public void Send() {
        
            System.out.println("This is mail sender...");
        }
    }
    
    class SmsSender implements Sender {
        
    
        @Override
        public void Send() {
        
            System.out.println("This is sms sender...");
        }
    }
    
    class SendFactory {
        
        public Sender produceMail() {
        
            return new MailSender();
        }
    
        public Sender produceSms() {
        
            return new SmsSender();
        }
    }
    
    public class FactoryPattern {
        
        public static void main(String[] args) {
        
            SendFactory factory = new SendFactory();
            Sender sender = factory.produceMail();
            sender.Send();
        }
    }

## 3. 静态工厂方法模式 ##

将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

interface Sender {
        
        void Send();
    }
    
    class MailSender implements Sender {
        
    
        @Override
        public void Send() {
        
            System.out.println("This is mail sender...");
        }
    }
    
    class SmsSender implements Sender {
        
    
        @Override
        public void Send() {
        
            System.out.println("This is sms sender...");
        }
    }
    
    class SendFactory {
        
        public static Sender produceMail() {
        
            return new MailSender();
        }
    
        public static Sender produceSms() {
        
            return new SmsSender();
        }
    }
    
    public class FactoryPattern {
        
        public static void main(String[] args) {
        
            Sender sender = SendFactory.produceMail();
            sender.Send();
        }
    }

总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

## 抽象工厂模式 ##

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要扩展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？  
那么这就用到了抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

interface Provider {
        
        Sender produce();
    }
    
    interface Sender {
        
        void Send();
    }
    
    class MailSender implements Sender {
        
    
        public void Send() {
        
            System.out.println("This is mail sender...");
        }
    }
    
    class SmsSender implements Sender {
        
    
        public void Send() {
        
            System.out.println("This is sms sender...");
        }
    }
    
    class SendMailFactory implements Provider {
        
    
        public Sender produce() {
        
            return new MailSender();
        }
    }
    
    class SendSmsFactory implements Provider {
        
    
        public Sender produce() {
        
            return new SmsSender();
        }
    }
    
    
    public class FactoryPattern {
        
        public static void main(String[] args) {
        
            Provider provider = new SendMailFactory();
            Sender sender = provider.produce();
            sender.Send();
        }
    }

其实这个模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好

## 代理模式 ##

为某个对象提供一个代理，从而控制这个代理的访问。代理类和委托类具有共同的父类或父接口，这样在任何使用委托类对象的地方都可以使用代理类对象替代。代理类负责请求的预处理、过滤、将请求分配给委托类处理、以及委托类处理完请求的后续处理。  
\#\#\#7.1、静态代理  
由程序员创建或工具生成代理类的源码，再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件，代理类和委托类的关系在运行前就确定了。  
示例代码：

1.  抽象角色

public interface AbstractSubject {
        
         void doSomething();
    }

1.  代理角色

public class ProxySubject implements AbstractSubject{
        
         private AbstractSubject  real ;
         public ProxySubject(AbstractSubject  real) {
        
             this.real=real ;
        }
         @Override
         public void doSomething() {
        
    
             real.doSomething();
        }
    
         public void doOtherthing() {
        
    
        }
    }

1.  真实角色

public class RealSubject implements AbstractSubject{
        
         @Override
         public void doSomething() {
        
            System.out.println( "真实角色被使用" );
        }
    }

1.  客户端

public class Client {
        
         public static void main(String[]  args ) {
        
            RealSubject real = new  RealSubject();
            ProxySubject proxy = new  ProxySubject( real );
             proxy.doSomething();
        }
    }

1.  静态代理的优缺点  
    优点： 业务类只需要关注业务逻辑本身，保证了业务类的重用性。这是代理的共有优点。  
    缺点：代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

### 7.2、动态代理 ###

动态代理类的源码是程序在运行期间由JVM根据反射等机制动态生成的，所以不存在代理类的字节码文件。代理角色和真实角色的联系在程序运行时确定。

1.  首先看看和动态代理相关JavaAPI  
    ① .java.lang.reflect.Proxy  
    这是Java动态代理机制生成的所有代理类的父类，它提供了一组静态的方法来为一组接口动态的生成代理类及其对象。  
    Proxy类的静态方法：

//方法 1: 该方法用于获取指定代理对象所关联的调用处理器  
    static InvocationHandler getInvocationHandler(Object proxy )  
    //方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象  
    static Class getProxyClass(ClassLoader loader,Class[] interfaces)  
    //方法 3：该方法用于判断指定类对象是否是一个动态代理类  
    static boolean isProxyClass(Class cl )    
    //方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
    static Object newProxyInstance(ClassLoader loader,  Class[] interfaces, InvocationHandler  h )

②.java.lang.reflect.InvocationHandler  
这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类对象上的方法调用，通常在该方法中实现对委托类的代理访问。每次生成动态代理类对象时都要指定一个对应的调用处理器对象。  
InvocationHandler核心方法

//该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象  
    //第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行   
    Object invoke(Object proxy, Method  method,Object[] args )

③ .java.lang.reflect.ClassLoader  
　　这是类装载器类，负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。每次生成动态代理类对象时都需要指定一个类装载器对象 。  
　　  
2. 动态代理实现步骤

实现InvocationHandler接口创建自己的调用处理器 。  
给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类 。  
执行真实角色具体任务。  
示例代码  
1.抽象角色和真实角色代码与上述相同 。  
4. 创建自己的调用处理器:

public class SubjectHandler implements InvocationHandler{
        
        AbstractSubject real;
        public SubjectHandler(AbstractSubject real){
        
            this.real=real;
        }
    
        @Override
        public Object invoke(Object obj, Method method, Object[] args)throws Throwable {
        
            System.out.println("代理类预处理任务");
            //利用反射机制将请求分派给委托类处理。Method的invoke返回Object对象作为方法执行结果。  
      //因为示例程序没有返回值，所以这里忽略了返回值处理
            method.invoke(real, args);
            System.out.println("代理类后续处理任务");
            return null;
        }
    
    }

1.  客户端 :

public class Client {
        
    
        public static void main(String[] args) {
        
            RealSubject real=new RealSubject();
            SubjectHandler handler=new SubjectHandler(real);
            //生成代理类对象
            AbstractSubject proxy=(AbstractSubject) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{
        AbstractSubject.class},handler);
            proxy.doSomething();
    
        }
    
    }

1.  动态代理的优缺点  
    优点：  
    　　动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。  
    不足：  
    　　Proxy 已经设计得非常优美，但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持 interface 代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫 Proxy。Java 的继承机制注定了这些动态代理类们无法实现对 class 的动态代理，原因是多继承在 Java 中本质上就行不通。