精华内容
下载资源
问答
  • 外模式和子模式
    千次阅读
    2021-01-28 05:46:03

    计算机模式结构有三种,分别为:外模式、模式和内模式 ,其中外模式一般也被称为用户子模式。

    一、外模式(External Schema)/用户子模式(Subschema)

    定义:也称用户子模式(Subschema)或用户模式,是数据库用户(包括应用程序员和最终用户)能够看见和使用的局部数据的逻辑结构和特征的描述,是数据库用户的数据视图,是与某一应用有关的数据的逻辑表示。

    理解:  ① 一个数据库可以有多个外模式;  ② 外模式就是用户视图;  ③ 外模式是保证数据安全性的一个有力措施。

    二、模式(Schema)

    定义:也称逻辑模式,是数据库中全体数据的逻辑结构和特征的描述,是所有用户的公共数据视图。

    理解:  ① 一个数据库只有一个模式;  ② 是数据库数据在逻辑级上的视图;  ③ 数据库模式以某一种数据模型为基础;  ④ 定义模式时不仅要定义数据的逻辑结构(如数据记录由哪些数据项构成,数据项的名字、类型、取值范围等),而且要定义与数据有关的安全性、完整性要求,定义这些数据之间的联系。

    三、内模式(Internal Schema)

    定义:也称存储模式(Storage Schema),它是数据物理结构和存储方式的描述,是数据在数据库内部的表示方式(例如,记录的存储方式是顺序存储、按照B树结构存储还是按hash方法存储;索引按照什么方式组织;数据是否压缩存储,是否加密;数据的存储记录结构有何规定)。

    理解:  ① 一个数据库只有一个内模式;  ② 一个表可能由多个文件组成,如:数据文件、索引文件。  它是数据库管理系统(DBMS)对数据库中数据进行有效组织和管理的方法  其目的有:  ① 为了减少数据冗余,实现数据共享;  ② 为了提高存取效率,改善性能。

    更多相关内容
  • 深入理解设计模式-外观模式(门面模式

    万次阅读 多人点赞 2022-01-21 10:06:31
    外观模式也称为门面模式,是一种通过为多个复杂的系统提供一个一致的接口,而使这些系统更加容易被访问的模式。该模式对外有一个统一接口,外部应用程序不用关心内部系统的具体的细节,这样会大大降低应用程序...


    一、什么是外观模式

    外观模式也称为门面模式,是一种通过为多个复杂的子系统提供一个一致的接口,而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口,外部应用程序不用关心内部子系统的具体的细节,这样会大大降低应用程序的复杂度,提高了程序的可维护性。​外观(Facade)模式是“迪米特法则”的典型应用。

    外观(Facade)模式包含以下主要角色:

    • 外观(Facade)角色:为多个子系统对外提供一个共同的接口。
    • 子系统(Sub System)角色:实现系统的部分功能,客户可以通过外观角色访问它。

    二、样例分析

    【例】智能家电控制
    小明的爷爷已经60岁了,一个人在家生活:每次都需要打开灯、打开电视、打开空调;睡觉时关闭灯、关闭电视、关闭空调;操作起来都比较麻烦。所以小明给爷爷买了智能音箱,可以通过语音直接控制这些智能家电的开启和关闭。类图如下:
    在这里插入图片描述

    // 灯类
    public class Light {
        public void on() {
            System.out.println("打开了灯....");
        }
    
        public void off() {
            System.out.println("关闭了灯....");
        }
    }
    
    // 电视类
    public class TV {
        public void on() {
            System.out.println("打开了电视....");
        }
    
        public void off() {
            System.out.println("关闭了电视....");
        }
    }
    
    // 控制类
    public class AirCondition {
        public void on() {
            System.out.println("打开了空调....");
        }
    
        public void off() {
            System.out.println("关闭了空调....");
        }
    }
    
    // 智能音箱
    public class SmartAppliancesFacade {
        private Light light;
        private TV tv;
        private AirCondition airCondition;
    
        public SmartAppliancesFacade() {
            light = new Light();
            tv = new TV();
            airCondition = new AirCondition();
        }
    
        public void say(String message) {
            if(message.contains("打开")) {
                on();
            } else if(message.contains("关闭")) {
                off();
            } else {
                System.out.println("我还听不懂你说的!!!");
            }
        }
    
        // 起床后一键开电器
        private void on() {
            System.out.println("起床了");
            light.on();
            tv.on();
            airCondition.on();
        }
    
        // 睡觉一键关电器
        private void off() {
            System.out.println("睡觉了");
            light.off();
            tv.off();
            airCondition.off();
        }
    }
    
    // 测试类
    public class Client {
        public static void main(String[] args) {
            //创建外观对象
            SmartAppliancesFacade facade = new SmartAppliancesFacade();
            //客户端直接与外观对象进行交互
            facade.say("打开家电");
            facade.say("关闭家电");
        }
    }
    
    

    三、优缺点

    优点:

    • 降低了子系统与客户端之间的耦合度,使得子系统的变化不会影响调用它的客户类。
    • 对客户屏蔽了子系统组件,减少了客户处理的对象数目,并使得子系统使用起来更加容易。

    缺点:

    • 不符合开闭原则,修改很麻烦

    四、使用场景

    • 对分层结构系统构建时,使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系。
    • 当一个复杂系统的子系统很多时,外观模式可以为系统设计一个简单的接口供外界访问。
    • 当客户端与多个子系统之间存在很大的联系时,引入外观模式可将它们分离,从而提高子系统的独立性和可移植性。

    五、Servlet源码应用解析

    使用tomcat作为web容器时,接收浏览器发送过来的请求,tomcat会将请求信息封装成ServletRequest对象,如下图①处对象。但是大家想想ServletRequest是一个接口,它还有一个子接口HttpServletRequest,而我们知道该request对象肯定是一个HttpServletRequest对象的子实现类对象,到底是哪个类的对象呢?可以通过输出request对象,我们就会发现是一个名为RequestFacade的类的对象。

    在这里插入图片描述
    RequestFacade类就使用了外观模式。先看结构图:

    在这里插入图片描述

    为什么在此处使用外观模式呢?

    ​定义 RequestFacade 类,分别实现 ServletRequest ,同时定义私有成员变量 Request ,并且方法的实现调用 Request 的实现。然后,将 RequestFacade上转为 ServletRequest 传给 servlet 的 service 方法,这样即使在 servlet 中被下转为 RequestFacade ,也不能访问私有成员变量对象中的方法。既用了 Request ,又能防止其中方法被不合理的访问。


    结尾

    • 感谢大家的耐心阅读,如有建议请私信或评论留言。
    • 如有收获,劳烦支持,关注、点赞、评论、收藏均可,博主会经常更新,与大家共同进步
    展开全文
  • 设计模式--外观模式

    千次阅读 2022-03-07 12:41:15
    外观模式,为这些系统提供一个外观类进行功能的封装,外观类负责和子系统中的类打交道,用户类外观类打交道,简化了用户类和子系统进行交互依赖。 2.如何实现? 1)系统,是若干个类的集合,这些类协同为...

    1.什么是外观模式?

    当一个用户类需要和某个系统中的多个子系统打交道时,为了避免该类和子系统中的类产生过多的依赖关系,可以采用外观模式。外观模式,为这些子系统提供一个外观类进行功能的封装,外观类负责和子系统中的类打交道,用户类和外观类打交道,简化了用户类和子系统进行交互和依赖。

    2.如何实现?

    1)子系统,是若干个类的集合,这些类协同为用户提供所需的功能,子系统中的任何类都不包含外观类的引用

    2)外观类(Facade),该类包含子系统中全部或部分类的实例引用。外观类可以替代子系统中的类和用户打打交道。

    3.代码实现?

    以一个广告系统做案例,该系统包含CheckWord,Charge,TypeSeting三个子类。

    AdFacade是这个子系的外观类,负责和用户类进行交互,并调用子系统中的功能实现用户需求。

    1)子系统CheckWord

    /**
     * 子系统1
     * 广告检查系统
     * 完成广告字数计算
     */
    public class CheckWord {
        int amount;
        String ad;
        public CheckWord (String ad){
            this.ad = ad;
        }
        /**
         * 计算广告字数,按字数收费
         * @return
         */
        public int setAmout( ){
            System.out.println("计算广告字数");
            amount = ad.length();
            return amount;
        }
    }
    

    2)Charge

    /**
     * 子系统2
     * 计算广告价格
     */
    public class Charge {
        CheckWord word;
        public int price;
        public Charge(CheckWord word){
            this.word = word;
        }
        public int giveCharge( ){
            //计算广告价格
            System.out.println("计算价格");
            price = word.amount*100;
            return price;
        }
    }
    

    3)TypeSetting

    /**
     * 子系统3
     * 广告排版
     */
    public class TypeSetting {
        private String ad;
        public TypeSetting(String ad){
            this.ad = ad;
        }
        public void typeSetting(){
            System.out.println("广告排版");
        }
    }
    

    4)外观类

    /**
     * 外观类
     * 包含子系统中全部或部分类。
     * 这个类替代子系统和用户类打交道,
     * 所有用户想要完成的功能由这个类进行调用,
     * 避免了用户类和子系统过多的依赖。
     */
    public class AdFacade {
        private CheckWord checkWord;
        private Charge charge;
        private TypeSetting typeSetting;
        public AdFacade(String ad){
            this.checkWord = new CheckWord(ad);
            this.charge = new Charge(checkWord);
            this.typeSetting = new TypeSetting(ad);
        }
    
        /**
         * 完成用户发布广告的任务
         */
        public void finishAdTask(){
            checkWord.setAmout();
            charge.giveCharge();
            typeSetting.typeSetting();
        }
    }
    

    5)测试类

    public class Main {
        public static void main(String args[]){
            String ad ="hello world";
    
            AdFacade adFacade = new AdFacade(ad);
            adFacade.finishAdTask();
    
        }
    }
    

     

    展开全文
  • I . 外观模式概念 II . 外观模式 适用场景 III . 外观模式 优缺点 IV . 外观模式与其它设计模式的联系与区别 V . 外观模式 代码示例



    I . 外观模式概念



    1 . 外观模式概念 :


    ① 设计模式类型 : 结构型 ;

    ② 标准定义 : 提供一个统一接口 , 用于访问子系统中的一群接口 ;

    ③ 隐藏复杂性目的 : 定义高层级接口 , 让子系统更容易使用 , 目的是隐藏系统的复杂性 ;

    ④ 交互流程 : 多个子系统联合完成一个操作 , 提供一个统一的接口 , 供客户端调用 , 客户端不与每个子系统进行复杂的交互 , 客户端只与提供接口的外观类进行交互 ;


    2 . 外观模式的相关角色 :


    ① 外观角色 : 外观类有自己的方法 , 用户可以通过调用外观类的方法 , 调用子系统提供的功能 ;

    ② 子系统角色 : 可以是若干个处理模块 , 数量 1 个或多个 ;

    ③ 用户角色 : 用户通过外观类调用子系统的功能 ;



    II . 外观模式 适用场景



    外观模式适用场景 :

    ① 子系统复杂 : 子系统复杂 , 通过使用外观模式可以简化调用接口 ;

    ② 层次复杂 : 系统结构层次复杂 , 每个层级都一个使用外观对象作为该层入口 , 可以简化层次间的调用接口 ;



    III . 外观模式 优缺点



    1 . 外观模式优点 :


    ① 简化调用 : 简化复杂系统的调用过程 , 无需对子系统进行深入了解 , 即可完成调用 ;

    ② 降低耦合 : 使用外观模式 , 只与外观对象进行交互 , 不与复杂的子系统直接进行交互 , 降低了系统间的依赖 , 使耦合关系更低 ; 子系统内部的模块更容易扩展和维护 ;

    ③ 层次控制 : 层次结构复杂的系统 , 有些方法需要提供给系统外部调用 , 有些方法需要在内部使用 , 将提供给外部的功能定义在外观类中 , 这样既方便调用 , 也能将系统内部的细节隐藏起来 ;

    ④ 符合迪米特法则 : 最少知道原则 , 用户不需要了解子系统内部的情况 , 也不需要与子系统进行交互 , 只与外观类进行交互 ; 降低了应用层与子系统之间的耦合度 ;


    2 . 外观模式缺点 :


    ① 子系统扩展风险 : 系统内部扩展子系统时 , 容易产生风险 ;

    ② 不符合开闭原则 : 外观模式 , 扩展子系统时 , 不符合开闭原则 ;



    IV . 外观模式与其它设计模式的联系与区别



    1 . 外观模式与中介者模式 :


    ① 外观模式 : 外观模式关注外部用户与子系统之间的交互 ;

    ② 中介者模式 : 中介者模式关注子系统内部之间的交互 ;


    2 . 外观模式与单例模式 : 外观类一般会被定义成单例类 ;


    3 . 外观模式 与 抽象工厂模式 : 外观类中 , 使用抽象工厂模式 , 获取子系统的实例对象 , 子系统内部可以屏蔽外观类 ;



    V . 外观模式 代码示例



    1 . 需求描述 : 实现一个购买商品的功能 , 用户提出购买某件商品 , 首先要查看库存 , 然后付款 , 最后物流发货 ;


    ① 用户与子系统直接交互 : 首先要与仓储子系统交互检查是否有库存 , 然后与支付子系统交互支付货款 , 最后进入物流子系统获取物流编号 ; 使用这种交互方式 , 导致用户与子系统耦合度太高 ;

    ② 引入外观类 : 将与仓储子系统 , 支付子系统 , 物流子系统之间的交互统一交给外观类进行处理 , 用户只需要与外观类对象进行交互 , 这样大大减少了用户与多个子系统之间的耦合度 ;


    2 . 多个子系统代码示例 : 三个子系统分别处理各自业务 ;


    ① 仓储子系统代码 :

    package kim.hsl.design.facade;
    
    /**
     * 仓库子系统
     * 查询是否有库存
     */
    public class StoreService {
        public boolean isStokeAvailable(Goods goods){
            System.out.println("校验是否有库存 : " + goods.toString() + " 有库存");
            return true;
        }
    }
    

    ② 支付子系统代码 :

    package kim.hsl.design.facade;
    
    /**
     * 支付子系统
     * 支付成功返回 true
     */
    public class PaymentService {
        public boolean pay(Goods goods){
            System.out.println("使用银联支付");
            return true;
        }
    }
    

    ③ 物流子系统代码 :

    package kim.hsl.design.facade;
    
    /**
     * 物流子系统
     * 进入发货流程 , 返回物流编号
     */
    public class LogisticsService {
        public String logistics(Goods goods){
            String logisticsNo = "31415926";
            System.out.println(goods + " 进入物流系统 , 运单号为 " + logisticsNo);
            return logisticsNo;
        }
    }
    

    3 . 外观类代码 : 外观类中维护三个子系统模块 , 用户通过 buyGoods 方法 , 作为与三个子系统之间的交互接口 ;

    package kim.hsl.design.facade;
    
    /**
     * 用户购买的统一接口
     * 用户只需要与该类进行交互
     * 该类统一处理 仓储 支付 物流 等购买流程
     */
    public class BuyFacade {
        private LogisticsService logisticsService;
        private PaymentService paymentService;
        private StoreService storeService;
    
        public BuyFacade() {
            storeService = new StoreService();
            paymentService = new PaymentService();
            logisticsService = new LogisticsService();
        }
    
        /**
         * 外观类提供的访问内部三个子系统的接口
         * 客户端只需要调用该方法 , 即可完整商品购买流程
         * @param goods
         */
        public void buyGoods(Goods goods){
            if(storeService.isStokeAvailable(goods)){
                if(paymentService.pay(goods)){
                    logisticsService.logistics(goods);
                }
            }
        }
    }
    

    4 . 商品类代码 :

    package kim.hsl.design.facade;
    
    /**
     * 商品
     */
    public class Goods {
        private String name;
        public Goods(String name) {
            this.name = name;
        }
        @Override
        public String toString() {
            return "Goods{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    

    5 . 测试函数入口代码 :

    package kim.hsl.design.facade;
    
    public class Main {
        public static void main(String[] args) {
            Goods goods = new Goods("肥皂");
            BuyFacade buyFacade = new BuyFacade();
            buyFacade.buyGoods(goods);
        }
    }
    

    6 . 最终执行结果 :

    校验是否有库存 : Goods{name='肥皂'} 有库存
    使用银联支付
    Goods{name='肥皂'} 进入物流系统 , 运单号为 31415926
    
    展开全文
  • 三级模式指的是模式、模式和内模式。 两级映射指的是模式-模式映射 和 模式-内模式映射。 文章目录一、模式(Schema)二、模式(External Schema)三、内模式(Internal Schema)工作原理 一、模式(Schema...
  • 外观模式

    千次阅读 2019-09-25 20:40:22
    外观模式(Facade Pattern)隐藏系统的复杂性,并向客户端提供了一个客户端可以访问系统...意图:为系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一系统更加容易使用。 主要...
  • 模式又叫子模式或用户模式,对应用户级,用户能看到的数据库视图,跟具体的程序或项目有关,可用DML来操作。 概念模式: 概念又叫模式,对应概念级,所有用户的公共视图(全局视图),可用数据定义语言DDL来定义...
  • 设计模式 - 外观模式

    千次阅读 热门讨论 2022-04-16 21:09:38
    从客户程序的角度来看,Facade模式不仅简化了整个组件系统的接口,同时对于组件内部与外部客户程序来说,从某种程度上也达到了一种“解耦”的效果——内部系统的任何变化不会影响到Façade接口的变化
  • 模式又称子模式或用户模式,对应于用户级。它是某个或某几个用户所看到的数据库的数据视图,是与某一应用有关的数据的逻辑表示。模式是从模式导出的一个子集,包含模式中允许特定用户使用的那部分数据。用户可以...
  • 设计模式——外观模式

    千次阅读 2018-04-06 17:33:15
    外观模式,是一种把系统客户端做松耦合操作的一个设计模式。这样客户端调用系统,根本不需要知道系统内部是如何操作的,只需要调用外部“接待员”即可,所以即使系统有变化时,也不需要客户端做改变,达到松...
  • 浅谈数据库三大模式:模式、概念模式和内模式

    万次阅读 多人点赞 2019-09-17 09:45:56
    对应数据库的升级、模式包括(子模式 用户模式) 用来描述用户看到或者使用那部分的数据的逻辑结构,用户根据模式用户数据操作语句或者程序去操作数据库中的数据,模式的主要特点用来描述组成用户视图各个记录...
  • 中介者模式和外观模式的区别

    千次阅读 2018-12-24 11:33:29
    对于中介者模式和外观模式或许有一定的了解,但是他们因为太过相似而难以分别,今天就总结一下,给自己深刻的理解; 外观模式定义:为系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,这个接口...
  • JAVA设计模式--外观模式

    万次阅读 2017-02-12 23:37:41
    四、外观模式和中介者模式 五、外观模式的优缺点 六、总结 一、什么是外观式 外观(Facade)模式是一种对象的结构型模式。为系统中的一组接口提供一个一致的界面, Facade模式定义了一个高层接口,这个接口使得...
  • C++ 外观模式

    千次阅读 2017-04-27 12:59:21
    Façade 为系统中的一组接口提供了一个统一的高层接口,该接口使得系统更加容易使用。 简述 模式结构 优缺点 适用场景 案例分析 代码实现 版权所有:一去丶二三里,转载请注明出处:...
  • 设计模式-外观模式(家庭影院你值得拥有)

    千次阅读 多人点赞 2021-03-18 12:17:15
    外观模式系统的一组接口提供了一个一致的界面,此模式定义了一个高层接口,这个接口使得这一系统更加容易使用。外观模式可以理解为转换一群接口,客户只要调用这一个接口而不用调用多个接口才能达到目的,也不...
  • 设计模式之外观模式

    千次阅读 2020-09-14 20:38:24
    它为系统中的一组接口提供了一个一致的界面,此模式定义了一个高层接口,这个接口使得这一系统更加容易使用。 外模模式通过定义一个一致的接口,用以屏蔽内部系统的细节,使得调用只需跟这个高层接口发生调用...
  • 设计模式 | 外观模式及典型应用

    万次阅读 多人点赞 2018-09-16 20:59:32
    前言 本文的主要内容: ...外观模式是一种使用频率非常高的结构型设计模式,它通过引入一个外观角色来简化客户端与系统之间的交互,为复杂的系统调用提供一个统一的入口,降低系统与客户...
  • 设计模式专题 - 外观模式

    千次阅读 2019-06-13 18:11:17
    系统中的一组接口提供了一个统一的访问接口,这个接口使得系统更容易被访问或者使用。堪称最简单的设计模式之一! 2. 外观模式应用场景 简单来说,该模式就是把一些复杂的流程封装成一个接口供给外部用户...
  • Java 设计模式——外观模式

    千次阅读 2016-06-06 00:11:17
    今天要说的外观模式是一个相对简单的设计模式,而且在日常的开发中,可能你也会时常使用它,只是你可能并未想过这是一个设计模式。本文会从一些实例着手,来对本文要说明的外观模式进行尽可能全面的讲解。希望于你...
  • Java常见设计模式总结

    万次阅读 多人点赞 2021-09-18 17:18:54
    设计模式是一套经过反复使用的代码设计经验,目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的,它使得代码编写真正工程化,它是软件工程的基石,如同大厦的一块块...
  • 设计模式之外观模式(结构型)

    千次阅读 2019-03-01 00:08:17
    外观模式:外观模式就是提供一个统一的接口,用来访问系统的一群接口。外观模式定义了一个高层接口,让系统更容易使用。,外观模式也称门户模式,是一种对象结构型设计模式。 二、模式角色 从模式定义可以知道...
  • 数据库的模式,内模式外模式

    千次阅读 2021-04-11 17:23:16
    一. 模式 ...模式(/子模式/用户模式):用户可以操作的视图,例如具体的数据库表; 一个数据库可以有多个模式; 三. 内模式 内模式(储存模式):数据库的物理结构储存方式,例如底层使用的数
  • Java设计模式之迭代子模式

    万次阅读 多人点赞 2015-04-17 07:26:39
    本文继续介绍23种设计模式系列之观察者模式。定义在软件构建过程中,集合对象内部结构常常变化各异,但对于这些集合对象,我们希望在不暴露其内部结构的同时,可以让外部客户代码透明地...迭代(Iterator)模式又叫游标
  • 中介者模式、代理模式和外观模式的Pk

    万次阅读 多人点赞 2015-02-28 08:34:30
    在学习设计模式的时候,发现这三个模式在一定程度上很是相似。所以总结一下,加以区分。
  • 外观模式(Facade Pattern)隐藏系统的复杂性,并向客户端提供了一个客户端可以访问系统的...意图:为系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一系统更加容易使用。...
  • 设计模式(八)外观模式

    万次阅读 2016-07-25 10:26:25
    当我们开发Android的时候,无论是做SDK还是封装API,我们大多都会用到外观模式,它通过一个外观类使得整个系统的结构只有一个统一的高层接口,这样能降低用户的使用成本。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,386,252
精华内容 554,500
关键字:

外模式和子模式