Ich werde Ihnen erklären, wie Sie einen einfachen Relay-Service für das Frontend erstellen (ein Beispiel wird in PHP sein) und wie einfach es ist, eine analoge API in der Basis zu entwerfen und für die Weiterleitung an das Frontend zu registrieren.
PS: Ein Beispiel für Backend und Frontend wird in der Firebird-Datenbank PHP sein. Dies ist jedoch nicht erforderlich. Sie können eine beliebige Programmiersprache und eine beliebige Datenbank verwenden.
PS: Ich bitte Sie, Ihre Hüte nicht zu werfen. Ich weiß, dass es jetzt nicht beliebt ist, aus bestimmten sozialen Gründen gibt es mehr PHP- oder Python-Spezialisten auf dem Markt als SQL-Programmierer, sie sind billiger, jeder liebt ORM. Es wird angenommen, dass es beim Festlegen der Logik in der Datenbank schwieriger ist, eine Microservice-Architektur zu organisieren. Die Versionskontrolle ist schwieriger zu verwalten. Go kompiliert und sollte schneller als eine Datenbank ausgeführt werden. Es ist beliebt, Geschäftslogik in PHP-Frameworks usw. zu legen.
Es gibt viele Gründe und jeder hat Argumente auf der einen und der anderen Seite, und jeder kann tief argumentiert werden.
Dieser Artikel richtet sich jedoch an Personen, die Geschäftslogik in der Datenbank festlegen möchten . Es gibt hier keinen Zweck, eine solche Methode zu fördern. Bitte seien Sie in den Kommentaren korrekt.
Im Allgemeinen ist die Methode sehr einfach und in Bezug auf die Geschwindigkeit ärgerlich. Wenn Sie ein kompetentes Microservice-Relay schreiben und Servicetabellen in der Datenbank aktiv verwenden, erfordert das Registrieren neuer APIs nur eine Servicetabelle des Formulars:
CREATE TABLE DFM_PROC (
ID INTEGER NOT NULL,
NAME VARCHAR(70) NOT NULL,
DISCRIPTION VARCHAR(1000)
);
Beispiel:
Das Schema lautet wie folgt:
Hier wird erläutert, wie die Arbeit des Mikroservices "Service for Interface" organisiert wird. Ich werde ein
Beispiel für ein Frontend in PHP geben
function ser1($proc_id,$json)
{
//
$post='hash='.$_SESSION['sess_id'].'&user_id='.$_SESSION['id_user'].'&proc_id='.$proc_id.'&json='.base64_encode($json);
//
$url = 'http://192.168.128.1/ser.php';
$ch = curl_init();
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST , true);
curl_setopt($ch, CURLOPT_POSTFIELDS ,$post);
$result = curl_exec($ch);
$arr_res=json_decode($result,true);
curl_close($ch);
return $arr_res;
}
//
//
// 4 -
if (isset($_POST['go_new_prof']))
{
unset($arr);
$arr['0']=$_SESSION['id_user'];
$arr['1']=(int)$_GET['tp'];
$arr['2']=(int)$_POST['lang_list'];
$arr_prof=ser1(4,json_encode($arr));
}
Ein Beispiel für eine aufgerufene Prozedur in SQL
create or alter procedure DFM_PROF_ADD (
USER_ID smallint,
TYPE_ varchar(10),
LANG smallint)
as
begin
INSERT INTO DFM_PROFILES (USER_ID, TYPE_, LANG)
VALUES (:USER_ID, :TYPE_, :LANG);
suspend;
end
Jetzt verstehen wir, wie ein Microservice-Relay versteht, dass es notwendig ist, dieses spezielle Verfahren durchzuführen, wie es versteht, welche Parameter es hat, wie es es abruft. Ich werde einen Beispielcode geben, Details in den Kommentaren im Code
<?php
$proc_id=(int)$_POST['proc_id'];
$json= base64_decode($_POST['json']);
$arr_json = json_decode($json,true);
// JSON
switch (json_last_error()) {
case JSON_ERROR_NONE:
$err = null;
break;
case JSON_ERROR_DEPTH:
$err = ' ';
break;
case JSON_ERROR_STATE_MISMATCH:
$err = ' ';
break;
case JSON_ERROR_CTRL_CHAR:
$err = ' ';
break;
case JSON_ERROR_SYNTAX:
$err = ' , JSON';
break;
case JSON_ERROR_UTF8:
$err = ' UTF-8, ';
break;
default:
$err = ' ';
break;
}
// JSON
if ($err==null)
{
// ID
$user_id=1;
// ID
$sql_proc = "select p.name from DFM_PROC p where p.id=".$proc_id;
$res_proc = ibase_query($dbh, $sql_proc);
$prom_proc = ibase_fetch_row($res_proc);
//
$sql_in='select ';
// ,
// RDB$PROCEDURE_PARAMETERS
$sql = 'select pp.rdb$parameter_number, pp.rdb$parameter_name from DFM_PROC p
left join RDB$PROCEDURE_PARAMETERS pp on pp.rdb$procedure_name=UPPER(p.name)
where p.id='.$proc_id.' and pp.rdb$parameter_type=1 --
order by pp.rdb$parameter_number';
$res = ibase_query($dbh, $sql);
$i_cou_out=0;
while($prom = ibase_fetch_row($res))
{
//p. -
$i_cou_out++;
if ($prom[0]>0) $sql_in.=',';
$sql_in.='p.'.$prom[1];
$name_out[$prom[0]]=$prom[1];
}
// -
$sql_in.=' from '.$prom_proc[0];
// , , execute procedure
if ($i_cou_out==0) $sql_in='execute procedure '.$prom_proc[0];
//
$sql = 'select
pp.rdb$parameter_number,
pp.rdb$parameter_name,
case
when f.rdb$field_type=7 then 1 --smalint
when f.rdb$field_type=8 then 2 --integer
when f.rdb$field_type=16 and f.rdb$field_scale=0 then 3 --bigint
when f.rdb$field_type=16 and f.rdb$field_scale<0 then 4 --frloat
when f.rdb$field_type=12 then 5 --date
when f.rdb$field_type=13 then 6 --time
when f.rdb$field_type=35 then 7 --timestamp
when f.rdb$field_type=37 then 8 --varcahr
end,
f.rdb$field_type, --
f.rdb$character_length, --
f.rdb$field_precision, --
f.rdb$field_scale --
from DFM_PROC p
left join RDB$PROCEDURE_PARAMETERS pp on pp.rdb$procedure_name=UPPER(p.name)
left join RDB$FIELDS f on f.rdb$field_name=pp.rdb$field_source
where p.id='.$proc_id.' and pp.rdb$parameter_type=0 --
order by pp.rdb$parameter_number';
$res = ibase_query($dbh, $sql);
$i_cou=0;
while($prom = ibase_fetch_row($res))
{
$i_cou++;
if ($prom[0]>0) $sql_in.=','; else $sql_in.='(';
if (($prom[2]==5)or($prom[2]==6)or($prom[2]==7)or($prom[2]==8))
//
// null
if ($arr_json[$prom[0]]=='')
$sql_in.="null";
else
$sql_in.="'".($arr_json[$prom[0]])."'";
else
//
if ($arr_json[$prom[0]]=='')
$sql_in.="null";
else
$sql_in.=($arr_json[$prom[0]]);
}
//
if ($i_cou_out==0)
{if ($i_cou>0) $sql_in.=')';}
else
{if ($i_cou>0) $sql_in.=') p'; else $sql_in.=' p';}
// p.
//
$res_in = ibase_query($dbh, $sql_in);
if ($i_cou_out==0)
{
// execute procedure
$json_out='{
"error_json":"",
"error_code_json":"",
"result":" execute procedure",
"result_code":0
}';
}
else
{
// json
$i_json=0;
$json_out='{';
while($prom_in = ibase_fetch_row($res_in))
{
if ($i_json>0) $json_out.=',';
$json_out.='"'.$i_json.'":{';
foreach($prom_in as $k => $v)
{
if ($k>0) $json_out.=',
';
$json_out.='"'.trim($name_out[$k]).'":"'.$v.'"';
}
$json_out.='}';
$i_json++;
}
$json_out.='}';
}
// - , ,
if (ibase_errmsg()=='')
{
//
echo $json_out;
}
else
{
//
$err_json='{
"error_json":"'.$err.'",
"error_code_json":'.json_last_error().',
"result":"'.str_replace('"','\'',ibase_errmsg()).'",
"result_code":2,
"sql_err":"'.$sql_in.'"}';
echo $err_json;
}
}
else
{
// JSON
$err_json='{
"error_json":"'.$err.'",
"error_code_json":'.json_last_error().',
"result":" json",
"result_code":3
}';
echo $err_json;
}
?>
Was wir am Ende bekommen.
1) Wir schreiben 1 Mal ein Microservice-Relais. Der gesamte Rest des Entwurfs der Backend-Architektur findet in der Datenbank statt. In PHP (oder Go, Python, wie der Microservice aussehen wird) klettern wir nicht mehr.
Zum Beispiel wurde eine neue Funktion auf der Site benötigt - ein Frontend wird durchgeführt, ein Verfahren wird durchgeführt. Die Prozedur ist in der Platte registriert und das Frontend ruft über seine Registrierungsnummer die Microservice-API auf. ALLES.
Ich empfehle, ein Microservice-Relay in Go als kompiliert und viel schneller zu schreiben. Der Vorteil ist, dass es nur einmal geschrieben werden muss und das Programm nicht kompliziert ist. Darüber hinaus wird es ein hoch geladenes Element sein, zu dem intensive Anrufe auftreten.
Bibliothek zum Verbinden von Firebird mit Goland: https://github.com/nakagami/firebirdsql .
2) Die gesamte Verarbeitung erfolgt in Prozeduren - wir erhalten kompilierte Elemente, die alles auf Datenbankebene verarbeiten und ein ERGEBNIS erzeugen. Jene. Wenn der Vorgang aus mehreren Auswahl-, Einfüge-, Aktualisierungs- usw. besteht. Wir leiten Daten nicht über das Netzwerk zum Backend, sondern verarbeiten sie sofort in der Datenbank.
Außerdem ist eine Prozedur ein kompiliertes Element mit einem generierten Abfrageplan. Auch dafür werden keine Ressourcen aufgewendet.
3) Microservice-Relay bezieht sich zur Bildung der Prozedur viermal auf die Datenbank.
1. Rufen Sie den Namen ab.
2. Rufen Sie die ausgehenden Parameter ab.
3. Rufen Sie die eingehenden Parameter ab.
4. Führen Sie die Prozedur aus
4 mal, weil wir eine universelle Methode in Betracht gezogen haben. Dies kann auf einmal reduziert werden.
Wie:
1. Es kann beispielsweise lokal in einem Texteditor auf einem Webserver gespeichert werden. In regelmäßigen Abständen nur diese Tabelle abrufen und aktualisieren, wenn eine neue hinzugefügt wird.
2.3. Ebenso können Sie es lokal speichern, indem Sie es überall hin ziehen, wenn etwas aktualisiert wird.
4) Nicht alle Backends können in der Datenbank ausgeführt werden! Dies ist ein wesentlicher Bestandteil von allem, aber man muss sich von Überlegungen zur Zweckmäßigkeit leiten lassen .
Zum Beispiel einige Chats, Mailings usw. Aspekte des Lebens eines Webdienstes müssen natürlich als separate Mikrodienste in der dafür am besten geeigneten Programmiersprache ausgeführt werden. Es ist nicht notwendig, die gesamte Logik des Webdienstes um jeden Preis auf die Basis zu übertragen! Sie müssen nur das Teil übertragen, das dafür geeignet ist!