简单工厂模式(Simple Factory Pattern)_Java

Simple Factory Pattern

简单工厂模式(Simple Factory Pattern)

 

工厂是什么呢？工厂是生产产品的，BeanFactory是生产Bean对象的，水果工厂是生产水果的，工厂模式的作用就是，我们不需要去new一个对象了，直接通过工厂模式，让工厂给我们提供需要的对象即可。

下面以水果工厂为例，简单说一下

 

package com.pattern.simplefactory;
/**
 * 水果工厂，用来造水果的，给我名字，我给你对象
 */
public class FruitFactory {

	public static Fruit getFruit(String name){
		if(name!=null&&name.equalsIgnoreCase("apple")){
			return new Apple();//匹配字符串，创建水果对象
		}
		return null;
	}
}

 

package com.pattern.simplefactory;
/**
 * 水果接口，所有的水果都有一个方法,sayName
 */
public interface Fruit {
	public void sayName();
}

 

package com.pattern.simplefactory;
/**
 * 苹果，实现了水果接口，有sayName方法
 */
public class Apple implements Fruit{

	@Override
	public void sayName() {
		System.out.println("Apple");
	}

}

 

package com.pattern.simplefactory;

public class Test {

	public static void main(String[] args) {
		Apple apple=(Apple) FruitFactory.getFruit("apple");
		apple.sayName();
	}
}

Spring里面的bean管理原理

Spring有一个工厂模式BeanFactory，提供一个getBean(name)方法
配置Spring的配置文件
applicationContext.xml
<bean name class/>
name对应的是获取class中完全限定名指定的类
用户通过getBean方法，传入name，获取指定的对象

bean管理的简单实现

 这里采用的是properties配置文件
prop.properties

apple=com.pattern.beanfactory.Apple

 

package com.pattern.beanfactory;

import java.io.IOException;
import java.util.Properties;

public class BeanFactory {
	//一次性读取src目录下的配置文件prop.properties存到prop中，Spring使用的是xml基本一样
	private static Properties prop;
	static{
		prop=new Properties();
		try {
			prop.load(BeanFactory.class.getClassLoader().getResourceAsStream("prop.properties"));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	//通过反射机制，返回指定name对应的class的实例
	public static Object getBean(String name){
		if(prop.containsKey(name)){
			String className=prop.getProperty(name);
			try {
				return Class.forName(className).newInstance();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}
}

 

package com.pattern.beanfactory;
/**
 * 水果接口，所有的水果都有一个方法,sayName
 */
public interface Fruit {
	public void sayName();
}

 

package com.pattern.beanfactory;
/**
 * 苹果，实现了水果接口，有sayName方法
 */
public class Apple implements Fruit{

	@Override
	public void sayName() {
		System.out.println("Apple");
	}

}

 

package com.pattern.beanfactory;

public class Test {
	public static void main(String[] args) {
		Apple apple=(Apple) BeanFactory.getBean("apple");
		apple.sayName();
	}
}

 

 

提醒：这是Spring的基本实现，但Spring的实例创建都是单例模式！

如何让我们的的BeanFactory提供的实例是单例模式呢？

 prop1.properties
apple=com.pattern.beanfactory1.Apple

package com.pattern.beanfactory1;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class BeanFactory {
	private static Properties prop;
	//map集合中用来装实例，保证一个name只对应一份实例
	private static Map<String, Object> map=new HashMap<String, Object>();
	static{
		prop=new Properties();
		try {
			prop.load(BeanFactory.class.getClassLoader().getResourceAsStream("prop1.properties"));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	//通过反射机制，返回指定name对应的class的实例
	public static Object getBean(String name){
		if(prop.containsKey(name)){
			//如果map中存在实例，直接返回，如果不存在，执行创建过程，并将新的实例添加到map中，下次getBean就不用newInstance了
			if(map.containsKey(name)){
				return map.get(name);
			} else{
				String className=prop.getProperty(name);
				try {
					Object o=Class.forName(className).newInstance();
					map.put(name, o);
					return o;
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return null;
	}
}

 

package com.pattern.beanfactory1;
/**
 * 水果接口，所有的水果都有一个方法,sayName
 */
public interface Fruit {
	public void sayName();
}

 

package com.pattern.beanfactory1;
/**
 * 苹果，实现了水果接口，有sayName方法
 */
public class Apple implements Fruit{

	@Override
	public void sayName() {
		System.out.println("Apple");
	}

}

 

package com.pattern.beanfactory1;

public class Test {
	public static void main(String[] args) {
		Apple apple=(Apple) BeanFactory.getBean("apple");
		Apple apple2=(Apple) BeanFactory.getBean("apple");
		System.out.println(apple==apple2);//true
	}
}

 

提醒：事实上，Spring在容器启动的时候就完成了配置的类的实例化，而不是用户需要的时候才去实例并单例的。

我们如何实现在容器启动的时候完成实例并单例呢？

其实很简单，把实例操作放到static静态块中即可！

只有BeanFactory中部分变化：

package com.pattern.beanfactory1;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;

public class BeanFactory {
	private static Properties prop;
	//map集合中用来装实例，保证一个name只对应一份实例
	private static Map<String, Object> map=new HashMap<String, Object>();
	static{
		prop=new Properties();
		try {
			prop.load(BeanFactory.class.getClassLoader().getResourceAsStream("prop1.properties"));
			//*****************************************************
			//Spring的真正的单例形式，大致是这样的，在容器启动的时候就实例所有的配置类
			for(Entry<Object, Object> entry:prop.entrySet()){
				String key=entry.getKey().toString();
				String className=entry.getValue().toString();
				try {
					map.put(key, Class.forName(className).newInstance());
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
			//*****************************
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public static Object getBean(String name){
		//获取实例，直接到map中去找即可
		if(map.containsKey(name)){
			return map.get(name);
		}
		return null;
	}
}

简单工厂模式是面试常考的题目，学完简单工厂模式，最大的收获应该是对Spring的BeanFactory有更深入的理解，并且对单例模式有了更深一层的认识！