先说下工厂模式的特性
1.对于调用者来说，影藏了复杂的逻辑处理过程，调用者只关心执行结果。
2.工厂要对结果负责，保证生产出符合规范的产品。
Git代码地址 https://github.com/wujiachengSH/WjcFactoryDemo
下述的3个栗子分别为简单工厂，工厂方法，抽象工厂
先来个栗子看看什么是工厂把
首先是简单工厂模式
声明一个动物工厂
package com.wjc.Factory;
public interface Animal {
String eat();
String dirnk();
String run();
}
来2个实现类
package com.wjc.Factory;
public class Elephant implements Animal {
@Override
public String eat() {
// TODO Auto-generated method stub
return "Elephant e";
}
@Override
public String dirnk() {
// TODO Auto-generated method stub
return "Elephant d";
}
@Override
public String run() {
// TODO Auto-generated method stub
return "Elephant r";
}
}
package com.wjc.Factory;
public class Leopard implements Animal {
@Override
public String eat() {
// TODO Auto-generated method stub
return "Leopard e";
}
@Override
public String dirnk() {
// TODO Auto-generated method stub
return "Leopard d";
}
@Override
public String run() {
// TODO Auto-generated method stub
return "Leopard r";
}
}
然后我们来定义一个工厂
package com.wjc.Factory.simple; import com.wjc.Factory.Animal;
import com.wjc.Factory.Elephant;
import com.wjc.Factory.Leopard; public class SimpleFactory { public Animal getAnimal(String name) {
if ("Elephant".equals(name)) {
return new Elephant();
}else if ("Leopard".equals(name)) {
return new Leopard();
}else {
return null;
}
} }
测试一下这段代码
package com.wjc.Factory.simple;
import com.wjc.Factory.Animal;
public class Test {
public static void main(String[] args) {
SimpleFactory simpleFactory = new SimpleFactory();
Animal animal = simpleFactory.getAnimal("Leopard");
System.out.println(animal.eat());
}
}
可以看到工厂模式的意义在于，当需要使用对象的时候，不再通过New对象的方式拿取对象实例，而是通过工厂来获取对象
通过工厂来声明Bean最大的好处就在于
可以在Bean工厂中控制Bean是单例的？原型模式的？被代理的等等等。
不过上述简单工厂能力过于强大，一个工厂竟然可以生产多种动物，显然不符合原理。我们来看正宗的工厂
工厂模式代码
1.声明一个工厂接口
package com.wjc.Factory.func;
import com.wjc.Factory.Animal;
public interface Factory {
Animal getAnimal();
}
2.分别实现工厂接口
package com.wjc.Factory.func; import com.wjc.Factory.Animal;
import com.wjc.Factory.Elephant; public class ElephantFactory implements Factory { @Override
public Animal getAnimal() {
// TODO Auto-generated method stub
return new Elephant();
} }
package com.wjc.Factory.func; import com.wjc.Factory.Animal;
import com.wjc.Factory.Leopard; public class LeopardFactory implements Factory { //来个单例工厂好了
private static class LeopardBean {
private static final Leopard INSTANCE = new Leopard();
} @Override
public Animal getAnimal() {
// TODO Auto-generated method stub
return LeopardBean.INSTANCE;
} }
3.通过工厂生成Bean
package com.wjc.Factory.func;
public class Test {
public static void main(String[] args) {
ElephantFactory elephantFactory = new ElephantFactory();
System.out.println(elephantFactory.getAnimal().eat());
LeopardFactory leopardFactory = new LeopardFactory();
System.out.println(leopardFactory.getAnimal().eat());
}
}
可以看到标准的Bean工厂，可以在工厂中声明和配置Bean对象的实现特性，甚至可以把上一篇代理模式使用进去。
https://www.cnblogs.com/wujc/p/10554933.html
但是上述代码还是存在着一个问题，工厂很多的情况下，获取实例其实并不方便，我们再进行进一步的封装，来靠近IOC
我们来定义一个默认工厂，调用刚才封装的几个工厂
先写一个抽象方法
package com.wjc.Factory.abstra; import com.wjc.Factory.Animal;
import com.wjc.Factory.func.ElephantFactory;
import com.wjc.Factory.func.LeopardFactory; public abstract class AbstarctFactory { protected abstract Animal getAnimal(); public Animal getAnimal(String name) {
if ("Elephant".equals(name)) {
return new ElephantFactory().getAnimal();
}else if ("Leopard".equals(name)) {
return new LeopardFactory().getAnimal();
}else {
return null;
}
} }
来个实现方法，其中有一个默认的产生对象
package com.wjc.Factory.abstra; import com.wjc.Factory.Animal;
import com.wjc.Factory.func.LeopardFactory; public class Factory extends AbstarctFactory { private LeopardFactory defaultFactory = new LeopardFactory(); @Override
protected Animal getAnimal() {
// TODO Auto-generated method stub
return defaultFactory.getAnimal();
} }
测试一下性能
package com.wjc.Factory.abstra;
public class Test {
public static void main(String[] args) {
Factory factory = new Factory();
System.out.println(factory.getAnimal("Elephant").eat());
}
}
上述改造后的代码就是抽象工厂模式了
小结一下工厂模式，特性是封装了创建Bean的过程。