四、结构型

1. 适配器（Adapter）

Intent

把一个类接口转换成另一个用户需要的接口。

Class Diagram

Target：定义客户端需要的跟特定领域相关的接口。

Adaptee：已经存在的接口，通常能满足客户端的功能要求，
但是接口与客户端要求的特定领域接口不一致，需要被适配。

Adapter：适配器，把Adaptee适配成为Client需要的Target。

Implementation1

美国的电饭煲是在电压为 110V 下工作，而中国的电饭煲在电压 220V 下工作。要求将在美国使用的电饭煲适配成能在中国使用。

/**
 * Adaptee:已经存在的接口，通常能满足客户端的功能要求。
 * 但是接口与客户端要求的特定领域接口不一致，需要被适配。
 */
public interface CHINA220 {
    //220 V电压接口
    void connect();
}

public class CHINA220Impl implements CHINA220{
    @Override
    public void connect() {
        System.out.println("220V 接通电源，开始工作...");
    }
}

/**
 * Target：定义客户端需要的跟特定领域相关的接口。
 */
public interface USA110 {
    //110 V电压接口
    void connect();
}

/**
 * Adapter：适配器，把Adaptee适配成为Client需要的Target。
 *
 * 将220V（Adapter）适配成110V(Target)
 */
public class PowerAdapter implements USA110{
    private CHINA220 china220;
    public PowerAdapter(CHINA220 china220){
        this.china220=china220;
    }
    @Override
    public void connect() {
        china220.connect();
    }
}

/**
 * 该电器在110V下工作
 */
public class USACooker {
    private USA110 usa110;
    public USACooker(USA110 usa110) {
        this.usa110 = usa110;
    }
    public void cook(){
        usa110.connect();
        System.out.println("开始煮饭...");
    }
}

public class Client {
    public static void main(String[] args) {
        // 110 V 电压下直接 cook
        USA110 usa110 = new USA110Impl();
        USACooker usaCooker = new USACooker(usa110);
        usaCooker.cook();
        // 220 V 电压下需要适配成 110V，才可 cook
        CHINA220 china220 = new CHINA220Impl();
        PowerAdapter adapter = new PowerAdapter(china220);
        USACooker usaCooker2 = new USACooker(adapter);
        usaCooker2.cook();
    }
}

110V 接通电源，开始工作...
开始煮饭...
220V 接通电源，开始工作...
开始煮饭...

Implementation2

鸭子（Duck）和火鸡（Turkey）拥有不同的叫声，Duck 的叫声调用 quack() 方法，而 Turkey 调用 gobble() 方法。

要求将 Turkey 的 gobble() 方法适配成 Duck 的 quack() 方法，从而让火鸡冒充鸭子！

public interface Duck {
    void quack();
}

public interface Turkey {
    void gobble();
}

public class WildTurkey implements Turkey {
    @Override
    public void gobble() {
        System.out.println("gobble!");
    }
}

public class TurkeyAdapter implements Duck {
    Turkey turkey;
    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;
    }
    @Override
    public void quack() {
        turkey.gobble();
    }
}

public class Client {
    public static void main(String[] args) {
        Turkey turkey = new WildTurkey();
        Duck duck = new TurkeyAdapter(turkey);
        duck.quack();
    }
}

JDK

• java.util.Arrays#asList()
• java.util.Collections#list()
• java.util.Collections#enumeration()
• javax.xml.bind.annotation.adapters.XMLAdapter

2. 桥接（Bridge）

Intent

将抽象与实现分离开来，使它们可以独立变化。

Class Diagram

• Abstraction：定义抽象类的接口
• Implementor：定义实现类接口

Implementation

RemoteControl 表示遥控器，指代 Abstraction。

TV 表示电视，指代 Implementor。

桥接模式将遥控器和电视分离开来，从而可以独立改变遥控器或者电视的实现。

public abstract class TV {
    public abstract void on();
    public abstract void off();
    public abstract void tuneChannel();
}

public class Sony extends TV {
    @Override
    public void on() {
        System.out.println("Sony.on()");
    }
    @Override
    public void off() {
        System.out.println("Sony.off()");
    }
    @Override
    public void tuneChannel() {
        System.out.println("Sony.tuneChannel()");
    }
}

public class RCA extends TV {
    @Override
    public void on() {
        System.out.println("RCA.on()");
    }
    @Override
    public void off() {
        System.out.println("RCA.off()");
    }
    @Override
    public void tuneChannel() {
        System.out.println("RCA.tuneChannel()");
    }
}

public abstract class RemoteControl {
    protected TV tv;
    public RemoteControl(TV tv) {
        this.tv = tv;
    }
    public abstract void on();
    public abstract void off();
    public abstract void tuneChannel();
}

public class ConcreteRemoteControl1 extends RemoteControl {
    public ConcreteRemoteControl1(TV tv) {
        super(tv);
    }
    @Override
    public void on() {
        System.out.println("ConcreteRemoteControl1.on()");
        tv.on();
    }
    @Override
    public void off() {
        System.out.println("ConcreteRemoteControl1.off()");
        tv.off();
    }
    @Override
    public void tuneChannel() {
        System.out.println("ConcreteRemoteControl1.tuneChannel()");
        tv.tuneChannel();
    }
}

public class ConcreteRemoteControl2 extends RemoteControl {
    public ConcreteRemoteControl2(TV tv) {
        super(tv);
    }
    @Override
    public void on() {
        System.out.println("ConcreteRemoteControl2.on()");
        tv.on();
    }
    @Override
    public void off() {
        System.out.println("ConcreteRemoteControl2.off()");
        tv.off();
    }
    @Override
    public void tuneChannel() {
        System.out.println("ConcreteRemoteControl2.tuneChannel()");
        tv.tuneChannel();
    }
}

public class Client {
    public static void main(String[] args) {
        RemoteControl remoteControl1 = new ConcreteRemoteControl1(new RCA());
        remoteControl1.on();
        remoteControl1.off();
        remoteControl1.tuneChannel();
        RemoteControl remoteControl2 = new ConcreteRemoteControl2(new Sony());
         remoteControl2.on();
         remoteControl2.off();
         remoteControl2.tuneChannel();
    }
}

JDK

• AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)
• JDBC

3. 组合（Composite）

Intent

将对象组合成树形结构来表示“整体/部分”层次关系，允许用户以相同的方式处理单独对象和组合对象。

Class Diagram

Leaf：叶子节点对象，定义和实现叶子对象的行为，不再包含其它的子节点对象。

Composite：组合对象，通常会存储子组件，定义包含子组件的那些组件的行为，并实现在组件接口中定义的与子组件有关的操作。

组件（Component）类是组合类（Composite）和叶子类（Leaf）的父类，可以把组合类看成是树的中间节点。

组合对象拥有一个或者多个组件对象，因此组合对象的操作可以委托给组件对象去处理，而组件对象可以是另一个组合对象或者叶子对象。

Implementation1

商品类别树的管理，比如有如下所示的商品类别树：

- 服装
    - 男装
        - 衬衣
        - 夹克
    - 女装
        - 裙子
        - 套装

• 根节点，比如服装，它没有父节点，它可以包含其它的节点
• 树枝节点，有一类节点可以包含其它的节点，称之为树枝节点，比如男装、女装
• 叶子节点，有一类节点没有子节点，称之为叶子节点，比如衬衣、夹克、裙子、套装

/**
 * 组件抽象类
 */
public abstract class Component {
    /**
     * 输出组件自身的名称
     */
    public abstract void doOperation(String preStr);
    /**
     * 向组合对象中加入组件对象
     * @param child 被加入组合对象中的组件对象
     */
    public void add(Component child) {
        throw new UnsupportedOperationException("对象不支持这个功能");
    }
    /**
     * 从组合对象中移出某个组件对象
     * @param child 被移出的组件对象
     */
    public void remove(Component child) {
        throw new UnsupportedOperationException("对象不支持移除功能");
    }
    /**
     * 返回某个索引对应的组件对象
     * @param index 需要获取的组件对象的索引，索引从0开始
     * @return 索引对应的组件对象
     */
    public Component getChildren(int index) {
        throw new UnsupportedOperationException("对象不支持获取子节点功能");
    }
}

/**
 * 叶子对象
 */
public class Leaf extends Component{
    //叶子对象元素信息
    private String name;
    public Leaf(String name){
        this.name=name;
    }
    @Override
    public void doOperation(String preStr) {
        System.out.println(preStr+"-"+name);
    }
}

/**
 * 组合对象，可以包含其它组合对象或者叶子对象
 */
public class Composite extends Component{
    private String name;
    /**
     * 用来存储组合对象中包含的子组件对象
     */
    private List<Component> childComponents;
    public Composite(String name){
        this.name=name;
    }
    @Override
    public void add(Component child) {
        if(childComponents==null){
            childComponents=new ArrayList<>();
        }
        childComponents.add(child);
    }
    /**
     * /**
     * 输出组合对象自身的结构
     * @param preStr 主要是按照层级拼接的空格，实现向后缩进
     */
    @Override
    public void doOperation(String preStr) {
        System.out.println(preStr+"+"+this.name);
        //如果还包含有子组件，那么就输出这些子组件对象
        if(this.childComponents!=null){
            //然后添加一个空格，表示向后缩进一个空格
            preStr+=" ";
            //输出当前对象的子对象了
            for(Component c : childComponents){
                //递归输出每个子对象
                c.doOperation(preStr);
            }
        }
    }
}

ublic class Client {
    public static void main(String[] args) {
        //定义所有的组合对象
        Component root = new Composite("服装");
        Component c1 = new Composite("男装");
        Component c2 = new Composite("女装");
        //定义所有的叶子对象
        Component leaf1 = new Leaf("衬衣");
        Component leaf2 = new Leaf("夹克");
        Component leaf3 = new Leaf("裙子");
        Component leaf4 = new Leaf("套装");
        //按照树的结构来组合组合对象和叶子对象
        root.add(c1);
        root.add(c2);
        c1.add(leaf1);
        c1.add(leaf2);
        c2.add(leaf3);
        c2.add(leaf4);
        //调用根对象的输出功能来输出整棵树
        root.doOperation("");
    }
}

输出结果：

+服装
 +男装
  -衬衣
  -夹克
 +女装
  -裙子
  -套装

Implementation2

public abstract class Component {
    protected String name;
    public Component(String name) {
        this.name = name;
    }
    public void print() {
        print(0);
    }
    abstract void print(int level);
    abstract public void add(Component component);
    abstract public void remove(Component component);
}

public class Composite extends Component{
    private List<Component> child;
    public Composite(String name){
        super(name);
        if(child==null){
            child=new ArrayList<>();
        }
    }
    @Override
    void print(int level) {
        for (int i = 0; i < level; i++) {
            System.out.print(" ");
        }
        System.out.println("+" + name);
        for (Component component : child) {
            component.print(level + 1);
        }
    }
    @Override
    public void add(Component component) {
        child.add(component);
    }
    @Override
    public void remove(Component component) {
        child.remove(component);
    }
}

public class Leaf extends Component {
    public Leaf(String name) {
        super(name);
    }
    @Override
    void print(int level) {
        for (int i = 0; i < level; i++) {
            System.out.print(" ");
        }
        System.out.println("-"+name);
    }
    @Override
    public void add(Component component) {
        throw new UnsupportedOperationException("对象不支持这个功能");
    }
    @Override
    public void remove(Component component) {
        throw new UnsupportedOperationException("对象不支持这个功能");
    }
}

public class Client {
    public static void main(String[] args) {
        Component root=new Composite("root");
        Component node1=new Leaf("1");
        Component node2=new Composite("2");
        Component node3=new Leaf("3");
        Component node21=new Leaf("21");
        Component node22=new Composite("22");
        Component node221=new Leaf("221");
        root.add(node1);
        root.add(node2);
        root.add(node3);
        node2.add(node21);
        node2.add(node22);
        node22.add(node221);
        root.print();
    }
}

输出结果：

+root
 -1
 +2
  -21
  +22
   -221
 -3

JDK

• javax.swing.JComponent#add(Component)
• java.awt.Container#add(Component)
• java.util.Map#putAll(Map)
• java.util.List#addAll(Collection)
• java.util.Set#addAll(Collection)

4. 装饰（Decorator）

Intent

为对象动态添加功能。

Class Diagram

装饰者（Decorator）和具体组件（ConcreteComponent）都继承自组件（Component），具体组件的方法实现不需要依赖于其它对象，而装饰者组合了一个组件，这样它可以装饰其它装饰者或者具体组件。所谓装饰，就是把这个装饰者套在被装饰者之上，从而动态扩展被装饰者的功能。装饰者的方法有一部分是自己的，这属于它的功能，然后调用被装饰者的方法实现，从而也保留了被装饰者的功能。可以看到，具体组件应当是装饰层次的最低层，因为只有具体组件的方法实现不需要依赖于其它对象。

Implementation1

给普通手机装饰上彩铃等功能。

/**
 * Component：组件对象的接口，可以给这些对象动态的添加职责。
 */
public interface Phone {
    void call();
}

/**
 * ConcreteComponent：具体的组件对象，实现组件对象接口，
 * 通常就是被装饰器装饰的原始对象，也就是可以给这个对象添加职责。
 */
public class IPhone implements Phone{
    @Override
    public void call() {
        System.out.println("IPhone打电话");
    }
}

/**
 * Decorator：所有装饰器的抽象父类，需要定义一个与组件接口一致的接口，并持有一个Component对象，其实就是持有一个被装饰的对象。
 * 注意，这个被装饰的对象不一定是最原始的那个对象了，
 * 也可能是被其它装饰器装饰过后的对象，反正都是实现的同一个接口，也就是同一类型。
 */
public abstract class PhoneDecorator implements Phone{
    protected Phone phone;
    public PhoneDecorator(Phone phone){
        this.phone=phone;
    }
    @Override
    public void call() {
        phone.call();
    }
}

/**
 * 具体的装饰类，实现具体要向被装饰对象添加的功能。
 */
public class MusicPhoneDecorator extends PhoneDecorator{
    public MusicPhoneDecorator(Phone phone) {
        super(phone);
    }
    @Override
    public void call(){
        phone.call();
        System.out.println("接完电话听点音乐");
    }
}

/**
 * 具体的装饰类，实现具体要向被装饰对象添加的功能。
 */
public class RingPhoneDecorator extends PhoneDecorator {
    public RingPhoneDecorator(Phone phone) {
        super(phone);
    }
    @Override
    public void call(){
        System.out.println("接电话前响铃");
        phone.call();
    }
}

public class Client {
    public static void main(String[] args) {
        //普通手机
        Phone p=new IPhone();
        p.call();
        System.out.println("====================");
        //使用装饰类 -->增加了彩铃功能
        RingPhoneDecorator rpd=new RingPhoneDecorator(p);
        rpd.call();
        System.out.println("====================");
        //使用装饰类 -->增加了听音乐的功能
        MusicPhoneDecorator mpd=new MusicPhoneDecorator(p);
        mpd.call();
        System.out.println("====================");
        //装饰类可以组合 -->先响铃-->接电话-->接完电话后，就听音乐
        //装饰类的特点
        MusicPhoneDecorator mpd2=new
                MusicPhoneDecorator(new RingPhoneDecorator(p));
        mpd2.call();
        System.out.println("===========================");
        RingPhoneDecorator mpd3= new 
            RingPhoneDecorator(new MusicPhoneDecorator(p));
        mpd3.call();
    }
}

输出结果：

IPhone打电话
====================
接电话前响铃
IPhone打电话
====================
IPhone打电话
接完电话听点音乐
====================
接电话前响铃
IPhone打电话
接完电话听点音乐
===========================
接电话前响铃
IPhone打电话
接完电话听点音乐

Implementation2

设计不同种类的饮料，饮料可以添加配料，比如可以添加牛奶，并且支持动态添加新配料。每增加一种配料，该饮料的价格就会增加，要求计算一种饮料的价格。

下图表示在 DarkRoast 饮料上新增新添加 Mocha 配料，之后又添加了 Whip 配料。DarkRoast 被 Mocha 包裹，Mocha 又被 Whip 包裹。它们都继承自相同父类，都有 cost() 方法，外层类的 cost() 方法调用了内层类的 cost() 方法。

public interface Beverage {
    double cost();
}

public class DarkRoast implements Beverage {
    @Override
    public double cost() {
        return 1;
    }
}

public class HouseBlend implements Beverage {
    @Override
    public double cost() {
        return 1;
    }
}

public abstract class CondimentDecorator implements Beverage {
    protected Beverage beverage;
}

public class Milk extends CondimentDecorator {
    public Milk(Beverage beverage) {
        this.beverage = beverage;
    }
    @Override
    public double cost() {
        return 1 + beverage.cost();
    }
}

public class Mocha extends CondimentDecorator {
    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }
    @Override
    public double cost() {
        return 1 + beverage.cost();
    }
}

public class Client {
    public static void main(String[] args) {
        Beverage beverage = new HouseBlend();
        System.out.println(beverage.cost()); //3.0
        beverage = new Mocha(beverage);
        System.out.println(beverage.cost()); //4.0
        beverage = new Milk(beverage);
        //本来3元的饮料，加上Mocha、Milk后就变成了5元
        System.out.println(beverage.cost()); //5.0
    }
}

3.0
4.0
5.0

设计原则

类应该对扩展开放，对修改关闭：也就是添加新功能时不需要修改代码。
饮料可以动态添加新的配料，而不需要去修改饮料的代码。

不可能把所有的类设计成都满足这一原则，应当把该原则应用于最有可能发生改变的地方。

JDK

• java.io.BufferedInputStream(InputStream)
• java.io.DataInputStream(InputStream)
• java.io.BufferedOutputStream(OutputStream)
• java.util.zip.ZipOutputStream(OutputStream)
• java.util.Collections#checkedList|Map|Set|SortedSet|SortedMap

5. 外观（Facade）

Intent

提供了一个统一的接口，用来访问子系统中的一群接口，从而让子系统更容易使用。

Class Diagram

Implementation

观看电影需要操作很多电器，使用外观模式实现一键看电影功能。

public class SubSystem {
    public void turnOnTV() {
        System.out.println("turnOnTV()");
    }
    public void setCD(String cd) {
        System.out.println("setCD( " + cd + " )");
    }
    public void starWatching(){
        System.out.println("starWatching()");
    }
}

public class Facade {
    private SubSystem subSystem = new SubSystem();
    public void watchMovie() {
        subSystem.turnOnTV();
        subSystem.setCD("a movie");
        subSystem.starWatching();
    }
}

public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.watchMovie();
    }
}

设计原则

最少知识原则：只和你的密友谈话。也就是说客户对象所需要交互的对象应当尽可能少。

6. 享元（Flyweight）

Intent

利用共享的方式来支持大量细粒度的对象，这些对象一部分内部状态是相同的。

Class Diagram

• Flyweight：享元对象
• IntrinsicState：内部状态，享元对象共享内部状态
• ExtrinsicState：外部状态，每个享元对象的外部状态不同

Implementation

public interface Flyweight {
    void doOperation(String extrinsicState);
}

public class ConcreteFlyweight implements Flyweight {
    private String intrinsicState;
    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }
    @Override
    public void doOperation(String extrinsicState) {
        System.out.println("Object address: " + System.identityHashCode(this));
        System.out.println("IntrinsicState: " + intrinsicState);
        System.out.println("ExtrinsicState: " + extrinsicState);
    }
}

public class FlyweightFactory {
    private HashMap<String, Flyweight> flyweights = new HashMap<>();
    Flyweight getFlyweight(String intrinsicState) {
        if (!flyweights.containsKey(intrinsicState)) {
            Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
            flyweights.put(intrinsicState, flyweight);
        }
        return flyweights.get(intrinsicState);
    }
}

public class Client {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        Flyweight flyweight1 = factory.getFlyweight("aa");
        Flyweight flyweight2 = factory.getFlyweight("aa");
        flyweight1.doOperation("x");
        flyweight2.doOperation("y");
    }
}

Object address: 1163157884
IntrinsicState: aa
ExtrinsicState: x
Object address: 1163157884
IntrinsicState: aa
ExtrinsicState: y

JDK

Java 利用缓存来加速大量小对象的访问时间。

• java.lang.Integer#valueOf(int)
• java.lang.Boolean#valueOf(boolean)
• java.lang.Byte#valueOf(byte)
• java.lang.Character#valueOf(char)

7. 代理（Proxy）

Intent

控制对其它对象的访问。

代理有以下四类：

• 远程代理（Remote Proxy）：控制对远程对象（不同地址空间）的访问，它负责将请求及其参数进行编码，并向不同地址空间中的对象发送已经编码的请求。
• 虚拟代理（Virtual Proxy）：根据需要创建开销很大的对象，它可以缓存实体的附加信息，以便延迟对它的访问，例如在网站加载一个很大图片时，不能马上完成，可以用虚拟代理缓存图片的大小信息，然后生成一张临时图片代替原始图片。
• 保护代理（Protection Proxy）：按权限控制对象的访问，它负责检查调用者是否具有实现一个请求所必须的访问权限。
• 智能代理（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；当第一次引用一个对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其它对象不能改变它。

Class Diagram

• Proxy：代理对象，通常具有如下功能：

1. 实现与具体的目标对象一样的接口，这样就可以使用代理来代替具体的目标对象
2. 保存一个指向具体目标对象的引用，可以在需要的时候调用具体的目标对象，
   可以控制对具体目标对象的访问，并可能负责创建和删除它

• Subject：目标接口，定义代理和具体目标对象的接口，这样就可以在任何使用具体目标对象的地方使用代理对象
• RealSubject：具体的目标对象，真正实现目标接口要求的功能。

Implementation

以下是一个虚拟代理的实现，模拟了图片延迟加载的情况下使用与图片大小相等的临时内容去替换原始图片，直到图片加载完成才将图片显示出来。

public interface Image {
    void showImage();
}

public class HighResolutionImage implements Image {
    private URL imageURL;
    private long startTime;
    private int height;
    private int width;
    public int getHeight() {
        return height;
    }
    public int getWidth() {
        return width;
    }
    public HighResolutionImage(URL imageURL) {
        this.imageURL = imageURL;
        this.startTime = System.currentTimeMillis();
        this.width = 600;
        this.height = 600;
    }
    public boolean isLoad() {
        // 模拟图片加载，延迟 3s 加载完成
        long endTime = System.currentTimeMillis();
        return endTime - startTime > 3000;
    }
    @Override
    public void showImage() {
        System.out.println("Real Image: " + imageURL);
    }
}

public class ImageProxy implements Image {
    private HighResolutionImage highResolutionImage;
    public ImageProxy(HighResolutionImage highResolutionImage) {
        this.highResolutionImage = highResolutionImage;
    }
    @Override
    public void showImage() {
        while (!highResolutionImage.isLoad()) {
            try {
                System.out.println("Temp Image: " + highResolutionImage.getWidth() + " " + highResolutionImage.getHeight());
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        highResolutionImage.showImage();
    }
}

public class ImageViewer {
    public static void main(String[] args) throws Exception {
        String image = "http://image.jpg";
        URL url = new URL(image);
        HighResolutionImage highResolutionImage = new HighResolutionImage(url);
        ImageProxy imageProxy = new ImageProxy(highResolutionImage);
        imageProxy.showImage();
    }
}

JDK

• java.lang.reflect.Proxy
• RMI

Java中的代理模式

Java对代理模式提供了内建的支持，在java.lang.reflect包下面，
提供了一个Proxy的类和一个InvocationHandler的接口。

• Java的静态代理

/**
 * Subject接口
 */
public interface IUserDao {
    void save();
}

/**
 * RealSubject
 */
public class UserDao implements IUserDao{
    @Override
    public void save() {
        System.out.println("保存数据");
    }
}

/**
 * Proxy
 * 1. 实现与具体的目标对象一样的接口，这样就可以使用代理来代替具体的目标对象
 * 2.保存一个指向具体目标对象的引用**，可以在需要的时候调用具体的目标对象，
 * 可以控制对具体目标对象的访问，并可能负责创建和删除它
 */
public class UserDaoProxy implements IUserDao{
    private UserDao target;
    public UserDaoProxy(UserDao userDao){
        this.target=userDao;
    }
    @Override
    public void save() {
        System.out.println("==保存之前增强==");
        target.save();
        System.out.println("==保存之后增强==");
    }
}

public class Client {
    public static void main(String[] args) {
        UserDao userDao=new UserDao();
        userDao.save();
        System.out.println("。。。使用代理后。。。");
        UserDaoProxy proxy=new UserDaoProxy(userDao);
        proxy.save();
    }
}

输出结果：

保存数据
。。。使用代理后。。。
==保存之前增强==
保存数据
==保存之后增强==

Java的静态代理有一个较大的缺点，就是如果Subject接口发生变化，那么代理类和具体的目标实现都要变化，不是很灵活。

• Java的动态代理

/**
 * Subject接口
 */
public interface IUserDao {
    void save();
    void update();
}

/**
 * RealSubject
 */
public class UserDao implements IUserDao {
    @Override
    public void save() {
        System.out.println("保存数据");
    }
    @Override
    public void update() {
        System.out.println("更新数据");
    }
}

public class PrxoyFactory {
    private Object target;
    public PrxoyFactory(Object target){
        this.target=target;
    }
    public Object getInstance(){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    //proxy - 在其上调用方法的代理实例
                    //method - 对应于在代理实例上调用的接口方法的 Method 实例。
                    //args - 包含传入代理实例上方法调用的参数值的对象数组，
                    //如果接口方法不使用参数，则为 null。
                    //基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object obj=null;
                        String methodName=method.getName();
                        //只对save方法增强
                        if("save".equals(methodName)){
                            System.out.println("提交事务");
                            //target 就是目标对象，arge就是方法的参数
                            obj=method.invoke(target,args);
                            System.out.println("结束事务");
                        }else{
                            obj=method.invoke(target,args);
                        }
                        return obj;
                    }
                }
        );
    }
}

public class Client {
    public static void main(String[] args) {
        IUserDao userDao=new UserDao();
        userDao.save();
        userDao.update();
        System.out.println("。。。使用代理后。。。");
        PrxoyFactory factory=new PrxoyFactory(userDao);
        //Java的动态代理目前只能代理接口
        IUserDao proxy=(IUserDao)factory.getInstance();
        proxy.save();
        proxy.update();
    }
}

输出结果：

保存数据
更新数据
。。。使用代理后。。。
提交事务
保存数据
结束事务
更新数据

动态代理跟静态代理相比，明显的变化是：

静态代理实现的时候，在Subject接口上定义很多的方法，代理类里面自然也要实现很多方法；

动态代理实现的时候，虽然Subject接口上定义了很多方法，但是动态代理类始终只有一个invoke方法。

这样当Subject接口发生变化的时候，动态代理的接口就不需要跟着变化了。

Java的动态代理目前只能代理接口，基本的实现是依靠Java的反射机制和动态生成class的技术，
来动态生成被代理的接口的实现对象。

• Java的Cglib代理

需要引入第三方 jar包，这里引入的是

spring-core-3.2.0.RELEASE.jar

/**
 * Subject接口
 */
public interface IUserDao {
    void save();
    void update();
}

public class UserDao implements IUserDao {
    @Override
    public void save() {
        System.out.println("保存数据");
    }
    @Override
    public void update(){
        System.out.println("更新数据");
    }
}

/**
 * Cglib代理工厂，
 * 实现了MthodInterceptor
 */
public class CglibProxyFactory implements MethodInterceptor{
    private Object target;
    public CglibProxyFactory(Object target){
        this.target=target;
    }
    public Object getInstance(){
        //1.工具类
        Enhancer enchancer=new Enhancer();
        //2.设置父类
        enchancer.setSuperclass(target.getClass());
        //3.设置回调函数
        enchancer.setCallback(this);
        //4.创建子类（代理对象）
        return enchancer.create();
    }
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        Object returnObj=null;
        if("save".equals(method.getName())){
            System.out.println("开启事务");
            returnObj=method.invoke(target,objects);
            System.out.println("关闭事务");
        }else{
            returnObj=method.invoke(target,objects);
        }
        return returnObj;
    }
}

public class Client {
    public static void main(String[] args) {
        IUserDao userDao=new UserDao();
        userDao.save();
        userDao.update();
        System.out.println("。。。使用代理后。。。");
        CglibProxyFactory factory=new CglibProxyFactory(userDao);
        //Cglib即可以代理接口，也可以代理对象
        IUserDao proxy=(IUserDao)factory.getInstance();
        //UserDao proxy=(UserDao)factory.getInstance();
        proxy.save();
        proxy.update();
    }
}