工厂模式：
工厂模式是一种创建模式，：什么是创建，我们知道Java是面向对象的语言，那么我们想使用类中的方法以及属性，那么我们需要创建对象才能调用，那么我们我们必须：A a = new A();来创建实例，我们的工厂模式就是使用工厂来帮我们创建对象。工厂模式主要是为创建对象提供了接口：工厂模式分为3类：简单工厂 、工厂方法、抽象工厂、工厂模式我们在什么时候使用呢？
1.在编码时不能预见需要创建那种对象。
2.系统不应依赖于产品类实例如何被创建，组合、和表达的细节。
一、简单工厂模式：
这个模式很简单，使用的业务比较简单的情况下；
由3种角色组成：
工厂类角色：：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现
抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现
具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现
package com.factory.simple; /** * 水果接口 */ public interface Fruitable { // 水果的功能 void WhatIm(); }
package com.factory.simple; /** * @author :wuzhilong * @date：2018年10月25日 */ public class Apple implements Fruitable { @Override public void WhatIm() { } }
package com.factory.simple; /** * @author :wuzhilong * @date：2018年10月25日 */ public class FruitFactory { //工厂方法 public Fruitable createFruit(String type){ if("apploe".equals (type)){ return new Apple (); }else if("Pear".equals (type)){ return new Pear (); } return null; } }
工厂方法模式：
1、抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
2、具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
3、抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
4、具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
package com.factory.method; /** * 工厂接口 */ public interface FactoryInterface { Fruit createFruit(); }
package com.factory.method; /** * @author :wuzhilong * @date：2018年10月25日 * 每个产品的具体工厂 */ public class AppleFactory implements FactoryInterface { @Override public Fruit createFruit() { return new Apple (); } }
package com.factory.method; /** * @author :wuzhilong * @date：2018年10月25日 * 每个产品的具体工厂 */ public class PearFactory implements FactoryInterface { @Override public Fruit createFruit() { return new Pear (); } }
package com.factory.method; /** * @author :wuzhilong * @date：2018年10月25日 * 水果类 */ public abstract class Fruit { }
package com.factory.method; /** * @author :wuzhilong * @date：2018年10月25日 */ public class Apple extends Fruit { }
package com.factory.method; /** * @author :wuzhilong * @date：2018年10月25日 */ public class Pear extends Fruit { }
抽象工厂模式：
1.系统中有多个产品族，而系统一次只可能消费其中一族产品
2.同属于同一个产品族的产品一起使用时。
来看看抽象工厂模式的各个角色（和工厂方法的如出一辙）：
抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
package com.factory.abs; /** * 产品接口 */ public interface ThinkPadInterface { public void show(); }
package com.factory.abs; /** * @author :wuzhilong * @date：2018年10月25日 * 具体的产品 */ public class ThinkPadE implements ThinkPadInterface { @Override public void show() { } }
package com.factory.abs; /** * @author :wuzhilong * @date：2018年10月25日 * 具体的产品 */ public class ThinkPadT implements ThinkPadInterface { @Override public void show() { } }
package com.factory.abs; /** * 工厂接口 */ public interface FactoryInterface { public ThinkPadE createThinkPad(); public ThinkPadT createThinkPadE(); }
package com.factory.abs; /** * @author :wuzhilong * @date：2018年10月25日 * 工厂 */ public class Factory implements FactoryInterface{ @Override public ThinkPadE createThinkPad() { return new ThinkPadE (); } @Override public ThinkPadT createThinkPadE() { return new ThinkPadT (); } }
代理模式：
什么是代理模式：
Proxy模式又叫代理模式，是构造型的模式之一，它可以为其他对象提供一种代理（Proxy）以控制对这个对象的访问。
所谓代理，是指具有与代理元（被代理的对象）具有相同的接口的类，客户端必须通过代理与被代理的目标类交互，而代理一般在交互的过程中（交互前后）进行某些特别的处理。
代理模式结构图：
代理模式的实现
代理模式可以有两种实现的方式，一种是静态代理类，另一种是各大框架都喜欢的动态代理
静态代理：
package com.wuzhilong.proxy; public interface ISinger { public void sing(); }
package com.wuzhilong.proxy; /** * 目标对象实现某一接口 */ public class Singer implements ISinger{ public void sing(){ System.out.println ("唱一首歌......"); } }
package com.wuzhilong.proxy; /** * 代理对象和目标对象实现相同接口 */ public class SingerProxy implements ISinger { //接收目标对象，来调用sing方法 private ISinger singer; public SingerProxy(ISinger singer) { this.singer = singer; } //对目标对象的sing方法进行扩展 @Override public void sing() { System.out.println ("向观众问好"); singer.sing (); System.out.println ("谢谢大家"); } }
测试：
package com.wuzhilong.proxy; /** * 静态代理模式 */ public class Demo { public static void main(String[] args) { //目标对象 ISinger iSinger = new Singer (); //代理对象 ISinger iSinger1 = new SingerProxy (iSinger); iSinger1.sing (); } }
总结：其实这里做的事情无非就是，创建一个代理类SingerProxy，继承了ISinger接口并实现了其中的方法。只不过这种实现特意包含了目标对象的方法，正是这种特征使得看起来像是“扩展”了目标对象的方法。假使代理对象中只是简单地对sing方法做了另一种实现而没有包含目标对象的方法，也就不能算作代理模式了。所以这里的包含是关键。
缺点：这种实现方式很直观也很简单，但其缺点是代理对象必须提前写出，如果接口层发生了变化，代理对象的代码也要进行维护。如果能在运行时动态地写出代理对象，不但减少了一大批代理类的代码，也少了不断维护的烦恼，不过运行时的效率必定受到影响。这种方式就是接下来的动态代理。
动态代理（JDK代理）：
package com.wuzhilong.jdkproxy; public interface ISinger { public void sing(); }
package com.wuzhilong.jdkproxy; import com.wuzhilong.jdkproxy.ISinger; /** * 目标对象实现某一接口 */ public class Singer implements ISinger { public void sing(){ System.out.println ("唱一首歌......"); } }
package com.wuzhilong.jdkproxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class SingerProxy implements InvocationHandler { //需要代理的真实对象 private Object subject; // 构造方法，给我们要代理的真实对象赋初值 public SingerProxy(Object subject) { this.subject = subject; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println ("向观众问好"); // 执行目标类的方法 method.invoke (subject,args); System.out.println ("谢谢大家"); return null; } }
package com.wuzhilong.jdkproxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; public class Demo { public static void main(String[] args) throws Exception{ //代理的真实对象 ISinger singer = new Singer (); // 我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的 InvocationHandler invocationHandler = new SingerProxy (singer); /* * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数 * 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象 * 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了 * 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上 */ ISinger singerProxy =(ISinger) Proxy.newProxyInstance (invocationHandler.getClass ().getClassLoader (),singer.getClass ().getInterfaces (),invocationHandler); //通过代理对象执行方法 singerProxy.sing (); } }