设计模式-工厂模式

class

@Data
public class Person{
 	String name;
  int age;
}

工厂模式

工厂模式谁都听过，不过实际运用的时候从来都不是基础的那个模样。

public class PersonFactory{
  
  public Person newPerson(){
    return new Person()
  }
}

单例模式

public class PersonFactory{
  private final Person uniqPerson = new Person();
  
  public Person getPerson(){
  	return uniqPerson;
  }
}

所以，如果都是这种基础的用法，为什么工厂模式还一直被提及呢。

误区

首先，由于内容的单调性，或者说没有经过泛化，因此，才会觉得工厂模式十分有限。

public class InstanceFactory {
	public <T> T newInstance(Class<T> clazz){
		try{
			Constructor<T> constructor = clazz.getDeclaredConstructor();
			constructor.setAccessible(true);
			return constructor.newInstance();
		}catch (Exception e){
			throw new RuntimeException("create Instance error : " + e.getMessage());
		}
	}
}

这种情况的话，感觉就会十分有用，为什么

对于单一的对象的外包装，是华而不实的，应该讲究核心的多样性。

同理，之所以觉得无用，是因为我们的内涵不够丰富而已。

如果是学校，或者企业，甚至是社会，Person的数量激增的时候，工厂的统一管理、调用方式必定是优于new的。

而且当有细微的操作的时候，只需要修改一处，而非涉及全体，集中而非离散。

抽象

单纯的觉得Factory不好用的，还有其中一点，那就是单调。

因为前面的操作，都是机械性的、重复性的操作，正如字面意义工厂。

仅仅在个体数量足够多的时候，工厂才有足够的意义，一个小作坊不配拥有工厂的模式，开销太大。

但是，一个大的工厂，不会仅仅只是有一条业务线。

于是，抽象工厂模式出线了，这个所谓的工厂的工厂。

public class SchoolFactory {
	final StudentFactory studentFactory = new StudentFactory();
	final TeacherFactory teacherFactory = new TeacherFactory();

	public StudentFactory getStudentFactory() {
		return studentFactory;
	}

	public TeacherFactory getTeacherFactory() {
		return teacherFactory;
	}
}

class Student{}
class Teacher{}
class StudentFactory{
	Student newStudent(){
		return new Student();
	}
}
class TeacherFactory{
	Teacher newTeacher(){
		return new Teacher();
	}
}

本质

如果非要说个一二三，起始就是从一个固定的地方，通过固定的方法，取出多变的东西。

通过这种方式进行管理，在面对复杂场景的时候也能保证接口的单一、纯净，提升系统的健壮性、可维护性。

从大了说，就是服务的注册和调用，从小了说，其实就是一个Map映射。

注册的是对象也好，服务也罢，基本就是这个流程，下面来写一个试试看

实现

统一接口

public interface FactoryInterface{
  Object newInstance();
}

抽象工厂

public abstract AbstractFactory implements FactoryInterface{
  private final ConcurrentHashMap<String, FactoryInterfact> factories = new ConcurrentHashMap<>();
  
  @PostConstruct
  public void  register(){
    factories.put(getClass(), this);
  }
  
  public Object newInstance(Class ){
    if(!factories.containsKey(name)){
    	return null;
    }
    return factories.get(name).newInstance();
  }

}

具体工厂

public class StudentFactory extends AbstractFactory {
  public Object newInstance(){
    return new Student();
  }
}

public class TeacherFactory extends AbstractFactory {
  public Object newInstance(){
    return new Teacher();
  }
}

小结

当采用这种方式之后，在顶层进行逻辑组织的时候，统一的API调用让系统更容易维护。

并且，通过@PostConstruct这种方式，结合Spring的话更好，让它实现自动注册。

由此，肆意的增加工厂甚至无需进行额外的维护操作，且外部的调用方式完全不用动，何乐而不为。

---

public class Entrance {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);
        System.out.println(AbstractFactory.newInstance(StudentFactory.class.getName()).getClass().getName());
    }
}
// sout : xxx.xxx.factory.StudentFactory