web設計模式的七大原則是什么

這篇文章主要介紹“web設計模式的七大原則是什么”，在日常操作中，相信很多人在web設計模式的七大原則是什么問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”web設計模式的七大原則是什么”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

設計模式的七大原則：
1：單一職責原則
    對類來說的，即一個類應該只負責一項職責，如類A負責兩個不同職責：職責1，職責2.
    當職責1需求變更而改變A時，可能造成職責2執行錯誤，所以需要將類A的粒度分解為A1,A2
2：接口隔離原則
    客戶端不應該依賴它不需要的接口，即一個類對另一個類的依賴應該建立在最小的接口上行

    將接口拆分

package com.yuandatou;

public class Segregation1 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        a.depend1(b); //A類通過接口去依賴B類
        a.depend2(b);
        a.depend3(b);
    }


    interface InterFace1 {
        void operation1();
    }
    interface InterFace2 {
        void operation2();

        void operation3();

    }
    interface InterFace3 {
        void operation4();

        void operation5();

    }

   static class B implements InterFace1,InterFace2 {

        @Override
        public void operation1() {
            System.out.println("B實現了operation1");
        }

        @Override
        public void operation2() {
            System.out.println("B實現了operation2");
        }

        @Override
        public void operation3() {
            System.out.println("B實現了operation3");
        }

    
    }


  static   class D implements InterFace1,InterFace3 {

        @Override
        public void operation1() {
            System.out.println("D實現了operation1");
        }

 

        @Override
        public void operation4() {
            System.out.println("D實現了operation4");
        }

        @Override
        public void operation5() {
            System.out.println("D實現了operation5");
        }
    }

   static class A{
        public void depend1(InterFace1 i){
            i.operation1();
        }
        public void depend2(InterFace2 i){
            i.operation2();
        }
        public void depend3(InterFace2 i){
            i.operation3();
        }
    }


   static class C{
        public void depend1(InterFace1 i){
            i.operation1();
        }
        public void depend2(InterFace3 i){
            i.operation4();
        }
        public void depend3(InterFace3 i){
            i.operation5();
        }
    }


}

3：依賴倒轉原則

        1：高層模塊不應該依賴低層模塊，二者都應該依賴其抽象
    2：抽象不應該依賴細節，細節應該依賴抽象
    3：依賴倒轉（倒置）的中心思想是面向接口編程
    4：依賴倒轉原則是基于這樣的設計理念：相當于細節的多變性，抽象的東西要穩定的多。
       以抽象為基礎搭建的架構比以細節為基礎的架構要穩定的多。在java中，抽象指的是接口或抽象類
       ，細節就是具體的實現類。
    5：使用接口或抽象類的目的是制定好規范，而不涉及任何具體的操作，把展現細節的任務交給他們的實現類去完成

package com.yuandatou;

public class Yilaidaozhuan {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
        person.receive(new Weixin());
    }
    interface Ireceiver {
        public String getInfo();
    }
    static class Email implements Ireceiver {
        @Override
        public String getInfo() {
            return "接收到了email消息";
        }
    }
    static class Weixin implements Ireceiver {
        @Override
        public String getInfo() {
            return "接收到了weixin消息";
        }
    }
    static class Person {
        public void receive(Ireceiver i) {
            System.out.println(i.getInfo());
        }
    }


}

4：里氏替換原則
5：開閉原則ocp

        1：開閉原則（Open closed principle）是編程中最基礎，最重要的設計原則
    2：一個軟件實體如類，模塊和函數應該對擴展開放（對提供方），對修改關閉（對使用方）。
    用抽象構建框架，用實現擴展細節。
    3：當軟件需要變化時，盡量通過擴展軟件實體的行為來實現變化，而不是通過修改已經有的代碼來實現變化
    4：編程中遵循其他原則，以及使用設計模式的目的就是遵循開閉原則。

package com.yuandatou;

public class Ocp {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new A());
        graphicEditor.drawShape(new B());
        graphicEditor.drawShape(new C());
    }
}
abstract class Draw {
    abstract void draw();
}

class GraphicEditor {
    public void drawShape(Draw draw) {
        draw.draw();
    }
}
class A extends Draw {
    @Override
    void draw() {
        System.out.println("繪制了一個A圖形");
    }
}
class B extends Draw {
    @Override
    void draw() {
        System.out.println("繪制了一個B圖形");
    }
}
class C extends Draw {
    @Override
    void draw() {
        System.out.println("繪制了一個C圖形");
    }
}

6：迪米特法則
7：合成復用原則

單例模式

簡單工廠模式
     1：簡單工廠模式是屬于創建型模式，是工廠模式的一種。簡單工廠模式是由一個工廠對象決定創建出哪一種產品類的實例。簡單工廠模式是工廠模式家族中最簡單實用的模式。
     2：簡單工廠模式：定義類一個創建對象的類，由這個類來封裝實例化對象的行為
     3：在軟件開發中，當我們會用到大量的創建某種，某類或者某批對象時，就會使用到工廠模式。
 工廠方法模式:
     工廠方法模式：定義了一個創建對象的抽象方法，由子類決定要實例化的類。工廠方法模式將對象的實例化推遲到子類。
     個人理解：就是把幾個簡單工廠模式再封裝一次
 抽象工廠模式
     1：抽象工廠模式：定義了一個interface用于創建或有依賴關系的對象簇，而無需指明具體的類
     2：抽象工廠模式可以將簡單工廠模式和工廠方法模式進行整個。
     3：從設計層面看，抽象工廠模式就是對簡單工廠模式的改進（或者成為進一步的抽象）
     4：將工廠抽象成兩層，AbsFactory（抽象工廠）和具體實現的工廠子類。程序員可以根據創建對象類型使用相應的工廠子類。這樣將單個的簡單工廠變成了工廠簇，更利于代碼的維護和擴展。

原型模式（Prototype Pattern）用于創建重復的對象，同時又能保證性能。它屬于創建型設計模式，它提供了一種創建對象的最佳方法。
這種模式是實現了一個原型接口，該接口用于創建當前對象的克隆。當直接創建對象的代價比較大時，則采用這種模式。例如，一個對象需要在一個高代價的數據庫操作之后被創建。我們可以緩存該對象，在下一個請求時返回它的克隆，在需要的時候更新數據庫，以此來減少數據庫調用。
淺拷貝的介紹：
1：對于屬于類型是基本數據類型的成員變量，淺拷貝會直接進行值傳遞，也就是將該屬性值復制一份給新的對象
2：對于數據類型是引用數據類型的成員變量，比如說成員變量是某個數組，某個類的對象等，那么淺拷貝會進行引用傳遞，也就是只是將該成員變量的引用值（內存地址）復制一份給新的對象。因為實際上兩個對象的該成員變量都指向同一個實例。在這種情況下，在一個對象中修改該成員變量對影響到另一個對象的該成員變量值、
3：前面我們克隆羊就是淺拷貝
4：淺拷貝是使用默認的clone()方法是來實現
 深拷貝基本介紹
 1：復制對象的所有基本數據類型的成員變量值
 2：為所有引用數據類型的成員變量申請存儲空間，并復制每個引用數據類型成員變量所引用額對象，直到該對象可達的所有對象。也就是說，對象進行深拷貝要對整個對象進行拷貝
 深拷貝實現方式1：重新clone方法來實現深拷貝
 深拷貝實現方式2：通過對象序列化實現深拷貝

原型模式在spring的使用

代理模式

個人理解就是一個類實現了一個接口，但是我想通過代理的方式來控制個這個類來實現這個接口，靜態代理的方法就是創建一個代理工廠，也去實現這個接口，然后通過代理工廠的實例來使得被代理的類來實現接口

靜態代理的缺點是被代理和代理工廠都要實現這個接口，一個被代理對象對應一個代理工廠太麻煩，所以使用了動態代理

Cglib代理

靜態代理和JDK搭理模式都要求目標對象是實現一個接口，但是有時候目標對象只是一個單獨的對象，并沒有實現任何的接口，這個時候可使用目標對象子類來實現代理，這就是Cglib代理。

Cglib代理也叫做子類代理，它是在內存中構建一個子類對象從而實現對目標對象功能擴展，有些書也將Cglib代理歸屬到動態代理

Cglib是一個強大的高性能代碼生成包，他可以在運行期擴展JAVA類與實現java接口，它廣泛的被許多AOP的框架使用，例如Spring AOP,實現方法攔截

在AOP編程中如何選擇代理模式：

目標對象需要實現接口，用JDK代理

目標對象不需要實現接口，用Cglib代理

Cglib包的底層是通過使用字節碼處理框架ASM來轉換字節碼并生成新的類

觀察者模式

觀察者模式

當對象間存在一對多關系時，則使用觀察者模式（Observer Pattern）。比如，當一個對象被修改時，則會自動通知依賴它的對象。觀察者模式屬于行為型模式。

介紹

意圖：定義對象間的一種一對多的依賴關系，當一個對象的狀態發生改變時，所有依賴于它的對象都得到通知并被自動更新。

主要解決：一個對象狀態改變給其他對象通知的問題，而且要考慮到易用和低耦合，保證高度的協作。

何時使用：一個對象（目標對象）的狀態發生改變，所有的依賴對象（觀察者對象）都將得到通知，進行廣播通知。

如何解決：使用面向對象技術，可以將這種依賴關系弱化。

關鍵代碼：在抽象類里有一個 ArrayList 存放觀察者們。

應用實例： 1、拍賣的時候，拍賣師觀察最高標價，然后通知給其他競價者競價。 2、西游記里面悟空請求菩薩降服紅孩兒，菩薩灑了一地水招來一個老烏龜，這個烏龜就是觀察者，他觀察菩薩灑水這個動作。

優點： 1、觀察者和被觀察者是抽象耦合的。 2、建立一套觸發機制。

缺點： 1、如果一個被觀察者對象有很多的直接和間接的觀察者的話，將所有的觀察者都通知到會花費很多時間。 2、如果在觀察者和觀察目標之間有循環依賴的話，觀察目標會觸發它們之間進行循環調用，可能導致系統崩潰。 3、觀察者模式沒有相應的機制讓觀察者知道所觀察的目標對象是怎么發生變化的，而僅僅只是知道觀察目標發生了變化。

使用場景：

• 一個抽象模型有兩個方面，其中一個方面依賴于另一個方面。將這些方面封裝在獨立的對象中使它們可以各自獨立地改變和復用。

• 一個對象的改變將導致其他一個或多個對象也發生改變，而不知道具體有多少對象將發生改變，可以降低對象之間的耦合度。

• 一個對象必須通知其他對象，而并不知道這些對象是誰。

• 需要在系統中創建一個觸發鏈，A對象的行為將影響B對象，B對象的行為將影響C對象……，可以使用觀察者模式創建一種鏈式觸發機制。

注意事項： 1、JAVA 中已經有了對觀察者模式的支持類。 2、避免循環引用。 3、如果順序執行，某一觀察者錯誤會導致系統卡殼，一般采用異步方式。

觀察者模式使用三個類 Subject、Observer 和 Client。Subject 對象帶有綁定觀察者到 Client 對象和從 Client 對象解綁觀察者的方法。我們創建 Subject 類、Observer 抽象類和擴展了抽象類 Observer 的實體類。

ObserverPatternDemo，我們的演示類使用 Subject 和實體類對象來演示觀察者模式。

到此，關于“web設計模式的七大原則是什么”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！