PHP3 设计模式、COMPOSER、异常处理

【composer】

    包管理工具，解决依赖、版本的问题、解决版本的升级问题

    它就像迅雷一样

    npm     node package manager

<?php

include "vendor/autoload.php";

use \NoahBuscher\Macaw\Macaw;

Macaw::get('/', function() {

  echo 'Hello world!';

});

Macaw::get('/love',function(){

    echo '我最近好想小亮啊';

});

Macaw::get('/userinfo' , 'UserController@info');

Macaw::get('/aa' , 'UserController@add');

Macaw::dispatch();

【下载】

    http://docs.phpcomposer.com/00-intro.html

    1、需要安装composer

    2、安装之前你需要在php.ini里面extension=php_openssl.dll打开

    3、下载安装

        安装到你的php.exe路径

    4、检测是否安装成功

【json数据格式】

 {

    "键1":"值1",

    "键2":"值2",

    "键3":"值3",

    "键1":[

        "键1":"值1",

        "键2":"值2",

        "键3":[]

    ]

}

composer在执行的时候需要一个配置文件composer.json

【dos常用命令】

    cd enter diectory 进入目录

    dir 常看当前文件夹下面的所有的东西

    cd .. 返回上一级目录

【composer常用的命令】

 clear-cache

 【版本号】

    "name":"likun",

    "description":"",

    "keywrods":" , , ",

    "lincence":"当前软件对应的协议"

【异常抛出】

    try{

    } catch (Exception $error) {

    }

    $error -> getMessage() //获取错误信息

    getLine() //获取错误行

    getFile() //获取错误的文件

    getCode() //获取错误号--可以手动指定

可以自定义异常抛出类，继承Execption

使用自定义异常抛出类时 需要注意：放在系统的基类Execption之前

<?php

//手动自定义一个异常抛出

class MyExecption extends Exception

{

    public function myGetCode()

    {

        echo $this->getLine().'<br />';

        echo $this->getMessage().'<br />';

        echo $this->getCode().'<br />';

    }

}

try {

    $fp = fopen('a.txt' , 'r');

    if (!$fp) {

        throw new MyExecption('文件打开失败' , 100);

    }

}catch (MyExecption $e) {

    echo $e->myGetCode();

} catch (Exception $e) {

    echo $e->getFile().'<br />';

}

   try catch 可以嵌套try catch

【异常抛出】

    set_exception_handler

<?php

set_exception_handler('myExecption');

function myExecption($e)

{

    echo '快到碗里来<br />';

    echo $e->getMessage();

    echo $e->getCode();

}

throw new Exception('你看我走到哪里了', 110);

【虚拟主机配置】

    第一步

        先打开C:\Windows\System32\drivers\etc

        hosts 文件

    第二步

        C:\wamp64\bin\apache\apache2.4.17\conf---httpd.conf

        #Include conf/extra/httpd-vhosts.conf 注释打开

        LoadModule rewrite_module modules/mod_rewrite.so 注释打开

    第三步 注意 配置的时候切记备份一份

        C:\wamp64\bin\apache\apache2.4.17\conf\extra --- httpd-vhosts.conf

    <VirtualHost *:80>

        ServerAdmin webmaster@dummy-host2.example.com

        //你的联系方式

        DocumentRoot "c:/Apache24/docs/dummy-host2.example.com"

        项目的根目录

        ServerName dummy-host2.example.com

        域名

        ErrorLog "logs/dummy-host2.example.com-error.log"

        错误日志

        CustomLog "logs/dummy-host2.example.com-access.log" common

        自定义的日志

    </VirtualHost>

    第四步

        找到你的hosts文件 把域名给你配置的写一致 重复服务

【设计模式】

    1、单例设计模式

<?php

//单例设计模式

//只实例化一次，始终都是一个对象

class Single

{

    public static $instance;

    private function __construct()

    {

        $link = mysqli_connect('localhost' , 'root' , 'kungezuishuai');

        return $link;

    }   

    public static function getInstance()

    {

        if (isset(self::$instance)) {

            return self::$instance;

        } else {

            return self::$instance = new self();

        }

    }   

}

$obj1 = Single::getInstance();

$obj2 = Single::getInstance();

if ($obj1 === $obj2) {

    echo '是同一个对象';

} else {

    echo '不是同一个对象';

}

    2、工厂设计模式

        1)普通工厂

<?php

//普通工厂

class Fly

{

    public function create()

    {

        echo '飞机被造出来了';

    }

}

class daPao

{

    public function create()

    {

        echo '大炮被造出来了';

    }

}

class Factory

{

    public static function create($type)

    {

        return new $type();

    }

}

$factroy = Factory::create('daPao');

$factroy ->create();

        2)标准工厂

<?php

//标准工厂

interface Wuqi

{

    public function create();

}

class Fly implements Wuqi

{

    public function create()

    {

        echo '飞机被造出来了<br />';

    }

}

class daPao implements Wuqi

{

    public function create()

    {

        echo '大炮被造出来了<br />';

    }

}

class WuqiFactory

{

    public $obj;

    public function __construct($type)

    {

        $this->obj = new $type();// new Fly();

    }

    public function make()

    {

        return $this->obj;

    }

}

$factory = new WuqiFactory('Fly');

$fly = $factory->make();

$fly->create();

        3)工厂方法  

<?php

//工厂方法

//把工厂给接口化

interface Wuqi

{

    public function create();

}

class Fly implements Wuqi

{

    public function create()

    {

        echo '制造飞机';

    }

}

class daPao implements Wuqi

{

    public function create()

    {

        echo '制造大炮';

    }

}

interface Factory

{

    public function make();

}

class FlyFactory implements Factory

{

    public function make()

    {

        return new Fly();

    }

}

class daPaoFacgory implements Factory

{

    public function make()

    {

        return new daPao();

    }

}

$factory = new FlyFactory();

$fly = $factory->make();

$fly->create();

        4)抽象工厂

<?php

//抽象工厂

//就是把工厂更细化

interface Wuqi

{

    public function create();

}

class BigFly implements Wuqi

{

    public function create()

    {

        echo 'this is bigFly';

    }   

}

class SmallFly implements Wuqi

{

    public function create()

    {

        echo 'this is SmallFly';

    }

}

interface Factory

{

    public function FlyBig();

    public function FlySmall();

}

class FlyFactory implements Factory

{

    public function FlyBig()

    {

        return new BigFly();

    }

    public function FlySmall()

    {

        return new SmallFly();

    }

}

$factory = new FlyFactory();

$fly = $factory->FlySmall();

$fly->create();

    3、观察者

//观察者 被观察者 消息(反应)

interface Observales

{

    //添加观察者

    public function attach($observer);

    //移出被观察者

    public function detach($observer);

    //消息

    public function notify();

}

class Boss implements Observales

{

    //实现添加被观察者

    public $observales = [];

    //定义一个价格

    public $price = 10;

    //添加观察者

    public function attach($observer)

    {

        if (!in_array($observer , $this->observales)) {

            $this->observales[] = $observer;

        }

    }

    //移出被观察者

    public function detach($observer)

    {

        foreach ($this->observales as $key => $val) {

            if ($val == $observer) {

                unset($this->observales[$key]);

            }

        }

    }

    //消息

    public function notify()

    {

        foreach ($this->observales as $observer) {

            $observer->do($this);

        }

    }

    //改变价格

    public function changePrice($price)

    {

        $this->price = $price;

        $this->notify();

    }

}

//观察者接口

interface Observer

{

    public function do($observales);

}

//穷人的反应

class Poor implements Observer

{

    public function do($observales)

    {

        if ($observales->price > 20) {

            echo '穷人说太贵了吃不起<br />';

        } else {

            echo '穷人说太便宜了不吃了<br />';

        }

    }

}

//富人的反应

class Rich implements Observer

{

    public function do($observales)

    {

        if ($observales->price > 20) {

            echo '富人说太便宜了吃不起<br />';

        } else {

            echo '富人说太便宜了不想吃<br />';

        }

    }

}

$boss = new Boss();

$rich = new Rich();

$boss->attach($rich);

$boss->changePrice(30);

    4、mvc

    5、适配器

<?php

//适配器

//解决类似功能，使用方法不一致的时候

//数据库 mysql Sqllite oracle

class MysqlDb

{

    public function connect()

    {

        echo 'mysql数据库链接方法<br />';

    }

    public function select()

    {

        echo 'mysql数据库查询方法<br />';

    }

}

//sqllite 数据库

class SqlLite

{

    public function find()

    {

        echo '这是sqllite查询一条数据<br />';

    }

}

//这是oracle的

class Oracle

{

    public function init()

    {

        echo '这是oracle的初始化方法';

    }

    public function connect()

    {

        echo '这是oracle的数据库链接';

    }

    public function pre()

    {

        echo '这是oracle的预处理方法';

    }

    public function select()

    {

        echo '这是oracle的查询方法<br />';

    }

}

interface Db

{

    public function select();

    public function connect();

}

class MysqlAdpter extends MysqlDb implements Db

{

    public function connect()

    {

        parent::connect();

    }

    public function select()

    {

        parent::select();

    }

}

class SqlLiteAdpter extends SqlLite implements Db

{

    public function connect()

    {

    }

    public function select()

    {

        parent::find();

    }

}

class OracleAdpter extends Oracle implements Db

{

    public function connect()

    {

        parent::init();

        parent::connect();

    }

    public function select()

    {

        parent::pre();

        parent::select();

    }

}

define('DB_TYPE' , 'Mysql');

$db_type = DB_TYPE.'Adpter';

$db = new $db_type();

$db->select();

    6、门面设计模式

<?php

//门面设计模式

//定义一个静态方法来完成一些调用复杂的功能

class Duck

{

    public function kill()

    {

        echo '第一步傻鸭子<br />';

    }

    public function bamao()

    {

        echo '第二步拔毛<br />';

    }

    public function xiaguo()

    {

        echo '第三步下锅<br />';

    }

}

class FacadeDuck

{

    public static function make()

    {

        $duck = new Duck();

        $duck->kill();

        $duck->bamao();

        $duck->xiaguo();

    }

}

FacadeDuck::make();

    7、策略设计模式

<?php

//策略设计模式

//你要实现什么功能，通过什么方式去实现

class Travel

{

    public $tool; //fly  对象

    public function __construct($tool)  //fly

    {

        $this->tool = $tool;

    }

    public function arrive()

    {

        echo '我要'.$this->tool->go().'去天竺';

    }

}

interface Tool

{

    public function go();

}

class Fly implements Tool

{

    public function go()

    {

        return '开着飞机去';

    }

}

class Bike implements Tool

{

    public function go()

    {

        return '骑着自行车去';

    }

}

$travel = new Travel(new Fly);

$travel->arrive();

    8、di 依赖注入 （翻转控制）

<?php

//di 依赖注入 翻转控制

//就是你实现什么功能 到时候需要用到其他的方法，把一个对象传进来

class Son

{

    public function cry(Father $father)

    {

        echo '哇哇哇哇!!!!';

        $father->baobao();

    }

}

class Father

{

    public function baobao()

    {

        echo '爸爸抱抱，乖别哭了<br />';

    }

}

class Mother

{

    public function baobao()

    {

        echo '妈妈抱抱，别哭了';

    }

}

$baby = new Son();

$baba = new Father();

$baby->cry($baba);

    9、容器

<?php

//容器

//利用静态的类，来实现创建对象

class Container

{

    public static $register = [];

                                //person

    public static function bind($name , closure $closure) //function(){return new Person();}

    {

        if (!isset(self::$register[$name])) {

            self::$register[$name] = $closure;

        }

    }

    public static function make($name)  // person

    {

        $func = self::$register[$name]; //就是匿名函数 //function(){return new Person();}

        return $func(); //function(){return new Person();}

    }

}

class Person

{

    public function say()

    {

        echo '我说话了<br />';

    }

}

Container::bind('person' , function(){

    return new Person();

});

$obj = Container::make('person');

$obj->say();

1、常见设计模式：

    单例、工厂、MVC、观察者、

    门面、容器、策略、工厂方法、

    抽象工厂、适配器、依赖注入

2、依赖注入：

    DI，也叫反转控制(IOC)

3、容器：

    是一种思维，是一种技术

4、反射：

    根据类的名字能够知道这个类的所有信息

    ReflectionClass：类报告了一个类的有关信息。

    ReflectionMethod：类报告了一个方法的有关信息。

    ReflectionParameter：取回了函数或方法参数的相关信息。

<?php

class Father

{

    public function hug()

    {

        echo '来，老爸抱一下<br />';

    }

}

class Mother

{

    public function nurse()

    {

        echo '赶紧喂奶';

    }

}

class Baby

{

    public function cry(Father $father)

    {

        echo '宝宝哇哇大哭<br />';

        $father->hug();

    }

    public function hungury(Mother $mother, $c = 3)

    {

        echo '宝宝饿了，哇哇哭了'.$c.'声<br />';

        $mother->nurse();

    }

}

//将依赖关系的控制，反转到调用链的起点，因此也叫反转控制

//当出现大量依赖对象的时候，创建一个对象将变得异常复杂

//因此可以通过容器技术，将对象的创建方法保存起来

//容器

class Container

{

    //用来保存所有创建对象的方式(闭包/函数)

    protected static $objects = [];

    //绑定对象的创建方法

    public static function bind($key, $closure)

    {

        self::$objects[$key] = $closure;

    }

    //根据指定的名称获取对象

    public static function make($key)

    {

        //如果已经绑定了创建方法

        if (array_key_exists($key, self::$objects)) {

            $closure = self::$objects[$key];

            return $closure();

        }

        //如果没有绑定，通过反射技术创建对象

        $ref = new ReflectionClass($key);

        //判断能否内实例化

        if (!$ref->isInstantiable()) {

            exit('此类不能被实例化');

        }

        //获取构造方法

        $construct = $ref->getConstructor();

        if (is_null($construct)) {

            return $ref->newInstanceArgs();

        }

        //若有构造方法，根据构造方法创建对象

        //获取构造方法的参数

        $parameters = $construct->getParameters();

        //封装函数，创建构造函数中依赖所有参数

        $dependencies = self::dependencies($parameters);

        return $ref->newInstanceArgs($dependencies);

    }

    protected static function dependencies($parameters)

    {

        //用来保存所有的参数

        $dependencies = [];

        foreach ($parameters as $parameter) {

            if ($class = $parameter->getClass()) {

                //是对象，递归创建

                $dependencies[] = self::make($class->name);

            } else {

                //不是对象

                //是否有默认值

                if ($parameter->isDefaultValueAvailable()) {

                    //有默认值

                    $dependencies[] = $parameter->getDefaultValue();

                } else {

                    //没有默认值

                    exit('what should I do ??');

                }

            }

        }

        return $dependencies;

    }

    public static function route($c, $a)

    {

        $controller = self::make($c);

        //创建反射方法的对象

        $refMethod = new ReflectionMethod($c, $a);

        //判断是否能够使公有方法

        if (!$refMethod->isPublic()) {

            exit('不能调用非公有方法');

        }

        //获取所有参数

        $parameters = $refMethod->getParameters();

        //创建所有的依赖

        $dependencies = self::dependencies($parameters);

        call_user_func_array([$controller, $a], $dependencies);

    }

}

/*

//需要提前将对象的依赖关系保存在容器中

Container::bind('Father',function(){

    return new Father();

});

Container::bind('Baby',function(){

    return new Baby(Container::make('Father'));

});

$baby = Container::make('Baby');

$baby->cry();

*/

$c = $_GET['c'];

$a = $_GET['a'];

Container::route($c,$a);