设计模式案例：简单工厂模式、策略模式、依赖注入模式

### 案例
请看下面这段程序：
```
import redis

class Storage(object):

def get(self, key):
        raise NotImplementedError

def set(self, key, value):
        raise NotImplementedError

class MemoryStorage(Storage):

def __init__(self):
        self._data = {}

def get(self, key):
        return self._data.get(key)

def set(self, key, value):
        self._data[key] = value

def RedisStorage(Storage):

def __init__(self, host, port, db):
        self._redis = redis.StrictRedis(host=host, port=port, db=db)

def get(self, key):
        return self._redis.get(key)

def set(self, key, value):
        self._redis.set(key, value)

class Cache(object):

def __init__(self, kind, timeout=600):
        self.kind = kind
        self.timeout = timeout
        self.storage = self.create_storage(kind)

def create_storage(self, kind):
        if kind == "memory":
            self.storage = MemoryStorage()
        elif kind == "redis":
            self.storage = RedisStorage("localhost", 6379, 0)
        else:
            raise ValueError(f"Unknown storage kind: {kind}")

def get(self, key):
        return self.storage.get(key)

def set(self, key, value):
        return self.storage.set(key, value)

class Cache2(object):

def __init__(self, storage, timeout=600):
        self.timeout = timeout
        self.storage = storage

def get(self, key):
        return self.storage.get(key)

def set(self, key, value):
        return self.storage.set(key, value)

kind = "memory"

cache_v1 = Cache(kind=kind)

if kind == "memory":
    storage = MemoryStorage()
elif kind == "redis":
    storage = RedisStorage("localhost", 6379, 0)
else:
    raise ValueError(f"Unknown storage kind: {kind}")
cache_v2 = Cache2(storage=storage)
```

### 问题1：这段程序体现了哪些设计模式？
### 回答：

#### 1. `Cache` 类：简单工厂模式
- 其中， `create_storage` 方法作为工厂方法；
- 对象创建的逻辑被封装在 create_storage 方法中；
- 工厂方法根据 kind 参数决定创建哪种存储对象；

#### 2. `Cache2` 类：策略模式 和 迭代器模式
是的，`Cache2` 同时体现了`策略模式`和`依赖注入模式`

1. `策略模式`的体现：
> Storage 作为策略接口；
MemoryStorage 和 RedisStorage 作为具体策略实现；
允许在运行时切换不同的存储策略；
将存储算法封装在独立的类中；

2. `依赖注入模式`的体现：
> 通过构造函数注入 storage 依赖；
依赖创建与使用分离；
依赖于抽象而非具体实现；

3. 这两种模式在此处的结合点：
> 策略模式定义了算法家族（不同的存储策略）；
依赖注入提供了一种松耦合的方式来使用这些策略；
策略的选择和注入都发生在类的外部；

4. 这种组合使用带来的好处：
> 更好的可测试性；
更强的灵活性；
更低的耦合度；
符合开闭原则和依赖倒置原则；

### 问题2：cache_v1和cache_v2 哪个实现方式更好？
### 回答：
`cache_v2` 的实现方式更好，原因如下：

1. 更好的可扩展性：
> 添加新的存储实现不需要修改Cache2类；
只需创建新的Storage接口实现即可；
符合开闭原则(Open-Closed Principle)；

2. 更好的可测试性：
> 可以轻松注入mock对象进行测试；
不需要依赖真实的存储实现；
单元测试更容易编写和维护；

3. 更低的耦合度：
> Cache2不依赖具体的存储实现；
依赖通过构造函数注入，而不是在内部创建；
符合依赖倒置原则(Dependency Inversion Principle)；

4. 更灵活的使用方式：
> 客户端可以控制具体使用哪种存储实现；
可以在运行时动态切换存储策略；
更容易配置和管理；

5. 更好的代码质量：
> 职责更单一，符合单一职责原则；
实现更简洁清晰；
更容易维护和理解；