php 工厂模式实现类似java中的server层dao层

简单工厂

通过静态方法传入不同的参数创建不同的对象，实现对象创建和使用的分离

 

//示例1 最基本的工厂模式

<?php
class mysql_conn{
    private $dbh = null;
    private $host = 'localhost';
    private $port = '3306';
    private $user = 'root';
    private $password = '****';
    private $dbname = 'test';

    public function __construct(){
        $this->dbh = new PDO('mysql:host=' . $this->host . ';port=' . $this->port . ';dbname=' . $this->dbname, $this->user, $this->password);
    }

    public function get_table_data($table_name){
        foreach($this->dbh->query("SELECT * from `$table_name`") as $row){
            echo "<pre>";
            print_r($row);
            echo "</pre>";
        }
    }
}

class psql_conn{
    private $dbh = null;
    private $host = 'localhost';
    private $port = '5432';
    private $user = 'postgres';
    private $password = '****';
    private $dbname = 'test';

    public function __construct(){
        $this->dbh = new PDO('pgsql:host=' . $this->host . ';port=' . $this->port . ';dbname=' . $this->dbname, $this->user, $this->password);
    }

    public function get_table_data($table_name){
        foreach($this->dbh->query("SELECT * from `$table_name`") as $row){
            echo "<pre>";
            print_r($row);
            echo "</pre>";
        }
    }

    public function custom_query($sql){
        $stmt = $this->dbh->prepare($sql);
        $stmt->execute();
        foreach ($stmt as $row) {
            echo "<pre>";
            print_r($row);
            echo "</pre>";
        }
    }
}

class Factory{
    public static function pdo_conn($db = 'mysql'){
        if ($db == 'mysql') {
            return new mysql_conn();
        }
        else if ($db == 'psql'){
            return new psql_conn();
        }
    }
}

// mysql
// $mysql_dbh = Factory::pdo_conn('mysql');
// $mysql_dbh->get_table_data('user');
// $mysql_dbh->get_table_data('order');

// postgresql
// $psql_dbh = Factory::pdo_conn('psql');
// $psql_dbh->custom_query('select * from student');

　　

// 开发模式之工程模式
// 工厂模式：
// 由工厂类根据参数来决定创建出哪一种产品类的实例；
// 工厂类是指包含了一个专门用来创建其他对象的方法的类。所谓按需分配，传入参数进行选择，返回具体的类。
// 工厂模式的最主要作用就是对象创建的封装、简化创建对象操作。 
// 简单的说，就是调用工厂类的一个方法（传入参数）来得到需要的类；
 
 
//示例2 最基本的工厂模式
 
class Myname{
	public function OutPutMyName(){
		return 'name is rongyouyuan!~';
	}
}
class NameFactory{
	public static function Namefunc(){
		return new Myname();
	}
}
$obj=NameFactory::Namefunc();
echo $obj->OutPutMyName();
?>

　　

抽象工厂

提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。

在工厂方法模式中，一个具体的工厂负责生产一类具体的产品，即一对一的关系，但是，如果需要一个具体的工厂生产多种产品对象，那么就需要用到抽象工厂模式了。

 

<?php
interface database_option{
    public function custom_query($sql);
    public function get_table_data($table_name);
}

class mysql_conn implements database_option{
    private $dbh = null;
    private $host = 'localhost';
    private $port = '3306';
    private $user = 'root';
    private $password = '****';
    private $dbname = 'test';

    public function __construct(){
        $this->dbh = new PDO('mysql:host=' . $this->host . ';port=' . $this->port . ';dbname=' . $this->dbname, $this->user, $this->password);
    }

    public function get_table_data($table_name){
        foreach($this->dbh->query("SELECT * from `$table_name`") as $row) {
            echo "<pre>";
            print_r($row);
            echo "</pre>";
        }
    }

    public function custom_query($sql){
        $stmt = $this->dbh->prepare($sql);
        $stmt->execute();
        foreach ($stmt as $row) {
            echo "<pre>";
            print_r($row);
            echo "</pre>";
        }
    }
}

class psql_conn implements database_option{
    private $dbh = null;
    private $host = 'localhost';
    private $port = '5432';
    private $user = 'postgres';
    private $password = '****';
    private $dbname = 'test';

    public function __construct(){
        $this->dbh = new PDO('pgsql:host=' . $this->host . ';port=' . $this->port . ';dbname=' . $this->dbname, $this->user, $this->password);
    }

    public function get_table_data($table_name){
        foreach($this->dbh->query("SELECT * from `$table_name`") as $row) {
            echo "<pre>";
            print_r($row);
            echo "</pre>";
        }
    }

    public function custom_query($sql){
        $stmt = $this->dbh->prepare($sql);
        $stmt->execute();
        foreach ($stmt as $row) {
            echo "<pre>";
            print_r($row);
            echo "</pre>";
        }
    }
}

abstract class Factory{
    abstract public static function create_mysql_conn();
    abstract public static function create_psql_conn();
}

class db_Factory extends Factory{
    public static function create_mysql_conn(){
        return new mysql_conn();
    }

    public static function create_psql_conn(){
        return new psql_conn();
    }
}

// mysql
// $mysql_dbh = db_Factory::create_mysql_conn();
// $mysql_dbh->get_table_data('order');

// psql
// $psql_dbh = db_Factory::create_psql_conn();
// $psql_dbh->custom_query('select * from student');

　　

php实现类似java中的Service层 DAO层

$adminInfo = ServiceFactory::getService(SrvType::COMMON_MERCHANT_ACCOUNT_ADMIN)->getInfoById($admin_id);

　　

<?php
namespace lwmf\services;

/**
 * 业务工厂，主要用于创建业务对象
 *
 */
class ServiceFactory
{
    /**
     * 获取指定类型业务对象
     *
     * @param string $serviceType
     *            - SrvType定义的业务类型
     * @return mixed
     * @throws ServiceException
     */
    public static function getService($serviceType)
    {

        if (self::$_srvImpls === NULL) {
            // 初始化
            self::init();
        }

        // 先在缓存服务中检查是否已经创建，如果有则直接返回
        if (isset(self::$_services[$serviceType])) {
            return self::$_services[$serviceType];
        }
        
        if (isset(self::$_tmpCaches[$serviceType])) {
            throw new ServiceException("重复初始化service对象, type={$serviceType}");
        }
        
        // 创建指定业务对象
        $srv = self::createService($serviceType);
        // 缓存服务
        if (LWM_APP_ID != 'unittest') {
            self::$_services[$serviceType] = $srv;
            self::$_tmpCaches[$serviceType] = 1;
        }
        
        return $srv;
    }
    
    /**
     * 创建指定业务对象
     *
     * @param string $serviceType
     *            - SrvType定义的业务类型
     * @return mixed
     * @throws ServiceException
     */
    private static function createService($serviceType)
    {
        /**
         * 根据配置映射关系，创建实现类实例。
         */
        if (!isset(self::$_srvImpls[$serviceType])) {
            throw new ServiceException("It hasn't such a service type:" . $serviceType);
        }
        $class = '\lwm\services\modules' . self::$_srvImpls[$serviceType];
        return new $class();
    }
    
    /**
     * 初始化
     *
     * @throws \Exception
     */
    private static function init()
    {
        $srvConfigPath = \Yii::app()->getProjectPath() . '/system/services/SrvImpsMapper.php';
        if (!file_exists($srvConfigPath)) {
            throw new ServiceException("services config not found, please init services's config");
        }
        // 加载业务实现映射
        self::$_srvImpls = require $srvConfigPath;
    }
    
    /**
     * 主要用于检测重复创建对象死循环
     * @var array
     */
    private static $_tmpCaches = [];
    /**
     * 业务实现映射
     *
     * @var array
     */
    private static $_srvImpls = NULL;
    /**
     * 业务对象缓存
     *
     * @var array
     */
    private static $_services = [];
}

　　SrvImpsMapper.php

<?php
use lwm\services\SrvType;

/**
 * 业务实现配置
 */
return [
    //店铺
    SrvType::COMMON_SHOP => '\common\shop\imps\Shop',
    SrvType::COMMON_SHOP_TYPE => '\common\shop\imps\ShopType',
    SrvType::COMMON_SHOPTABLE => '\common\shop\imps\ShopTable',
    SrvType::COMMON_SHOP_COLLECT => '\common\shop\imps\Collect',
     。
     。
     。      
];

　　

SrvType.php

<?php
namespace lwm\services;
/**
 * 业务类型定义
 *
 */
class SrvType
{
    /**
     * 店铺业务
     */
    const COMMON_SHOP = 'common.shop.Shop';

    /**
     * 店铺分类
     */
    const COMMON_SHOP_TYPE = 'common.shop.ShopType';

    /**
     * 店铺桌位
     */
    const COMMON_SHOPTABLE = 'common.shop.ShopTable';

   
}

　　业务路径如下