1. El origen histórico del modelo de fábrica
En la vida real, todos sabemos que la sociedad primitiva es autosuficiente (sin fábrica), la sociedad de pequeña agricultura (fábrica simple, tienda de vinos populares), la línea de ensamblaje de la revolución industrial (método de fábrica, de producción propia y de venta propia), la fundición de cadena industrial moderna (resumen) Fábrica, Foxconn)
2. Modelo de fábrica simple
El patrón de fábrica simple (Patrón de fábrica simple) se refiere a una instancia de la clase de producto que crea un objeto de fábrica, pero no pertenece a los patrones de diseño GOF, 23. Materiales de referencia
Simple factory es adecuado para escenarios donde la clase de fábrica es responsable de crear menos objetos, y el cliente solo necesita pasar los parámetros de la clase de fábrica, y no hay necesidad de preocuparse por la lógica de cómo crear los objetos.
Primero, podemos definir una interfaz ICourse estándar del curso
public interface ICourse {
/** 录制视频 */
public void record();
}
Cree una clase JavaCourse de implementación del curso Java:
public class JavaCourse implements ICourse {
public void record() {
System.out.println("录制 Java 课程");
}
}
Cree la clase de fábrica CourseFactory:
public class CourseFactory {
public ICourse create(String name){
if("java".equals(name)){
return new JavaCourse();
}else if("python".equals(name)){
return new PythonCourse();
}else {
return null;
}
}
}
Modifique el código de llamada del cliente:
public class SimpleFactoryTest {
public static void main(String[] args) {
CourseFactory factory = new CourseFactory();
factory.create("java");
}
}
Por supuesto, para la conveniencia de llamar, podemos cambiar el create () de la fábrica a un método estático. Echemos un vistazo:
las llamadas del lado del cliente son simples, pero si nuestro negocio continúa expandiéndose y necesitamos agregar cursos de front-end, entonces create () en la fábrica. Es necesario modificar la lógica del código cada vez de acuerdo con la riqueza de la cadena de productos. No se ajusta al principio de apertura y cierre. Por lo tanto, podemos seguir optimizando la fábrica simple y podemos utilizar tecnología de reflexión:
public class CourseFactory {
public ICourse create(String className){
try {
if (!(null == className || "".equals(className))) {
return (ICourse) Class.forName(className).newInstance();
}
}catch (Exception e){
e.printStackTrace();
}
return null;
}
}
Modifique el código de llamada del cliente:
public static void main(String[] args) {
CourseFactory factory = new CourseFactory();
ICourse course = factory.create("com.gupaoedu.vip.pattern.factory.simple factory.JavaCourse");
course.record();
}
Después de la optimización, el producto se enriquece continuamente sin modificar el código en CourseFactory. Sin embargo, existe el problema de que el parámetro del método es una cadena, es necesario mejorar la capacidad de control y se requiere una transformación obligatoria. Modifiquemos el código nuevamente:
public ICourse create(Class<? extends ICourse> clazz){
try {
if (null != clazz) {
return clazz.newInstance();
}
}catch (Exception e){
e.printStackTrace();
}
return null;
}
Optimiza el código del cliente:
public static void main(String[] args) {
CourseFactory factory = new CourseFactory();
ICourse course = factory.create(JavaCourse.class);
course.record();
}
Mire el diagrama de clases nuevamente: el
patrón de fábrica simple también es omnipresente en el código fuente del JDK. Ahora, tomemos un ejemplo, como la clase Calendar. Mire el método Calendar.getInstance (). La siguiente es la clase de creación específica de Calendar:
private static Calendar createCalendar(TimeZone zone, Locale aLocale)
{
CalendarProvider provider =
LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale).getCalendarProvider();
if (provider != null) {
try {
return provider.getInstance(zone, aLocale);
} catch (IllegalArgumentException iae) {
// fall back to the default instantiation
}
}
Calendar cal = null;
if (aLocale.hasExtensions()) {
String caltype = aLocale.getUnicodeLocaleType("ca");
if (caltype != null) {
switch (caltype) {
case "buddhist":
cal = new BuddhistCalendar(zone, aLocale);
break;
case "japanese":
cal = new JapaneseImperialCalendar(zone, aLocale);
break;
case "gregory":
cal = new GregorianCalendar(zone, aLocale);
break;
}
}
}
if (cal == null) {
// If no known calendar type is explicitly specified,
// perform the traditional way to create a Calendar:
// create a BuddhistCalendar for th_TH locale,
// a JapaneseImperialCalendar for ja_JP_JP locale, or
// a GregorianCalendar for any other locales.
// NOTE: The language, country and variant strings are interned.
if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
cal = new BuddhistCalendar(zone, aLocale);
} else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja" && aLocale.getCountry() == "JP") {
cal = new JapaneseImperialCalendar(zone, aLocale);
} else {
cal = new GregorianCalendar(zone, aLocale);
}
}
return cal;
}
También hay un logback que todo el mundo usa a menudo. Podemos ver que hay varios métodos sobrecargados en LoggerFactory getLogger ():
public static Logger getLogger(String name) {
ILoggerFactory iLoggerFactory = getILoggerFactory();
return iLoggerFactory.getLogger(name);
}
public static Logger getLogger(Class clazz) {
return getLogger(clazz.getName());
}
La fábrica simple también tiene sus defectos: las responsabilidades de la clase de fábrica son relativamente pesadas y no es fácil ampliar la estructura del producto demasiado compleja.