常用的设计模式

常用的设计模式：

一、单例模式

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 {@Overridepublic String getName() {return "美式咖啡";}
}/*** 卡布奇诺* @author Lsj**/
public class Cappuccino extends Coffee {@Overridepublic String getName() {return "卡布奇诺";}
}
/*** 拿铁* @author Lsj**/
public class Latte extends Coffee {@Overridepublic String getName() {return "拿铁";}
}

2、工厂模式

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

/*** 定义一个抽象的咖啡工厂* @author Lsj*/
public abstract class CoffeeFactory {/*** 生产可制造的咖啡* @return*/public abstract Coffee[] createCoffee();}/*** 中国咖啡工厂* @author Lsj**/
public class ChinaCoffeeFactory extends CoffeeFactory {@Overridepublic Coffee[] createCoffee() {// TODO Auto-generated method stubreturn new Coffee[]{new Cappuccino(), new Latte()};}
}
/*** 美国咖啡工厂* @author Lsj**/
public class AmericaCoffeeFactory extends CoffeeFactory {@Overridepublic Coffee[] createCoffee() {// TODO Auto-generated method stubreturn 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 {@Overridepublic Coffee createCoffee() {// TODO Auto-generated method stubreturn new Latte();}@Overridepublic Tea createTea() {// TODO Auto-generated method stubreturn new MilkTea();}@Overridepublic Sodas createSodas() {// TODO Auto-generated method stubreturn null;}}/*** 美国饮品制造工厂* 制造咖啡和碳酸饮料* @author Lsj**/
public class AmericaDrinksFactory implements AbstractDrinksFactory {@Overridepublic Coffee createCoffee() {// TODO Auto-generated method stubreturn new Latte();}@Overridepublic Tea createTea() {// TODO Auto-generated method stubreturn null;}@Overridepublic Sodas createSodas() {// TODO Auto-generated method stubreturn 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";@Overridepublic void visit() {System.out.println(name);}
}
public class ProxySubject implements Subject{private Subject subject;public ProxySubject(Subject subject) {this.subject = subject;}@Overridepublic 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;}@Overridepublic 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();}@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("CglibProxy--------->");return method.invoke(obj,objects);}
}