常用的设计模式：

一、单例模式

java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、双重检查锁定
1、单例模式有以下特点：
　　a、单例类只能有一个实例。
　　b、单例类必须自己创建自己的唯一实例。
　　c、单例类必须给所有其他对象提供这一实例。
2、代码特点
　　a、私有静态变量
　　b、私有构造方法
　　c、公有的静态访问方法

3、懒汉式 - 懒汉式非线程安全

public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法 
    public static Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
    }
}

4、饿汉式 - 线程安全

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

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

5、懒汉式和饿汉式区别

6、双重检查锁定

public static Singleton getInstance() {
        if (singleton == null) {  
            synchronized (Singleton.class) {  
               if (singleton == null) {  
                  singleton = new Singleton(); 
               }  
            }  
        }  
        return singleton; 
    }

7、应用场景

a、需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。
a、某类只要求生成一个对象的时候，如一个班中的班长等。
b、某些类创建实例时占用资源较多，或实例化耗时较长，且经常使用。
c、某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。
e、频繁访问数据库或文件的对象。

二、工厂模式

工厂模式是 Java 中最常用的设计模式之一，工厂模式模式的写法有好几种，这里主要介绍三种：简单工厂模式、工厂模式、抽象工厂模式

1、简单工厂模式

这里以制造coffee的例子开始工厂模式设计之旅。

我们知道coffee只是一种泛举，在点购咖啡时需要指定具体的咖啡种类：美式咖啡、卡布奇诺、拿铁等等。

/**
 * 拿铁、美式咖啡、卡布奇诺等均为咖啡家族的一种产品
 * 咖啡则作为一种抽象概念
 * @author Lsj
 *
 */
public abstract class Coffee {
    /**
     * 获取coffee名称
     * @return
     */
    public abstract String getName();
}

/**
 * 美式咖啡
 * @author Lsj
 *
 */
public class Americano extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

/**
 * 卡布奇诺
 * @author Lsj
 *
 */
public class Cappuccino extends Coffee {

    @Override
    public String getName() {
        return "卡布奇诺";
    }
}
/**
 * 拿铁
 * @author Lsj
 *
 */
public class Latte extends Coffee {

    @Override
    public String getName() {
        return "拿铁";
    }
}

2、工厂模式

定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法让类把实例化推迟到了子类。

/**
 * 定义一个抽象的咖啡工厂
 * @author Lsj
 */
public abstract class CoffeeFactory {
    
    /**
     * 生产可制造的咖啡
     * @return
     */
    public abstract Coffee[] createCoffee();

}

/**
 * 中国咖啡工厂
 * @author Lsj
 *
 */
public class ChinaCoffeeFactory extends CoffeeFactory {
    @Override
    public Coffee[] createCoffee() {
        // TODO Auto-generated method stub
        return new Coffee[]{new Cappuccino(), new Latte()};
    }
}
/**
 * 美国咖啡工厂
 * @author Lsj
 *
 */
public class AmericaCoffeeFactory extends CoffeeFactory {

    @Override
    public Coffee[] createCoffee() {
        // TODO Auto-generated method stub
        return new Coffee[]{new Americano(), new Latte()};
    }

}
/**
 * 工厂方法测试
 * @author Lsj
 *
 */
public class FactoryMethodTest {

    static void print(Coffee[] c){
        for (Coffee coffee : c) {
            System.out.println(coffee.getName());
        }
    }
    public static void main(String[] args) {
        CoffeeFactory chinaCoffeeFactory = new ChinaCoffeeFactory();
        Coffee[] chinaCoffees = chinaCoffeeFactory.createCoffee();
        System.out.println("中国咖啡工厂可以生产的咖啡有：");
        print(chinaCoffees);
        CoffeeFactory americaCoffeeFactory = new AmericaCoffeeFactory();
        Coffee[] americaCoffees = americaCoffeeFactory.createCoffee();
        System.out.println("美国咖啡工厂可以生产的咖啡有：");
        print(americaCoffees);
    }
}

3、抽象工厂

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

在上述的场景上继续延伸：咖啡工厂做大做强，引入了新的饮品种类：茶、 碳酸饮料。中国工厂只能制造咖啡和茶，美国工厂只能制造咖啡和碳酸饮料。

如果用上述工厂方法方式，除去对应的产品实体类还需要新增2个抽象工厂（茶制造工厂、碳酸饮料制造工厂），4个具体工厂实现。随着产品的增多，会导致类爆炸。

所以这里引出一个概念产品家族，在此例子中，不同的饮品就组成我们的饮品家族， 饮品家族开始承担创建者的责任，负责制造不同的产品。

/**
 * 抽象的饮料产品家族制造工厂
 * @author Lsj
 *
 */
public interface AbstractDrinksFactory {

    /**
     * 制造咖啡
     * @return
     */
    Coffee createCoffee();
    
    /**
     * 制造茶
     * @return
     */
    Tea createTea();
    
    /**
     * 制造碳酸饮料
     * @return
     */
    Sodas createSodas();
}


/**
 * 中国饮品工厂
 * 制造咖啡与茶
 * @author Lsj
 *
 */
public class ChinaDrinksFactory implements AbstractDrinksFactory {

    @Override
    public Coffee createCoffee() {
        // TODO Auto-generated method stub
        return new Latte();
    }

    @Override
    public Tea createTea() {
        // TODO Auto-generated method stub
        return new MilkTea();
    }

    @Override
    public Sodas createSodas() {
        // TODO Auto-generated method stub
        return null;
    }

}


/**
 * 美国饮品制造工厂
 * 制造咖啡和碳酸饮料
 * @author Lsj
 *
 */
public class AmericaDrinksFactory implements AbstractDrinksFactory {

    @Override
    public Coffee createCoffee() {
        // TODO Auto-generated method stub
        return new Latte();
    }

    @Override
    public Tea createTea() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public Sodas createSodas() {
        // TODO Auto-generated method stub
        return new CocaCola();
    }

}


/**
 * 抽象工厂测试类
 * @author Lsj
 *
 */
public class AbstractFactoryTest {
    
    static void print(Drink drink){
        if(drink == null){
            System.out.println("产品：--" );
        }else{
            System.out.println("产品：" + drink.getName());
        }
    }
    
    public static void main(String[] args) {
        AbstractDrinksFactory chinaDrinksFactory = new ChinaDrinksFactory();
        Coffee coffee = chinaDrinksFactory.createCoffee();
        Tea tea = chinaDrinksFactory.createTea();
        Sodas sodas = chinaDrinksFactory.createSodas();
        System.out.println("中国饮品工厂有如下产品：");
        print(coffee);
        print(tea);
        print(sodas);
        
        AbstractDrinksFactory americaDrinksFactory = new AmericaDrinksFactory();
        coffee = americaDrinksFactory.createCoffee();
        tea = americaDrinksFactory.createTea();
        sodas = americaDrinksFactory.createSodas();
        System.out.println("美国饮品工厂有如下产品：");
        print(coffee);
        print(tea);
        print(sodas);
    }
}

4、总结

a、简单工厂：不能算是真正意义上的设计模式，但可以将客户程序从具体类解耦。

b、工厂方法：使用继承，把对象的创建委托给子类，由子类来实现创建方法，可以看作是抽象工厂模式中只有单一产品的情况。

c、抽象工厂：使对象的创建被实现在工厂接口所暴露出来的方法中。

工厂模式可以帮助我们针对抽象/接口编程，而不是针对具体类编程，在不同的场景下按具体情况来使用。

三、代理模式

代理模式：即通过代理对象访问目标对象，实现目标对象的方法。这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，实现对目标功能的扩展。

这涉及到一个编程思想：不要随意去修改别人已经写好的代码或者方法（有坑）。如果需要修改，可以通过代理模式实现。

代理模式通常有三种实现写法：静态代理、动态代理、Cglib代理

代理模式的UML图

从UML图中，可以看出代理类与真正实现的类都是继承了抽象的主题类，这样的好处在于代理类可以与实际的类有相同的方法，可以保证客户端使用的透明性。

1、静态代理

我们先看针对上面UML实现的例子，再看静态代理的特点。
Subject接口的实现

public interface Subject {
    void visit();
}

实现了Subject接口的两个类：

public class RealSubject implements Subject {

    private String name = "byhieg";
    @Override
    public void visit() {
        System.out.println(name);
    }
}
public class ProxySubject implements Subject{

    private Subject subject;

    public ProxySubject(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void visit() {
        subject.visit();
    }
}

具体调用如下：

public class Client {

    public static void main(String[] args) {
        ProxySubject subject = new ProxySubject(new RealSubject());
        subject.visit();
    }
}

通过上面的代理代码，我们可以看出代理模式的特点，代理类接受一个Subject接口的对象，任何实现该接口的对象，都可以通过代理类进行代理，增加了通用性。但是也有缺点，每一个代理类都必须实现一遍委托类（也就是realsubject）的接口，如果接口增加方法，则代理类也必须跟着修改。其次，代理类每一个接口对象对应一个委托对象，如果委托对象非常多，则静态代理类就非常臃肿，难以胜任。

2、动态代理

动态代理有别于静态代理，是根据代理的对象，动态创建代理类。这样，就可以避免静态代理中代理类接口过多的问题。动态代理是实现方式，是通过反射来实现的，借助Java自带的java.lang.reflect.Proxy,通过固定的规则生成。
其步骤如下：

编写一个委托类的接口，即静态代理的（Subject接口）
实现一个真正的委托类，即静态代理的（RealSubject类）
创建一个动态代理类，实现InvocationHandler接口，并重写该invoke方法
在测试类中，生成动态代理的对象。
第一二步骤，和静态代理一样，不过说了。第三步，代码如下：

public class DynamicProxy implements InvocationHandler {
    private Object object;
    public DynamicProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(object, args);
        return result;
    }
}

第四步，创建动态代理的对象

Subject realSubject = new RealSubject();
DynamicProxy proxy = new DynamicProxy(realSubject);
ClassLoader classLoader = realSubject.getClass().getClassLoader();
Subject subject = (Subject) Proxy.newProxyInstance(classLoader, new  Class[]{Subject.class}, proxy);
subject.visit();

创建动态代理的对象，需要借助Proxy.newProxyInstance。该方法的三个参数分别是：

ClassLoader loader表示当前使用到的appClassloader。
Class<?>[] interfaces表示目标对象实现的一组接口。
InvocationHandler h表示当前的InvocationHandler实现实例对象。

jdk自带动态代理

java.lang.reflect.Proxy

• 作用：动态生成代理类和对象

java.lang.reflect.InvocationHandler(处理器接口)

• 可以通过invoke方法实现对真实角色的代理访问
• 每次通过Proxy生成代理类对象时，都指定对对应的处理器对象

3、Cglib代理

要实现Cglib代理，必须引入cglib.jar 包，由于Spring-core包中已经包含了cglib功能，且大部分Java项目均引入了spring 相关jar包，这边使用spring的cglib来讲解。（他俩实现方式都是一样的）

public class CglibProxy implements MethodInterceptor {
    //目标对象
    private Object obj;
    public CglibProxy(Object obj){
        this.obj=obj;
    }
 
    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(obj.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();
    }
 
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("CglibProxy--------->");
        return method.invoke(obj,objects);
    }
}

说明：可以看出，Cglib代理模式实现不需要目标对象一定实现接口，故目标对象如果没有实现接口，可以使用cglib代理模式。其实Spring的代理模式也是这么实现的。