Miracle

>文章中部分定义和解释性文字，都是引用百度百科，主要的代码及场景应用为本人原创

**桥接模式是将抽象部分与它的实现部分分离，使它们都可以独立地变化**

>场景：在一个文件管理系统中，文件来源有两个一个本地文件源，一个FTP文件源，而需要开发的客户端因功能不同，有多中文件客户端。客户端和文件源都是可以变化的，而且文件源也会随着系统复杂化，不断增加，为了保证客户端和文件源的多变灵活性，可以使用桥接模式

**结构**

* 抽象化角色：抽象化给出的定义，并保存一个对实现化对象的引用。（FileClient）
* 修正抽象化角色：扩展抽象化角色，改变和修正父类对抽象化的定义。（SimpleFileClient，MultifunctionalFileClient）
* 实现化角色：这个角色给出实现化角色的接口，但不给出具体的实现。（FileSource）
* 具体实现化角色：这个角色给出实现化角色接口的具体实现。（FtpFileSource，LocalFileSource）

**设计**

![这里写图片描述](https://img-blog.csdn.net/20180423200322505?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RlbHVuZHVzaWpp/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

**实现**

代码地址：[`https://github.com/telundusiji/designpattern`](https://github.com/telundusiji/designpattern)

实现化角色 文件源接口

```
public interface FileSource {
    List<String> searchFile(String name);
    List<String> list();
    void delete(String name);
}

```

具体实现化角色 FTP文件源

```
@Slf4j
public class FtpFileSource implements FileSource {

private List<String> files;

public FtpFileSource() {
        files = new ArrayList<>();
        files.add("test1.txt");
        files.add("test2.txt");
        files.add("test4.txt");
        files.add("test17.txt");
        files.add("test3.txt");
        files.add("test15.txt");
        files.add("test8.txt");
        files.add("other.txt");
    }

@Override
    public List<String> searchFile(String name) {
        log.info("登录Ftp服务器...");
        log.info("开始搜索...");
        List<String> result = new ArrayList<>();
        for(String s : files){
            if(s.contains(name)){
                result.add(s);
            }
        }
        log.info("搜索完成!");
        return result;

}

@Override
    public List<String> list() {
        log.info("登录Ftp服务器...");
        log.info("获取所有文件完毕!");
        return files;
    }

@Override
    public void delete(String name) {
        log.info("登录Ftp服务器...");
        log.info("开始删除文件...");
        Iterator<String> iterator = files.iterator();
        while (iterator.hasNext()){
            if(iterator.next().equals(name)){
                iterator.remove();
            }
        }
        log.info("删除完成");
    }

}

```

具体实现化角色 本地文件源

```
@Slf4j
public class LocalFileSource implements FileSource {

private List<String> files;

public LocalFileSource() {
        files = new ArrayList<>();
        files.add("test7.txt");
        files.add("test10.txt");
        files.add("test56.txt");
        files.add("test17.txt");
        files.add("test9.txt");
        files.add("test0.txt");
        files.add("test8.txt");
        files.add("other.txt");
    }

@Override
    public List<String> searchFile(String name) {
        log.info("开始搜索...");
        List<String> result = new ArrayList<>();
        for(String s : files){
            if(s.contains(name)){
                result.add(s);
            }
        }
        log.info("搜索完成!");
        return result;
    }

@Override
    public List<String> list() {
        return files;
    }

@Override
    public void delete(String name) {
        log.info("开始删除文件...");
        Iterator<String> iterator = files.iterator();
        while (iterator.hasNext()){
            if(iterator.next().equals(name)){
                iterator.remove();
            }
        }
        log.info("删除完成");
    }
}

```

抽象化角色 文件客户端

```
@Data
public abstract class FileClient {

private FileSource fileSource;

public FileClient(FileSource fileSource) {
        this.fileSource = fileSource;
    }

public abstract void list();

public abstract void search(String name);

public abstract void delete(String name);
}

```

修正抽象化角色 简单文件客户端

```
@Slf4j
public class SimpleFileClient extends FileClient {

public SimpleFileClient(FileSource fileSource) {
        super(fileSource);
    }

@Override
    public void list() {
        List<String> list = getFileSource().list();
        for(String s: list){
            log.info("文件：{}",s);
        }
    }

@Override
    public void search(String name) {
        List<String> list = getFileSource().searchFile(name);
        log.info("---------------搜索{}结果--------------",name);
        for(String s: list){
            log.info("文件：{}",s);
        }
    }

@Override
    public void delete(String name) {
        getFileSource().delete(name);
        log.info("--------------{}文件删除-----------",name);
    }
}

```

修正抽象化角色 多功能文件客户端

```
@Slf4j
public class MultifunctionalFileClient extends FileClient {

public MultifunctionalFileClient(FileSource fileSource) {
        super(fileSource);
    }

@Override
    public void list() {
        List<String> list = getFileSource().list();
        for(String s: list){
            log.info("文件：{}",s);
        }
    }

public void listWithSort(){
        List<String> list = getFileSource().list();
        Collections.sort(list,String::compareTo);
        for(String s: list){
            log.info("文件：{}",s);
        }
    }

@Override
    public void delete(String name) {
        getFileSource().delete(name);
        log.info("--------------{}文件删除-----------",name);
    }

public void delete(String... args){
        for (String s : args){
            getFileSource().delete(s);
            log.info("--------------{}文件删除-----------",s);
        }
    }
}

```

**优缺点**

优点：

* 提高系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需修改原有系统。
* 将抽象化和实现化之间的耦合解脱开，将两个角色之间的继承关系改为聚合关系，从而使两者可以相对独立地变化。

缺点：

* 要求正确识别出系统中两个独立变化的维度，所以其使用范围具有一定的局限性。

设计模式入门：桥接模式