Php 디자인 모델 (3): 행동 형 모델 part 2
22927 단어 디자인 모드
온라인 으로 실행 하여 효 과 를 볼 수 있 습 니 다!
《 윗글 을 잇다 》.
5. 중개 자 모드 (Mediator):
중개 대상 으로 일련의 대상 의 상호작용 을 밀봉 하고 중 개 는 각 대상 이 명시 적 으로 서로 인용 할 필요 가 없 게 한다.우체국 과 비슷 하 게 우송 자 와 수신 자 는 스스로 먼 길 을 가지 않 고 우체국 을 통과 하면 된다.
장점: 대상 간 의 관 계 를 간소화 하고 하위 클래스 의 생 성 을 줄인다.
단점: 중개 대상 이 매우 복잡 해 지고 시스템 을 유지 하기 어 려 울 수 있 습 니 다.
응용 장면: 상호작용 을 표시 할 필요 가 없습니다.
코드 구현:
<?php
/**
*
*
* Mediator
*
* @author
* @see http://www.ucai.cn
*/
function output($string) {
echo $string . "
";
}
abstract class Mediator { //
abstract public function send($message,$colleague);
}
abstract class Colleague { //
private $_mediator = null;
public function __construct($mediator) {
$this->_mediator = $mediator;
}
public function send($message) {
$this->_mediator->send($message,$this);
}
abstract public function notify($message);
}
class ConcreteMediator extends Mediator { //
private $_colleague1 = null;
private $_colleague2 = null;
public function send($message,$colleague) {
if($colleague == $this->_colleague1) {
$this->_colleague1->notify($message);
} else {
$this->_colleague2->notify($message);
}
}
public function set($colleague1,$colleague2) {
$this->_colleague1 = $colleague1;
$this->_colleague2 = $colleague2;
}
}
class Colleague1 extends Colleague { //
public function notify($message) {
output(sprintf('Colleague-1: %s', $message));
}
}
class Colleague2 extends Colleague { //
public function notify($message) {
output(sprintf('Colleague-2: %s', $message));
}
}
class Client {
public static function test(){
// client
$objMediator = new ConcreteMediator();
$objC1 = new Colleague1($objMediator);
$objC2 = new Colleague2($objMediator);
$objMediator->set($objC1,$objC2);
$objC1->send("to c2 from c1");
$objC2->send("to c1 from c2");
}
}
Client::test();
6. 상태 모드 (State):
대상 은 서로 다른 상태 에서 서로 다른 행 위 를 보인다.여자친 구 처럼 당신 의 손 을 잡 는 것 이 기 쁘 고 개 를 산책 시 키 는 것 이 기 쁘 지 않 습 니 다.두 가지 상태 에서 서로 다른 행 위 를 드러내다.
장점: if 문장 이 실 용적 이지 않도록 새로운 상 태 를 증가 시 키 고 상태 전환 규칙 을 봉인 합 니 다.
단점: 시스템 류 와 대상 의 수 를 늘린다.
응용 장면: 대상 의 서로 다른 기능 의 전환 에 사용 합 니 다.
코드 구현:
<?php
/**
*
*
* State
*
* @author
* @see http://www.ucai.cn
*/
function output($string) {
echo $string . "
";
}
abstract class ILift {
//
const OPENING_STATE = 1; //
const CLOSING_STATE = 2; //
const RUNNING_STATE = 3; //
const STOPPING_STATE = 4; // ；
//
public abstract function setState($state);
//
public abstract function open();
// ，
public abstract function close();
// ，
public abstract function run();
//
public abstract function stop();
}
/**
*
*/
class Lift extends ILift {
private $state;
public function setState($state) {
$this->state = $state;
}
//
public function close() {
//
switch ($this->state) {
case ILift::OPENING_STATE: // ，
$this->setState(ILift::CLOSING_STATE);
break;
case ILift::CLOSING_STATE: // ，
//do nothing;
return ;
break;
case ILift::RUNNING_STATE: // ， ，
//do nothing;
return ;
break;
case ILift::STOPPING_STATE: // ， ，
//do nothing;
return ;
break;
}
output('Lift colse');
}
//
public function open() {
//
switch($this->state){
case ILift::OPENING_STATE: // ，
//do nothing;
return ;
break;
case ILift::CLOSING_STATE: // ，
$this->setState(ILift::OPENING_STATE);
break;
case ILift::RUNNING_STATE: // ， ，
//do nothing;
return ;
break;
case ILift::STOPPING_STATE: // ，
$this->setState(ILift::OPENING_STATE);
break;
}
output('Lift open');
}
///
public function run() {
switch($this->state){
case ILift::OPENING_STATE: // ， ，
//do nothing;
return ;
break;
case ILift::CLOSING_STATE: // ，
$this->setState(ILift::RUNNING_STATE);
break;
case ILift::RUNNING_STATE: // ，
//do nothing;
return ;
break;
case ILift::STOPPING_STATE: // ，
$this->setState(ILift::RUNNING_STATE);
}
output('Lift run');
}
//
public function stop() {
switch($this->state){
case ILift::OPENING_STATE: // ， ，
//do nothing;
return ;
break;
case ILift::CLOSING_STATE: // ，
$this->setState(ILift::CLOSING_STATE);
break;
case ILift::RUNNING_STATE: // ，
$this->setState(ILift::CLOSING_STATE);
break;
case ILift::STOPPING_STATE: // ，
//do nothing;
return ;
break;
}
output('Lift stop');
}
}
class Client {
public static function test() {
$lift = new Lift();
//
$lift->setState(ILift::STOPPING_STATE);
// ，
$lift->open();
//
$lift->close();
// ， ，
$lift->run();
// ，
$lift->stop();
}
}
Client::test();
<?php
/**
*
*
* State
*
* @author
* @see http://www.ucai.cn
*/
function output($string) {
echo $string . "
";
}
/**
*
*
*/
abstract class LiftState{
// ，
protected $_context;
public function setContext(Context $context){
$this->_context = $context;
}
//
public abstract function open();
// ，
public abstract function close();
// ，
public abstract function run();
// ，
public abstract function stop();
}
/**
* : 。 ConcreteState ， 。
*/
class Context {
//
static $openningState = null;
static $closeingState = null;
static $runningState = null;
static $stoppingState = null;
public function __construct() {
self::$openningState = new OpenningState();
self::$closeingState = new ClosingState();
self::$runningState = new RunningState();
self::$stoppingState = new StoppingState();
}
//
private $_liftState;
public function getLiftState() {
return $this->_liftState;
}
public function setLiftState($liftState) {
$this->_liftState = $liftState;
//
$this->_liftState->setContext($this);
}
public function open(){
$this->_liftState->open();
}
public function close(){
$this->_liftState->close();
}
public function run(){
$this->_liftState->run();
}
public function stop(){
$this->_liftState->stop();
}
}
/**
*
*/
class OpenningState extends LiftState {
/**
* ，
*
*/
public function close() {
//
$this->_context->setLiftState(Context::$closeingState);
// CloseState
$this->_context->getLiftState()->close();
}
//
public function open() {
output('lift open...');
}
// ， ， ！
public function run() {
//do nothing;
}
// ？
public function stop() {
//do nothing;
}
}
/**
* ，
*/
class ClosingState extends LiftState {
// ，
public function close() {
output('lift close...');
}
// ， ，
public function open() {
$this->_context->setLiftState(Context::$openningState); //
$this->_context->getLiftState()->open();
}
// ，
public function run() {
$this->_context->setLiftState(Context::$runningState); // ；
$this->_context->getLiftState()->run();
}
// ，
public function stop() {
$this->_context->setLiftState(Context::$stoppingState); // ；
$this->_context->getLiftState()->stop();
}
}
/**
*
*/
class RunningState extends LiftState {
// ？
public function close() {
//do nothing
}
// ？ ！
public function open() {
//do nothing
}
//
public function run() {
output('lift run...');
}
// ， ？！
public function stop() {
$this->_context->setLiftState(Context::$stoppingState); // ；
$this->_context->getLiftState()->stop();
}
}
/**
*
*/
class StoppingState extends LiftState {
// ？ ！
public function close() {
//do nothing;
}
// ， ， ！
public function open() {
$this->_context->setLiftState(Context::$openningState);
$this->_context->getLiftState()->open();
}
// ，
public function run() {
$this->_context->setLiftState(Context::$runningState);
$this->_context->getLiftState()->run();
}
// ？
public function stop() {
output('lift stop...');
}
}
/**
*
*/
class Client {
public static function test() {
$context = new Context();
$context->setLiftState(new ClosingState());
$context->open();
$context->close();
$context->run();
$context->stop();
}
}
Client::test();
7. 직책 체인 모델 (책임 체인):
여러 대상 이 요청 을 처리 할 기회 가 있 습 니 다. 요청 발송 자 와 수신 자 를 위해 결합 을 해제 합 니 다.은행 의 현금인출기 처럼 그것 을 막론하고 돈 을 찾 을 수 있다.
장점: 대상 의 숨겨 진 체인 구 조 를 단순화 하여 새로운 직책 노드 를 추가 하기 쉽다.
단점: 요청 이 수용자 가 없 거나 여러 수신 자 에 의 해 호출 되 어 성능 이 떨 어 질 수 있 습 니 다.
응용 장면: 여러 가지 요청 을 처리 합 니 다.
코드 구현:
<?php
/**
*
*
* Chain of Responsibility
*
* @author
* @see http://www.ucai.cn
*/
function output($string) {
echo $string . "
";
}
/**
* ， 0.5 ， leader OK 。
0.5<= <=3 ， leader ， 。
3< ， leader ， ， ，
10 ， 。
*/
/**
* (Handler:Approver): ， ( )
*
*/
abstract class Handler
{
protected $_handler = null;
protected $_handlerName = null;
public function setSuccessor($handler)
{
$this->_handler = $handler;
}
protected function _success($request)
{
output(sprintf("%s's request was passed", $request->getName()));
return true;
}
abstract function handleRequest($request);
}
/**
* (ConcreteHandler:President): ， ， ， 。
*
*/
class ConcreteHandlerLeader extends Handler
{
function __construct($handlerName){
$this->_handlerName = $handlerName;
}
public function handleRequest($request)
{
if($request->getDay() < 0.5) {
output(sprintf('%s was told', $this->_handlerName)); // leader
return $this->_success($request);
}
if ($this->_handler instanceof Handler) {
return $this->_handler->handleRequest($request);
}
}
}
/**
* Manager
*
*/
class ConcreteHandlerManager extends Handler
{
function __construct($handlerName){
$this->_handlerName = $handlerName;
}
public function handleRequest($request)
{
if(0.5 <= $request->getDay() && $request->getDay()<=3) {
output(sprintf('%s signed', $this->_handlerName)); //
return $this->_success($request);
}
if ($this->_handler instanceof Handler) {
return $this->_handler->handleRequest($request);
}
}
}
class ConcreteHandlerGeneralManager extends Handler
{
function __construct($handlerName){
$this->_handlerName = $handlerName;
}
public function handleRequest($request)
{
if(3 < $request->getDay() && $request->getDay() < 10){
output(sprintf('%s signed', $this->_handlerName)); //
return $this->_success($request);
}
if ($this->_handler instanceof Handler) {
return $this->_handler->handleRequest($request);
} else {
output(sprintf('no one can approve request more than 10 days'));
}
}
}
/**
*
*
*/
class Request
{
private $_name;
private $_day;
private $_reason;
function __construct($name= '', $day= 0, $reason = ''){
$this->_name = $name;
$this->_day = $day;
$this->_reason = $reason;
}
public function setName($name){
$this->_name = $name;
}
public function getName(){
return $this->_name;
}
public function setDay($day){
$this->_day = $day;
}
public function getDay(){
return $this->_day ;
}
public function setReason($reason ){
$this->_reason = $reason;
}
public function getReason( ){
return $this->_reason;
}
}
class Client {
public static function test(){
$leader = new ConcreteHandlerLeader('leader');
$manager = new ConcreteHandlerManager('manager');
$generalManager = new ConcreteHandlerGeneralManager('generalManager');
//
$request = new Request('ucai',4,' ');
$leader->setSuccessor($manager);
$manager->setSuccessor($generalManager);
$result = $leader->handleRequest($request);
}
}
Client::test();
8. 전략 모델 (Strategy):
일련의 알고리즘 을 정의 하고 모든 알고리즘 을 봉 하여 서로 바 꿀 수 있 도록 합 니 다.농구 팀 의 선수 들 처럼 경기장 과 장 하 는 휴식 을 취한 다.감독 은 코트 를 내 려 놓 을 수도 있 고, 코트 를 내 려 놓 을 수도 있다.
장점: 재 활용 가능 한 일련의 알고리즘 과 행 위 를 정의 하고 if else 문 구 를 제거 합 니 다.
단점: 호출 단 은 모든 전략 류 를 알 아야 합 니 다.
응용 장면: 대상 간 의 교체 에 사용 합 니 다.
코드 구현:
<?php
/**
*
*
* Strategy
*
* @author
* @see http://www.ucai.cn
*/
function output($string) {
echo $string . "
";
}
//
interface IStrategy {
public function OnTheWay();
}
class WalkStrategy implements IStrategy {
public function OnTheWay() {
output( ' ');
}
}
class RideBickStrategy implements IStrategy {
public function OnTheWay() {
output( ' ');
}
}
class CarStrategy implements IStrategy {
public function OnTheWay() {
output( ' ');
}
}
// Context
class Context {
public function find($strategy) {
$strategy->OnTheWay();
}
}
class Client {
public static function test(){
$travel = new Context();
$travel->find(new WalkStrategy());
$travel->find(new RideBickStrategy());
$travel->find(new CarStrategy());
}
}
Client::test();
대상 을 한 시각 에 저장 하 는 상태 입 니 다.친, '선생님 오 셨 어 요. 불 러 주세요' 짝 꿍 기억 나 세 요?
장점: 사용자 에 게 상 태 를 회복 할 수 있 는 메커니즘 을 제공 합 니 다.
단점: 자원 소모.
응용 장면: 저장 할 데이터 에 사용
코드 구현:
<?php
/**
*
*
* Memento
*
* @author
* @see http://www.ucai.cn
*/
function output($string) {
echo $string . "
";
}
class Originator { // (Originator)
private $_state;
public function __construct() {
$this->_state = '';
}
public function createMemento() { //
return new Memento($this->_state);
}
public function restoreMemento(Memento $memento) { //
$this->_state = $memento->getState();
}
public function setState($state) { $this->_state = $state; }
public function getState() { return $this->_state; }
public function showState() {
output($this->_state);
}
}
class Memento { // (Memento)
private $_state;
public function __construct($state) {
$this->setState($state);
}
public function getState() { return $this->_state; }
public function setState($state) { $this->_state = $state;}
}
class Caretaker { // (Caretaker)
private $_memento;
public function getMemento() { return $this->_memento; }
public function setMemento(Memento $memento) { $this->_memento = $memento; }
}
class Client {
public static function test(){
$org = new Originator();
$org->setState('open');
$org->showState();
/* */
$memento = $org->createMemento();
/* Caretaker */
$caretaker = new Caretaker();
$caretaker->setMemento($memento);
/* */
$org->setState('close');
$org->showState();
/* */
$org->restoreMemento($caretaker->getMemento());
$org->showState();
}
}
Client::test();
return;
try {
$db->beginTransaction();
$succ = $db->exec($sql_1);
if (!$succ) {
throw new Exception('SQL 1 update failed');
}
$succ = $db->exec($sql_2);
if (!$succ) {
throw new Exception('SQL 2 update failed');
}
$succ = $db->exec($sql_3);
if (!$succ) {
throw new Exception('SQL 3 update failed');
}
$db->commit();
} catch (Exception $exp) {
$db->rollBack();
}
언어의 문법 을 정의 하고 이 언어의 문장 을 해석 하 는 해석 기 를 만 듭 니 다.사전 을 써 본 모든 동 화 는 다 안다.
장점: 확장 성 이 좋 고 유연성 이 크다.
단점: 복잡 한 문법 을 지 키 기 어 려 울 수 있 습 니 다.
응용 장면: 쌍 을 이 루 거나 한 쌍 이 많은 수요 에 사용 합 니 다.
2. 방문 자 모드 (Visitor):
특정한 데이터 구조 에서 각 요소 에 작용 하 는 조작 을 밀봉 하면 데이터 구 조 를 바 꾸 지 않 는 전제 에서 이러한 요소 에 작용 하 는 새로운 조작 을 정의 할 수 있다.예 를 들 어 은행 번호 매기 기.
장점: 관련 사물 을 방문 자 대상 에 집중 시킨다.
단점: 새로운 데이터 구 조 를 늘 리 는 것 은 어렵다.
응용 장면: 줄 서기, 번호 매기 기.
3. 총화
본 고 는 행위 형 모델 을 소개 했다. 행위 모델 은 알고리즘 과 대상 직책 간 의 분배 와 관련 되 고 행위 유형 모델 은 계승 체 제 를 이용 하여 유형 간 에 분 파 된 행 위 를 하 며 Template Method 와 Interpreter 는 유형 행위 모델 이다.행위 대상 모델 사용 대상 복합 이 아니 라 계승, 일부 행위
대상 모드 는 서로 대등한 대상 이 어떻게 서로 협력 하여 그 어떠한 대상 도 단독으로 완성 할 수 없 는 임 무 를 완성 하 는 지 설명 합 니 다. 예 를 들 어 Mediator 가 대상 간 에 mediator 대상 을 도입 하여 소나무 결합 에 필요 한 간접 성 을 제공 합 니 다.Chain of Responsibility 는 더욱 느슨 한 결합 을 제공 합 니 다.
이 는 후보 대상 체인 을 통 해 한 대상 에 게 암시 적 으로 요청 을 보 내 고 실행 시간 에 어떤 후보자 가 체인 에 참여 하 는 지 결정 할 수 있 습 니 다.Observer 는 대상 간 의 의존 관 계 를 정의 하고 유지 합 니 다.다른 행위 대상 모드 는 항상 행 위 를 한 대상 에 밀봉 하고 요청 을 할당 합 니 다.
이 는 Strategy 모드 에서 알고리즘 을 대상 에 밀봉 하여 한 대상 이 사용 하 는 알고리즘 을 변경 하고 지정 할 수 있 습 니 다.command 모드 는 요청 을 대상 에 밀봉 합 니 다. 그러면 매개 변수 로 전달 할 수 있 고 역사 목록 에 저장 하거나 다른 방식 으로 사용 할 수 있 습 니 다.State
패턴 은 대상 의 상 태 를 밀봉 하여 이 대상 의 상태 대상 이 변화 할 때 이 대상 은 행동 을 바 꿀 수 있 습 니 다.Visitor 모드 는 여러 종류 사이 에 분포 하 는 행 위 를 봉인 합 니 다.Iterator 모드 는 집합 대상 을 방문 하고 옮 겨 다 니 는 방식 을 추상 화 했다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
디자인 모델 의 공장 모델, 단일 모델자바 는 23 가지 디자인 모델 (프로 그래 밍 사상/프로 그래 밍 방식) 이 있 습 니 다. 공장 모드 하나의 공장 류 를 만들어 같은 인 터 페 이 스 를 실현 한 일부 종 류 를 인 스 턴 스 로 만 드 는 것...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
