一次搞懂几种常用的设计模式

已于 2022-09-19 12:03:30 修改
阅读量540 收藏 2
点赞数 1
分类专栏： 后端 文章标签： php 设计模式
于 2019-12-31 16:50:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012830303/article/details/103784012
版权

文章目录


设计模式虽多，但实际开发中，我们常用的无非是简单的几种，即：工厂模式、依赖倒置、控制反转、依赖注入

简单工厂模式

简单工厂模式是编程中用到的最初级的设计模式，主要作用是分离代码中重复的建立对象的过程，实现代码的复用。

比如，当我们需要项目中根据需求不同，要链接不同类型的数据库，以下是一个factory.php代码

class Db{
	public function getDb($db_type){
		if($db_type == 'mongodb'){
			return new MongoDB(...);
		}elseif($db_type == 'redis'){
			return new Redis(...);
		}else{
			return new Mysql(...);
		}
	}
}
//使用
$db_factory = new Db();
$db = $db_factory->getDb($_GET['type']);

以上只能算式简单工厂模式，还不够完善，下面我们将通引入依赖导致原则，使工厂模式更加完善

依赖倒置

依赖倒置是一种面向对象的设计原则。它要求高层调用和底层实现之间，不能直接依赖，应该依赖于抽象

简单工厂模式虽然规范了类的获取方式，但没有规范类的实现方式。

class MongoDb{
	public function getOne(){}//获取1条数据
	public function getList(){}//获取多条数据
}
class Redis{
	public function getRow(){}//获取1条数据
	public function getRows(){}//获取多条数据
}
class Mysql{
	public function findOne(){}//获取1条数据
	public function findAll(){}//获取多条数据
}
//使用
$db_factory = new Db();
$db = $db_factory->getDb($_GET['type']);
//获取一条数据
if($db_type == 'mongodb'){
	$res = $db->getOne();
}elseif($db_type == 'redis'){
	$res = $db->getRow();
}else{
	$res = $db->findOne();
}

上面代码就是类的实现没有规范导致的结果，不同的数据库实例，对同一需求的操作方法不同，导致我们还要进行二次判断。
我们可以把判断的代码放在工厂类中，在类生成后，根据传入的操作参数来调用类中对应方法。但当需求增加时，需要添加判断代码，导致代码也来越臃肿。

此时依赖倒置就派上用场了。在上面的代码中，工厂类依赖了各个数据库操作类。依赖倒置就是把两者的依赖关系拆开，在他们中间加一层抽象类作为规范。

修改前依赖关系：工厂类–>数据库类
修改后依赖关系：工厂类–>抽象类/接口<–数据库类
数据库类从之前的被依赖类，变成了需要依赖其他类。依赖关系反转了，这就是依赖倒置。

修改后代码如下

//定义一个接口
interface DbInterface{
	public function findOne();
	public function findAll();
}
//所有数据库类必须实现DbInterface接口
class MongoDb implement DbInterface{
	public function findOne(){}//获取1条数据
	public function findAll(){}//获取多条数据
}
class Redis implement DbInterface{
	public function findOne(){}//获取1条数据
	public function findAll(){}//获取多条数据
}
class Mysql implement DbInterface{
	public function findOne(){}//获取1条数据
	public function findAll(){}//获取多条数据
}
//工厂类
class Db{
	private DbInterface $model;
	public function getDb($db_type):DbInterface{
		if($db_type == 'mongodb'){
			$this->model = new MongoDB(...);
		}elseif($db_type == 'redis'){
			$this->model = new Redis(...);
		}else{
			$this->model = new Mysql(...);
		}
		return $this->model;
	}
}

工厂方法模式

简单工厂模式的缺点是，无法扩展。比如当需要增加orcal数据操作时，需要修改工厂类方法，违背了面向对象设计的开闭原则。
这个时候工厂方法模式可以弥补这个不足，代码如下

//定义一个接口
interface DbInterface{
	public function findOne();
	public function findAll();
}
//所有数据库类必须实现DbInterface接口
class MongoDb implements DbInterface{...}
class Redis implements DbInterface{...}
class Mysql implements DbInterface{...}
//工厂方法接口
interface getDb{
	public static function create():DbInterface
}
//具体工厂类，创建一个具体产品实例
class MysqlDb implements getDb(){
	public static function create(){
		new Mysql();
	}
}
//调用
$db = MysqlDb::create();

当需要新增orcal操作时，只需新增一个实现DbInterface的类和实现getDb的类即可，不需要修改工厂类代码。在调用层可自由实例化想要的数据库

所以工厂方法模的定义为

一个抽象产品类，可以派生出多个具体产品类。每个具体工厂类只能创建一个具体产品类的实例

抽象工厂模式

理解了工厂方法，抽象工厂其实就好理解了，它的定义如下

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。一个抽象工厂类可以派生出多个具体工厂类。每个具体工厂类可以创建多个具体产品的实例。

说人话就是，抽象工厂接口里，可以定义多个方法（即具体类可以创建多个产品实例）
其实大多数情况下，工厂方法已经能满足需求，抽象工厂可用可不用

控制反转

一个类中用到其他类的实例时，我们不在该类中创建实例，而是在类外创建实例后把实例作为参数传入类中

高阶编程中我们希望高层调用和低层模块之间尽量做到低耦合，避免高层因参数变化就需要修改低层代码。
以上面代码为例，工厂类虽然规范了类的调用和实现，但是当增加新的数据库类时，我们还需要在工厂增加新的判断。

但如果只是简单的实现控制反转，那我们又回了最初没有使用工厂模式时的状态，需要手动的判断和创建需要用到的对象。所以针对控制反转的思想，诞生了依赖注入设计模式

依赖注入

当需要创建大量的类的实例的时候，我们为了方便管理，把类实例化的过程分离出来，并存把实例化对象存放在一个数组或对象中（即容器),然后我们在类中直接从容器中获取我们需要的实例即可。这就是依赖注入设计模式的基本思想

初级实现

下面我们通过实现一个缓存模块，来展示依赖注入和容器的基本使用。
首先，建立一个容器类Di.php

<?php   
class Di
{
	//存储依赖实例的数组
    protected  $_definitions= [];
    //把对象存入实例数组，并指定名称
    public function set($name, $definition)
    {
        $this->_definitions[$name] = $definition;
    }
    //根据名称，获取一个实例
    public function get($name)
    {
        if (isset($this->_definitions[$name])) {
            $definition = $this->_definitions[$name];
        } else {
            throw new Exception("class not exist");
        }
        if (is_object($definition) || is_callable($definition)) {
            $instance = call_user_func($definition);
        }else{
            throw new Exception("class not obj");
		}
    }
}

缓存类型有file、Db、Redis,我们建立这三种类型对应的操作类

//创建接口
interface BackendInterface{
    public function find($key, $lifetime);
    public function save($key, $value, $lifetime);
    public function delete($key);
}
//实现接口
class redis implements BackendInterface
{
    public function find($key, $lifetime) { }
    public function save($key, $value, $lifetime) { }
    public function delete($key) { }
}

class db implements BackendInterface
{
    public function find($key, $lifetime) { }
    public function save($key, $value, $lifetime) { }
    public function delete($key) { }
}

class file implements BackendInterface
{
    public function find($key, $lifetime) { }
    public function save($key, $value, $lifetime) { }
    public function delete($key) { }
}

建立Cache类，即被注入类

class cache
{
	//实例容器
    protected $_di;
	//当前类实例化时传入的参数
    protected $_options;
	//当前缓存用到的媒介对象。即上面创建的db，redis，file中的一种
    protected $_connect;

    public function __construct($options)
    {
        $this->_options = $options;
    }
	//把外部容器传入对象中
    public function setDI($di)
    {
        $this->_di = $di;
         $options = $this->_options;
         //根据实例化时传入的参数，获取当前缓存要使用的媒介对象名称
        if (isset($options['connect'])) {
            $service = $options['connect'];
        } else {
        	//没传，则默认使用redis
            $service = 'redis';
        }
		//根据媒介对象名称，从容器中找出对应的实例
        $this->_connect = $this->_di->get($service);
    }


    public function get($key, $lifetime)
    {
        $connect = $this->_connect;
        return $connect->find($key, $lifetime);
    }

    public function save($key, $value, $lifetime)
    {
        $connect = $this->_connect;
        return $connect->save($key, $lifetime);
    }

    public function delete($key)
    {
        $connect = $this->_connect;
        $connect->delete($key, $lifetime);
    }
}

我们看到cache的实现，需要依赖BackendInterface接口的实例。所以我们第一步首先把BackendInterface的实例注入到容器中，如下

$di = new Di();
//  往Di容器中注入redis实例
$di->set('redis', function() {
     return new redis([
         'host' => '127.0.0.1',
         'port' => 6379
     ]);
});
$di->set('file', function() {
     return new file([
         'paht' => 'cache/file_cach.log'
     ]);
});
$di->set('db', function() {
     return new db([
         'host' => '127.0.0.1',
         'port' => 3306
     ]);
});

把可能用到的实例注入到容器中后，把容器传给cache对象，cache就可从容器中拿到自己需要的实例来操作内容，代码如下

//实例化cache对象，并使用参数控制想使用的缓存类型
$cache = new cache(['connent'=>'file']);
//把容器传入cache对象
$cache->setDI($di);
// 调用cache方法实现缓存
$cache->save();

初级实现的问题

  • 以上过程实现了简单的依赖注入和容器，但是我们发现，上面的依赖关系只有一层。如果将Db类进行扩展，可以选择使用mysql或orcal数据库。
    那么此时依赖关系就变成了三层，在把db实例注入容器前，需要先把mysql和orcal的实例注入到容器中，否则在db中调用容器中的mysql或orcal实例时，将无法找到。
  • 当依赖层级较多的时候，一个个的注入不仅不方便，一旦顺序错误也会造成错误。这个时候我们就需要使用php的ReflectionClass反射机制，构建一个自动注入且不需要关心注入顺序的Di容器。

中级实现

初级实现中，我们需要先把依赖的实例注入到Di容器中，在被注入的类中需要用到时从Di容器中取。
中级实现，则是自动注入。在被注入函数实例化或者方法被调用时，根据构造函数或方法中指定的参数类型，把对象类型的参数实例化后再传入被注入类中。而要获取类的各种信息，就需要用到反射类 ReflectionClass

改造后Di代码如下

class Di {
	//保存实例的数组
	protected $_definitions=[];
    // 获得类的对象实例
    public static function getInstance($className) {
    	//根据类名，从实例数组中查找实例。存在则返回
		if(isset($this->_definitions[$className]))	return $this->_definitions[$className];
        //实例不存在，则获取该类下构造方法中的参数的实例
        $paramArr = self::getMethodParams($className);
        //使用反射，生成实例，并插入到实例数组中
        $this->_definition[$className] = (new ReflectionClass($className))->newInstanceArgs($paramArr);
        return $this->_definition[$className]；
    }

    //直接调用类的方法
    public static function make($className, $methodName, $params = []) {
        $instance = self::getInstance($className);
        // 获取方法所需要依赖注入的参数
        $paramArr = self::getMethodParams($className, $methodName);
        //
        return $instance->$methodName(array_merge($paramArr, $params));
    }

    // 获得类的方法参数，把对象类参数实例化
    protected static function getMethodParams($className, $methodsName = '__construct') {

        // 通过反射获得该类的信息
        $class = new ReflectionClass($className);
        $paramArr = []; // 记录参数，和参数类型

        // 判断函数方法名是否存在
        if ($class->hasMethod($methodsName)) {
            $construct = $class->getMethod($methodsName);
            // 判断函数方法是否有参数
            $params = $construct->getParameters();
            if (count($params) > 0) {
                // 遍历参数，并判断参数类型
                foreach ($params as $key => $param) {
                	//如果参数名是一个存在的类，说明需要实例化该类作为依赖
                    if (class_exists($param->name)) {
                        //递归获取依赖的对象是否依赖其他对象
                        $args = self::getMethodParams($param->name);
                        //返回依赖对象的实例作为参数
                        $paramArr[] = (new ReflectionClass($param->name))->newInstanceArgs($args);
                    }
                }
            }
        }
        return $paramArr;
    }
}

cache和db代码改造后如下

class cache
{
    protected $_connect;

    public function __construct(db $db)
    {
        $this->_connect= $db;
    }
    ......
}


class db implements BackendInterface
{
	public $_connect;
	public __construct（mysql $mysql）{
        $this->_connect = $mysql->connect();
	}
    public function find($key, $lifetime) {
		$connect = $this->_connect();
		return $connect->find();
	 }
    public function save($key, $value, $lifetime) { }
    public function delete($key) { }
    }
}

//调用
$cache = Di::getInstance('cache');

改造后我们无需注册依赖，就可以直接调用实例化cache并调用方法。容器会根据依赖的类型名称，自动查找并实例化类。

中级实现的问题

  • 自动实例化时，必须能够保证能在当前路径够找到这些类。这就需要提前引入需要用的的类的命名空间地址，这导致项目复杂时，需要在容器类中引入所有可能用到的类，而且后期还需要不断的增加，这显然是不优雅的
  • 当我们需要调整cache的存储方式为redis时，发现不能通过传入参数调整

高级实现

针对中级实现的问题，我们需要进行两点优化

  • 可动态引入需要使用类的命名空间
  • 可传入参数，控制实例化过程

为解决以上两点，还是要引入注册机制。但此时是的注册不像初级实现那样注册对象。这里的注册仅指定依赖关系，而不是实例化依赖对象。当Di解析依赖时，可根据注册的依赖关系获取依赖对象。且此时注册也不需要分先后顺序。

调用代码

$di = new Di();

//注册依赖关系时，指定了类的路径，容器中就不需引入类的命名空间
//注册不分先后顺序，因为此时并没有实例化，只是注册了依赖关系
$di->set('cache',['class'=>'\\cache'])
$di->set('BackendInterface ',['class'=>'\\app\\db']);

//注册依赖关系时，也指定了类实例化时的参数，用以控制实例化过程
//若我们要用redis方式存储缓存数据，可以修改后面的配置信息
//如：$di->set('BackendInterface ',['class'=>'\\app\\redis','host'=>'','name'=>'']);
$di->set('sql',['class'=>'\\sql\\mysql','host'=>'127.0.0.1','name'=>'test']);
//调用时自动解析依赖并实例化
$cache = $di->get('cache');

容器代码

class Di {
	protected $_dependencies=[];//存储依赖对象实例
	protected $_definitions=[];//存储依赖注册信息
    // 注册依赖关系
    public function set($className,$param) {
    	
    	//查看依赖是否注册，已注册直接返回
		if(isset($this->_definitions[$className]))	return $this->_definitions[$className];
		//注册依赖映射
		//依赖名称不是类名，可自定义。类名通过参数中的class指定
        $this->_definitions[$className] = $param;
    }

    // 获取依赖
    public function get($className) {
    	//实例数组中存在，直接返回
		if(isset($this->_dependencies($className)))	return $this->_dependencies($className));
		//实例不存在，使用反射生成所需依赖的实例
		//获取实例化依赖类需要的参数
		$paramArr = $this->getMethodParams($className);
		//实例化依赖并存入依赖数组
		$this->_dependencies[$className] = (new ReflectionClass($className))->newInstanceArgs($paramArr);
		return $this->_dependencies[$className]；
    }
    // 获得类的方法参数，把对象类参数实例化
    protected function getMethodParams($className) {

        // 通过反射获得该类的信息
        $class = new ReflectionClass($this->_definitions[$className]['class']);
        // 记录构造方法参数
        $paramArr = []; 
        // 判断构造函数方法名是否存在
        $methodsName = '__construct'
        if ($class->hasMethod($methodsName)) {
            $construct = $class->getMethod($methodsName);
            // 判断函数方法是否有参数
            $params = $construct->getParameters();
            if (count($params) > 0) {
           
                foreach ($params as $key => $param) {
                	// 判断参数类型,如果参数名称在注册信息数组中，说明是对象，递归实例化参数
                    if (in_array($param->name,array_keys($this->_definitions))) {
                        //递归获取依赖的对象是否依赖其他对象
                        $args = self::getMethodParams($param->name);
                        //返回依赖对象的实例作为参数
                        $paramArr[] = (new ReflectionClass($this->_definitions[$param->name]['class']))->newInstanceArgs($args);
                    }else{
					//如果参数是普通值，从依赖注册数组中查看是否有对应的值
						if(isset($this->_definitions[$className][$param->name])){
							$paramArr[] = $this->_definitions[$className][$param->name];
						}
					}
                }
            }
        }
        return $paramArr;
    }
}

class cache
{
    protected $_connect;
	//类的依赖信息放在构造函数中，便于在实例化类时解析相关依赖。同时也符合了迪米特法则
	//解析依赖时根据指定的实例路径生成映射，我们从上面Di的get代码中看到，获取依赖对象的映射时
	//并不是直接使用的指定路径，而是通过指定的路径从_definitions中获取真实的依赖类信息，这样我们需要用到不同模块时，只要修改配置中的class等信息即可
    public function __construct(BackendInterface $cache)
    {
        $this->_connect= $cache;
    }
    public function get($key, $lifetime)
    {
        $connect = $this->_connect;
        return $connect->find($key, $lifetime);
    }

    public function save($key, $value, $lifetime)
    {
    }

    public function delete($key)
    {
    }
}

class db implements BackendInterface
{
	public $connect;
	public __construct(sql $db,$host='localhost',$port='3306'）{
		 $this->connect = $db;
	}
    public function find($key, $lifetime) {
		return $this->connect->find();
	 }
    public function save($key, $value, $lifetime) { }
    public function delete($key) { }
    }
}
keep-study
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文搞懂Kafka的设计与实现
程序员光剑
10-11 636
Apache Kafka是一个开源流处理平台，主要用于实时数据传输、存储、分析和应用的一种分布式消息系统。它最初由LinkedIn公司开发，目前属于Apache Software Foundation下顶级项目，是最受欢迎的开源消息系统之一。它的设计目标如下：1.易用性：开箱即用，通过一系列的参数配置，用户可以快速部署一个Kafka集群。同时支持多种语言的客户端接口，比如Java、Scala、Python等。2.高吞吐量：Kafka具备出色的性能和可靠性。
【C#进阶3-4】C#设计模式
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
05-19 6669
一、目录 文章目录一、目录二、设计原则三、创建型模式3.1、单例模式（Singleton Pattern）3.2、工厂方法模式（Factory Pattern）3.3、抽象工厂模式（Abstract Pattern）3.4、建造者模式（Builder Pattern）3.5、原型模式（Prototype Pattern）四、结构性模式4.1、适配器模式（Adapter Pattern）4.2、桥接模式（Bridge Pattern）4.3、装饰者模式（Decorator Pattern）4.4、组合模式（C
常用设计模式讲解(史上最简短)
guku001的博客
11-12 189
这篇文章会简单粗暴地讲解一下常用设计模式，算是一个汇总，不会作详细地讲解 系统设计从设计原则开始，在过程中会自然而然发现需要加入模式的地方。所有的原则都不是必须遵守的，要考虑全局进行舍取，常常要折中。 所有的设计模式都是一种思想，即使在某种场合下没有办法实现常规的写法，但是用到它们的思想就可以了。尽可能保持设计的简单，只有真正需要模式时才使用，复杂度一般与灵活性正相关。 使用设计模式的目的:在不改变设计好的运行框架的前提下，需增加功能是只需要额外添加一个类，然后就可以在系统运行时增加功能 适配器模式 能
设计模式
baofeidyz
05-24 267
设计模式 创建型 工厂 通过传参获取不同的实例.一般来说,返回的实例需要实现共同的接口. 抽象工厂 对工厂模式进行抽象封装,工厂类基层抽象工厂进行封装.与工厂模式一样,通过传参返回不同的工厂实现,再通过传参返回不同的实例. 单例 该类负责创建自己的对象,同时确保只有单个对象被创建.该类提供了一种访问其唯一对象的方式,可以直接访问,不需要实例化该类的对象. 注意点: 单例类只能有一个实例. 单例类必须自己创建自己的唯一实例. 单例类必须给所有其他对象提供这一实例. 建造者 使用多个简单的对象一步一步构建成
设计模式——创建型
码农@攻城狮
08-15 300
创建型设计模式常用的有单例模式，工厂模式(简单工厂模式，工厂方法模式，抽象工厂模式)
设计模式：Builder模式（多个构造器参数时可显著改善可读性）
不更新了
02-24 1530
前言看到《Effective Java》第2条：遇到多个构造器参数时要考虑用构建器。马上想起之前自己写的一段代码：return InvestorPurchaseCurrentParamPackage.create( investorSum.getReference_id(), entityCode,
设计模式系列-Builder模式(高效构建参数)
10-11 2054
引言 在Java编程中，常常需要为一个Bean构建成员变量或者构建参数，常用的方法有使用构造函数、使用JavaBean的set()方法，但是这两个方案或多或少都存在一定的缺点，于是今天的主角builder模式出场了，它解决了这种典型应用场景的问题，采用简洁明了的使用方式，灵活多变的链式调用，使得多个参数的Bean的构建变得十分简洁。 本文不想以传统的类图的形式来讲解，而是从实际例子来看builde...
常用的设计模式
weixin_41270708的博客
10-15 191
一、建造者 需求： 画人物，需要画一个人的左手，右手，左脚，右脚，身体，头部 画一个瘦子、画一个胖子 from abc import ABCMeta,abstractmethod class Builder(): __metaclass__=ABCMeta @abstractmethod def draw_left_arm(self): ...
Java常用设计模式
最新发布
Java技术攻略的博客
02-27 85
创建型模式总体上比较简单，它们的作用就是为了产生实例对象，算是各种工作的第一步了，因为我们写的是面向对象的代码，所以我们第一步当然是需要创建一个对象了。简单工厂模式最简单；工厂模式在简单工厂模式的基础上增加了选择工厂的维度，需要第一步选择合适的工厂；抽象工厂模式有产品族的概念，如果各个产品是存在兼容性问题的，就要用抽象工厂模式。单例模式就不说了，为了保证全局使用的是同一对象，一方面是安全性考虑，一方面是为了节省资源；建造者模式专门对付属性很多的那种类，为了让代码更优美；
JAVA设计模式总结之23种设计模式
weixin_43513980的博客
02-15 549
JAVA设计模式总结之23种设计模式 一、什么是设计模式 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该
c# 实现的简单的 注入容器
09-21
在学习 IOC 的时候根据自己的理解，实现的简单的注入容器，实现构造函数注入，属性注入，字段注入。代码比较简单 适合理解 注入容器原理
golang设计模式——结构模式
qq_39280718的博客
09-03 690
结构模式主要关注类和对象的组合
14.架构基础-JAVA设计模式-行为型-策略模式
lijunliang2017的博客
08-21 188
策略模式定义及结构： 策略模式定义：策略模式为一系列父类与子类的关系，为一系列子类提供统一方法，一个父类多个子类，由执行类作为统一入口，根据不同规则执行不同策略 策略模式主要由以下几个模块组成： 抽象策略接口：定义一个执行的公共接口 具体策略实现类：该类实现了抽象策略接口，并在各个实现类中定义不同的执行方法 统一入口类：该类提供统一入口，根据用户自身需求或者传入参数执行不同的策略 模式使用案例： 策略接口类： package com.hyt.controller.strategy;.
常见的几种Java设计模式
weixin_41047704的博客
02-05 1301
目录 1、什么是设计模式？设计模式有什么用？ 2、设计模式应该遵循的面向对象设计原则 3、设计模式的六大原则 4、设计模式的四种类型（包括J2EE设计模式） 5、几种常见的设计模式 5.1、工厂模式 5.2、抽象工厂模式 5.3、单例模式 5.4、适配器模式 5.5、装饰器模式 5.6、代理模式 5.7、策略模式 5.8、观察者模式 1、什么是设计模式？设计模式有什么用...
23种设计模式之单例模式
weixin_40948132的博客
03-06 241
文章目录简介单例模式的实现饿汉式创建懒汉式创建DCL饿汉式创建静态内部类创建使用枚举 简介 单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例。单例模式是23种设计模式中比较简单，也是比较重要的一种设计模式。在现在流行的框架中十分常见，比如：MyBatis框架。 单例模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一...
Bean注入容器的多种方式
u014365523的博客
08-19 3014
bean注入容器
Spring中依赖注入与容器
可小辉的博客
04-08 712
依赖注入、IoC/DI Spring 框架（核心）IoC 容器 IoC：控制反转 DI：依赖注入 什么是依赖?一个组件（对象）的运行需要用到另一个组件（对象），称这种关系为依赖关系 举例：鱼依赖水，生命依赖空气、阳光、水、食物 组件依赖的资源（其他组件）由所在环境（上下文、容器）传递进去 依赖注入的几种形式 - 接口注入 - 构造器注入 - 属性（setter）注入 ...
设计模式之策略模式【内附通过工厂方法+枚举实现根据参数调用不同的策略】
Ouyzc的博客
09-09 3126
设计模式之策略模式【内附通过工厂方法+枚举实现根据参数调用不同的策略】
设计模式解析：工厂模式详解
设计模式之工厂模式是对创建对象过程的一种抽象，它将对象的实例化过程封装起来，使得客户端无需关心具体的创建细节，只需要调用工厂提供的方法就能获取所需对象。工厂模式主要分为三类： 1. 简单工厂模式：这种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值