web设计模式的七大原则是什么

这篇文章主要介绍“web设计模式的七大原则是什么”，在日常操作中，相信很多人在web设计模式的七大原则是什么问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”web设计模式的七大原则是什么”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

创新互联是一家专注于成都网站建设、成都做网站与策划设计,忻府网站建设哪家好?创新互联做网站,专注于网站建设十载,网设计领域的专业建站公司;建站业务涵盖:忻府等地区。忻府做网站价格咨询:18980820575

设计模式的七大原则：
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设计模式的七大原则是什么”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注创新互联网站，小编会继续努力为大家带来更多实用的文章！