设计模式-简单工厂，工厂方法，抽象工厂。Spring举例。

1.简单工厂

由工厂来决定创建什么对象。 一个工厂类，通过入参，决定创建出哪一种实例。
缺点：每次加新product都要修改工厂类createProduct方法代码。

abstract class Product {
}

public class Product01 extends Product {

    public Product01() {
        System.out.println("----create product01");
    }
}

public class Product02 extends Product{
    public Product02() {
        System.out.println("----create product02");
    }
}

public class ProductFactory {
    public Product createProduct(String name){
        if ("Product01".equalsIgnoreCase(name)){
            return new Product01();
        }else if ("Product02".equalsIgnoreCase(name)){
            return new Product02();
        }else {
            return null;
        }
    }

    //测试
    public static void main(String[] args) {
        ProductFactory productFactory = new ProductFactory();
        Product product01 = productFactory.createProduct("product01");
    }
}

2.工厂方法

让不同的工厂类和生产其工厂对应的产品。
缺点：每个Product对应一个工厂会造成很多工厂。

public abstract class Product {
}

public class Product01 extends Product{
    public Product01() {
        System.out.println("---create product01");
    }
}

public class Product02 extends Product{
    public Product02() {
        System.out.println("---create product02");
    }
}

public class Product01Factory implements Factory{
    public Product createProduct(){
        return new Product01();
    }
}

public class Product02Factory implements Factory{
    public Product createProduct(){
        return new Product02();
    }
}

public interface Factory {
    Product createProduct();

    //测试
    public static void main(String[] args) {
        Product01Factory product01Factory = new Product01Factory();
        product01Factory.createProduct();
    }
}

3.抽象工厂

适用工厂生产的产品类目互相交错，一个产品属于多种品类，产品族很多的情况。
比如，WomanProduct02既属于product02,也属于womenProduct。

abstract class Product {
}

public class Product01 extends Product {

    public Product01() {
        System.out.println("----create product01");
    }
}

public class Product02 extends Product {

}

public class WomanProduct01 extends Product01{
}

public class WomanProduct02 extends Product02{
}

public class ManProduct01 extends Product01{
}

public class ManProduct02 extends Product02{
    public ManProduct02() {
        System.out.println("---create manProduct02");
    }
}

public class Product02Factory extends AbstractProductFactory{
    @Override
    public Product creatWomanProduct() {
        return new WomanProduct02();
    }

    @Override
    public Product creatManProduct() {
        return new ManProduct02();
    }
}

public class Product01Factory extends AbstractProductFactory{
    @Override
    public Product creatWomanProduct() {
        return new WomanProduct01();
    }

    @Override
    public Product creatManProduct() {
        return new ManProduct01();
    }
}

abstract class AbstractProductFactory {
    public abstract Product creatWomanProduct();

    public abstract Product creatManProduct();

    //测试
    public static void main(String[] args) {
        Product02Factory product02Factory = new Product02Factory();
        product02Factory.creatManProduct();
    }
}

spring简单工厂举例（通过入参，让工厂决定创建什么实例）

public class BeanFactory {

    static BeanFactory beanFactory = new BeanFactory();

     BeanFactory getBeanFactory(){
        return beanFactory;
    }

    Object createBeanInstance(BeanDefinition beanDefinition) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class beanClass = Class.forName(beanDefinition.getBeanClassName());
        Constructor constructor = beanClass.getDeclaredConstructor();
        return constructor.newInstance();
    }

    Object createBean(BeanDefinition beanDefinition) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
        Object beanInstance = createBeanInstance(beanDefinition);
        //依赖注入
        setPropertyValues(beanInstance, beanDefinition);
        return beanInstance;
    }
}

如有错误，麻烦指正。