[网络协议]408面试总结

计算机网络

1.Http和Https的区别

Hyper Text Transfer Protocol Hyper Text Transfer Protocol over SecureSocket Layer

HTTPS和HTTP的区别主要如下：

Https协议不是一种新的协议，它就是Http协议和SSL（现在叫TLS协议）协议组合而成的协议，所以他们的不同就是SSL的作用

1、相比较比http，https协议加上了加密处理（共享密钥加密（公开密钥加密，私有密钥解密）和对称密码加密（加密和解密使用同样的密钥））和认证（第三方机构提供的证书）以及完整性保护（应用层发送数据的时候会附加MAC消息验证码的报文摘要，能够查到报文是否被篡改）。

这三部分是https相对于http的优点，那现在也仍然有很多网站不使用https，使用http协议，原因就是http也有它的优点

? 1、http比https要快，因为https使用ssl协议，它的通信慢，CPU和内存的消耗比较大，所以处理速度也会变慢。单位时间里能处理的请求数量就会变少。所以如果不是一些敏感信息，用http更合适。特别对于一些小网站来说负载太多根本承担不了。

? 2、最后一点就是购买申请证书也是要钱的，用http就可以节约成本。

这就是就是http和https各自的优缺点，也就是他们的区别。

3、http和https用的端口也不一样，前者是80，后者是443。

Certificate Authority

2.前后端如何交互

前后端的交互就是客户端和服务器端以及数据库之间的交互。主要是通过接口实现的。后端给前端提供一个接口，这个接口包括接口的地址，需要的参数，返回的参数和数据。前端可以通过接口地址传递参数。后端得到这个参数之后再和数据库进行交互。之后响应给前端（spring里面通过Model），前端再进行展示。这个过程通过借助Ajax完成，data存放发送请求的数据和返回的数据。

3.三次握手四次挥手

三次握手

参考文章:面试官，不要再问我三次握手和四次挥手 - 知乎 (zhihu.com)

三次握手(Three-way Handshake)就是建立一个TCP连接的时候,需要客户端和服务器端一共发送3个包.

主要作用就是彼此确定双方的接收能力和发送能力是否正常

为什么要三次握手,两次不行嘛?

不行,三次握手他的这个流程是这样.第一次的握手,客户端向服务器端发包,此时服务器端接受到了的话,服务器端就知道了客户端的发送能力没有问题,自己的接受能力没有问题.第二次握手服务器端向客户端发包,客户端接收到的话,客户端就知道了自己和服务器端的发送和接收能力都没有问题.但这时候服务器端是不知道自己的发送能力和客户端的接收能力有没有问题的,所以需要第三次握手.客户端要再发一次包给服务器端.如果这时候服务器端接收到了.证明双方的发送能力和接收能力都没有问题.

四次挥手

SYN

synchronous(建立联机 单词的意思是同步) 反义词 asychronous 异步

ACK

acknowledgement 确认

PSH

push 传送

FIN

finish 完成

4.doGet、doPost

get、post是HTTP协议里面的两种方法（此外还有head、delete）

get、post两种方法有本质上没有区别。

1. 因为，Http的底层是或者说是基于TCP/IP协议。所以Get和Post的能做的事情是一样的。你可以给Get方法加上request body，也可以给post方法在url中加上参数。但是约定俗成，浏览器会限制url的长度，而且服务器针对藏在requestbody中的get方法提交的数据，有时候不进行接收和处理，这就是他们的本质。

所以说完本质后，通常情况下有区别：

1. get只有一个流，提交请求的时候，参数是附在url后面的，大小个数都有限制而且只能是字符串。post方法的参数是使用另外的流进行传递的，并不通过url，所以大小个数都很大，而且可以传递二进制数据，如文件的上传。所以在传输大数据的时候选择post方法。
2. get方法产生一个TCP数据包，而post方法产生两个产生两个TCP数据包。get只需要发送一次就可以header和data发送出去，而post则需要发送两次才能算一次请求成功。所以post发送耗费的时间比较多。也就是说get方法的效率高一点。

doGet（）和doGost（）是servlet中处理get、post方法的

可以在把方法写在doGet中，在doPost中去调用执行，这样无论不管你用哪种方法提交，都会执行。

5.TCP和UDP的区别

• TCP是面向有连接的传输层协议。在发送数据之前，需要在收发主机之间连接一条通信线路。发送数据之后必须进行断开连接的处理（面向有连接就像平常打电话，队方必须接听之后，你才可以真正和他交流，通话结束必须）

• 它可以保证两端通信主机之间的通信可达。

• TCP能够正确处理在传输过程中丢包、传输顺序乱掉等异常情况。

• TCP还可以有效的利用带宽，缓解网络拥堵。

• 缺点就是建立断开连接需要至少7次的收发包，导致网络流量的浪费。

UDP是面向无连接的传输层协议。不需要建立和断开连接。即使接收端不存在，发送端也能发送数据。所以在无连接的状态下，接收端要时常确认是否收到了数据。这种无连接的通信对于一些特殊设备，它是一种非常有效的方法。因为省略了很多繁琐的步骤，易于制作一些低成本的产品，减轻处理负担。

6.OSI 7层协议和TCP/IP 5层协议区别

同一层之间的交互叫做协议。上下层之间之间的交互叫做接口。

OSI开放式系统互联模型，它是早期国际协议标准，并未得到普及，现在都是作为制定协议的原型去参考。而TCP/IP是世界上最广泛应用的通信协议。主要区别有：

• TCP/IP协议具有开发性和实用性。它可以真正的实现通信的技术。而OSI复杂不实用。

• OSI协议只是规定了那一层应该实现什么功能。而TCP/IP协议的每一层都有属于本层的协议，去实现功能。

• TCP/IP协议是5层的，它的应用层包含了OSI协议中的应用层、表现层以及会话层的功能

操作系统

计算机组成原理

数据结构和算法

设计模式

六大原则：

单一职责原则（Single Responsibility Principle）：

There should never be more than one reason for a class to change.

一个类只有一个职责。让职责更加单一。

职责划分清楚，代码维护容易，增加可读性和可维护性

也适用于接口和方法

开闭原则（Open Closed Principle）：

Software entities like classes, modules and functions should be open for extension but closed for modification

对扩展开放，对修改关闭

里氏替换原则（Liskov Substitution Principle）

Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.

所有引用基类的地方必须能透明引用使用其子类的对象

所有基类存在的地方都可以换成子类，程序依然可以正常运行

六大设计原则之里氏替换原则（LSP） - 简书 (jianshu.com)

继承存在缺点：

继承是侵入性的。只要继承，就必须拥有父类的所有属性和方法。

降低代码的灵活性。因为继承的时候，父类对子类会有一种约束

增强了耦合性。当需要对父类的代码进行修改的时候，必须考虑到对子类产生的影响。

里氏替换的针对缺点的解决办法：

子类必须实现父类的抽象方法，不得重写（覆盖）父类的非抽象方法（已实现）方法。

子类中可以增加其特有方法

前置条件（方法的形参）更加宽松，后置条件更加严格

迪米特法则（Law of Demeter）

Talk only to your immediate friends and not to strangers

不跟陌生人说话

两个软件实体无须直接通信，那么就不应该发生相互的调用，可以通过第三方转发调用

降低类之间的耦合度，提高模块的独立性

从依赖者的角度来说，只依赖应该依赖的对象。

从被依赖者的角度说，只暴露应该暴露的方法。

接口隔离原则（Interface Segregation Principle）

Clients should not be forced to depend upon interfaces that they don`t use.

客户端不应该依赖它不需要的接口。
类间的依赖关系应该建立在最小的接口上。

The dependency of one class to another one should depend on the smallest possible.

这个接口是个泛指的概念，不仅仅指Java中的接口还有抽象类。

要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。

依赖倒置原则（Dependence Inversion Principle）

High level modules should not depend upon low level modules. Both should depend upon abstractions.
Abstractions should not depend upon details. Details should depend upon abstractions.

上层模块不应该依赖于底层模块，两者都应该依赖于抽象

抽象不应该依赖于细节，细节应该依赖于抽象

代理模式

proxy：代理

设计模式—代理模式 - Dan_Go - 博客园 (cnblogs.com)

1.给某一个对象提供一个代理对象，

2.并由代理对象控制对原对象的引用。

3.通俗的来讲代理模式就是我们生活中常见的中介。

分类：按照代理创建的时间来分类的话

静态代理：程序员创建的，在运行之前，.class文件就已经被创建了

优点：可以做到在符合开闭原则的情况下对目标对象进行功能扩展

缺点：我们得为每一个服务创建代理类，工作量太大了，不易管理。同时接口一旦发生变化，代理类也得相应的进行修改

动态代理：程序运行时通过反射机制动态创建的。

静态代理例子：

package com.liu.ssm.student.other;

/**
 * 1.这是 买房子 接口
 *
 * @author : 刘可
 * @date : 2021-08-11 08:26
 **/
public interface BuyHouse {
    void buyHouse();
}

package com.liu.ssm.student.other;

/**
 * 2.我要买房，我是 委托类
 *
 * @author : 刘可
 * @date : 2021-08-11 08:29
 **/
public class BuyHouseImpl  implements BuyHouse{
    @Override
    public void buyHouse() {
        System.out.println("我是委托人，我要买房子");
    }
}

package com.liu.ssm.student.other;

/**
 * 3.我是 委托人的代理 我是代理类
 *
 * @author : 刘可
 * @date : 2021-08-11 08:30
 **/
public class BuyHouseProxy implements BuyHouse {

    private BuyHouse buyHouse;

    public BuyHouseProxy(final BuyHouse buyHouse) {
        this.buyHouse = buyHouse;
    }

    @Override
    public void buyHouse() {
        System.out.println("买房前的准备：我先攒够了首付");
        buyHouse.buyHouse();
        System.out.println("买房前的准备：我先攒够了首付");
    }
}

package com.liu.ssm.student.other;

/**
 * 4.这是测试类
 *
 * @author : 刘可
 * @date : 2021-08-11 08:37
 **/
public class ProxyTest {
    public static void main(String[] args) {
        BuyHouse buyHouse = new BuyHouseImpl();
        System.out.println("<=======================>");
        BuyHouseProxy buyHouseProxy = new BuyHouseProxy(buyHouse);
        buyHouseProxy.buyHouse();
    }
}

运行结果：
<=======================>
买房前的准备：我先攒够了首付
我是委托人，我要买房子
买房前的准备：我先攒够了首付

动态代理

在动态代理中，我们不需要手动创建代理类，我们只需要编写一个动态处理器即可。真正的代理对象由jdk在运行的时候为我们动态的创建。

package com.liu.ssm.student.other;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 这是动态代理处理器
 *
 * @author : 刘可
 * @date : 2021-08-12 07:23
 **/
public class DynamicProxyHandler implements InvocationHandler {

    private Object object;

    public DynamicProxyHandler(Object object ){
      this.object=object;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("买房前的准备");
        Object result = method.invoke(object, args);
        System.out.println("买房后的装修");
        return result;
    }


    public static void main(String[] args) {
        BuyHouse buyHouse = new BuyHouseImpl();
        BuyHouse proxyBuyHouse =(BuyHouse) Proxy.newProxyInstance(BuyHouse.class.getClassLoader(), new Class[]{BuyHouse.class}, new DynamicProxyHandler(buyHouse));
        proxyBuyHouse.buyHouse();
    }
}

Proxy.newProxyInstance()的方法接受三个参数

ClassLoader loader：指定目标对象使用的类加载器，获取加载器的方法是固定的

Class<?> interface:指定目标对象实现接口的类型，使用泛型确定类型

InvocationHandler：指定 动态处理器，执行目标对象的方法的时候，会触发事件处理器的方法

相对于静态代理，动态代理大大减少了我们的开发任务，减少了对业务接口的依赖，降低了耦合度。