首先向大家道个歉,这篇文章出的慢。其实呢,我也费了很大的劲来写的,从礼拜天就开始写了,后来因为小区停电了,没有保存,后面不得不重新写了。嗯,昨天晚上又是写到12点了,今天是公司培训,中午回家吃了泡面又接着写下去。下午非常累吧,中途睡着了,财务培训的检测做的很差,估计要挂了,希望不要找我回来再培训啊。条件比较幸苦吧,不管怎么样,我还是必须坚持下去,嗯,加油!!!
这期的文章是Java设计模式系列之Factory工厂模式,内容相对呢多一些,但是我会尽量把她写详细清楚。
工厂模式呢有三种,简单工厂模式,工厂方法模式,抽象工厂模式。基本掌握前两种就可以了,第三种要慢慢理解,我也是慢慢体会才弄明白的,呵呵,大家应该比我聪明,更容易理解。
简单工厂模式:
简单工厂模式就是根据条件产生对象,比如条件为1产生什么对象,条件为2产生什么对象。。。嗯,我这里没有这么做,为了方便起见就打印了句话。
package org.javaer.pattern.factory;
public class SimpleFactory {
//这里就用到了singleton单例模式
private static SimpleFactory factory = new SimpleFactory();
private SimpleFactory(){}
public static SimpleFactory getInstance(){
return factory;
}
public void factory(int type){
if(type==1){//条件为1,打印KFC鸡翅
System.out.println(“KFC’s chicken wing”);
}else if(type==2){//条件为2,打印麦当劳鸡翅
System.out.println(“Mcdonald’s chicken wing”);
}else{//其他情况,没有鸡翅
System.out.println(“no chicken wing”);
}
}
public void factory(String type){
if(“KFC”.equals(type)){
System.out.println(“KFC’s chicken wing”);
}else if(“Mcdonald’s”.equals(type)){
System.out.println(“Mcdonald’s chicken wing”);
}else{
System.out.println(“no chicken wing”);
}
}
public static void main(String[] args) {
SimpleFactory simpleFactory = SimpleFactory.getInstance();
simpleFactory.factory(1);
simpleFactory.factory(“Mcdonald’s”);
}
}
——————————————————————————————-简单工厂模式完
我们就可以在配置文件里配置我们要产生的对象的全名就可以了,比如erp.cfg.properties 文件中这样配置org.javaer.erp.dao.DAO=org.javaer.erp.dao.impl.DAOSupport
调用的时候就传入通过读取配置文件得到的Properties类,根据key得到value。有这个字符串,那就容易啦,就像你有了数据库的驱动类的类路径
就用Class.forName(“classname”).newInstance();得到对象,同理是吧。这样就可以通过配置来得到提高系统的可维护性,后面你要是替换实现了,就只要
该配置文件好啦,比如org.javaer.erp.dao.DAO=org.javaer.erp.dao.impl.DAOImpl,那么系统用到这个的时候就会自动全部换掉,而不用一个一个的更改,
是不是方便多了呢。
工厂方法模式:
工厂方法我就不多说了,就是多态嘛,父类或接口引用不同的子类对象。我这里用的例子是快餐店生产快餐,有点尴尬了,我不提倡吃快餐的,又贵又没有营养。不过吃的时候貌似不得以而为之,呵呵,下次坚决不吃。
package org.javaer.pattern.factory;
public class FactoryMethod {
public static void main(String[] args) {
Store store = new KFCStore();
store.makeFood();//KFC卖鸡翅
Store store1 = new McdonaldStore();
store1.makeFood();//麦当劳卖汉堡
}
}
//快餐店卖食物
interface Store{
public Food makeFood();
}
//KFC卖快餐(kfc鸡翅)
class KFCStore implements Store{
public Food makeFood(){
return new Food(“KFC wing”);
}
}
//Mcdonald卖快餐(Mcdonald汉堡)
class McdonaldStore implements Store{
public Food makeFood(){
return new Food(“Mcdonald’s hamburger”);
}
}
//食物类(鸡翅、汉堡)
class Food{
String name = null;
public Food(){}
public Food(String name){
this.name = name;
}
}
如果你要开个必胜客快餐店,写个类实现Store接口就好了,业务就扩展了。
//必胜客卖食物(披萨)
class Pizzahut implements Store{
public Food makeFood(){
return new Food(“Pizza hut pizza”);
}
}
用的时候就用Store store = new Pizzahut();store.makeFood();
——————————————————————————————————-工厂方法模式完
抽象工厂模式:
抽象工厂呢就是在工厂方法模式上面在包一层,因为你的业务可能还需要根据不同的情况产生不同的工厂。
比如我们要有FoodFactory食物工厂,又要有SoftFactory软件工厂。。。那我们就在上面加一层用来产生工厂。而工厂又去生产产品(工厂方法)
package org.javaer.pattern.factory;
//抽象工厂
public abstract class AbstractFactory {
public abstract FoodFactory createFoodFactory();
public abstract SoftFactory createSoftFactory();
//测试main方法,懒得再写一测试类
public static void main(String[] args) {
AbstractFactory abstractFactory = new AbstractFactorySupport();
//产生一级工厂FoodFactory
FoodFactory foodFactory = abstractFactory.createFoodFactory();
foodFactory.makeFood();
System.out.println(“==============================”);
//产生二级工厂KFCFactory
KFCFactory kfcFactory = foodFactory.createKFCFactory();
kfcFactory.makeFood();
//产生二级工厂McdonaldFactory
McdonaldFactory mcdonaldFactory = foodFactory.createMcdonaldFactory();
mcdonaldFactory.makeFood();
System.out.println();
//产生一级工厂SoftFactory
SoftFactory softFactory = abstractFactory.createSoftFactory();
softFactory.createSoft();
System.out.println(“=================================”);
//产生二级工厂IBMFactory
IBMFactory ibmFactory = softFactory.createIBMFactory();
ibmFactory.createSoft();
//产生二级工厂SUNFactory
SUNFactory sunFactory = softFactory.createSUNFactory();
sunFactory.createSoft();
}
}
//抽象工厂实现类,实现产生工厂的抽象方法
class AbstractFactorySupport extends AbstractFactory{
//长生食物工厂
@Override
public FoodFactory createFoodFactory() {
return new FoodFactory();
}
//产生软件公司
@Override
public SoftFactory createSoftFactory() {
return new SoftFactory();
}
}
//食物工厂
class FoodFactory {
public void makeFood(){System.out.println(“food factory make food”);}
public McdonaldFactory createMcdonaldFactory() {return new McdonaldFactory();}
public KFCFactory createKFCFactory(){return new KFCFactory();}
}
//KFC工厂继承食物工厂,生产KFC食物
class KFCFactory extends FoodFactory {
public void makeFood(){
System.out.println(“we make KFC wing”);
}
}
//Mcdonald工厂继承食物工厂,生产Mcdonald食物
class McdonaldFactory extends FoodFactory {
public void makeFood(){
System.out.println(“we make Mcdonald’s wing”);
}
}
//软件公司开发软件
class SoftFactory {
public void createSoft(){System.out.println(“soft factory create software”);}
public SUNFactory createSUNFactory() {return new SUNFactory();}
public IBMFactory createIBMFactory(){return new IBMFactory();}
}
//IBM公司继承软件工厂,开发软件(IBM软件)
class IBMFactory extends SoftFactory{
public void createSoft(){
System.out.println(“we create IBM software”);
}
}
//SUN公司继承软件工厂,开发软件(开源软件)
class SUNFactory extends SoftFactory{
public void createSoft(){
System.out.println(“we create SUN software”);
}
}
运行AbstractFactory 的main方法输出:
food factory make food
==============================
we make KFC wing
we make Mcdonald’s wing
soft factory create software
=================================
we create IBM software
we create SUN software
我们要加一个手机工厂就可以这样做
//手机生产商设计手机
class MobileFactory{
public AppleFactory createAppleFactory(){return new AppleFactory();}
public MeizuFactory createMeizuFactory(){return new MeizuFactory();}
public Product designMobile(){System.out.println(“mobile factory design mobile”);}
}
//Apple公司设计手机(iPhone4)
class AppleFactory extends MobileFactory{
public Product designMobile(){
return new Product(“Apple iphone4″);
}
}
//魅族公司设计手机(M9)
class MeizuFactory extends MobileFactory(){
public Product designMobile(){
return new Product(“Meizu M9″);
}
}
而在抽象工厂类就添加
public abstract MobileFactory createMobileFactory();
—————————————————————————-抽象工厂模式完
嗯这个抽象工厂我做的不是很好,也是因为我的业务比较松散有关吧,我这里的工厂都是没有关联的FoodFactory,SoftFactory,MobileFactory
网上有例子,我觉得那个更好些。网址是http://zhidao.baidu.com/question/63058512.html,大家可以去看看。
最后呢给出一个综合的例子,加上之前的singleton单例模式,我们做一个JMS发送消息的demo吧。这里有点难懂了,嗯涉及到了EJB3.0中的知识了,不过不必深究了,知道整个程序的大致思路就可以啦。
class ContextHelper{
//这个类是一个单例模式,主要功能有两个1.loadJBOSSProperties(String filename)读取JBOSS的上下文环境配置2.得到上下文,那么我们就可以通过这个上下文从EJB容器中通过JNDI读取对象了Lookup(String ejb)。
private static ContextHelper chelper = new ContextHelper();
private ContextHelper(){};
public static ContextHelper getInstance(){
return chelper;
}
public Properties loadJBOSSProperties(String filename){
Properties props = new Properties();
props.load(new FileInputStream(filename));
return props;
}
public Object lookup(String ejb){
Context conx = new InitailContext(this.loadJBOSSProperties());
return conx.lookup(ejb);
}
}
//发送消息的接口
interface MessageSender{
public void sendMessage(Message message);
}
//发送一对一消息的实现
class QueueMessageSender implements MessageSender{
public void sendMessage(){
QueueConnectionFctory qcf = (QueueConnectionFctory)ContextHelper.getInstance().lookup(“ConnectionFactory”);
QueueConnection qconnection = qcf.getConnection();
QueueSession qs = qconnection.getSession(false,TopicConnection.AUTO_ACKOWNLEDGE);
Queue queue = (Queue)ContextHelper.getInstance().lookup(“Queue/myQueue”);
Message message =(TextMessage) queue .createMessage(“我是一个消息”);
QueueSender qsender = qs.createSender(queue);
qsender.send(message);
qs.close();
qconnection.close();
}
}
//发送一对多消息的实现
class TopicMessageSender implements MessageSender{
public void sendMessage(){
TopicConnectionFctory tcf = (TopicConnectionFctory)ContextHelper.getInstance().lookup(“ConnectionFactory”);
TopicConnection tconnection = tcf.getConnection();
TopicSession ts = tconnection.getSession(false,TopicConnection.AUTO_ACKOWNLEDGE);
Topic topic = (Topic)ContextHelper.getInstance().lookup(“Topic/myTopic”);
Message message =(TextMessage) topic.createMessage(“我是一个主题”);
TopicPublisher tp= ts.createPublisher(topic);
tp.send(message);
ts.close();
tconnection.close();
}
}
//消息发送的工厂类
class MessageSenderFactory{
public MessageSender createQueueMessageSender(){
return new QueueMessageSender();
}
public MessageSender createTopicMessageSender(){
return new TopicMessageSender();
}
public static void main(String[] args) {
MessageSenderFactory msf = new MessageSenderFactory();
msf.createQueueMessageSender().sendMessage();//我们就发送消息
msf.createTopicMessageSender().sendMessage();//我们就发送主题
}
}
有朋友说文章不是很容易看懂,特别是抽象工厂模式。嗯,我觉得也是,今天有空就再看看,增加了更多的注释,文章机构画一下。有什么意见可以提,不同意见可以排版,还有不明白的可以交流。Skeype:linmei.dong、MSN:donglinmei@hotmail.com(文/linmei.dong)转载请注明出处http://mtoou.info/java-factory-gcmoshi/
嗯,java设计模式系列之factory工厂模式就写到这里啦,下期是java设计模式系列之Builder构建模式,敬请持续关注~