精华内容
下载资源
问答
  • 定义: 外观模式门面模式,提供了一个统一的接口,用来访问子系统中一群接口。 外观模式定义了一个高层接口,让子系统更容易使用 类型: 结构型 适用场景: 1、子系统越来越复杂,增加外观模式提供简单接口调用 ...

    快速导航

    一、外观模式简介

    二、代码展示

    三、jdk中使用的外观模式

    一、外观模式简介

    定义: 外观模式又叫门面模式,提供了一个统一的接口,用来访问子系统中一群接口。
    外观模式定义了一个高层接口,让子系统更容易使用
    类型: 结构型

    适用场景:

    1、子系统越来越复杂,增加外观模式提供简单接口调用
    2、构建多层系统结构,利用外观对象作为每层的入口,简化层间调用

    优点:
    1、简化了调用过程,无需深入了解子系统,防止带来风险。
    2、减少系统依赖、松散耦合
    3、更好的划分访问层次
    4、符合迪米特法则,即最少知道原则

    缺点:
    1、增加子系统、扩展子系统行为容易引入风险
    2、增加子系统、扩展子系统 不符合开闭原则

    相关设计模式:
    1、外观模式和中介者模式
    2、外观模式和单例模式
    3、外观模式和抽象工厂模式

    二、代码展示

    代码展示的总体思路:
    BuyBookService 是购买图书对外(客户端)提供的统一接口,外部不需要关注买书后具体什么业务逻辑,是BuyBookService 封装了 LogisticsService (物流服务)、IntegralService (积分服务)、OrderService (订单服务),这个就是门面模式。

    /**
     * @program: adpn-pattern->BuyBook
     * @description: 外观模式--对外的暴露的接口
     * @author: Jstar
     * @create: 2019-11-24 17:36
     **/
    public class BuyBookService {
        private LogisticsService logisticsService=new LogisticsService();
        private IntegralService integralService=new IntegralService();
        private OrderService orderService=new OrderService();
    
        public String buyBook(Book book){
            //省略业务逻辑
            String logistics = logisticsService.realLogistics(book);
            integralService.realIntegral(book);
            orderService.realOrder(book);
            System.out.println("购买成功,"+logistics);
            return "success";
        }
    }
    
    /**
     * @program: adpn-pattern->Book
     * @description: 实体书
     * @author: Jstar
     * @create: 2019-11-24 17:40
     **/
    public class Book {
        private String name;
        private String address;
    
        public Book(String name, String address) {
            this.name = name;
            this.address = address;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getAddress() {
            return address;
        }
        public void setAddress(String address) {
            this.address = address;
        }
    }
    
    /**
     * @program: adpn-pattern->LogisticsService
     * @description: 物流服务
     * @author: Jstar
     * @create: 2019-11-24 17:38
     **/
    public class LogisticsService {
        public String realLogistics(Book book){
            //这里省略业务逻辑
            System.out.println(book.getName()+" 物流信息校验成功");
            return "地址为:"+book.getAddress();
        }
    }
    
    /**
     * @program: adpn-pattern->IntegralService
     * @description: 积分服务
     * @author: Jstar
     * @create: 2019-11-24 17:38
     **/
    public class IntegralService {
        public String realIntegral(Book book){
            //这里省略业务逻辑
            System.out.println(book.getName()+" 积分增加50分");
            return "integral success";
        }
    }
    
    /**
     * @program: adpn-pattern->OrderService
     * @description: 订单服务
     * @author: Jstar
     * @create: 2019-11-24 17:37
     **/
    public class OrderService {
        public String realOrder(Book book){
            //这里省略业务逻辑
            System.out.println(book.getName()+" 下单成功");
            return "order success";
        }
    }
    
    /**
     * @program: adpn-pattern->BookTest
     * @description: 测试类
     * @author: Jstar
     * @create: 2019-11-24 17:50
     **/
    public class BookTest {
        public static void main(String[] args) {
            Book book = new Book("平凡的世界", "北京市.海淀区");
            BuyBookService buyBookService = new BuyBookService();
            String flag = buyBookService.buyBook(book);
            System.out.println(flag);
        }
    }
    

    以上类中注释 description 都有说明类的作用,业务逻辑就省略了,只演示外观模式;BuyBookService 是对外暴露的接口。
    来看一下,结构的UML图:

    在这里插入图片描述
    从图中我们可以看出,外界客户端只和 BuyBookService 和 Book 有关联,至于BuyBookService 和其它Service的关联,是不对外暴露的。

    运行结果也如预期所料:
    在这里插入图片描述

    三、jdk中使用的外观模式

    1、JdbcUtils 中封装了 java.sql.Connection的 方法。
    在这里插入图片描述
    下面还有 closeStatement、
    closeResultSet、getResultSetValue 方法都是类似的做法。

    2、Mybatis 中的 Configuration 实例,也有外观模式。
    newMetaObject、newParameterHandler、newResultSetHandler 都是封装了接口,对外提供服务。
    在这里插入图片描述

    3、Tomcat 也用了很多外观模式,像一些带Facade的接口。(RequestFacade 是对 Request进行的封装、ResponseFacade 等)

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 门面模式(Facade Pattern):外部与一个子系统的通信必须通过一个统一的外观对象进行,为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。门面模式又称为...

    门面模式(Facade Pattern):外部与一个子系统的通信必须通过一个统一的外观对象进行,为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。门面模式又称为外观模式,它是一种对象结构型模式。


    其实就是把这些注册的流程封装起来成一个Façade类,然后客户只需要调用这个Façade的request方法则可以去注册那些流程。

    又比如去茶馆喝茶,用户不用自己泡茶,煮热水,直接通知服务员来一壶茶就可以了。

     

    其实我们平时使用最多的就是这种模式,比如我们经常封装一些Util类等等,然后再调用该类实现我们想要的结果。即迪米特法则(多内聚,少耦合)。把所有的过程内聚到一个类上,然后不要跟调用的类太过耦合。只提供该类给调用即可。


    展开全文
  • 外观模式(FACADE),也叫门面模式,属于对象结构型模式,通过为子系统中的一组接口提供一个一致的界面(外观对象)来简化客户端与子系统之间的交互。Facade模式定义了一个高层接口,这个接口为子系统中较一般的设施提供...

    外观模式(FACADE),也叫门面模式,属于对象结构型模式,通过为子系统中的一组接口提供一个一致的界面(外观对象)来简化客户端与子系统之间的交互。Facade模式定义了一个高层接口,这个接口为子系统中较一般的设施提供一个单一而简单的界面,从而使子系统间的通信和相互依赖关系达到最小,并且隔离了客户类和子系统类,降低了两者的耦合度。如下图所示:

    外观模式

    一、使用场景

     1、 当要为访问一系列复杂的子系统提供一个简单入口时。facade类很好的屏蔽了子系统中因不断演化而产生的越来越多的小类,降低访问子系统的复杂性。
     2、 客户端程序与多个子系统之间存在很大的依赖性。引入外观类可以将子系统与客户端解耦,提高子系统的独立性和可移植性。

     3、 当需要构建一个层次结构的子系统时,使用facade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的,则可以让它们仅通过facade进行通讯,从而简化子系统间的依赖关系。

    二、UML图

    门面模式uml图

    三、Java实现

    [java] view plaincopy在CODE上查看代码片派生到我的代码片
    1. package study.patterns.facade;  
    2. /** 
    3.  *  外观模式是一种使用频率非常高的结构型设计模式,它通过引入一个外观角色来简化客户端与子系统之间的交互, 
    4.  *  为复杂的子系统调用提供一个统一的入口,降低子系统与客户端的耦合度,且客户端调用非常方便。 
    5.  *  生活中充满形形色色的外观角色,比如服务员,ATM机等,正因为这些外观角色的存在,生活才更美好! 
    6.  * @author qbg 
    7.  */  
    8. public class FacadePattern {  
    9.     public static void main(String[] args) {  
    10.         IFacade facade = new Facade();  
    11.         facade.method();  
    12.     }  
    13. }  
    14. /** 
    15.  * 外观统一接口,可以根据需要实现相应的外观类. 
    16.  * 面向接口编程。 
    17.  */  
    18. interface IFacade{  
    19.     public void method();  
    20. }  
    21. /** 
    22.  * 外观角色:对外提供的外观类实现,在客户端可以调用它的方法,它知道相关的(一个或者多个)子系统的功能和责任; 
    23.  * 在正常情况下,它将所有从客户端发来的请求委派到相应的子系统去,传递给相应的子系统对象处理。 
    24.  */  
    25. class Facade implements IFacade{  
    26.     private SubSystemA sa = new SubSystemA();  
    27.     private SubSystemB sb = new SubSystemB();  
    28.     private SubSystemC sc = new SubSystemC();  
    29.       
    30.     @Override  
    31.     public void method() {  
    32.         sa.methodA();  
    33.         sb.methodB();  
    34.         sc.methodC();  
    35.     }  
    36.       
    37. }  
    38. /** 
    39.  * 子系统角色:在软件系统中可以有一个或者多个子系统角色,每一个子系统可以不是一个单独的类,而是一个类的集合,它实现子系统的功能; 
    40.  * 每一个子系统都可以被客户端直接调用,或者被外观角色调用,它处理由外观类传过来的请求; 
    41.  * 子系统并不知道外观的存在,对于子系统而言,外观角色仅仅是另外一个客户端而已。 
    42.  */  
    43. class SubSystemA{  
    44.     public void methodA(){  
    45.         System.out.println("子系统A业务处理....");  
    46.     }  
    47. }  
    48. class SubSystemB{  
    49.     public void methodB(){  
    50.         System.out.println("子系统B业务处理....");  
    51.     }  
    52. }  
    53. class SubSystemC{  
    54.     public void methodC(){  
    55.         System.out.println("子系统C业务处理....");  
    56.     }  
    57. }  

    四、模式优缺点

    优点:

    1、 它对客户端屏蔽了子系统组件,减少了客户处理的对象数目,并使得子系统使用起来更加方便。
    2、 它实现了子系统与客户端之间的松耦合关系,这使得子系统的变化不会影响到调用它的客户端,只需要调整外观类即可。
    3、 一个子系统的修改对其他子系统没有任何影响,而且子系统内部变化也不会影响到外观对象。

    4、Facade模式有助于建立层次结构系统,也有助于对对象之间的依赖关系分层。

    5、Facade模式不限制客户使用子系统类,客户可以根据需要在系统易用性和通用性之间加以选择。


    转载于:http://blog.csdn.net/qbg19881206/article/details/18193701

    展开全文
  • 门面模式(Facade Pattern)叫做外观模式,是一种比较常用的封装模式,其定义如下: 要求一个子系统的外部与其内部的通信必须通过一个统一的对象 进行。门面模式提供一个高层次的接口,使得子系统更易于使用。 ...
    1、门面模式的定义:

    门面模式(Facade Pattern)也叫做外观模式,是一种比较常用的封装模式,其定义如下:  要求一个子系统的外部与其内部的通信必须通过一个统一的对象

    进行。门面模式提供一个高层次的接口,使得子系统更易于使用。

    2、举例理解(医院的例子)


    解决这种不便的方法便是引进门面模式,医院可以设置一个接待员的位置,由接待员负责代为挂号、划价、缴费、取药等。这个接待员就是门面模式的体现,病人只接触接待员,由接待员与各个部门打交道。

    3、门面模式的结构


    在这个对象图中,出现了两个角色:


      ●  门面(Facade)角色 :客户端可以调用这个角色的方法。此角色知晓相关的(一个或者多个)子系统的功能和责任。在正常情况下,本角色会将所有

    从客户端发来的请求委派到相应的子系统去。


      ●  子系统(SubSystem)角色 :可以同时有一个或者多个子系统。每个子系统都不是一个单独的类,而是一个类的集合(如上面的子系统就是由

    ModuleA、ModuleB、ModuleC三个类组合而成)。每个子系统都可以被客户端直接调用,或者被门面角色调用。子系统并不知道门面的存在,对于子系统

    而言,门面仅仅是另外一个客户端而已。外观模式中所指的子系统是一个广义的概念,它可以是一个类、一个功能模块、系统的一个组成部分或者一个完整的

    系统。子系统类通常是一些业务类,实现了一些具体的、独立的业务功能


    4、通用代码如下
    子系统

    public class ModuleA {  
        //示意方法  
        public void testA(){  
            System.out.println("调用ModuleA中的testA方法");  
        }  
    } 
    public class ModuleB {  
        //示意方法  
        public void testB(){  
            System.out.println("调用ModuleB中的testB方法");  
        }  
    }  
    public class ModuleC {  
        //示意方法  
        public void testC(){  
            System.out.println("调用ModuleC中的testC方法");  
        }  
    }
    门面对象

    public class Facade {  
        //示意方法,满足客户端需要的功能  
        public void test(){  
            ModuleA a = new ModuleA();  
            a.testA();  
            ModuleB b = new ModuleB();  
            b.testB();  
            ModuleC c = new ModuleC();  
            c.testC();  
        }  
    }


    客户端调用

    public class Client {  
      
        public static void main(String[] args) {  
              
            Facade facade = new Facade();  
            facade.test();  
        }  
      
    }
    Facade类其实相当于A、B、C模块的外观界面,有了这个Facade类,那么客户端就不需要亲自调用子系统中的A、B、C模块了,也不需要知道系统内部的实

    现细节,甚至都不需要知道A、B、C模块的存在,客户端只需要跟Facade类交互就好了,从而更好地实现了客户端和子系统中A、B、C模块的解耦,让客户

    端更容易地使用系统。


    5、门面模式的实现

    使用门面模式还有一个附带的好处,就是能够有选择性地暴露方法。一个模块中定义的方法可以分成两部分,一部分是给子系统外部使用的,一部分是子系统

    内部模块之间相互调用时使用的。有了Facade类,那么用于子系统内部模块之间相互调用的方法就不用暴露给子系统外部了。

      比如,定义如下A、B、C模块。


    public class Module A{  
        /** 
         * 提供给子系统外部使用的方法 
         */  
        public void a1(){};  
          
        /** 
         * 子系统内部模块之间相互调用时使用的方法 
         */  
        private void a2(){};  
        private void a3(){};  
    }
    public class ModuleB {  
        /** 
         * 提供给子系统外部使用的方法 
         */  
        public void b1(){};  
          
        /** 
         * 子系统内部模块之间相互调用时使用的方法 
         */  
        private void b2(){};  
        private void b3(){};  
    }
    public class ModuleC {  
        /** 
         * 提供给子系统外部使用的方法 
         */  
        public void c1(){};  
          
        /** 
         * 子系统内部模块之间相互调用时使用的方法 
         */  
        private void c2(){};  
        private void c3(){};  
    }

    public class ModuleFacade {  
          
        ModuleA a = new ModuleA();  
        ModuleB b = new ModuleB();  
        ModuleC c = new ModuleC();  
        /** 
         * 下面这些是A、B、C模块对子系统外部提供的方法 
         */  
        public void a1(){  
            a.a1();  
        }  
        public void b1(){  
            b.b1();  
        }  
        public void c1(){  
            c.c1();  
        }  
    }
    这样定义一个ModuleFacade类可以有效地屏蔽内部的细节,免得客户端去调用Module类时,发现一些不需要它知道的方法。比如a2()和a3()方法就不需要让

    客户端知道,否则既暴露了内部的细节,又让客户端迷惑。对客户端来说,他可能还要去思考a2()、a3()方法用来干什么呢?其实a2()和a3()方法是内部模块

    之间交互的,原本就不是对子系统外部的,所以干脆就不要让客户端知道。


    6、门面模式的优点


    ● 减少系统的相互依赖
    想想看,如果我们不使用门面模式,外界访问直接深入到子系统内部,相互之间是一种强耦合关系,你死我就死,你活我才能活,这样的强依赖是系统设计所不能接受的,门面模式的出现就很好地解决了该问题,所有的依赖都是对门面对象的依赖,与子系统无关。


    ● 提高了灵活性
    依赖减少了,灵活性自然提高了。不管子系统内部如何变化,只要不影响到门面对象,任你自由活动。


    ● 提高安全性
    想让你访问子系统的哪些业务就开通哪些逻辑,不在门面上开通的方法,你休想访问到。

    7、门面模式的缺点


    门面模式最大的缺点就是不符合开闭原则,对修改关闭,对扩展开放。

    8、需要注意的几点

    (1)一个系统可以有几个门面类
      在门面模式中,通常只需要一个门面类,并且此门面类只有一个实例,换言之它是一个单例类。当然这并不意味着在整个系统里只有一个门面类,而

    仅 是说对每一个子系统只有一个门面类。或者说,如果一个系统有好几个子系统的话,每一个子系统都有一个门面类,整个系统可以有数个门面类。



    (2)为子系统增加新行为
      初学者往往以为通过继承一个门面类便可在子系统中加入新的行为,这是错误的。门面模式的用意是为子系统提供一个集中化和简化的沟通管道,而不能

    向子系统加入新的行为。比如医院中的接待员并不是医护人员,接待员并不能为病人提供医疗服务。()

    (3)外观模式与迪米特法则 
    外观模式创造出一个外观对象,将客户端所涉及的属于一个子系统的协作伙伴的数量减到最少,使得客户端与子系统内部的对象的相互作用被外观对象所取

    代。外观类充当了客户类与子系统类之间的“第三者”,降低了客户类与子系统类之间的耦合度,外观模式就是实现代码重构以便达到“迪米特法则”要求的一个

    强有力的武器。 

    (4)抽象外观类的引入 
    外观模式最大的缺点在于违背了“开闭原则”,当增加新的子系统或者移除子系统时需要修改外观类,可以通过引入抽象外观类在一定程度上解决该问题,客户

    端针对抽象外观类进行编程。对于新的业务需求,不修改原有外观类,而对应增加一个新的具体外观类,由新的具体外观类来关联新的子系统对象,同时通过

    修改配置文件来达到不修改源代码并更换外观类的目的。


    9、模式适用场景
           在以下情况下可以考虑使用外观模式:
           (1) 当要为访问一系列复杂的子系统提供一个简单入口时可以使用外观模式。
           (2) 客户端程序与多个子系统之间存在很大的依赖性。引入外观类可以将子系统与客户端解耦,从而提高子系统的独立性和可移植性。
           (3) 在层次化结构中,可以使用外观模式定义系统中每一层的入口,层与层之间不直接产生联系,而通过外观类建立联系,降低层之间的耦合度。


    10、实例程序

    假设有一个登录系统,与数据库有关的操作相当于子系统,登录界面则相当于客户端,我们在中间使用一个统一的对象,即门面来使两者不直接产生交互。

    客户端类Login.java

    /* 
     * 功能:学生成绩管理系统 
     * 步骤1、登录界面的静态实现 
     * 步骤2:实现界面的切换 
     * 步骤3:使用数据库来验证用户名和密码 
     * 步骤4:对代码进行优化。增加专门用来与数据库进行连接的类 
     * 步骤5:优化代码,增加判断条件。 
     * 步骤6:使用数据库进行查询时,优化查询方法和判断条件。数据库的表中可有多个数据。引入不同的表来查询。 
     * author:ywq 
     */  
    package facade_test;  
    import javax.swing.*;  
    import java.awt.*;  
    import java.awt.event.ActionEvent;  
    import java.awt.event.ActionListener;  
      
      
    public class Login6 extends JFrame implements ActionListener {  
      
        //定义登录界面的组件  
        JButton jb1,jb2,jb3=null;  
        JRadioButton jrb1,jrb2=null;  
        JPanel jp1,jp2,jp3,jp4=null;  
        JTextField jtf=null;  
        JLabel jlb1,jlb2,jlb3=null;  
        JPasswordField jpf=null;  
        ButtonGroup bg=null;      
          
        //菜单项  
        JMenuBar jmb=null;    
        JMenu jm=null;  
        JMenuItem jmi1,jmi2=null;  
          
        Facade fcd=new Facade();  
          
        //从数据库取得的密码pwd  
        String pwd=null;  
          
          
        public static void main(String[] args) {  
            // TODO Auto-generated method stub  
            Login6  ms=new Login6();  
              
                              
        }  
        //构造函数  
        public Login6()  
        {  
             //创建组件  
            jb1=new JButton("登录");  
            jb2=new JButton("重置");  
            jb3=new JButton("退出");  
            //设置监听  
            jb1.addActionListener(this);  
            jb2.addActionListener(this);  
            jb3.addActionListener(this);  
              
            jmb=new JMenuBar(); //JMenuBar指菜单栏  
            jm=new JMenu("选项"); //JMenu是菜单栏中的选项栏  
            jmi1=new JMenuItem("开始"); //JMenuItem指选项栏中的选项  
            jmi2=new JMenuItem("退出系统");  
            jm.add(jmi1);  
            jm.add(jmi2);  
            jmb.add(jm);  
              
              
            jrb1=new JRadioButton("教师",true);  
            jrb2=new JRadioButton("学生");  
            bg=new ButtonGroup();  
            bg.add(jrb1);  
            bg.add(jrb2);  
    //      jrb2.setSelected(true);  
              
            jp1=new JPanel();  
            jp2=new JPanel();  
            jp3=new JPanel();  
            jp4=new JPanel();                 
              
            jlb1=new JLabel("用户名:");  
            jlb2=new JLabel("密    码:");  
            jlb3=new JLabel("权    限:");  
              
            jtf=new JTextField(10);  
            jpf=new JPasswordField(10);  
            //加入到JPanel中  
            jp1.add(jlb1);  
            jp1.add(jtf);  
              
            jp2.add(jlb2);  
            jp2.add(jpf);  
              
            jp3.add(jlb3);  
            jp3.add(jrb1);  
            jp3.add(jrb2);  
              
            jp4.add(jb1);  
            jp4.add(jb2);  
            jp4.add(jb3);  
              
            //加入JFrame中  
            this.setJMenuBar(jmb);  
            this.add(jp1);  
            this.add(jp2);  
            this.add(jp3);  
            this.add(jp4);  
            //设置布局管理器  
            this.setLayout(new GridLayout(4,1));  
            //给窗口设置标题  
            this.setTitle("学生成绩管理系统");  
            //设置窗体大小  
            this.setSize(300,250);  
            //设置窗体初始位置  
            this.setLocation(200, 150);  
            //设置当关闭窗口时,保证JVM也退出  
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
            //显示窗体  
            this.setVisible(true);  
            this.setResizable(true);  
              
        }  
        @Override  
        public void actionPerformed(ActionEvent e) {  
      
            if(e.getActionCommand()=="退出")  
            {  
                System.exit(0);  
            }else if(e.getActionCommand()=="登录")  
            {  
                if(!jtf.getText().isEmpty() && !jpf.getText().isEmpty())  
                {  
                    //当点击登录按钮时,首先与数据库建立连接  
                    fcd.facade_connect();  
      
                    //如果选中教师登录  
                    if(jrb1.isSelected())  
                    {  
                        pwd=fcd.facade_querytea("教师",jtf.getText());  
    //                  System.out.println(pwd);  
      
                        //首先判断是否存在该用户,即是否得到了密码  
                        if(pwd ==null)  
                        {  
                             this.clear();  
                        }else  
                        {  
                            //调用登录方法  
                            this.tealogin();  
                        }  
                    }else if(jrb2.isSelected()) //学生在登录系统  
                    {  
                        pwd=fcd.facade_querystu("学生",jtf.getText());  
      
                        //首先判断是否存在该用户,即是否得到了密码  
                        if(pwd ==null)  
                        {  
                             this.clear();  
                        }else  
                        {  
                            //调用登录方法  
                            this.stulogin();  
                        }  
                         
                    }  
                }else if(jtf.getText().isEmpty())  
                {  
                    JOptionPane.showMessageDialog(null,"请输入用户名","提示消息",JOptionPane.WARNING_MESSAGE);  
                    this.clear();  
                }else if(jpf.getText().isEmpty())     
                {  
                    JOptionPane.showMessageDialog(null,"请输入密码","提示消息",JOptionPane.WARNING_MESSAGE);  
                    this.clear();  
                }  
            }else if(e.getActionCommand()=="重置")  
            {  
                this.clear();  
            }             
              
        }  
                      
            //清空文本框和密码框  
        public  void clear()  
            {  
                jtf.setText("");  
                jpf.setText("");  
            }  
                //学生登录判断方法  
                public void stulogin()  
                {  
                    if(pwd.equals(jpf.getText()))  
                    {  
    //                  System.out.println("登录成功");  
                        JOptionPane.showMessageDialog(null,"登录成功!","提示消息",JOptionPane.WARNING_MESSAGE);  
                        this.clear();  
                        //关闭当前界面  
                         dispose();  
                         //创建一个新界面  
    //                   Stu_UI6 ui=new Stu_UI6();  
                    }else if(jtf.getText().isEmpty()&&jpf.getText().isEmpty())  
                    {  
                        JOptionPane.showMessageDialog(null,"请输入用户名和密码!","提示消息",JOptionPane.WARNING_MESSAGE);  
                    }else if(jtf.getText().isEmpty())  
                    {  
                        JOptionPane.showMessageDialog(null,"请输入用户名!","提示消息",JOptionPane.WARNING_MESSAGE);  
                    }else if(jpf.getText().isEmpty())  
                    {  
                        JOptionPane.showMessageDialog(null,"请输入密码!","提示消息",JOptionPane.WARNING_MESSAGE);  
                    }else  
                    {  
                        JOptionPane.showMessageDialog(null,"用户名或者密码错误!\n请重新输入","提示消息",JOptionPane.ERROR_MESSAGE);  
                        //清空输入框  
                        this.clear();  
                    }  
                }  
                  
                //教师登录判断方法  
                public void tealogin()  
                {  
                    if(pwd.equals(jpf.getText()))  
                    {  
    //                  System.out.println("登录成功");  
                         JOptionPane.showMessageDialog(null,"登录成功!","提示消息",JOptionPane.WARNING_MESSAGE);  
                         this.clear();    
                        //关闭当前界面  
                         dispose();  
                         //创建一个新界面,适用于教师来管理学生  
    //                  Teacher6 t=new Teacher6();                                    
                    }else if(jtf.getText().isEmpty()&&jpf.getText().isEmpty())  
                    {  
                        JOptionPane.showMessageDialog(null,"请输入用户名和密码!","提示消息",JOptionPane.WARNING_MESSAGE);  
                    }else if(jtf.getText().isEmpty())  
                    {  
                        JOptionPane.showMessageDialog(null,"请输入用户名!","提示消息",JOptionPane.WARNING_MESSAGE);  
                    }else if(jpf.getText().isEmpty())  
                    {  
                        JOptionPane.showMessageDialog(null,"请输入密码!","提示消息",JOptionPane.WARNING_MESSAGE);  
                    }else  
                    {  
                        JOptionPane.showMessageDialog(null,"用户名或者密码错误!\n请重新输入","提示消息",JOptionPane.ERROR_MESSAGE);  
                        //清空输入框  
                        this.clear();  
                    }  
                }  
              
    }     

    数据库类如下:

    /* 
     * 功能:用来和数据库SQLserver进行连接,以及相应的查询方法。 
     */  
    package facade_test;  
      
    import java.sql.Connection;  
    import java.sql.DriverManager;  
    import java.sql.PreparedStatement;  
    import java.sql.ResultSet;  
    import java.sql.SQLException;  
      
    import javax.swing.JOptionPane;  
      
    //写一个类,用来与数据库建立连接,并且查询数据  
    public class GetSQL {  
        // 设定用户名和密码  
        String userword;  
        String pwd;  
      
        Connection ct = null;  
        PreparedStatement ps = null;  
        ResultSet rs = null;  
      
        // 用于连接数据库的方法,可用于子类的继承  
        public void ConnectSQL() {  
            try {  
                Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");  
                ct = DriverManager.getConnection("jdbc:odbc:ywq");  
                System.out.println("The SQL is connected");  
            } catch (Exception e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
      
        }  
      
        // 用于向数据库进行查询的方法  
        public String querystu(String s,String username) {  
            // 创建火箭车  
            try {  
                ps = ct.prepareStatement("select * from info where 权限=? and 用户名=? ");  
                // 给?赋值(可防止SQL注入漏洞问题),不要直接使用拼接的方式  
                ps.setString(1, s);  
                ps.setString(2, username);  
                // ResultSet结果集,大家可以把ResultSet理解成返回一张表行的结果集  
                rs = ps.executeQuery();  
                // 循环取出  
                if (rs.next()) {  
                    // 将教师的用户名和密码取出  
                    userword = rs.getString(2);  
                    pwd = rs.getString(3);  
                    System.out.println("成功获取到密码和用户名from数据库");  
                    System.out.println(userword + "\t" + pwd + "\t");  
                      
                    //调用登录方法  
                  
                }else  
                {  
                    JOptionPane.showMessageDialog(null, "没有此用户,请重新输入!", "提示消息", JOptionPane.WARNING_MESSAGE);  
                      
                }  
            } catch (Exception e1) {  
                // TODO Auto-generated catch block  
                e1.printStackTrace();  
            }  
            return pwd;  
        }  
        //在教师表中进行查询  
        public String querytea(String s,String name ) {  
            // 创建火箭车  
            try {  
                ps = ct.prepareStatement("select * from info_tea where 权限=? and 用户名=? ");  
                // 给?赋值(可防止SQL注入漏洞问题),不要直接使用拼接的方式  
                ps.setString(1, s);  
                ps.setString(2, name);  
                // ResultSet结果集,大家可以把ResultSet理解成返回一张表行的结果集  
                rs = ps.executeQuery();  
                // 循环取出  
                if (rs.next()) {  
                    // 将教师的用户名和密码取出  
                    userword = rs.getString(2);  
                    pwd = rs.getString(3);  
                    System.out.println("成功获取到密码和用户名from数据库");  
                    System.out.println(userword + "\t" + pwd + "\t");  
                }else  
                {  
                    JOptionPane.showMessageDialog(null, "没有此用户,请重新输入!", "提示消息", JOptionPane.WARNING_MESSAGE);  
                }  
            } catch (Exception e1) {  
                // TODO Auto-generated catch block  
                e1.printStackTrace();  
            }  
            return pwd;  
        }  
    }

    统一的对象即门面类如下:

    package facade_test;  
    /* 
     * 门面模式,将操作数据库的类与其它客户端分开,不直接发生关系。 
     */  
    public class Facade {  
          
        String pwd=null;  
          
        private GetSQL Sql=new GetSQL();  
          
        public void  facade_connect(){  
              
            Sql.ConnectSQL();  
        }  
          
        public String facade_querytea(String s,String name){  
              
            pwd=Sql.querytea(s, name);  
              
            return pwd;  
              
      
        }  
          
        public String facade_querystu(String s,String username){  
              
            pwd=Sql.querystu(s, username);  
              
            return pwd;  
              
          
        }  
      
          
    }


    本文参考链接:http://blog.csdn.net/qq_25827845/article/details/52032536

                                  http://langgufu.iteye.com/blog/2086884

                                http://blog.csdn.net/jason0539/article/details/22775311


    展开全文
  • 外观模式

    2019-09-22 15:39:06
    外观模式也叫过程模式。外观模式通常定义一个一致的接口,用于屏蔽内部子系统的细节,使得调用端只需跟这个接口发行调用,而无需关心这个子系统的内部细节。 二、外观模式原理 外观模式原理类图如下所示: ...
  • 门面模式也叫外观模式。 模式特点 门面模式包含两个角色: Facade:门面 SubSystem:子系统 优点 统一入口,客户端不需要了解系统细节,操作简单 降低了子系统与客户之间的耦合关系,子系统...
  • 前段时间,牛市很牛有部分股民大赚,但80%的股民还是亏损;估计有好多怕是新股民。其实主要还是对这个股市了解的太少,瞎掺合。大家都知道基金相对股市来说,...好了扯了这么多,我们引入需要探讨的设计模式---外观模式
  • 设计模式-外观模式

    2021-03-17 14:32:54
    外观模式也叫门面模式,它只涉及单一的类,即对外提供一个接口类,适用方无须知道具体实现,通常封装的工具类、mvc模式的controller等都是门面模式的应用。该模式符合迪米特法则。属于结构型模式。 ...
  • Java外观模式(门面模式Facade)

    千次阅读 2019-03-15 11:45:07
      外观模式也叫门面模式,是开发过程中使用频率非常高的一种设计模式,但非常容易理解。 概念介绍   外观模式(Facade),他隐藏了系统的复杂性,并向客户端提供了一个可以访问系统的接口。这种类型的设计模式...
  • 设计模式之–外观模式 ...  外观模式也叫门面模式是结构型设计模式之一. 是我们常用写用来写一些简单工具类的常用做法. 可能我们用了都不知道.就是通过一个我们自己写的外观类去调用另外一些类的...
  • 设计模式---外观模式

    2020-02-12 15:53:17
    外观模式也叫过程模式,外观模式为子系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,这个接口使得这一字系统更加容易使用 外观模式通过定义一个一致的接口,用以屏蔽内部子系统的细节,使得调用端...
  • 外观模式也叫门面模式。 考虑这样一个业务场景,商城里面有积分兑换功能,比如1000积分可以兑换一个键盘等。这里可以拆分出三个子系统,积分数量和礼物库存校验子系统,积分支付子系统,物流子系统。 //创建积分...
  • 简单的讲门面模式(也叫外观模式)要求一个子系统的外部与其内部的通信必须通过一个统一的门面(Facade)对象进行。门面模式提供一个高层次的接口,使得子系统更易于使用。 也就相当于我们配机的第二个方案。 当然...
  • 外观模式也叫门面模式。 通常我们对API进行封装,都会用到外观模式,只是我们可能不知道而已。外观模式通过一个外观类使得整个系统的结构只有一个统一的高层接口,这样能降低用户的使用成本。 3.UML类图 角色...
  • 建造者模式也是创建型模式的一种。同工厂模式类似,但是简单工厂模式不是23种的一种。 建造者模式 是将一个复杂的对象的构建与他的表示分离,使得同样的构建过程可以创建不同的表示。 建造者应用场景: 去...
  • 结构型模式~外观模式

    2019-06-24 23:40:36
    外观模式也叫门面模式 要求一个子系统的外部与内部的通信必须通过一个统一的对象进行,外观模式提供一个高层次的接口,使得子系统更容易使用 角色: 外观角色:客户端可以调用该角色的方法,该角色知晓相关子...
  • 外观模式也叫门面模式, 它为子系统提供统一入口,封装系统复杂性。如同医院看病,病人需要与挂号,门诊,划价,化验,收费,取药等部门打交道 如同一个子系统客户端和另一个子系统各个类打交道一样,相互耦合处理...
  • 外观模式:外观模式也叫门面模式,为子系统中的一组接口提供一致的界面,facade提供了一高层接口,这个接口使得子系统更容易使用。 特征: 外观模式对外隐藏了子系统的实现细节,减少了客户端对子系统的耦合 外观...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 612
精华内容 244
关键字:

外模式也叫