重温设计模式【工厂模式】

工厂模式：1 隐藏复杂的逻辑过程，只关心结果。

简单工厂 工厂方法 抽象工厂

生产者和消费者要分开来

举例：

买早饭：面包，牛奶（产品）

消费者来说：产品是否过保质期，产品效果，产品价格

不关心面包和牛奶是怎么生产的

 

就以消费汽车为例子：

我们定义一个car的接口

package com.factory.test;

/**
 * 汽车产品接口 需要满足一定的标准
 * @author lulf
 *
 */
public interface Car {
	//规定汽车的品牌
	String getName();
}

 

 

 

 

 

 

定义三个汽车牌子

package com.factory.test;

public class Audi implements Car {

	@Override
	public String getName() {
		return "Audi";
	}
}

 

package com.factory.test;

public class Benz implements Car {

	@Override
	public String getName() {
		return "Benz";
	}
}

 

 

package com.factory.test;

public class Bmw implements Car {

	@Override
	public String getName() {
		return "Bmw";
	}
}

 

定义一个简单工厂，用于分管所有的车型

 

package com.factory.test;
//对这个工厂而言
//这个工厂可以分管了所有的车型
public class SimpleFactory {
	
	//实现了统一管理，专业化管理
	//如果没有工厂模式，小作坊，没有执行标准化
	public Car getCar(String name){
		if("Bmw".equals(name)){
			return new Bmw();
		}else if("Benz".equals(name)){
			return new Benz();
		}else if("Audi".equals(name)){
			return new Audi();
		}else{
			System.out.println("无此车型");
			return null;
		}
	}
}

再利用定义一个测试类的消费者

package com.factory.test;

public class TestSimpleFactory {
	public static void main(String[] args) {
		// 这就是我们的消费者
		Car car = new SimpleFactory().getCar("Bmw");
		System.out.println(car.getName());
	}
}

以上便是简单工厂模式

我们思考下显示生活中这种包含所有汽车的工厂是不存在的，而且为了管理，所以我们引入了

工厂方法的实现方式

首先我们定义一个工厂的通用接口factory

 

package com.factory.test;
//工厂接口，定义了所有工厂的执行标准
public interface Factory {
	//符合汽车上路标准
	Car getcar();
}

定义三种汽车牌子的各自的factory实现类

 

package com.factory.test;

public class AudiFactory implements Factory{

	@Override
	public Car getcar() {
		return new Audi();
	}

}

package com.factory.test;

public class BenzFactory implements Factory{

	@Override
	public Car getcar() {
		// TODO Auto-generated method stub
		return new Benz();
	}

}

 

package com.factory.test;

public class BmwFactory implements Factory{

	@Override
	public Car getcar() {
		// TODO Auto-generated method stub
		return new Bmw();
	}

}

 

然后消费者调用：

 

package com.factory.test;

public class FactoryTest {
	public static void main(String[] args) {
		//工厂方法模式
		// 各个产品的生厂商，都拥有自己各自的工厂
		// 生产工艺，生成的高科技程度各不相同
		Factory factory1=new AudiFactory();
		System.out.println(factory1.getcar());
		//消费者只关心自己想要的那个生产工厂
		Factory factory2=new BenzFactory();
		System.out.println(factory2.getcar());
	}
}

工厂方法

如上工厂方法增加了使用的复杂度，所以我们引入了抽象工厂让他能够自动选择

package com.lulf.abstractfactory.demo;

import com.factory.test.Car;

public abstract class AbstractFactory {

	protected abstract Car getCar();

	//动态配置的过程
	public Car getCar(String name) {
		if ("Bmw".equals(name)) {
			return new BmwFactory().getCar();
		} else if ("Benz".equals(name)) {
			return new BenzFactory().getCar();
		} else if ("Audi".equals(name)) {
			return new AudiFactory().getCar();
		} else {
			System.out.println("无此车型");
			return null;
		}
	}

}

抽象工厂

定义一个抽象的工厂类：

分别用三个类去集成这个类

package com.lulf.abstractfactory.demo;

import com.factory.test.Audi;
import com.factory.test.Car;

public class AudiFactory extends AbstractFactory{

	@Override
	protected Car getCar() {
		return new Audi();
	}

}

package com.lulf.abstractfactory.demo;

import com.factory.test.Benz;
import com.factory.test.Car;

public class BenzFactory extends AbstractFactory{

	@Override
	protected Car getCar() {
		// TODO Auto-generated method stub
		return new Benz();
	}

}

package com.lulf.abstractfactory.demo;

import com.factory.test.Bmw;
import com.factory.test.Car;

public class BmwFactory extends AbstractFactory{

	@Override
	protected Car getCar() {
		// TODO Auto-generated method stub
		return new Bmw();
	}

}

 

 

 

学习Spring的BeanFactory定义一个默认的defaultfactory让他能够有个默认的工厂

package com.lulf.abstractfactory.demo;

import com.factory.test.Car;

//具体的业务逻辑层
public class DefaultFactory extends AbstractFactory{
	
	//什么都不传的话是默认工厂
	private AudiFactory DefaultFactory=new AudiFactory();

	@Override
	protected Car getCar() {
		return DefaultFactory.getCar();
	}

}

 

写一个test类

package com.lulf.abstractfactory.demo;

public class testFactory {
	public static void main(String[] args) {
		DefaultFactory defaultFactory=new DefaultFactory();
		//默认工厂
		System.out.println(defaultFactory.getCar());
		//传值
		System.out.println(defaultFactory.getCar("Bmw"));
		
	}

}

优点：

只关注结果，

工厂模式：简单工厂 工厂方法 抽象工厂

Spring的工厂模式：

生产的是Bean

BeanFactory 生成Bean、

单例的Bean 被代理的Bean 最原始的Bean List类型的Bean 作用域不同的Bean

//getBean Spring获取Bean 核心就是为了解耦化开发 低耦合高聚合