1.1 就不能不换DB吗?
都是换数据库惹的祸。
"我们团队前段时间用.net的C#来开发好一个项目,是给一家企业做的电子商务网站,是用SQL Server作为数据库的,应该说上线后除了开始有些小问题,基本都还可以。而后,公司接到另外一家公司类似需求的项目,但这家公司想省钱,租用了一个空间,只能用Access,不能用SQL Server,于是就要求我今天改造原来那个项目的代码。"
"C#与Java差不多,这不是重点,但换数据库远远没有我想得那么简单。"
"哈哈,你的麻烦来了。"
"是呀,那是相当的麻烦。但开始我觉得很简单呀,因为SQL Server和Access在ADO.NET上的使用是不同的,在SQL Server上用的是System.Data.SqlClient命名空间下的SqlConnection、SqlCommand、SqlParameter、SqlDataReader、SqlDataAdapter,而Access则要用System.Data.OleDb命名空间下的相应对象,我以为只要做一个全体替换就可以了,哪知道,替换后,错误百出。"
注:以上为.net框架上的术语,不了解并不影响阅读,只要知道数据库之间调用代码相差很大即可
"那是一定的,两者有不少不同的地方。你都找到了些什么问题?"
"实在是多呀。在插入数据时Access必须要insert into而SQL Server可以不用into的;SQL Server中的GetDate()在Access中没有,需要改成Now();SQL Server中有字符串函数Substring,而Access中根本不能用,我找了很久才知道,可以用Mid,这好像是VB中的函数。"
"insert into这是标准语法,你干吗不加into,这是自找的麻烦。"
"这些问题也就罢了,最气人的是程序的登录代码,老是报错,我怎么也找不到出了什么问题,搞了几个小时。最后才知道,原来Access对一些关键字,例如password是不能作为数据库的字段的,如果密码的字段名是password,SQL Server中什么问题都没有,运行正常,在Access中就是报错,而且报得让人莫名其妙。"
"'关键字'应该要用'['和']'包起来,不然当然是容易出错的。"
"就这样,今天加班到这时候才回来。"
"以后你还有的是班要加了。"
"为什么?"
"只要网站要维护,比如修改或增加一些功能,你就得改两个项目吧,至少在数据库中做改动,相应的程序代码都要改,甚至和数据库不相干的代码也要改,你既然有两个不同的版本,两倍的工作量也是必然的。"
"是呀,如果哪一天要用MySQL或者Oracle数据库,估计我要改动的地方更多了。"
"那是当然,MySQL、Oracle的SQL语法与SQL Server的差别更大。你的改动将是空前的。"
"哪有这么严重,大不了再加两天班就什么都搞定了。"
"菜鸟程序员碰到问题,只会用时间来摆平,所以即使整天加班,老板也不想给菜鸟加工资,原因就在于此。"
1.2 最基本的数据访问程序
写一段你原来的数据访问的做法给我看看。""那就用'新增用户'和'得到用户'为例吧。
用户类,假设只有ID和Name两个字段,其余省略。
package code.chapter15.abstractfactory1;//用户类
public class User {//用户IDprivate int _id;public int getId(){return this._id;}public void setId(int value){this._id=value;}//用户姓名private String _name;public String getName(){return this._name;}public void setName(String value){this._name=value;}}
SqlserverUser类——用于操作User表,假设只有"新增用户"和"得到用户"方法,其余方法以及具体的SQL语句省略。
package code.chapter15.abstractfactory1;public class SqlserverUser {//新增一个用户public void insert(User user){System.out.println("在SQL Server中给User表增加一条记录"); }//获取一个用户信息public User getUser(int id){System.out.println("在SQL Server中根据用户ID得到User表一条记录"); return null; }
}
package code.chapter15.abstractfactory1;public class Test {public static void main(String[] args){System.out.println("**********************************************"); System.out.println("《大话设计模式》代码样例");System.out.println(); User user = new User();SqlserverUser su = new SqlserverUser();su.insert(user); //新增一个用户su.getUser(1); //得到用户ID为1的用户信息System.out.println();System.out.println("**********************************************");}
}
"这里之所以不能换数据库,原因就在于SqlserverUser su = new SqlserverUser()使得su这个对象被框死在SQL Server上了。你可能会说,是因为取名叫SqlserverUser,但即使没有Sqlserver名称,它本质上也是在使用SQL Server的SQL语句代码,确实存在耦合。如果这里是灵活的,专业点的说法,是多态的,那么在执行'su.insert(user);'和'su.getUser(1);'时就不用考虑是在用SQL Server还是在用Access。"
"我明白你的意思了,你是希望我用'工厂方法模式'来封装new SqlserverUser()所造成的变化?"
工厂方法模式是定义一个用于创建对象的接口,让子类决定实例化哪一个类。
1.3 用了工厂方法模式的数据访问程序
代码结构图
IUser接口:用于客户端访问,解除与具体数据库访问的耦合。
package code.chapter15.abstractfactory2;//用户类接口
public interface IUser {public void insert(User user);public User getUser(int id);
}
SqlserverUser类:用于访问SQL Server的User。
package code.chapter15.abstractfactory2;//用户类接口
public interface IUser {public void insert(User user);public User getUser(int id);
}
AccessUser类:用于访问Access的User。
package code.chapter15.abstractfactory2;public class AccessUser implements IUser {//新增一个用户public void insert(User user){System.out.println("在Access中给User表增加一条记录"); }//获取一个用户信息public User getUser(int id){System.out.println("在Access中根据用户ID得到User表一条记录"); return null; }}
IFactory接口:定义一个创建访问User表对象的抽象的工厂接口。
package code.chapter15.abstractfactory2;//工厂接口
public interface IFactory {public IUser createUser();}
SqlServerFactory类:实现IFactory接口,实例化SqlserverUser。
package code.chapter15.abstractfactory2;//Sqlserver工厂
public class SqlserverFactory implements IFactory {public IUser createUser(){return new SqlserverUser();}}
AccessFactory类:实现IFactory接口,实例化AccessUser。
package code.chapter15.abstractfactory2;//Access工厂
public class AccessFactory implements IFactory {public IUser createUser(){return new AccessUser();}}
package code.chapter15.abstractfactory2;public class Test {public static void main(String[] args){System.out.println("**********************************************"); System.out.println("《大话设计模式》代码样例");System.out.println(); User user = new User();IFactory factory = new SqlserverFactory();IUser iu = factory.createUser();iu.insert(user); //新增一个用户iu.getUser(1); //得到用户ID为1的用户信息IFactory factory2 = new AccessFactory();IUser iu2 = factory2.createUser();iu2.insert(user); //新增一个用户iu2.getUser(1); //得到用户ID为1的用户信息System.out.println();System.out.println("**********************************************");}
}
现在如果要换数据库,只需要把new SqlServerFactory()改成new AccessFactory(),此时由于多态的关系,使得声明IUser接口的对象iu事先根本不知道是在访问哪个数据库,却可以在运行时很好地完成工作,这就是所谓的业务逻辑与数据访问的解耦。
这样写,代码里还是有指明'new SqlServerFactory()'呀,我要改的地方,依然很多。
问题没有完全解决,你的数据库里不可能只有一个User表吧,很可能有其他表,比如增加部门表(Department表),此时如何办呢?
package code.chapter15.abstractfactory3;//部门类
public class Department {//部门IDprivate int _id;public int getId(){return this._id;}public void setId(int value){this._id=value;}//部门名称private String _name;public String getName(){return this._name;}public void setName(String value){this._name=value;}}
1.4 用了抽象工厂模式的数据访问程序
IDepartment接口:用于客户端访问,解除与具体数据库访问的耦合。
package code.chapter15.abstractfactory3;//部门类接口
public interface IDepartment {public void insert(Department department);public Department getDepartment(int id);
}
SqlserverDepartment类:用于访问SQL Server的Department。
package code.chapter15.abstractfactory3;public class SqlserverDepartment implements IDepartment {//新增一个部门public void insert(Department department){System.out.println("在SQL Server中给Department表增加一条记录"); }//获取一个部门信息public Department getDepartment(int id){System.out.println("在SQL Server中根据部门ID得到Department表一条记录"); return null; }
}
AccessDepartment类:用于访问Access的Department。
package code.chapter15.abstractfactory3;public class AccessDepartment implements IDepartment {//新增一个部门public void insert(Department department){System.out.println("在Access中给Department表增加一条记录"); }//获取一个部门信息public Department getDepartment(int id){System.out.println("在Access中根据部门ID得到Department表一条记录"); return null; }}
IFactory接口:定义一个创建访问Department表对象的抽象的工厂接口。
package code.chapter15.abstractfactory3;//工厂接口
public interface IFactory {public IUser createUser();public IDepartment createDepartment();}
SqlServerFactory类:实现IFactory接口,并实例化SqlserverUser和SqlserverDepartment。
package code.chapter15.abstractfactory3;//Sqlserver工厂
public class SqlserverFactory implements IFactory {public IUser createUser(){return new SqlserverUser();}public IDepartment createDepartment(){return new SqlserverDepartment();}}
AccessFactory类:实现IFactory接口,实例化AccessUser和AccessDepartment。
package code.chapter15.abstractfactory3;//Access工厂
public class AccessFactory implements IFactory {public IUser createUser(){return new AccessUser();}public IDepartment createDepartment(){return new AccessDepartment();}}
package code.chapter15.abstractfactory3;public class Test {public static void main(String[] args){System.out.println("**********************************************"); System.out.println("《大话设计模式》代码样例");System.out.println(); User user = new User();Department department = new Department();IFactory factory = new SqlserverFactory();//IFactory factory = new AccessFactory();IUser iu = factory.createUser();iu.insert(user); //新增一个用户iu.getUser(1); //得到用户ID为1的用户信息IDepartment idept = factory.createDepartment();idept.insert(department); //新增一个部门idept.getDepartment(2); //得到部门ID为2的用户信息System.out.println();System.out.println("**********************************************");}
}
这样就可以做到,只需更改IFactory factory = new SqlServerFactory()为IFactory factory = new AccessFactory(),就实现了数据库访问的切换了。
很好,实际上,在不知不觉间,你已经通过需求的不断演化,重构出了一个非常重要的设计模式。刚才不就是工厂方法模式吗?只有一个User类和User操作类的时候,是只需要工厂方法模式的,但现在显然你数据库中有很多的表,而SQL Server与Access又是两大不同的分类,所以解决这种涉及多个产品系列的问题,有一个专门的工厂模式叫抽象工厂模式。
1.5 抽象工厂模式
抽象工厂模式(Abstract Factory),提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。[DP]
抽象工厂模式(Abstract Factory)结构图
"AbstractProductA和AbstractProductB是两个抽象产品,之所以为抽象,是因为它们都有可能有两种不同的实现,就刚才的例子来说就是User和Department,而ProductA1、ProductA2和ProductB1、ProductB2就是对两个抽象产品的具体分类的实现,比如ProductA1可以理解为是SqlserverUser,而ProductB1是SqlserverDepartment。"
"这么说,IFactory是一个抽象工厂接口,它里面应该包含所有的产品创建的抽象方法。而ConcreteFactory1和ConcreteFactory2就是具体的工厂了。就像SqlserverFactory和AccessFactory一样。"
"理解得非常正确。通常是在运行时刻再创建一个ConcreteFactory类的实例,这个具体的工厂再创建具有特定实现的产品对象,也就是说,为创建不同的产品对象,客户端应使用不同的具体工厂。"
1.6 抽象工厂模式的特点
"这样做的好处是什么呢?"
"最大的好处便是易于交换产品系列,由于具体工厂类,例如IFactory factory =new AccessFactory(),在一个应用中只需要在初始化的时候出现一次,这就使得改变一个应用的具体工厂变得非常容易,它只需要改变具体工厂即可使用不同的产品配置。我们的设计不能去防止需求的更改,那么我们的理想便是让改动变得最小,现在如果你要更改数据库访问,我们只需要更改具体工厂就可以做到。第二大好处是,它让具体的创建实例过程与客户端分离,客户端是通过它们的抽象接口操纵实例,产品的具体类名也被具体工厂的实现分离,不会出现在客户代码中。事实上,你刚才写的例子,客户端所认识的只有IUser和IDepartment,至于它是用SQL Server来实现还是Access来实现就不知道了。"
"啊,我感觉这个模式把开放-封闭原则、依赖倒转原则发挥到极致了。
"没这么夸张,应该说就是这些设计原则的良好运用。抽象工厂模式也有缺点。你想得出来吗?"
"想不出来,我觉得它已经很好用了,哪有什么缺点?"
"是个模式都是会有缺点的,都有不适用的时候,要辩证地看待问题哦。抽象工厂模式可以很方便地切换两个数据库访问的代码,但是如果你的需求来自增加功能,比如我们现在要增加项目表Project,你需要改动哪些地方?"
"啊,那就至少要增加三个类,IProject、SqlserverProject、AccessProject,还需要更改IFactory、SqlserverFactory和AccessFactory才可以完全实现。啊,要改三个类,这太糟糕了。"
"是的,这非常糟糕。"
"还有就是刚才问你的,我的客户端程序类显然不会是只有一个,有很多地方都在使用IUser或IDepartment,而这样的设计,其实在每一个类的开始都需要声明IFactory factory = new SqlserverFactory(),如果我有100个调用数据库访问的类,是不是就要更改100次IFactory factory = new AccessFactory()这样的代码才行?这不能解决我要更改数据库访问时,改动一处就完全更改的要求呀!"
"改就改啰,公司花这么多钱养你干吗?不就是要你努力工作吗。100个改动,不算难的,加个班,什么都搞定了。"
"不可能,你讲过,编程是门艺术,这样大批量的改动,显然是非常丑陋的做法。一定有更好的办法。"我来想想办法改进一下这个抽象工厂。"
"好,小伙子,有立场,有想法,不向丑陋代码低头,那就等你的好消息。"
1.7 用简单工厂来改进抽象工厂
去除IFactory、SqlserverFactory和AccessFactory三个工厂类,取而代之的是DataAccess类,用一个简单工厂模式来实现。
代码结构图
package code.chapter15.abstractfactory4;public class DataAccess {private static String db = "Sqlserver";//数据库名称,可替换成Access//private static String db ="Access";//创建用户对象工厂public static IUser createUser(){IUser result = null;switch(db){case "Sqlserver":result = new SqlserverUser();break;case "Access":result = new AccessUser();break;}return result;}//创建部门对象工厂public static IDepartment createDepartment(){IDepartment result = null;switch(db){case "Sqlserver":result = new SqlserverDepartment();break;case "Access":result = new AccessDepartment();break;}return result;}}
package code.chapter15.abstractfactory4;public class Test {public static void main(String[] args){System.out.println("**********************************************"); System.out.println("《大话设计模式》代码样例");System.out.println(); User user = new User();Department department = new Department();//直接得到实际的数据库访问实例,而不存在任何依赖IUser iu = DataAccess.createUser();iu.insert(user); //新增一个用户iu.getUser(1); //得到用户ID为1的用户信息//直接得到实际的数据库访问实例,而不存在任何依赖IDepartment idept = DataAccess.createDepartment();idept.insert(department); //新增一个部门idept.getDepartment(2); //得到部门ID为2的用户信息System.out.println();System.out.println("**********************************************");}
}
"我觉得这里与其用那么多工厂类,不如直接用一个简单工厂来实现,我抛弃了IFactory、SqlserverFactory和AccessFactory三个工厂类,取而代之的是DataAccess类,由于事先设置了db的值(Sqlserver或Access),所以简单工厂的方法都不需要输入参数,这样在客户端就只需要DataAccess.createUser()和DataAccess.createDepartment()来生成具体的数据库访问类实例,客户端没有出现任何一个SQL Server或Access的字样,达到了解耦的目的。"
"你的改进确实是比之前的代码要更进一步了,客户端已经不再受改动数据库访问的影响了。可以打95分。"为什么不能得满分?原因是如果我需要增加Oracle数据库访问,本来抽象工厂只增加一个OracleFactory工厂类就可以了,现在就比较麻烦了。"
"是的,没办法,这样就需要在DataAccess类中每个方法的switch中加case了。"
1.8 用反射+抽象工厂的数据访问程序
"我们要考虑的就是可不可以不在程序里写明'如果是Sqlserver就去实例化SQL Server数据库相关类,如果是Access就去实例化Access相关类'这样的语句,而是根据字符串db的值去某个地方找应该要实例化的类是哪一个。这样,我们的switch就可以对它说再见了。"
"听不太懂哦,什么叫'去某个地方找应该要实例化的类是哪一个'?
"我要说的就是一种编程方式:依赖注入(Dependency Injection),从字面上不太好理解,我们也不去管它。关键在于如何去用这种方法来解决我们的switch问题。本来依赖注入是需要专门的IoC容器提供,比如Spring,显然当前这个程序不需要这么麻烦,你只需要再了解一个简单的Java技术'反射'就可以了。"
"你一下子说出又是'依赖注入'又是'反射'这些莫名其妙的名词,很晕。"我就想知道,如何向switch说bye-bye!至于那些什么概念我不想了解。"
"心急讨不了好媳妇!你急什么?"反射技术看起来很玄乎,其实实际用起来不算难。它的格式是:
Object result = Class.forName(className).getDeclaredConstructor().newInstance();
这样使用反射来帮我们克服抽象工厂模式的先天不足。"
"具体怎么做呢?快说快说。
"有了反射,我们获得实例可以用下面两种写法。"
//常规的写法
IUser result = new SqlserverUser();//反射的写法
IUser result = (IUser)Class.forName("code.chapter15.abstractfactory5.SqlserverUser").getDeclaredConstructor().newInstance();
"实例化的效果是一样的,但这两种方法的区别在哪里?"
"常规方法是写明了要实例化SqlserverUser对象。反射的写法,其实也是指明了要实例化SqlserverUser对象呀。"
"常规方法你可以灵活更换为AccessUser吗?"
"不可以,这都是事先编译好的代码。"
"那你看看,在反射中'Class.forName("code.chapter15.abstractfactory5.SqlserverUser").getDeclaredConstructor().newInstance();',可以灵活更换'SqlserverUser'为'AccessUser'吗?"
"还不是一样,写死在代码……等等,哦!!!我明白了。""因为这里是字符串,可以用变量来处理,也就可以根据需要更换。哦,My God!太妙了!"
"哈哈,我以前对你讲四大发明之活字印刷时,曾说过'体会到面向对象带来的好处,那种感觉应该就如同是一中国酒鬼第一次喝到了茅台,西洋酒鬼第一次喝到了XO一样,怎个爽字可形容呀',你有没有这种感觉了?"
"嗯,我一下子知道这里的差别主要在原来的实例化是写死在程序里的,而现在用了反射就可以利用字符串来实例化对象,而变量是可以更换的。"
"写死在程序里,太难听了。准确地说,是将程序由编译时转为运行时。由于'Class.forName("包名。类名").getDeclaredConstructor().newInstance();'中的字符串是可以写成变量的,而变量的值到底是Sqlserver,还是Access,完全可以由事先的那个db变量来决定。所以就去除了switch判断的麻烦。"
DataAccess类,用反射技术,取代IFactory、SqlserverFactory和AccessFactory。
package code.chapter15.abstractfactory5;import java.lang.reflect.InvocationTargetException;
public class DataAccess {private static String assemblyName = "code.chapter15.abstractfactory5.";private static String db ="Sqlserver";//数据库名称,可替换成Access//创建用户对象工厂public static IUser createUser() {return (IUser)getInstance(assemblyName + db + "User");}//创建部门对象工厂public static IDepartment createDepartment(){return (IDepartment)getInstance(assemblyName + db + "Department");}private static Object getInstance(String className){Object result = null;try{result = Class.forName(className).getDeclaredConstructor().newInstance();}catch (InvocationTargetException e) {e.printStackTrace();}catch (NoSuchMethodException e) {e.printStackTrace();}catch (InstantiationException e) {e.printStackTrace();}catch (IllegalAccessException e) {e.printStackTrace();}catch (ClassNotFoundException e) {e.printStackTrace();}return result;}
}
"现在如果我们增加了Oracle数据访问,相关的类的增加是不可避免的,这点无论我们用任何办法都解决不了,不过这叫扩展,开放-封闭原则性告诉我们,对于扩展,我们开放。但对于修改,我们应该要尽量关闭,就目前而言,我们只需要更改private static String db ="Sqlserver";为private static String db = "Oracle";也就意味着"
"这样的结果就是DataAccess.createUser()本来得到的是SqlserverUser的实例,而现在变成了OracleUser的实例了。"
"那么如果我们需要增加Project产品时,如何做呢?"
"只需要增加三个与Project相关的类,再修改DataAccesss,在其中增加一个public static IProject createProject()方法就可以了。"
"怎么样,编程的艺术感是不是出来了?"
"哈,比以前,这代码是漂亮多了。但是,总感觉还是有点缺憾,因为在更换数据库访问时,我还是需要去改程序(改db这个字符串的值)重编译,如果可以不改程序,那才是真正地符合开放-封闭原则。"
1.9 用反射+配置文件实现数据访问程序
"我们还可以利用配置文件来解决更改DataAccess的问题。"
"哦,对的,对的,我可以读文件来给DB字符串赋值,在配置文件中写明是Sqlserver还是Access,这样就连DataAccess类也不用更改了。"
添加一个db.properties文件,内容如下。
db=Sqlserver
再更改DataAccess类,添加与读取文件内容相关的包。
package code.chapter15.abstractfactory6;import java.lang.reflect.InvocationTargetException; //与读文件内容相关的包
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties; public class DataAccess {private static String assemblyName = "code.chapter15.abstractfactory6.";public static String getDb() {String result="";try{Properties properties = new Properties();//编译后,请将db.properties文件复制到要编译的class目录中,并确保下面path路径与//实际db.properties文件路径一致。否则会报No such file or directory错误String path=System.getProperty("user.dir")+"/code/chapter15/abstractfactory6/db.properties";System.out.println("path:"+path); BufferedReader bufferedReader = new BufferedReader(new FileReader(path));properties.load(bufferedReader);result = properties.getProperty("db");}catch(IOException e){e.printStackTrace();}return result;}//创建用户对象工厂public static IUser createUser() {String db=getDb();return (IUser)getInstance(assemblyName + db + "User");}//创建部门对象工厂public static IDepartment createDepartment(){String db=getDb();return (IDepartment)getInstance(assemblyName + db + "Department");}private static Object getInstance(String className){Object result = null;try{result = Class.forName(className).getDeclaredConstructor().newInstance();}catch (InvocationTargetException e) {e.printStackTrace();}catch (NoSuchMethodException e) {e.printStackTrace();}catch (InstantiationException e) {e.printStackTrace();}catch (IllegalAccessException e) {e.printStackTrace();}catch (ClassNotFoundException e) {e.printStackTrace();}return result;}}
"将来要更换数据库,根本无须重新编译任何代码,只需要更改配置文件就好了。这下基本可以算是满分了,现在我们应用了反射+抽象工厂模式解决了数据库访问时的可维护、可扩展的问题。"
"从这个角度上说,所有在用简单工厂的地方,都可以考虑用反射技术来去除switch或if,解除分支判断带来的耦合。"
"说得没错,switch或者if是程序里的好东西,但在应对变化上,却显得老态龙钟。反射技术的确可以很好地解决它们难以应对变化,难以维护和扩展的诟病。"
1.10 商场收银程序再再升级
"还记得我们在策略模式、装饰模式、工厂方法模式都学习过的商场收银程序吗?"
"我记得,当时做了很多次的重构升级,感觉代码的可维护、可扩展能力都提高很多很多。"
"今天我们学习了反射,你想想看,那个代码,还有重构的可能性吗?"
"呃!我想想看。原来的CashContext是有一个长长的switch,这是可以用反射来解决的。"
经过一定时间的思考,对代码改进如下:
首先要制作一个可以很容易修改的文本配置文件data.properties,将它放在编译的.class同一目录下。
strategy1=CashRebateReturnFactory,1d,0d,0d
strategy2=CashRebateReturnFactory,0.8d,0d,0d
strategy3=CashRebateReturnFactory,0.7d,0d,0d
strategy4=CashRebateReturnFactory,1d,300d,100d
strategy5=CashRebateReturnFactory,0.8d,300d,100d
strategy6=CashReturnRebateFactory,0.7d,200d,50d
修改CashContext类。
先修改构造方法,此时已经没有了长长的switch,直接读文件配置即可。
增加两个函数,一个用来读配置文件,一个通过反射生成实例。
package code.chapter15.abstractfactory7;import java.lang.reflect.InvocationTargetException;
//与读文件内容相关的包
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties; public class CashContext {private static String assemblyName = "code.chapter15.abstractfactory7.";private ISale cs; //声明一个ISale接口对象//通过构造方法,传入具体的收费策略public CashContext(int cashType){String[] config = getConfig(cashType).split(",");IFactory fs=getInstance(config[0],Double.parseDouble(config[1]),Double.parseDouble(config[2]),Double.parseDouble(config[3]));this.cs = fs.createSalesModel();}//通过文件得到销售策略的配置文件private String getConfig(int number) {String result="";try{Properties properties = new Properties();String path=System.getProperty("user.dir")+"/code/chapter15/abstractfactory7/data.properties";System.out.println("path:"+path); BufferedReader bufferedReader = new BufferedReader(new FileReader(path));properties.load(bufferedReader);result = properties.getProperty("strategy"+number);}catch(IOException e){e.printStackTrace();}return result;}//根据配置文件获得相关的对象实例private IFactory getInstance(String className,double a,double b,double c){IFactory result = null;try{result = (IFactory)Class.forName(assemblyName+className).getDeclaredConstructor(new Class[]{double.class,double.class,double.class}).newInstance(new Object[]{a,b,c}); }catch (InvocationTargetException e) {e.printStackTrace();}catch (NoSuchMethodException e) {e.printStackTrace();}catch (InstantiationException e) {e.printStackTrace();}catch (IllegalAccessException e) {e.printStackTrace();}catch (ClassNotFoundException e) {e.printStackTrace();}return result;}public double getResult(double price,int num){//根据收费策略的不同,获得计算结果return this.cs.acceptCash(price,num);}
}
"此时,我们如果需要更改销售策略,不再需要去修改代码了,只需要去改data.properties文件即可。我们的每个代码都尽量做到了'向修改关闭,向扩展开放'。"
1.11 无痴迷,不成功
"设计模式真的很神奇哦,如果早先这样设计,我今天就用不着加班加点了。""这就说明你是做程序员的料,一个程序员如果从来没有熬夜写程序的经历,不能算是一个好程序员,因为他没有痴迷过,所以他不会有大成就。"
"是的,无痴迷,不成功。我一定会成为优秀的程序员。我坚信.