从重构的角度进修bridge设计模式

副标题#e#

从重构的角度进修bridge设计模式

Bridge模式是一个在实际系统中常常应用的模式。它最能浮现设计模式的原则针对接口举办编程，和利用聚合不利用担任这两个原则。

由于我们过度的利用担任，使类的布局过于巨大，不易领略，难以维护。出格是在Java中由于不能同时担任多个类，这样就会造成多层担任，维护更难。

Bridge模式是办理多层担任的基础原因。假如你在实现应用中一个类，需要担任两个以上的类，而且这两者之间又持有某种干系，它们两个城市有多种变革。

Bridge模式是把这两个类，解析为一个抽象，一个实现，使它们两个疏散，这样两种类可以独立的变革。

抽象就是，把一个实体的配合观念(沟通的步调)，抽取出来（解析出几个彼此独立的步调），作为一个进程。如我们把数据库的 操纵抽象为一个进程，有几个步调，建设SQL语句，发送到数据库处理惩罚，取得功效。

实现就是奈何完成这个抽象步调,如发送到数据库，需要团结详细的数据库，思量奈何完成这个步调等。而且同一步调大概存在差异的实现，如对差异的数据库需要差异的实现。

此刻我们假设一个环境，也是WEB中常常碰着的，在一个page有输入框，如客户信息的姓名，地点等，输入信息后，然后按查找按钮，把查找的功效显示出来。

我们此刻假设查找客户信息和帐户信息，它们在差异的表中。

可是我们的系统面临两种人群，总部的它们信息生存到oracle数据库，可是各个分公司的数据生存在Sybase中，数据库的位置等各不沟通，这两种的操纵差异。

下面是我们一般首先会利用的方法，利用if else举办，判定，这样利用系统难以维护，难以扩展，不妨你增加一种查询，可能一种数据库试试？

public class SearchAction(){
public Vector searchData(string ActionType,String DbType){
String SQL="";
if(ActionType.equal("查找客户信息")){
//假如是查询客户信息，拼SQL语句从客户表中读取数据
SQL="select * from Customer "
　　 if(dbType.equal("oracle")){
//从总部数据库读取，数据库为Oracle
String connect_string ="jdbc:oracle:thin:hr/hr@localhost:1521:HRDB";
DriverManager.registerDriver (new oracle.jdbc.OracleDriver());
Connection conn = DriverManager.getConnection (connect_string);
// Create a statement
Statement stmt = conn.createStatement ();
ResultSet rset = stmt.executeQuery (SQL);
//以下省略部门动态从数据库中取出数据，组装成Vector,返回
..................................
...................................
}else(dbType.equal("sybase")){
//从分公司数据库读取，数据库为Sybase
String connect_string ="jdbc:sybase:Tds:cai/cai@192.168.1.12:1521:FIN";
DriverManager.registerDriver (new com.sybase.jdbc.SybDriver());
Connection conn = DriverManager.getConnection (connect_string);
// Create a statement
Statement stmt = conn.createStatement ();
ResultSet rset = stmt.executeQuery (SQL);
//以下省略部门动态从数据库中取出数据，组装成Vector,返回
..................................
...................................
　　 }
　　 }else if(ActionType.equal("查找帐户信息")){
//假如是查询帐户信息，拼接SQL语句从帐户表中读取数据
SQL="select * from Account "
if(dbType.equal("oracle")){
..........................
..........................
(作者注：此处省略从oracle读取，约300字)
　　 }else if(dbType.equal("Sybase")){
..........................
..........................
(作者注：此处省略从Sybase读取，约300字)
}
　　 }
}
}

#p#副标题#e#

假如你认为这写的较量弱智，应该举办利用函数，可是你也会大量利用if else。

于是我们举办重构，首先我们进修过DAO模式，就是把数据读取举办分里，我们界说一个配合的接口，它认真数据库的操纵，然后按照差异的数据库举办实现，在我们的查询操纵中，利用接口，举办操纵，这样就可以不消思量详细的实现，我们尽管实现进程。

查询配合接口：

public interface searchDB{
public Vector searchFromDB(String SQL)
}
Oracle数据库的查询实现
public class searchDBOracleImpl{
public Vector searchFromDB(String SQL){
//从总部数据库读取，数据库为Oracle
String connect_string ="jdbc:oracle:thin:hr/hr@localhost:1521:HRDB";
DriverManager.registerDriver (new oracle.jdbc.OracleDriver());
　　 ResultSet rset = stmt.executeQuery (SQL);
.............................
............................
　　 }
}
Sybase数据库的查询实现
public class searchDBSysbaseImpl{
public Vector searchFromDB(String SQL){
//从分公司数据库读取，数据库为Sysbase
String connect_string ="jdbc:sybase:Tds:cai/cai@192.168.1.12:1521:FIN";
DriverManager.registerDriver (new com.sybase.jdbc.SybDriver());
ResultSet rset = stmt.executeQuery (SQL);
.............................
............................
　　 }
}

#p#分页标题#e#

这样在我们的查询中就可以利用接口searchDB，可是建设有是一个问题，因为我们不能静态简直定，查询的数据库范例，必需动态确定，于是我们又想到利用简朴工场要领，来别离建设这里的详细实现，按照种别，建设

public class searchFactory{
public static searchDB createSearch(int DBType){
if(DBType.equal("oracle")){
return searchDBOracleImpl();
}else if(DBType.equal("sybase")){
return searchDBSysbaseImpl();
}
}
}
于是我们的查询代码可以改变为这样了；
public class SearchAction(){
　　 public Vector searchData(string ActionType,String DbType){
String SQL="";
if(ActionType.equal("查找客户信息")){
//假如是查询客户信息，拼SQL语句从客户表中读取数据
SQL="select * from Customer "
searchDB obj=searchFactory.createSearch(DbType);
return obj.searchFromDB(SQL);
　　 }else if(ActionType.equal("查找帐户信息")){
//假如是查询帐户信息，拼接SQL语句从帐户表中读取数据
SQL="select * from Account "
searchDB obj=searchFactory.createSearch(DbType);
return obj.searchFromDB(SQL);
}
}
}

#p#副标题#e#

是不是简朴一些，假如增加一个新的数据库，对我们只需增加一个新的数据库实现便可，老的代码，不需改变，这样便实现开－闭原则（Open-closed原则），在我们的查询查询中利用的是接口，这就是设计模式的原则，针对接口举办编程，而且利用聚合，而不是直接的担任各人，可以思量利用担任来完成该事情奈何实现。上面是把实现举办疏散，实现可以动态变革！

我们把查询的操纵的详细数据库实现举办了疏散，加强了机动性，可是我们的查询。仍然利用了if else这样仍然不易举办扩展，于是我们举办抽象一个查询操纵的进程，把它分成几个详细步调，建设SQL语句，发送到数据库，执行查询，返回功效。

它们固然是差异的查询，SQL各不沟通，差异数据库执行差异，返回功效的内容差异。可是这个进程却是稳定的，于是我们声明一个抽象类，来完成这个进程。

public abstract class searchAction{
searchDB obj;
//两个步调
public searchDB createSearchImple(int DbType){
return searchFactory.createSearch(DbType);
}
public abstract String createSQL();
　　 //查询进程，最后返回功效
public vector searchResult(int DbType){
obj=createSearchImple(DbType);
return obj.searchFromDB(createSQL())
}
}
　　 //我们客户查询，操纵
public class searchCustomerAction{
public String createSQL(){
return "select * from Customer"
}
}
//我们的帐户查询操纵
public class searchAccountAction{
public String createSQL(){
return "select * from account"
}
}

这样我们的查询编程简朴的建设SQL语句，我们应该再建设一个工场要领，来完成建设它们

public class actionFactory{
public static searchAction ceateAction(int actionType){
if(actionType.equal("customer")){
return searchCustomerAction();
}else if(actionType.equal("account")){
return searchAccountAction();
}
}
}

这样我们把查询操纵的进程举办了抽象，界说了步调，和详细进程，颠末我们的两次改变把抽象部门和实现部门举办疏散，使他们都可以独立的变革，加强机动性。

我们再看当初查询实现，此刻颠末这两次的地修改，酿成了什么容貌？如下：

public class SearchAction(){
public Vector searchData(string ActionType,String DbType){
searchAction action=actionFactory.ceateAction(ActionType);
return action.searchResult(DbType);
}