《设计模式之美》(三：结构型模式)

结构型模式：解耦不同功能

1. 代理模式
   • 实现方式：实现同一个接口(加上组合)，或者继承
   • 动态代理：在代理类比较多的情况下，可以通过动态代理，在程序运行的时候动态创建代理类
   • 应用场景：监控、鉴权、统计、限流

public interface PlayGame {
    void play();
}

public class LiLiPalyGame implements PlayGame{
    @Override
    public void play() {
        System.out.println("yin yin yin");
    }
}

public class PlayGameProxy implements PlayGame{
    private LiLiPalyGame liLiPalyGame;


    public PlayGameProxy() {
        liLiPalyGame = new LiLiPalyGame();

    }

    @Override
    public void play() {
        System.out.println("pre");
        liLiPalyGame.play();
        System.out.println("after");
    }
}

public class PlayGameDynamicProxy {

    public Object createProxy(Object object){
        DynamicProxy dynamicProxy = new DynamicProxy(object);
        Object instance = Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), dynamicProxy);
        return instance;
    }

    public class  DynamicProxy implements InvocationHandler{
        private Object proxies;
        public DynamicProxy(Object obj) {
            proxies = obj;
        }

        @Override
        public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
            System.out.println("before");
            method.invoke(proxies,objects);
            System.out.println("after");
            return null;
        }
    }


}


    PlayGameProxy playGameProxy = new PlayGameProxy();
        playGameProxy.play();

        PlayGameDynamicProxy playGameDynamicProxy = new PlayGameDynamicProxy();
        PlayGame playGame = (PlayGame) playGameDynamicProxy.createProxy(new LiLiPalyGame());
        playGame.play()

技术方案：
jdk
javasist
cglib
javasist&cglib通过添加依赖，性能相似

2. 装饰器模式
   和代理模式相似，都是组合代替继承，不同点在于，代理模式添加不相关的功能，装饰模式是扩展功能

eg:java的输入输出流，就是基于装饰器模式
带缓存的输入流
InputStream in = new FileInputStream("路径")
InputStrean bin = new BufferInputStream(in);
byte[] data = new byte[128]
while(bin.read(data) != -1){
}

3. 适配器模式
   偏向于"事后补救"，"插头装换"

public interface ITarget {
    void f1();
    void f2();
    void f3();
}

public  class Adaptee {
    void fa(){}
    void fb(){}
    void fc(){}
}

//继承模式
public class Adaptor extends Adaptee implements ITarget {
    @Override
    public void f1() {
        super.fa();
    }

    @Override
    public void f2() {
        super.fb();
    }

    @Override
    public void f3() {
    super.fc();
    }
}

//泛型话组合模式 Android 的ListView 和ListAdapter关系
public class Adaptor2<T extends Adaptee> implements ITarget{
    private T adaptee;

    public Adaptor2(T adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void f1() {
        adaptee.fa();
    }

    @Override
    public void f2() {
        adaptee.fb();
    }

    @Override
    public void f3() {
        adaptee.fc();
    }
}

4. 门面模式
   目的：让调用者易调用

eg
解决性能问题，依次调三个接口合并成一个接口
解决分布式事务

5. 组合模式
   场景：适合树形的数据结构
   实现：继承同一父类

public abstract class FileSystemNode {
    private String path;

    public FileSystemNode(String path) {
        this.path = path;
    }

    public abstract int countNumOfFiles();
    public abstract long countSizeOfFiles();

    public String getPath() {
        return path;
    }
}

public class File extends FileSystemNode {
    public File(String path) {
        super(path);
    }

    @Override
    public int countNumOfFiles() {
        return 1;
    }

    @Override
    public long countSizeOfFiles() {
        java.io.File file = new java.io.File(getPath());
        if (!file.exists()) return 0;
        return file.length();
    }
}


public class Directory extends FileSystemNode {

    public Directory(String path) {
        super(path);

    }

    private List<FileSystemNode> subNodes = new ArrayList<>();
    @Override
    public int countNumOfFiles() {

        int fileNum = 0;
        for (int i = 0; i < subNodes.size(); i++) {
            long l = subNodes.get(i).countNumOfFiles();
            fileNum +=l;
        }
        return fileNum;
    }

    @Override
    public long countSizeOfFiles() {
        int fileSize = 0;
        for (int i = 0; i < subNodes.size(); i++) {
            long l = subNodes.get(i).countSizeOfFiles();
            fileSize +=l;
        }
        return fileSize;
    }

    public void addSubNode(FileSystemNode fileSystemNode){
        subNodes.add(fileSystemNode);
    }

    public void removeNode(FileSystemNode fileSystemNode){
        int i = 0 ;
        for (;i < subNodes.size();i++){
            if (fileSystemNode.getPath().equalsIgnoreCase(subNodes.get(i).getPath())){
                break;
            }
        }
        if (i < subNodes.size()){
            subNodes.remove(fileSystemNode);
        }
    }
}

public static void main(String[] args){
        /**
         * /
         * /tml/
         * /tml/1.txt
         * /tml/book/
         * /tml/book/designModel.txt
         * /tml/book/Java.txt
         * /wc/
         * /wc/2.txt
         * /wc/movie/
         * /wc/movie/helloWorld.mp4
         * /wc/movie/helloJava.mp4
         */
        Directory fileSystemTree = new Directory("/");

        Directory tmlDirectory = new Directory("/tml");
        Directory wcDirectory = new Directory("/wc");
        fileSystemTree.addSubNode(tmlDirectory);
        fileSystemTree.addSubNode(wcDirectory);

        File file1 = new File("/tml/1.txt");
        Directory node_tmlDirectory = new Directory("/tml/book/");
        Directory node_wcDirectory = new Directory("/wc/movie/");
        File file2 = new File("/wc/2.txt");
        tmlDirectory.addSubNode(file1);
        tmlDirectory.addSubNode(node_tmlDirectory);
        wcDirectory.addSubNode(node_wcDirectory);
        wcDirectory.addSubNode(file2);

        File designModelFile = new File("/tml/book/designModel.txt");
        File JavaFile = new File("/tml/book/Java.txt");
        File helloWorldFile = new File("/wc/movie/helloWorld.mp4");
        File helloJavaFile = new File("/wc/movie/helloJava.mp4");
        node_tmlDirectory.addSubNode(designModelFile);
        node_tmlDirectory.addSubNode(JavaFile);
        node_wcDirectory.addSubNode(helloWorldFile);
        node_wcDirectory.addSubNode(helloJavaFile);
        int fileNum = fileSystemTree.countNumOfFiles();
        long fileSize = fileSystemTree.countSizeOfFiles();
        System.out.println("fileNum: "+fileNum+" fileSize: "+fileSize);
    }

6. 享元模式
   理解：复用，节省内存
   实现：利用工厂模式，Map或List缓存创建好的对象，用的时候直接从缓存读取
   实例：象棋；Word文字格式
   区别：vs多例 享元是为了节省内存，缓存是为了节省时间

Integer
Integer i1 = 56;
Integer i2 = 56;
Integer i3 = new Integer(56);
Integer i4 = 128;
Integer i5 = 128;

i1 == i2 true
i2 == i3 false
i4 == i5 false
缓存-128~127
 
String 同理

7. 桥接模式