Write RESTful interface in PHP, write restful_PHP tutorial in PHP

PHP writes RESTful interface, PHP writes restful

First of all, let’s get to know RESTful

Restful is a design style rather than a standard. For example, an interface originally looked like this: http://www.test.com/user/view/id/1

means to obtain the user information with ID 1. If you use Restful style, it can become like this:

http://www.test.com/user/1

The benefits of this can be clearly seen:

1. More concise URL, friendly to programmers

2. Does not expose internal code structure, safer

So, how to implement this interface? First, we need to receive the /user/1 part.

$path = $_SERVER['PATH_INFO']; 
$arr = explode('/',$path); 
print_r($arr);

Get the following results:

Array ( [0] => [1] => User [2] => 1 )

After obtaining the parameters, the following operation is very simple:

if($arr[1] == 'user'){ 
$model = new UserModel(); 
$id = $arr[2]; //读取用户信息 
$user_info = $model->find($id); 
echo json_encode($user_info); 
}

In this way, we have implemented a Restful style API.

Next, let’s look at how to implement the interface for reading the user list, the traditional way: http://www.test.com/user/list
Using Restful style, it can be more concise:

http://www.test.com/user

The difference between

and reading user information is that there is no id after user, so we can make some modifications based on the reading part:

if($arr[1] == 'user'){ 
$model = new UserModel(); 
$id = $arr[2]; if($id){ //读取用户信息 
$user_info = $model->find($id); 
echo json_encode($user_info); 
}else{ //读取用户列表 
$user_list = $model->select(); 
echo json_encode($user_list); } }

This implements the interface for reading the user list.

Let’s look at how to implement the interface for adding users, the traditional way:

http://www.test.com/user/add

Restful style:

http://www.test.com/user
It is the same as the interface for reading the user list. How to distinguish it? In fact, it is very simple. Reading is a GET request, while adding is a POST request. User information is stored in the POST parameters, so the following modifications can be made to the code:

if($arr[1] == 'user'){ 
$model = new UserModel(); 
$id = $arr[2]; 
if($id){ //读取用户信息 
$user_info = $model->find($id); 
echo json_encode($user_info); 
}else{ 
if(IS_POST){ //增加用户 
$res = $model->add($_POST); 
if($res){ echo 'success'; 
}else{ echo 'fail'; } 
}else{ //读取用户列表 
$user_list = $model->select(); 
echo json_encode($user_list); } } } 

The same interface can execute different logic according to the HTTP request method.
This is the core idea of ​​implementing Restful style API. By analogy, we can implement editing user interface and deletion user interface:

http://www.test.com/user/1
As long as different request methods are used, they can be distinguished. We can use PUT requests to perform editing operations and DELETE requests to perform deletion operations.

I won’t write the specific code. Interested friends can try to implement the following by themselves.

The Thinkphp framework also provides support for Restful style, and the principle is similar.

To summarize, the Restful style uses simple URLs and HTTP requests to implement interfaces.

PHPRS github

This is a lightweight framework designed for rapid development of RESTful interfaces. If you are like me and are tired of using the traditional MVC framework to write microservices or API interfaces with separate front-end and back-end, and can't stand a lot of redundant coding (and CTRL-C/CTRL-V) for a simple interface, then, You will definitely love this frame!

Let me give you a chestnut first

Write HelloWorld.php and place it in the directory specified by the framework (the default is the apis/directory at the same level as index.php)

/**
 * @path("/hw")
 */
class HelloWorld
{
  /** 
   * @route({"GET","/"})
   */
  public function doSomething() {
    return "Hello World!";
  }
}

Enter http://your-domain/hw/
in your browser

You will see: Hello World! It’s that simple, no additional configuration, no inheritance or combination is required.

What happened

Looking back at HelloWorld.php, the special thing is the annotations (@path, @route). Yes, the framework obtains routing information and binds input and output through annotations. But don't worry about performance, annotations will only be parsed once after the class file is modified. More @ comments will be explained later.

Let’s look at a more specific example

This is an example of the login interface

/**
 * 用户权限验证
 * @path("/tokens/") 
 */
class Tokens
{ 
  /**
   * 登录
   * 通过用户名密码授权
   * @route({"POST","/accounts/"}) 
   * @param({"account", "$._POST.account"}) 账号
   * @param({"password", "$._POST.password"}) 密码
   * 
   * @throws ({"InvalidPassword", "res", "403 Forbidden", {"error":"InvalidPassword"} }) 用户名或密码无效
   * 
   * @return({"body"})  
   * 返回token，同cookie中的token相同,
   * {"token":"xxx", "uid" = "xxx"}
   *
   * @return({"cookie","token","$token","+365 days","/"}) 通过cookie返回token
   * @return({"cookie","uid","$uid","+365 days","/"}) 通过cookie返回uid
   */
  public function createTokenByAccounts($account, $password, &$token,&$uid){
    //验证用户
    $uid = $this->users->verifyPassword($account, $password);
    Verify::isTrue($uid, new InvalidPassword($account));
    $token = ...;
    return ['token'=>$token, 'uid'=>$uid];
  } 
  /**
   * @property({"default":"@Users"})  依赖的属性，由框架注入
   * @var Users
   */
  public $users;
}

What else can you do

1. Dependency management (dependency injection),
2. Automatically output interface documents (not doxgen-style class and method documents, but documents describing http interfaces)
3. Interface cache
4. hook
   

Cooperate with ezsql to access the database

ezsql is a simple object-oriented SQL building tool that provides simple basic SQL operations.

Interface

/** @path(/myclass) */
class MyClass{

  /**
  * @route({"GET","/do"})
  * @param({"arg0","$._GET.arg0"})
  */
  public doSomething($arg0){
    return Sql::select('xxx')->from('table_xxx')->where( 'xxx = ?', $arg0)->get($this->db);
  }
  /**
   * 依赖注入PDO实例
   * @property
   * @var PDO
   */
  public $db;
}

Configuration file

{
  {
    "MyClass":{
      "properties":{
        "db":"@db1"   
      }
    },
  },
  "db1":{
    "singleton":true,
    "class":"PDO",
    "pass_by_construct":true,
    "properties":{
      "dsn":"mysql:host=127.0.0.1;dbname=xxx",
      "username":"xxxx",
      "passwd":"xxxx"      
    }
  },
}

Articles you may be interested in:

• Sharing of routing classes for PHP to handle restful requests
• PHP implements automatic recognition of the return content type of Restful API
• php Making a cross-platform restful interface based on curl extension
• How to write a RESTful interface in PHP

http://www.bkjia.com/PHPjc/1102463.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/1102463.htmlTechArticlePHP writes RESTful interface, php writes restful. First, let’s understand RESTful. Restful is a design style rather than a standard. For example, an interface originally looked like this: http://www.test.com/...