设计模式-三种工厂模式实例
1.简单工厂模式：代替new产生对象，产品的类型比较少时。
我们要获得三种不同的数据库对象，如mysql,sqlserver,oracle，它们拥有共同的特征，即可以进行抽象，简单工厂目的是将获得具体数据库实体的任务交给工厂类。
接口database：
public interface database {
public void open();
public void close();
}
类mysql:
public class mysql implements database {
@override
public void open() {
system.out.println("open mysql");
}
@override
public void close() {
system.out.println("close mysql");
}
}
类oracle:
public class oracle implements database {
@override
public void open() {
system.out.println("open oracle");
}
@override
public void close() {
system.out.println("close oracle");
}
}
类sqlserver:
public class sqlserver implements database {
@override
public void open() {
system.out.println("open sqlserver");
}
@override
public void close() {
system.out.println("close sqlserver");
}
}
工厂类及测试：
public class factory {
public database getdatabase(string type){
if(type == null){
return null;
}
if(type.equalsignorecase("mysql")){
return new mysql();
} else if(type.equalsignorecase("oracle")){
return new oracle();
} else if(type.equalsignorecase("sqlserver")){
return new sqlserver();
}
return null;
}
@test
public void test(){
factory factory = new factory();
database d1= factory.getdatabase("mysql");
d1.open();
database d2= factory.getdatabase("oracle");
d2.open();
database d3= factory.getdatabase("sqlserver");
d3.open();
}
}
特点： 如果要新增其他数据库，只需创建新数据库类实现功能接口，修改工厂类。
问题1：根据“开闭原则”：对现有功能进行拓展，但不允许修改原有代码。很明显，这时简单工厂模式需多次修改工厂类。
问题2：使用者实际使用时并不知道类名，他只知道有database这个接口,使用这个接口就能创建对象，使用open()函数,当然实际中肯定还需传入用户名和密码等参数。
针对问题2：可以使用枚举的方式，代码如下：
public class factory2 {
enum databasetype{
mysql,
sqlserver,
oracle
}
public static database getdatabase(databasetype type){
switch(type){
case mysql:
return new mysql();
case oracle:
return new oracle();
case sqlserver:
return new sqlserver();
default:
throw new unknowntypeexception(null, type);
}
}
@test
public void test(){
database s1=factory2.getdatabase(databasetype.mysql);
s1.open();
database s2=factory2.getdatabase(databasetype.oracle);
s2.open();
}
}
2.工厂方法模式(factory method)：定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到其子类。
使用简单工厂方式使得工厂函数很难维护，而且请求者还需知道被实例化的类，而工厂方法模式可避免之。
新建抽象工厂 ifactory，对于每个数据库都新建相应的工厂类，如mysqlfactory,oraclefactory实现 ifactory，这样在新增一种数据库时，不必修改工厂类而造成破坏封闭原则。
public interface ifactory {
public database get();
}
class sqlfactory implements ifactory{
public database get(){
return new mysql();
}
}
class oraclefactory implements ifactory{
public database get(){
return new oracle();
}
}
class sqlserverfactory implements ifactory{
public database get(){
return new sqlserver();
}
}
//测试
public class factorymethod{
public static void main(string[] args){
database d1=new sqlfactory().get();
d1.open();
}
}
问题1：如果数据库类型越来越多，将无限的增加工厂子类，使用者同样还是需要知道工厂子类的名称。
问题2：在使用时数据库时可能还需与其他的类相关联，工厂方法模式无法解决。
3.抽象工厂模式（abstract factory）：提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类。
场景：若在新建数据库连接时需指定方言，而且不同数据库的sql语言也不相同的情况下。
组成元素：
1.方言类和接口，如图所示：
2.之前的数据库类和接口
3.operfactory抽象工厂
public abstract class operfactory{
private idialect dialect;
abstract void add();
abstract void delete();
abstract void update();
public void setdialect(string classname){
idialect cf=null;
try {
cf=(idialect)class.forname(classname).newinstance();
setdialect(cf);
} catch (instantiationexception | illegalaccessexception | classnotfoundexception e) {
e.printstacktrace();
}
}
public idialect getdialect() {
return dialect;
}
public void setdialect(idialect dialect) {
this.dialect = dialect;
}
}
4. mysqlfatory，oraclefactory（ 均继承上面的抽象工厂类）
public class mysqlfatory extends operfactory {
@override
void add() {
system.out.println("使用的方言为："+this.getdialect().showdialect());
system.out.println("mysql add()");
}
@override
void delete() {
system.out.println("使用的方言为："+this.getdialect().showdialect());
system.out.println("mysql delete()");
}
@override
void update() {
system.out.println("使用的方言为："+this.getdialect().showdialect());
system.out.println("mysql update()");
}
}
public class oraclefactory extends operfactory {
@override
void add() {
system.out.println("使用的方言为："+this.getdialect().showdialect());
system.out.println("oracle add()");
}
@override
void delete() {
system.out.println("使用的方言为："+this.getdialect().showdialect());
system.out.println("oracle delete()");
}
@override
void update() {
system.out.println("使用的方言为："+this.getdialect().showdialect());
system.out.println("oracle update()");
}
}
5.工厂构造器类 factoryproducer 负责生成想要的数据库工厂。
public class factoryproducer {
public static operfactory getfactory(string class_name) {
operfactory cf=null;
try {
cf=(operfactory)class.forname(class_name).newinstance();
} catch (instantiationexception | illegalaccessexception | classnotfoundexception e) {
e.printstacktrace();
}
return cf;
}
}
6.测试
public static void main(string[] args){
operfactory of2=factoryproducer.getfactory(databasefactorytype.mysql);
of2.setdialect(dialecttype.mysql5innodbdialect);
of2.update();
operfactory of= factoryproducer.getfactory(databasefactorytype.oralce);
of.setdialect(dialecttype.oracle10gdialect);
of.add();
}
结果：
总之抽象工厂总是关于创建一系列相关或相互有依赖的对象，以上例子中即database对象与dialect对象具有相关性。但是使用者要了解各种工厂和方言。
三者区别：
简单工厂实现简单，扩展也很容易，但是会频繁修改工厂类代码，难以维护，在维护的时候容易引发新的bug。
工厂方法模式则是把对象的实例化延迟到了继承的子类里面，这样就变成了扩展工厂，从而满足了“开闭”原则， 但是不支持产品切换，也就是只能满足一层的产品（算法）抽象，当需与其他对象合作时无能为力。
抽象工厂则是继续把产品进行再次抽象，最后得到一个可以支持产品切换的结构，但问题过于复杂，不过我们使用反射机制，可以弥补这个缺点，但是使用者却需要知道工厂的名称。
以上工程源码分享：链接：https://pan.baidu.com/s/1elhalizkrr1n7391jw8uta 密码：1ikz