设计模式（第三式：抽象工厂模式）

概念：

　　抽象工厂模式：为创建一组相关或相互依赖的对象提供一组接口，而且无需指定它们的具体类。

实现：

　　定义书籍接口：

    public interface Book {
    }

　　定义工厂接口：

    public interface OperateFactory {
        /**
         * 想数据库中添加一本书
         * @param book 要添加的对象
         */
        void addBook(Book book);

        /**
         * 根据id从数据库中删除某个对象
         * @param id
         */
        void delete(Integer id);

        /**
         * 根据id从数据库中查询某本书籍
         * @param id 带查询的对象id
         * @return book
         */
        Book getBook(Integer id);

        /**
         * 修改数据库中对象
         * @param book
         * @return
         */
        Boolean modify(Book book);
    }

　　书籍类别：（小说类书籍、工具类书籍...）

    public class NovelBook implements Book {

        private Integer id;
        private String name;

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

    public class NovelBook implements Book {

        private Integer id;
        private String name;

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

　　工厂类别：

    public class MySQLOperateFactory implements OperateFactory {

        @Override
        public void addBook(Book book) {
            System.out.println("从mysql中添加一本书");
        }

        @Override
        public void delete(Integer id) {
            System.out.println("从mysql中删除id为"+id+"的数据");
        }

        @Override
        public Book getBook(Integer id) {
            System.out.println("从mysql中根据id查询一本书");
            return new Book() {
            };
        }

        @Override
        public Boolean modify(Book book) {
            System.out.println("从mysql中修改一本书");
            return Boolean.TRUE;
        }
    }

    public class OracleOpareteFactory implements OperateFactory {
        @Override
        public void addBook(Book book) {
            System.out.println("从oracle中添加一本书");
        }

        @Override
        public void delete(Integer id) {
            System.out.println("从oracle中删除id为"+id+"的数据");
        }

        @Override
        public Book getBook(Integer id) {
            System.out.println("从oracle中根据id查询一本书");
            return new Book() {
            };
        }

        @Override
        public Boolean modify(Book book) {
            System.out.println("从oracle中修改一本书");
            return Boolean.TRUE;
        }
    }

　　分析：通过代码可以简单的分析一下，有没有觉得和工厂方法模式几乎差不多，就是里面装的方法多了一点，但仔细体会，会有很奇妙的发现，就是有不一样的地放

　　　　1.提高了内聚

　　　　2.方法组上扩展不方便，都得重写接口，这种情况下集成的越多，改动越多，所以可以考虑中加夹层抽象类做缓冲

　　　　3.看上去和工厂方法区别不大，但是真的不一样，不只是方法多了而已，主要的应用层级也不一样，可以感受一下：工厂方法是在乎产品的分类，他操作的是分类的对象，目的是为了方便实现实体类；抽象工厂是在乎工厂中的方　　法，它操作的分类对象的接口，即不在乎具体是哪个对象。总体来说抽象工厂注重的层级应该比工厂方法高一些。

　　　　4.适用场景：

　　　　　　a.有一组对象或者有相同约束。

　　　　　　……

　　经典框架中使用的：

　　　　Spring框架，hibernate框架，mybatis框架等都有使用过