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有更深入的理解，并且对单例模式有了更深一层的认识！