设计模式-工厂模式

一、简单工厂：简单工厂模式就是由一个工厂类根据传入的参数决定创建哪一种的产品类

PS：工厂模式分为简单工厂模式、工厂方法模式、抽象工厂模式。简单工厂模式是对代码的自然封装，比较容易理解，几乎每个人都会用的上。真正算的上设计模式的是抽象工厂模式，但是大部分人都很少能用上抽象工厂模式。Spring框架中的IOC用到的就是简单工厂模式。

 简单工厂（反射）实现

//反射实现工厂类，优点：新增时不用修改工厂类
public class FroductFactoryImp implements ProductFactory {
    @Override
    public Object createProduct(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Class<?> animal=Animal.class.forName(className);
        Object object=  animal.newInstance();
        return object ;
    }
}

//测试类
public class test {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        ProductFactory factory=new FroductFactoryImp();
        Animal animal=(Animal) factory.createProduct("com.java.SimpleFactory.Man");
        animal.say();
        Car car=(Car) factory.createProduct("com.java.SimpleFactory.Benchi");
        car.run();
    }
}

 二、简单工厂 反射+配置文件 实现

//模拟springIOC bean 工厂
public class BeanFactory {
    private static Properties properties = new Properties();
    private static HashMap<String,Object> beanMap = new HashMap();

    //加载配置文件
    static{
        InputStream inputStream = BeanFactory.class.getClassLoader().getResourceAsStream("beanFactory.properties");
        try {
            properties.load(inputStream);
            Enumeration<Object> keys = properties.keys();
            while (keys.hasMoreElements()){
                String key = (String) keys.nextElement();
                String property = properties.getProperty(key);
                Object value = Class.forName(property).newInstance();
                beanMap.put(key,value);
            }
        } catch (IOException e) {
            throw new ExceptionInInitializerError();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }

    public static<T> T getBean(String className){
        return (T) beanMap.get(className);
    }

}


//beanFactoryProperties 配置文件
man=com.java.SimpleFactory.Man
car=com.java.SimpleFactory.Benchi

二、工厂方法：

一、抽象工厂模式理解

场景：生产的产品是不变的，但是不同工厂的表现形式不同，如：工厂固定生产手机和电脑，A工厂和B工长都生产手机电脑，此时C也想生产手机和电脑，那么只需要新建C工厂以及在C工厂新建手机和电脑。总结，不可以增加产品，但是可以增加产品簇（不同的工厂）

与工厂方法的异同：抽象工厂往往生产多种产品，而工厂方法则生产一种产品

二、抽象工厂实现

//工厂统一接口
public interface DataBaseFactory {
    public Connect createConnect();
    public Command createCommand();
}

//产品1 统一接口
public interface Connect {
    public void connect();
}
//产品2 统一接口
public interface Command {
    public void command();
}
//系列工厂1实现类
public class MysqlDataBase implements DataBaseFactory{
    @Override
    public Connect createConnect() {
        return new MysqlConnect();
    }
    @Override
    public Command createCommand() {
        return new MySqlCommand();
    }
}
//系列工厂2实现类
public class OracleDataBase implements DataBaseFactory {
    @Override
    public Connect createConnect() {
        return new OracleConnect();
    }
    @Override
    public Command createCommand() {
        return new OracleCommand();
    }
}
//系列工厂1下产品1 实现类
public class MysqlConnect implements Connect {
    @Override
    public void connect() {
        System.out.println("mysql 连接数据库");
    }
}
//系列工厂1下产品2 实现类
public class MySqlCommand implements Command {
    @Override
    public void command() {
        System.out.println("mysql 执行sql 语句");
    }
}
//系类工厂2 下产品1 实现类
public class OracleConnect implements Connect {
    @Override
    public void connect() {
        System.out.println("Oracle 连接数据库");
    }
}
//谢列工厂2下产品2 实现类
public class OracleCommand implements Command {
    @Override
    public void command() {
        System.out.println("Oracle 执行sql语句");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        DataBaseFactory factory=new MysqlDataBase();
        Connect connect=factory.createConnect();
        connect.connect();
        Command command=factory.createCommand();
        command.command();
    }
}