3.34 说说 HTTP 中的 referer 头的作用

3.35 说说 HTTP 的方法有哪些

参考回答

GET ： 用于请求访问已经被 URI （统一资源标识符）识别的资源，可以通过 URL 传参给服务器

POST ：用于传输信息给服务器，主要功能与 GET 方法类似，但一般推荐使用 POST 方式。

PUT ： 传输文件，报文主体中包含文件内容，保存到对应 URI 位置。

HEAD ： 获得报文首部，与 GET 方法类似，只是不返回报文主体，一般用于验证 URI 是否有效。

DELETE ：删除文件，与 PUT 方法相反，删除对应 URI 位置的文件。

OPTIONS ：查询相应 URI 支持的 HTTP 方法。

3.36 简述 HTTP 1.0，1.1，2.0 的主要区别

参考回答

http/1.0 :

1. 默认不支持长连接，需要设置 keep-alive 参数指定

2. 强缓存 expired 、协商缓存 last-modified\if-modified-since 有一定的缺陷http 1.1 :

1. 默认长连接 (keep-alive) ， http 请求可以复用 Tcp 连接，但是同一时间只能对应一个 http 请求 (http 请求在一个Tcp 中是串行的 )

2. 增加了强缓存 cache-control 、协商缓存 etag\if-none-match 是对 http/1 缓存的优化http/2.0 :

1. 多路复用，一个 Tcp 中多个 http 请求是并行的 ( 雪碧图、多域名散列等优化手段 http/2 中将变得多余 )

2. 二进制格式编码传输

3. 使用 HPACK 算法做 header 压缩

4. 服务端推送

3.37 说说 HTTP 常见的响应状态码及其含义

参考回答

200 : 从状态码发出的请求被服务器正常处理。

204 : 服务器接收的请求已成功处理，但在返回的响应报文中不含实体的主体部分【即没有内

容】。

206 : 部分的内容（如：客户端进行了范围请求，但是服务器成功执行了这部分的干请求）。

301 : 跳转，代表永久性重定向（请求的资源已被分配了新的 URI ，以后已使用资源，现在设置了

URI ）。

302 : 临时性重定向（请求的资源已经分配了新的 URI ，希望用户本次能够使用新的 URI 来进行访

问。

303 : 由于请求对应的资源存在的另一个 URI （因使用 get 方法，定向获取请求的资源）。

304 : 客户端发送附带条件的请求时，服务器端允许请求访问资源，但因发生请求未满足条件的情

况后，直接返回了 304 。

307 : 临时重定向【该状态码与 302 有着相同的含义】。

400 : 请求报文中存在语法错误（当错误方式时，需修改请求的内容后，再次发送请求）。

401 : 发送的请求需要有通过 HTTP 认证的认证信息。

403 : 对请求资源的访问被服务器拒绝了。

404 : 服务器上无法找到请求的资源。

500 : 服务器端在执行请求时发生了错误。

503 : 服务器暂时处于超负载或者是正在进行停机维护，现在无法处理请求。

答案解析 1XX : 信息类状态码（表示接收请求状态处理）

2XX : 成功状态码（表示请求正常处理完毕）

3XX : 重定向（表示需要进行附加操作，已完成请求）

4XX : 客户端错误（表示服务器无法处理请求）

5XX : 服务器错误状态码（表示服务器处理请求的时候出错）

3.38 说说 GET请求和 POST 请求的区别

参考回答

1. GET 请求在 URL 中传送的参数是有长度限制的，而 POST 没有。

2. GET 比 POST 更不安全，因为 参数直接暴露在 URL 上，所以不能用来传递敏感信息。

3. GET 参数通过 URL 传递， POST 放在 Request body 中。

4. GET 请求参数会被完整保留在浏览器历史记录里 ，而 POST 中的参数 不会被保留 。

5. GET 请求只能进行 url 编码，而 POST 支持多种编码方式 。

6. GET 请求会被浏览器主动 cache ，而 POST 不会，除非手动设置。

7. GET 产生的 URL 地址可以被 Bookmark ，而 POST 不可以。

8. GET 在浏览器回退时是无害的，而 POST 会再次提交请求

3.39 说说 Cookie 和 Session 的关系和区别是什么

参考回答

1. Cookie 与 Session 都是会话的一种方式。它们的典型使用场景比如 “ 购物车 ” ，当你点击下单按钮

时，服务端并不清楚具体用户的具体操作，为了标识并跟踪该用户，了解购物车中有几样物品，服

务端通过为该用户创建 Cookie/Session 来获取这些信息。

2. cookie 数据存放在客户的浏览器上， session 数据放在服务器上。

3. cookie 不是很安全 ，别人可以分析存放在本地的 COOKIE 并进行 COOKIE 欺骗 考虑到安全应当使用session。

4. session 会 在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能 考虑到减轻服务器性能方面，应当使用COOKIE 。

5. 单个 cookie 保存的数据不能超过 4K ，很多浏览器都限制一个站点最多保存 20 个 cookie 。

3.40 简述 HTTPS 的加密与认证过程

参考回答

1. 客户端在浏览器中输入一个 https 网址，然后连接到 server 的 443 端口 采用 https 协议的 server 必须

有一套数字证书（一套公钥和密钥） 首先 server 将证书（公钥）传送到客户端 客户端解析证书，

验证成功，则生成一个随机数（私钥），并用证书将该随机数加密后传回 server server 用密钥解密

后，获得这个随机值，然后将要传输的信息和私钥通过某种算法混合在一起（加密）传到客户端 客户端用之前的生成的随机数（私钥）解密服务器端传来的信息

2. 首先浏览器会从内置的证书列表中索引，找到服务器下发证书对应的机构，如果没有找到，此时就会提示用户该证书是不是由权威机构颁发，是不可信任的。如果查到了对应的机构，则取出该机构颁发的公钥。

用机构的证书公钥解密得到证书的内容和证书签名，内容包括网站的网址、网站的公钥、证书的有

效期等。浏览器会先验证证书签名的合法性。签名通过后，浏览器验证证书记录的网址是否和当前

网址是一致的，不一致会提示用户。如果网址一致会检查证书有效期，证书过期了也会提示用户。

这些都通过认证时，浏览器就可以安全使用证书中的网站公钥了。

2.设计模式

2.1 说说什么是单例设计模式，如何实现

        

参考回答

1. 单例模式定义

保证 一个类仅有一个实例 ，并提 供一个访问它的全局访问点，该实例被所有程序模块共享 。

那么我们就必须保证：

（1） 该类不能被复制。

（ 2 ）该类不能被公开的创造。

那么对于 C++ 来说，它的 构造函数，拷贝构造函数和赋值函数都不能被公开调用 。

2. 单例模式 实现方式

单例模式通常有两种模式，分别为 懒汉式单例 和 饿汉式单例 。两种模式实现方式分别如下：

（1）懒汉式设计模式实现方式（2种）

a. 静态指针 + 用到时初始化

b. 局部静态变量

（2）饿汉式设计模式（2种）

a. 直接定义静态对象

b. 静态指针 + 类外初始化时 new 空间实现

答案解析

1. 懒汉模式

懒汉模式的特点 是 延迟加载， 比如配置文件，采用懒汉式的方法，配置文件的 实例直到用到的时候

才会加载，不到万不得已就不会去实例化类，也就是说在第一次用到类实例的时候才会去实例化 。

以下是懒汉模式实现方式 C++ 代码：

//代码实例（线程不安全）
template<typename T>
class Singleton
{
public:
static T& getInstance()
{
if (!value_)
{
value_ = new T();
}
return *value_;
}
private:
Singleton();
~Singleton();
static T* value_;
};
template<typename T>
T* Singleton<T>::value_ = NULL;

在单线程中，这样的写法是可以正确使用的，但是在多线程中就不行了，该方法是线程不安全的。

a. 假如线程 A 和线程 B, 这两个线程要访问 getInstance 函数，线程 A 进入 getInstance 函数，并检测 if

条件，由于是第一次进入， value 为空， if 条件成立，准备创建对象实例。

b. 但是，线程 A 有可能被 OS 的调度器中断而挂起睡眠，而将控制权交给线程 B 。

c. 线程 B 同样来到 if 条件，发现 value 还是为 NULL ，因为线程 A 还没来得及构造它就已经被中断了。

此时假设线程 B 完成了对象的创建，并顺利的返回。

d. 之后线程 A 被唤醒，继续执行 new 再次创建对象，这样一来，两个线程就构建两个对象实例，这

就破坏了唯一性。另外，还存在内存泄漏的问题，new 出来的东西始终没有释放，下面是一种饿汉式的一种改进。

//代码实例（线程安全）
emplate<typename T>
class Singleton
{
public:
static T& getInstance()
{
if (!value_)
{
value_ = new T();
}
return *value_;
}
private:
class CGarbo
{
public:
~CGarbo()
{
if(Singleton::value_)
delete Singleton::value_;
}
};
static CGarbo Garbo;
Singleton();
~Singleton();
static T* value_;
};
template<typename T>
T* Singleton<T>::value_ = NULL;

在程序运行结束时，系统会调用 Singleton 的静态成员 Garbo 的析构函数，该析构函数会删除单例的

唯一实例。使用这种方法释放单例对象有以下特征：

a. 在单例类内部定义专有的嵌套类；

b. 在单例类内定义私有的专门用于释放的静态成员；

c. 利用程序在结束时析构全局变量的特性，选择最终的释放时机。

（2） 懒汉模式实现二：局部静态变量

//代码实例（线程不安全）
template<typename T>
class Singleton
{
public:
static T& getInstance()
{
static T instance;
return instance;
}
private:
Singleton(){};
Singleton(const Singleton&);
Singleton& operator=(const Singleton&);
};

同样，静态局部变量的实现方式也是线程不安全的。如果存在多个单例对象的析构顺序有依赖时，

可能会出现程序崩溃的危险。对于局部静态对象的也是一样的。因为 static T instance ；语句不是一个原子操作，在第一次被调用时会调用Singleton的构造函数，而如果构造函数里如果有多条初始化语句，则初始化动作可以分解为多步操作，就存在多线程竞争的问题。为什么存在多个单例对象的析构顺序有依赖时，可能会出现程序崩溃的危险？

原因：由于静态成员是在第一次调用函数 GetInstance 时进行初始化，调用构造函数的，因此构造

函数的调用顺序时可以唯一确定了。对于析构函数，我们只知道其调用顺序和构造函数的调用顺序

相反，但是如果几个 Singleton 类的析构函数之间也有依赖关系，而且出现类似单例实例 A 的析构函

数中使用了单例实例 B ，但是程序析构时是先调用实例 B 的析构函数，此时在 A 析构函数中使用 B 时

就可能会崩溃。

//代码实例（线程安全）
#include <string>
#include <iostream>
using namespace std;
class Log
{
public:
static Log* GetInstance()
{
static Log oLog;
return &oLog;
}
void Output(string strLog)
{
cout<<strLog<<(*m_pInt)<<endl;
}
private:
Log():m_pInt(new int(3))
{
}
~Log()
{cout<<"~Log"<<endl;
delete m_pInt;
m_pInt = NULL;
}
int* m_pInt;
};
class Context
{
public:
static Context* GetInstance()
{
static Context oContext;
return &oContext;
}
~Context()
{
Log::GetInstance()->Output(__FUNCTION__);
}
void fun()
{
Log::GetInstance()->Output(__FUNCTION__);
}
private:
Context(){}
Context(const Context& context);
};
int main(int argc, char* argv[])
{
Context::GetInstance()->fun();
return 0;
}

在这个反例中有两个 Singleton: Log 和 Context ， Context 的 fun 和析构函数会调用 Log 来输出一些信

息，结果程序 Crash 掉了，该程序的运行的序列图如下（其中画红框的部分是出问题的部分）：

//代码实例（线程安全）
class Singleton
{
protected:
Singleton(){}
private:
static Singleton* p;
public:
static Singleton* initance();
};
Singleton* Singleton::p = new Singleton;
Singleton* singleton::initance()
{
return p;
}

#include <iostream>
#include <set>
#include <map>
#include <list>
#include <vector>
#include <unordered_map>
using namespace std;
#include <mutex>
#include <thread>

class Singleton
{

public:
    static Singleton *getInstance()
    {

        if (m_instance == nullptr)
        {
            mtx.lock();
            if (m_instance == nullptr)
            {

                m_instance = new Singleton();
            }
            mtx.unlock();
        }
        return m_instance;
    }

    class CGarbo
    {
    public:
        ~CGarbo()
        {
            if (m_instance != nullptr)
            {
                cout << "garbage recycle" << endl;
                delete Singleton::m_instance;
                Singleton::m_instance = nullptr;
            }
        }
    };

    // static CGarbo bo;

private:
    Singleton(){};
    Singleton(const Singleton &t) = delete;
    Singleton &operator=(const Singleton &t) = delete;

    static Singleton *m_instance;
    static mutex mtx;
};

mutex Singleton::mtx;
Singleton *Singleton::m_instance = nullptr;
Singleton::CGarbo bo;

//
class Singleton1
{

public:
    static Singleton1 *getInstance()
    {
        return m_instance;
    }

private:
    Singleton1() {}
    Singleton1(const Singleton1 &t) = delete;
    Singleton1 &operator=(const Singleton1 &t) = delete;
    static Singleton1 *m_instance;
};

Singleton1 *Singleton1::m_instance = new Singleton1;
int main()
{
    // Singleton *instance = Singleton::getInstance();
    thread t1([]()
              { cout << Singleton1::getInstance() << endl; });

    thread t2([]()
              { cout << Singleton1::getInstance() << endl; });
    cout << Singleton1::getInstance() << endl;

    system("pause");
    return 0;
}

2.2 简述一下单例设计模式的懒汉式和饿汉式，如何保证线程安全

//程序实例（简单工厂模式）
enum CTYPE {COREA, COREB};
class SingleCore
{
public:
virtual void Show() = 0;
};
//单核A
class SingleCoreA: public SingleCore
{
public:
void Show() { cout<<"SingleCore A"<<endl; }
};
//单核B
class SingleCoreB: public SingleCore
{
public:
void Show() { cout<<"SingleCore B"<<endl; }
};
//唯一的工厂，可以生产两种型号的处理器核，在内部判断
class Factory
{
public:
SingleCore* CreateSingleCore(enum CTYPE ctype)
{
if(ctype == COREA) //工厂内部判断
return new SingleCoreA(); //生产核A
else if(ctype == COREB)
return new SingleCoreB(); //生产核B
else
return NULL;
}
};

//程序实例（工厂方法模式）
class SingleCore
{
public:
virtual void Show() = 0;
};
//单核A
class SingleCoreA: public SingleCore
{
public:
void Show() { cout<<"SingleCore A"<<endl; }
};
//单核B
class SingleCoreB: public SingleCore
{
public:
void Show() { cout<<"SingleCore B"<<endl; }
};
class Factory
{
public:
virtual SingleCore* CreateSingleCore() = 0;
};
//生产A核的工厂
class FactoryA: public Factory
{
public:
SingleCoreA* CreateSingleCore() { return new SingleCoreA; }
};
//生产B核的工厂
class FactoryB: public Factory
{
public:
SingleCoreB* CreateSingleCore() { return new SingleCoreB; }
};

优点： 扩展性好，符合了开闭原则 ，新增一种产品时，只需增加改对应的产品类和对应的工厂子类即可。

缺点： 每增加一种产品，就需要增加一个对象的工厂 。如果这家公司发展迅速，推出了很多新的处

理器核，那么就要开设相应的新工厂。在 C++ 实现中，就是要定义一个个的工厂类。显然，相比简

单工厂模式，工厂方法模式需要更多的类定义。

（3）抽象工厂模式

举例： 这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。现在简单工厂

模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为 提供一个创建一系列相关或相

互依赖对象的接口，而无需指定它们具体的类 。具体这样应用，这家公司还是开设两个工厂，一个

专门用来生产 A 型号的单核多核处理器，而另一个工厂专门用来生产 B 型号的单核多核处理器，下面给出实现的代码：

//程序实例（抽象工厂模式）
//单核
class SingleCore
{
public:
virtual void Show() = 0;
};
class SingleCoreA: public SingleCore
{
public:
void Show() { cout<<"Single Core A"<<endl; }
};
class SingleCoreB :public SingleCore
{
public:
void Show() { cout<<"Single Core B"<<endl; }
};
//多核
class MultiCore
{
public:
virtual void Show() = 0;
};
class MultiCoreA : public MultiCore
{
public:
void Show() { cout<<"Multi Core A"<<endl; }
};
class MultiCoreB : public MultiCore
{
public:
void Show() { cout<<"Multi Core B"<<endl; }
};
//工厂
class CoreFactory
{
public:
virtual SingleCore* CreateSingleCore() = 0;
virtual MultiCore* CreateMultiCore() = 0;
};
//工厂A，专门用来生产A型号的处理器
class FactoryA :public CoreFactory
{
public:
SingleCore* CreateSingleCore() { return new SingleCoreA(); }
MultiCore* CreateMultiCore() { return new MultiCoreA(); }
};
//工厂B，专门用来生产B型号的处理器
class FactoryB : public CoreFactory
{
public:
SingleCore* CreateSingleCore() { return new SingleCoreB(); }
MultiCore* CreateMultiCore() { return new MultiCoreB(); }
};

优点： 工厂抽象类创建了多个类型的产品，当有需求时，可以创建相关产品子类和子工厂类来获

取。

缺点： 扩展新种类产品时困难 。抽象工厂模式需要我们在工厂抽象类中提前确定了可能需要的产品种类，以满足不同型号的多种产品的需求。但是如果我们需要的产品种类并没有在工厂抽象类中提前确定，那我们就需要去修改工厂抽象类了，而一旦修改了工厂抽象类，那么所有的工厂子类也需要修改，这样显然扩展不方便。

答案解析

三种工厂模式的 UML 图如下：

1. 简单工厂模式 UML

#include <string>
#include <iostream>
//基础组件接口定义了可以被装饰器修改的操作
class Component {
public:
virtual ~Component() {}
virtual std::string Operation() const = 0;
};
//具体组件提供了操作的默认实现。这些类在程序中可能会有几个变体
class ConcreteComponent : public Component {
public:
std::string Operation() const override {
return "ConcreteComponent";
}
};
//装饰器基类和其他组件遵循相同的接口。这个类的主要目的是为所有的具体装饰器定义封装接口。
//封装的默认实现代码中可能会包含一个保存被封装组件的成员变量，并且负责对齐进行初始化
class Decorator : public Component {
protected:
Component* component_;
public:
Decorator(Component* component) : component_(component) {
}
//装饰器会将所有的工作分派给被封装的组件
std::string Operation() const override {
return this->component_->Operation();
}
};
//具体装饰器必须在被封装对象上调用方法，不过也可以自行在结果中添加一些内容。
class ConcreteDecoratorA : public Decorator {
//装饰器可以调用父类的是实现，来替代直接调用组件方法。
public:
ConcreteDecoratorA(Component* component) : Decorator(component) {
}
std::string Operation() const override {
return "ConcreteDecoratorA(" + Decorator::Operation() + ")";
}
};
//装饰器可以在调用封装的组件对象的方法前后执行自己的方法
class ConcreteDecoratorB : public Decorator {
public:
ConcreteDecoratorB(Component* component) : Decorator(component) {
}
std::string Operation() const override {
return "ConcreteDecoratorB(" + Decorator::Operation() + ")";
}
};
//客户端代码可以使用组件接口来操作所有的具体对象。这种方式可以使客户端和具体的实现类脱耦
void ClientCode(Component* component) {
// ...
std::cout << "RESULT: " << component->Operation();
// ...
}
int main() {
Component* simple = new ConcreteComponent;
std::cout << "Client: I've got a simple component:\n";
ClientCode(simple);
std::cout << "\n\n";
Component* decorator1 = new ConcreteDecoratorA(simple);
Component* decorator2 = new ConcreteDecoratorB(decorator1);
std::cout << "Client: Now I've got a decorated component:\n";
ClientCode(decorator2);
std::cout << "\n";
delete simple;
delete decorator1;
delete decorator2;
return 0;
}

5.5 请说说观察者设计模式，如何实现

//观察者
class Observer
{
public:
Observer() {}
virtual ~Observer() {}
virtual void Update() {}
};
//博客
class Blog
{
public:
Blog() {}
virtual ~Blog() {}
void Attach(Observer *observer) { m_observers.push_back(observer); } //添
加观察者
void Remove(Observer *observer) { m_observers.remove(observer); } //移
除观察者
void Notify() //通知观察者
{
list<Observer*>::iterator iter = m_observers.begin();
for(; iter != m_observers.end(); iter++)
(*iter)->Update();
}
virtual void SetStatus(string s) { m_status = s; } //设置状态
virtual string GetStatus() { return m_status; } //获得状态
private:
list<Observer* > m_observers; //观察者链表
protected:
string m_status; //状态
};

//具体博客类
class BlogCSDN : public Blog
{
private:
string m_name; //博主名称
public:
BlogCSDN(string name): m_name(name) {}
~BlogCSDN() {}
void SetStatus(string s) { m_status = "CSDN通知 : " + m_name + s; } //具体设置
状态信息
string GetStatus() { return m_status; }
};
//具体观察者
class ObserverBlog : public Observer
{
private:
string m_name; //观察者名称
Blog *m_blog; //观察的博客，当然以链表形式更好，就可以观察多个博客
public:
ObserverBlog(string name,Blog *blog): m_name(name), m_blog(blog) {}
~ObserverBlog() {}
void Update() //获得更新状态
{
string status = m_blog->GetStatus();
cout<<m_name<<"-------"<<status<<endl;
}
};
//测试案例
int main()
{
Blog *blog = new BlogCSDN("wuzhekai1985");
Observer *observer1 = new ObserverBlog("tutupig", blog);
blog->Attach(observer1);
blog->SetStatus("发表设计模式C++实现（15）——观察者模式");
blog->Notify();
delete blog; delete observer1;
return 0;
}