设计模式-建造模式-工厂模式

package com.example.demo.designpattern.factory;

public interface Shape {
void draw();
}

package com.example.demo.designpattern.factory;

public class Circle implements Shape{
@Override
public void draw() {
System.out.println(“画圆形”);
}
}

package com.example.demo.designpattern.factory;

public class Rectangle implements Shape{
@Override
public void draw() {
System.out.println(“画矩形”);
}
}

package com.example.demo.designpattern.factory;

public class Square implements Shape{
@Override
public void draw() {
System.out.println(“画正方形”);
}
}

package com.example.demo.designpattern.factory;

import org.springframework.util.StringUtils;
//工厂模式的工厂类，创建型模式，在于产生对象，不会暴露对象的创建逻辑，屏蔽产品实现，调用者只需关心产品接口
public class ShapeFactory {
public Shape getShape(String shapeType) {
if(StringUtils.isEmpty(shapeType)) {
return null;
}
if(shapeType.equalsIgnoreCase(“CIRCLE”)) {
return new Circle();
}
if(shapeType.equalsIgnoreCase(“RECTANGLE”)) {
return new Rectangle();
}
if(shapeType.equalsIgnoreCase(“SQUARE”)) {
return new Square();
}
return null;
}
}

package com.example.demo.designpattern.factory;

public class FactoryPatternDemo {
public static void main(String[] args) {
//调用者只需引入工厂类，不需要知道对象具体怎么创建的
ShapeFactory shapeFactory = new ShapeFactory();
Shape circle = shapeFactory.getShape(“CIRCLE”);
circle.draw();
Shape rectangle = shapeFactory.getShape(“RECTANGLE”);
rectangle.draw();
Shape square = shapeFactory.getShape(“SQUARE”);
square.draw();
}
}

spring的 beanfactory就是典型的工厂模式

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.beans.factory;

import org.springframework.beans.BeansException;
import org.springframework.core.ResolvableType;
import org.springframework.lang.Nullable;

public interface BeanFactory {
String FACTORY_BEAN_PREFIX = “&”;

Object getBean(String var1) throws BeansException;

<T> T getBean(String var1, Class<T> var2) throws BeansException;

Object getBean(String var1, Object... var2) throws BeansException;

<T> T getBean(Class<T> var1) throws BeansException;

<T> T getBean(Class<T> var1, Object... var2) throws BeansException;

<T> ObjectProvider<T> getBeanProvider(Class<T> var1);

<T> ObjectProvider<T> getBeanProvider(ResolvableType var1);

boolean containsBean(String var1);

boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;

boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;

boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;

boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;

@Nullable
Class<?> getType(String var1) throws NoSuchBeanDefinitionException;

@Nullable
Class<?> getType(String var1, boolean var2) throws NoSuchBeanDefinitionException;

String[] getAliases(String var1);

}