前言:我们在开发及测试过程中, 可能项目放在VMware中或远程的虚拟机中, 那么本地物理机如何同步代码到远程呢.下面窝为大家来讲解.
- 选择创建类型
- 选择连接方式
- 选择本地项目
- 配置选项
- 尝试连接
- 该错误可能是虚拟机中的nginx服务器没开,所以连接不上
7.绑定域名及映射文件夹(注意,若是VMware,物理机需要配置host)
8.测试
docker-compose up -d zookeeper
# 需要先安装zookeeper,不然启动kafka会报错
docker-compose up -d kafka
KAFKA_ADVERTISED_HOST=192.168.20.128
PHP_FPM_INSTALL_RDKAFKA=true
WORKSPACE_INSTALL_RDKAFKA=true
### kafka ####################################################
kafka:
image: wurstmeister/kafka
ports:
- "9092:9092"
environment:
KAFKA_BROKER_ID: 1
KAFKA_ADVERTISED_HOST_NAME: ${KAFKA_ADVERTISED_HOST}
KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://${KAFKA_ADVERTISED_HOST}:9092
KAFKA_MESSAGE_MAX_BYTES: 2000000
KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
volumes:
- ${DATA_PATH_HOST}/kafka:/kafka
- /var/run/docker.sock:/var/run/docker.sock
networks:
- backend
compose require nmred/kafka-php
<?php
require __DIR__ . "/../vendor/autoload.php";
date_default_timezone_set('PRC');
//use Monolog\Logger;
//use Monolog\Handler\StdoutHandler;
// Create the logger
//$logger = new Logger('my_logger');
// Now add some handlers
//$logger->pushHandler(new StdoutHandler());
$config = \Kafka\ProducerConfig::getInstance();
$config->setMetadataRefreshIntervalMs(10000);
$config->setMetadataBrokerList('192.168.20.128:9092');
$config->setBrokerVersion('1.0.0');
$config->setRequiredAck(1);
$config->setIsAsyn(false);
$config->setProduceInterval(500);
$producer = new \Kafka\Producer(
function() {
return [
[
'topic' => 'test',
'value' => 'test....message.333333',
'key' => 'testkey',
],
];
}
);
//$producer->setLogger($logger);
$producer->success(function($result) {
var_dump($result);
});
$producer->error(function($errorCode) {
var_dump($errorCode);
});
$producer->send(true);
<?php
require __DIR__ . "/../vendor/autoload.php";
$objRdKafka = new RdKafka\Consumer();
$objRdKafka->setLogLevel(LOG_DEBUG);
$objRdKafka->addBrokers("192.168.20.128:9092");
$oObjTopic = $objRdKafka->newTopic("test");
/**
* consumeStart
* 第一个参数标识分区，生产者是往分区0发送的消息，这里也从分区0拉取消息
* 第二个参数标识从什么位置开始拉取消息，可选值为
* RD_KAFKA_OFFSET_BEGINNING : 从开始拉取消息
* RD_KAFKA_OFFSET_END : 从当前位置开始拉取消息
* RD_KAFKA_OFFSET_STORED : 猜测跟RD_KAFKA_OFFSET_END一样
*/
$oObjTopic->consumeStart(0, RD_KAFKA_OFFSET_END);
while (true) {
// 第一个参数是分区，第二个参数是超时时间
$oMsg = $oObjTopic->consume(0, 1000);
// 没拉取到消息时，返回NULL
if (!$oMsg) {
usleep(10000);
continue;
}
if ($oMsg->err) {
echo $oMsg->errstr(), "\n";
break;
} else {
echo $oMsg->payload, "\n";
}
}
function dubbleSort($arr)
{
$length = count($arr);
if ($length == 1) return $arr;
for ($i = 0; $i < $length; $i++) {
$isOver = false
for ($j = 0; $j < $length - $i - 1; $j++) {
if ($arr[$j] > $arr[$j + 1]) {
$temp = $arr[$j];
$arr[$j] = $arr[$j + 1];
$arr[$j + 1] = $temp;
$isOver = true;
}
}
if (!$isOver) {
break;
}
}
return $arr;
}
function selectSort($arr)
{
$len = count($arr);
for($i = 0;$i<$length -1;$i++){
$min = $i;
for($j = $i + 1;$j<$length;$j++){
if($arr[$j] < $arr[$i]){
$min = $j;
}
}
if($i != $min){
$temp = $arr[$i];
$arr[$i] = $arr[$min];
$arr[$min] = $temp;
}
}
return $arr;
}
function quickSort($arr)
{
if(count($arr) <= 1) return $arr;
$mid = $arr[0];
$left = [];
$right = [];
for($i = 1;$i<count($arr);$i++){
if($arr[$i] > $mid){
$right[] = $arr[$i];
}else{
$left[] = $arr[$i];
}
}
$left = quickSort($left);
$right = quickSort($right);
return array_merge($left,[$mid],$right);
}
function insertSort($arr)
{
$length = count($arr);
for ($i = 1; $i < $length; $i++) {
$pos = $i;
$key = $arr[$i];
while ($pos > 0 && $arr[$pos - 1] > $key) {
$arr[$pos] = $arr[$pos - 1];
$pos = $pos - 1;
}
$arr[$pos] = $key;
}
return $arr;
}
function search($arr, $target)
{
return recursion(&$arr, 0, count($arr) - 1, $target);
}
function recursion($arr, $l, $r, $tarfet)
{
$mid = intval(($l + $r) / 2);
if ($l > $r) return -1;
if ($target > $arr[$mid]) {
return recursion($arr, $arr[$mid] + 1, $r, $tarfet);
} elseif ($target < $arr[$mid]) {
return recursion($arr, $l, $arr[$mid] - 1, $tarfet);
} else {
return $mid;
}
}
function str_rev($str)
{
$i = 0;
while(1){
if(!isset($str)){
break;
}
$i++;
}
for($j = $i -1;$j>=0;$j--){
$temp .= $str[$j];
}
return $temp;
}
前言:我们在开发及测试过程中, 可能项目放在VMware中或远程的虚拟机中, 那么本地物理机如何同步代码到远程呢.下面窝为大家来讲解.
7.绑定域名及映射文件夹(注意,若是VMware,物理机需要配置host)
8.测试
卸载旧版本
sudo yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
下载需要的安装包
sudo yum install -y yum-utils
设置仓库镜像
sudo yum-config-manager \
--add-repo \
https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo #默认为国外
sudo yum makecache fast # 更新yum索引
安装docker
sudo yum install docker-ce docker-ce-cli containerd.io
启动docker
sudo systemctl start docker
测试docker镜像
sudo docker run hello-world
查看镜像
sudo docker images
卸载docker环境
sudo yum remove docker-ce docker-ce-cli containerd.io
卸载docker
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd
启动docker
sudo systemctl start docker
sudo systemctl restart docker #重启
docker常用运行方式
-d #后台加载
-it #交互运行
-p #绑定端口
-v #绑定挂载目录
docker ps #查看docker进程
docker images #查看镜像
docker commit -m #提交镜像文件
docker save #保存镜像文件
docker pull #获取镜像
docker run 将镜像加载到容器
docker up 将镜像更新启动到容器
docker start 开启容器
创建docker-compose目录
mkdir docker-compose
安装docker-compose
cd docker-compose
vim docker-compose.yml
upstream
利用dockerFile定义运行环境镜像
使用docker-compose.yml定义组成应用的各服务
运行docker-compose up
.env 文件修改
DB_HOST=mysql
REDIS_HOST=redis
QUEUE_HOST=beanstalkd
PHP56=5.6 #添加php5.6常量
打开docker-compose.yml文件(主要修改两处)
新增 PHP-FPM-56 配置项
LARADOCK_PHP_VERSION=${PHP56}
ports:
- "19003:19003"
### PHP-FPM-56 ##############################################
php-fpm-56:
build:
context: ./php-fpm-56
args:
- CHANGE_SOURCE=${CHANGE_SOURCE}
- BASE_IMAGE_TAG_PREFIX=${PHP_FPM_BASE_IMAGE_TAG_PREFIX}
- LARADOCK_PHP_VERSION=${PHP56}
- LARADOCK_PHALCON_VERSION=${PHALCON_VERSION}
- INSTALL_BZ2=${PHP_FPM_INSTALL_BZ2}
- INSTALL_ENCHANT=${PHP_FPM_INSTALL_ENCHANT}
- INSTALL_GMP=${PHP_FPM_INSTALL_GMP}
- INSTALL_GNUPG=${PHP_FPM_INSTALL_GNUPG}
- INSTALL_XDEBUG=${PHP_FPM_INSTALL_XDEBUG}
- INSTALL_PCOV=${PHP_FPM_INSTALL_PCOV}
- INSTALL_PHPDBG=${PHP_FPM_INSTALL_PHPDBG}
- INSTALL_BLACKFIRE=${INSTALL_BLACKFIRE}
- INSTALL_SSH2=${PHP_FPM_INSTALL_SSH2}
- INSTALL_SOAP=${PHP_FPM_INSTALL_SOAP}
- INSTALL_XSL=${PHP_FPM_INSTALL_XSL}
- INSTALL_SMB=${PHP_FPM_INSTALL_SMB}
- INSTALL_IMAP=${PHP_FPM_INSTALL_IMAP}
- INSTALL_MONGO=${PHP_FPM_INSTALL_MONGO}
- INSTALL_AMQP=${PHP_FPM_INSTALL_AMQP}
- INSTALL_CASSANDRA=${PHP_FPM_INSTALL_CASSANDRA}
- INSTALL_GEARMAN=${PHP_FPM_INSTALL_GEARMAN}
- INSTALL_MSSQL=${PHP_FPM_INSTALL_MSSQL}
- INSTALL_BCMATH=${PHP_FPM_INSTALL_BCMATH}
- INSTALL_PHPREDIS=${PHP_FPM_INSTALL_PHPREDIS}
- INSTALL_MEMCACHED=${PHP_FPM_INSTALL_MEMCACHED}
- INSTALL_OPCACHE=${PHP_FPM_INSTALL_OPCACHE}
- INSTALL_EXIF=${PHP_FPM_INSTALL_EXIF}
- INSTALL_AEROSPIKE=${PHP_FPM_INSTALL_AEROSPIKE}
- INSTALL_OCI8=${PHP_FPM_INSTALL_OCI8}
- INSTALL_MYSQLI=${PHP_FPM_INSTALL_MYSQLI}
- INSTALL_PGSQL=${PHP_FPM_INSTALL_PGSQL}
- INSTALL_PG_CLIENT=${PHP_FPM_INSTALL_PG_CLIENT}
- INSTALL_POSTGIS=${PHP_FPM_INSTALL_POSTGIS}
- INSTALL_INTL=${PHP_FPM_INSTALL_INTL}
- INSTALL_GHOSTSCRIPT=${PHP_FPM_INSTALL_GHOSTSCRIPT}
- INSTALL_LDAP=${PHP_FPM_INSTALL_LDAP}
- INSTALL_PHALCON=${PHP_FPM_INSTALL_PHALCON}
- INSTALL_SWOOLE=${PHP_FPM_INSTALL_SWOOLE}
- INSTALL_TAINT=${PHP_FPM_INSTALL_TAINT}
- INSTALL_IMAGE_OPTIMIZERS=${PHP_FPM_INSTALL_IMAGE_OPTIMIZERS}
- INSTALL_IMAGEMAGICK=${PHP_FPM_INSTALL_IMAGEMAGICK}
- INSTALL_CALENDAR=${PHP_FPM_INSTALL_CALENDAR}
- INSTALL_FAKETIME=${PHP_FPM_INSTALL_FAKETIME}
- INSTALL_IONCUBE=${PHP_FPM_INSTALL_IONCUBE}
- INSTALL_APCU=${PHP_FPM_INSTALL_APCU}
- INSTALL_CACHETOOL=${PHP_FPM_INSTALL_CACHETOOL}
- INSTALL_YAML=${PHP_FPM_INSTALL_YAML}
- INSTALL_RDKAFKA=${PHP_FPM_INSTALL_RDKAFKA}
- INSTALL_GETTEXT=${PHP_FPM_INSTALL_GETTEXT}
- INSTALL_ADDITIONAL_LOCALES=${PHP_FPM_INSTALL_ADDITIONAL_LOCALES}
- INSTALL_MYSQL_CLIENT=${PHP_FPM_INSTALL_MYSQL_CLIENT}
- INSTALL_PING=${PHP_FPM_INSTALL_PING}
- INSTALL_SSHPASS=${PHP_FPM_INSTALL_SSHPASS}
- INSTALL_MAILPARSE=${PHP_FPM_INSTALL_MAILPARSE}
- INSTALL_PCNTL=${PHP_FPM_INSTALL_PCNTL}
- ADDITIONAL_LOCALES=${PHP_FPM_ADDITIONAL_LOCALES}
- INSTALL_FFMPEG=${PHP_FPM_FFMPEG}
- INSTALL_AUDIOWAVEFORM=${PHP_FPM_AUDIOWAVEFORM}
- INSTALL_WKHTMLTOPDF=${PHP_FPM_INSTALL_WKHTMLTOPDF}
- INSTALL_XHPROF=${PHP_FPM_INSTALL_XHPROF}
- INSTALL_XMLRPC=${PHP_FPM_INSTALL_XMLRPC}
- INSTALL_PHPDECIMAL=${PHP_FPM_INSTALL_PHPDECIMAL}
- INSTALL_ZOOKEEPER=${PHP_FPM_INSTALL_ZOOKEEPER}
- INSTALL_SSDB=${PHP_FPM_INSTALL_SSDB}
- DOWNGRADE_OPENSSL_TLS_AND_SECLEVEL=${PHP_DOWNGRADE_OPENSSL_TLS_AND_SECLEVEL}
- PUID=${PHP_FPM_PUID}
- PGID=${PHP_FPM_PGID}
- IMAGEMAGICK_VERSION=${PHP_FPM_IMAGEMAGICK_VERSION}
- LOCALE=${PHP_FPM_DEFAULT_LOCALE}
- PHP_FPM_NEW_RELIC=${PHP_FPM_NEW_RELIC}
- PHP_FPM_NEW_RELIC_KEY=${PHP_FPM_NEW_RELIC_KEY}
- PHP_FPM_NEW_RELIC_APP_NAME=${PHP_FPM_NEW_RELIC_APP_NAME}
- INSTALL_DOCKER_CLIENT=${PHP_FPM_INSTALL_DOCKER_CLIENT}
- http_proxy
- https_proxy
- no_proxy
volumes:
- ./php-fpm/php${PHP_VERSION}.ini:/usr/local/etc/php/php.ini
- ${APP_CODE_PATH_HOST}:${APP_CODE_PATH_CONTAINER}${APP_CODE_CONTAINER_FLAG}
- docker-in-docker:/certs/client
ports:
- "19003:19003"
expose:
- "9000"
extra_hosts:
- "dockerhost:${DOCKER_HOST_IP}"
environment:
- PHP_IDE_CONFIG=${PHP_IDE_CONFIG}
- DOCKER_HOST=tcp://docker-in-docker:2376
- DOCKER_TLS_VERIFY=1
- DOCKER_TLS_CERTDIR=/certs
- DOCKER_CERT_PATH=/certs/client
- FAKETIME=${PHP_FPM_FAKETIME}
depends_on:
- workspace
networks:
- backend
links:
- docker-in-docker
打开 /var/www/laradock/nginx/sites/ 目录项目文件配置
location ~ \.php$ {
try_files $uri /index.php =404;
fastcgi_pass php-fpm-56:9000;
fastcgi_index index.php;
fastcgi_buffers 16 16k;
fastcgi_buffer_size 32k;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
#fixes timeouts
fastcgi_read_timeout 600;
include fastcgi_params;
}
注意事项, 启动失败可能是端口冲突, 我们需要查看进程是否正常
正向代理
- 使单个域名对应的端口号对应单个项目
- vim /var/www/laradock/nginx/dockerFile
修改 EXPOSE 80 81 443 8888
- vim /var/www/laradock/nginx/sites/laravel.conf #配置端口映射
server {
listen 8888;
listen [::]:8888;
# For https
# listen 443 ssl;
# listen [::]:443 ssl ipv6only=on;
# ssl_certificate /etc/nginx/ssl/default.crt;
# ssl_certificate_key /etc/nginx/ssl/default.key;
server_name myproject.test;
root /var/www/laraFile/public;
index index.php index.html index.htm;
location / {
try_files $uri $uri/ /index.php$is_args$args;
}
location ~ \.php$ {
try_files $uri /index.php =404;
fastcgi_pass php-upstream;
fastcgi_index index.php;
fastcgi_buffers 16 16k;
fastcgi_buffer_size 32k;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
#fixes timeouts
fastcgi_read_timeout 600;
include fastcgi_params;
}
location ~ /\.ht {
deny all;
}
location /.well-known/acme-challenge/ {
root /var/www/letsencrypt/;
log_not_found off;
}
error_log /var/log/nginx/laravel_error.log;
access_log /var/log/nginx/laravel_access.log;
}
- /var/www/laradock/docker-compose.yml #添加端口映射
### NGINX Server #########################################
nginx:
build:
context: ./nginx
args:
- CHANGE_SOURCE=${CHANGE_SOURCE}
- PHP_UPSTREAM_CONTAINER=${NGINX_PHP_UPSTREAM_CONTAINER}
- PHP_UPSTREAM_PORT=${NGINX_PHP_UPSTREAM_PORT}
- http_proxy
- https_proxy
- no_proxy
volumes:
- ${APP_CODE_PATH_HOST}:${APP_CODE_PATH_CONTAINER}${APP_CODE_CONTAINER_FLAG}
- ${NGINX_HOST_LOG_PATH}:/var/log/nginx
- ${NGINX_SITES_PATH}:/etc/nginx/sites-available
- ${NGINX_SSL_PATH}:/etc/nginx/ssl
ports:
- "${NGINX_HOST_HTTP_PORT}:80"
- "${NGINX_HOST_HTTPS_PORT}:443"
- "${VARNISH_BACKEND_PORT}:81"
- "${MY_PROJECT_PORT}:8888"
depends_on:
- php-fpm
networks:
- frontend
- backend
- vim /var/www/laradock/.env #配置.env文件
### Paths #################################################
DB_HOST=mysql
REDIS_HOST=redis
QUEUE_HOST=beanstalkd
PHP56=5.6
MY_PROJECT_PORT=8888
反向代理
upstream cluster {
server 192.168.20.128;
}
server {
listen 8888;
listen [::]:8888;
# For https
# listen 443 ssl;
# listen [::]:443 ssl ipv6only=on;
# ssl_certificate /etc/nginx/ssl/default.crt;
# ssl_certificate_key /etc/nginx/ssl/default.key;
server_name myproject.test;
root /var/www/laraFile/public;
index index.php index.html index.htm;
location / {
try_files $uri $uri/ /index.php$is_args$args;
proxy_pass http://cluster;
}
location ~ \.php$ {
try_files $uri /index.php =404;
fastcgi_pass php-upstream;
fastcgi_index index.php;
fastcgi_buffers 16 16k;
fastcgi_buffer_size 32k;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
#fixes timeouts
fastcgi_read_timeout 600;
include fastcgi_params;
}
location ~ /\.ht {
deny all;
}
location /.well-known/acme-challenge/ {
root /var/www/letsencrypt/;
log_not_found off;
}
error_log /var/log/nginx/laravel_error.log;
access_log /var/log/nginx/laravel_access.log;
}
php数组
in_array
is_array
array_merge
array_push 从尾部插入
array_pop 从尾部移除
array_shift 从头部移除
array_unshift 从头部插入
array_map
array_keys
array_key_exists
array_key_first
array_key_last
array_values
array_column
array_diff 获取两个数组的差集
array_intersect 获取两个数组的交集
array_chunk 将数组分块
array_reduce
count
foreach
explode
join
sort
oop面向对象
1.封装:将对象信息通过访问权限修饰符隐藏,不允许外部直接访问.
2.继承:子类继承父类的方法与属性.
3.多态:方法重写和重载
php 超全局变量
$GLOBAL
$_GET
$_POST
$_FILES
$_COOKIE
$_SESSION
$_SERVER
$_REQUEST
$_ENV
魔术方法
__construct
__destruct
__call
__callStatic
__get
__set
__isset
__unset
__sleep
__toString
__clone
__wakeup
魔术常量
__FILE__
__LINE__
__DIR__
__CLASS__
__METHOD__
__FUNCTION__
数据结构,基础算法,设计模式
数组
链表
栈
array_unshift()从头部入队
array_shift()从头部移除
array_pop()出队
队列
array_push()从尾部入队
array_pop()出队
树
二分查找
function search(&$arr,$number,$left,$right)
{
/**
* 先计算中位数
* 随后将数组中的值与中位数进行比较
* 若在中位数的右侧,则舍去左边部分 $left + 1
* 若在中位数的左侧,则舍去右边部分 $right -1
* 若都不在则返回中位数
*/
$mid = intval($left + $right)/2
if($left > $right)
{
return -1;
}
if($number > $arr[$mid])
{
search($arr,$number,$mid+1,$right);
}
else if($number < $arr[$mid])
{
search($arr,$number,$left,$right -1);
}
else
{
return $mid;
}
}
插值查找
function insertSort($arr) {
$len = count($arr);
for($i = 1 ;$i < $len; $i++)
{
$key = $arr[$i];
$pos = $i
while($pos > 0 && $arr[$pos -1] > $key)
{
$arr[$pos] = $arr[$pos - 1];
$pos = $pos-1
}
$arr[$pos] = $key;
}
return $arr;
}
冒泡排序
function bubbleSort($arr)
{
$len = count($arr);
if($len == 1) return $arr;
for($i = 0;$i < $len;$i++){
$isOver = false
for($j = 0; $j < $len - $i -1;$j++){
if($arr[$j] > $arr[$j+1]){
$temp = $arr[$j];
$arr[$j] = $arr[$j+1];
$arr[$j+1] = $temp
$isOver = true;
}
}
if(!$isOver){
break;
}
}
return $arr;
}
快速排序
选择排序
单例模式
class single
{
private static $instance;
private function __construct()
{
}
public static function getInstance(){
if(!(self::$instance instanceof self)){
self::$instance = new self;
}
return $self::$instance;
}
private function __clone()
{
}
}
工厂模式
class Factory
{
private static $nameList = [
'a' => APP\Lib\A,
'b' => APP\Lib\B,
];
public static function GetObject($className){
$obj = new $nameList[self::className]();
return $obj;
}
}
策略模式
interface Base
{
public function run();
}
class A ipmlements Base
{
public function run(){
reuturn 'aaaa';
}
}
class B ipmlements Base
{
public function run(){
reuturn 'bbbb';
}
}
class C ipmlements Base
{
public function run(){
reuturn 'cccc';
}
}
class Ci {
public $sub;
public function __construct(Base $base)
{
$this->sub = $base;
}
public function test()
{
$this->sub->run();
}
}
$test = new Ci(new A)
$test->test();
门脸模式
class SubSysOne
{
function methodone()
{
return 'rethod one';
}
}
class SubSysTwo
{
function methodtwo()
{
return 'rethod two';
}
}
class SubSysTree
{
function methodthree()
{
return 'rethod three';
}
}
class Facade {
private $subSystemOne = null;
private $subSystemTwo = null;
private $subSystemThree = null;
public function __contruct()
{
$this->subSystemOne = new SubSysOne;
$this->subSystemTwo = new SubSysTwo;
$this->subSystemThree = new SubSysThree;
}
public function methodA()
{
$this->subSystemOne->methodone();
}
public function methodB()
{
$this->subSystemOne->methodtwo();
}
public function methodC()
{
$this->subSystemOne->methodthree();
}
}
网络协议(TCP/IP, HTTP)
-- 三次握手,四次回收
--网络七层
-物理层
-数据链路层
-网络层
-传输层
-会话层
-表示层
-应用层
-IP协议属于网络层
-TCP协议属于传输层
-RPC属于会话层
一、什么是TCP连接的三次握手
第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认;
第二次握手：服务器收到syn包，必须确认客户的SYN(ack=j+1)，同时自己也发送一个SYN包(syn=k)，即SYN+ACK包，此时服务器进入SYN_RECV状态;
第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。
握手过程中传送的包里不包含数据，三次握手完毕后，客户端与服务器才正式开始传送数据。
理想状态下，TCP连接一旦建立，在通信双方中的任何一方主动关闭连接之前，TCP 连接都将被一直保持下去。
断开连接时服务器和客户端均可以主动发起断开TCP连接的请求，断开过程需要经过“四次握手”(过程就不细写了，就是服务器和客户端交互，最终确定断开)
swoft
Restful API
Nginx
nginx 是一个高性能的HTTP和反向代理服务器
使用epoll 的IO模型
工作进程一般是cpu核心数的两倍
开启高效传输模式 sendfile on
连接超时时间
fastcgi 调优
-应答时间调整
-接收超时时间调整
proxy_cache / fastcgi_cache
若其他网站引用我们网站的静态资源，我们可以在nginx 上添加防盗链/*-
cgi与fastcgi与fpm等
cgi 是通用网关接口,用于接收客户端的所有请求,转化为服务器能运行的代码再返回给客户端,在处理完进程后会kill进程
fast-cgi是cgi 的升级版,常驻进程,
php-cgi是fast-cgi 的实现,提供了进程管理功能,一个master进程,多个work进程,每个work进程都配备了一个php解释器.
--运行流程
www.example.com
|
|
Nginx
|
|
路由到www.example.com/index.php
|
|
加载nginx的fast-cgi模块
|
|
fast-cgi监听127.0.0.1:9000地址
|
|
www.example.com/index.php请求到达127.0.0.1:9000
|
|
php-fpm 监听127.0.0.1:9000
|
|
php-fpm 接收到请求，启用worker进程处理请求
|
|
php-fpm 处理完请求，返回给nginx
|
|
nginx将结果通过http返回给浏览器
rpc
基于会话层的传输协议
php 的反射机制
递归
php四种运行模式
-CGI
通用网关接口,有多少个连接就有多少个cgi子进程,效率低
-fast-cgi
-cli
-DLL模块
上传文件
<?php
$uploaddir = '/var/www/uploads/';
$uploadfile = $uploaddir . basename($_FILES['userfile']['name']);
echo '<pre>';
if (move_uploaded_file($_FILES['userfile']['tmp_name'], $uploadfile)) {
echo "File is valid, and was successfully uploaded.\n";
} else {
echo "Possible file upload attack!\n";
}
echo 'Here is some more debugging info:';
print_r($_FILES);
print "</pre>";
?>
DDD领域设计
接入层
-内部rpc服务
-对外api服务
业务层
-业务层insterface调用,模块独立化
服务层
-controller代码处理逻辑
基础设施层
-系统局部与全局基础设施搭建
基本指令
什么是docker
docker 与虚拟机有什么不同
什么是docker镜像
什么是docker容器
docker有哪几种状态
PHP 相关
共同点：都支持composer
不同点：1.laravel拥有中间件，tp拥有初始化函数_interlize
2.laravel提交表单有csrf验证, tp需要手动完成防跨站请求的代码
3.渲染方式不同,laravel中是return view(),tp中是$this->display();
4.laravel内置了hash加密,tp则是md5()加密
5.laravel可以使用php artisan migrate命令建表.laravel有专用的tinker直接与应用进行交互,建立模型建表都可以用artisan
6.laravel拥有blade模板
7.laravel必须定义路由,tp的请求路径则是请求类与请求方法拼接
tp是国人开发,MVC风格也比较适合国人思想,
laravel 由于每次请求都要加载一系列的服务及配置,所以性能方面会低很多,但是通过一些优化,性能会提升一下.
1.缓存路由 php artisan route:cache
2.优化composer 自动加载
3.缓存配置文件 php artisan config:cache
4.关闭debug
5.删除缓存文件php artisan optimize
dd()
artisan
migrate 建表
定时任务
集合
缓存
路由
模型orm
一个类需要依赖另外一个类来实现功能, 利用了php的反射机制来构造
能说说 PHP 的生命周期吗？传统的 php-fpm 模式和 swoole 有什么区别？
在项目中都是怎么用 hyperf 的？了解 hyperf 中的依赖注入实现原理吗？使用 hyperf 中的类是怎么实现的，是通过注解引入吗？
说说你在项目中使用到的 PHP 函数，任意说几个以及它的功能？
--string
--array
--sort
--file
php中的变量存储在变量容器zval中，zval中除了存储变量类型和值外，还有is_ref和refcount字段。refcount表示指向变量的元素个数，is_ref表示变量是否有别名。如果refcount为0时，就回收该变量容器。如果一个zval的refcount减1之后大于0，它就会进入垃圾缓冲区。当缓冲区达到最大值后，回收算法会循环遍历zval，判断其是否为垃圾，并进行释放处理。/*
1.性能提升, php7比php5性能提升了两倍
2.php7新增了函数返回类型声明及标量类型申明
3.php7新增了匿名类
4.php7中if条件中的数据key若不存在会直接报错,而php5则直接返回false
5.php7中新增了比较运算符
说说 php-fpm 与 NGINX 工作原理是怎么样的？
cgi 与 fast_cgi 关系是怎么样的？
isset、empty 和 is_null 区别是怎么样的？如果传递一个 null，该三个函数分别返回什么？
false,false,true
isset 表示变量是否设置, 当传递 false null 0 空串 empty会返回true反之为false ,is_null 用于判断该参数是否为null 类型
require_once 与 include_once，require 与 include 的区别？为什么一个是警告一个是致命错误？
require 在执行过程中若出现异常则会抛出一个致命错误,中断后续的程序 , 而include在执行时出现异常则会报一个wating警告,继续执行后面的代码.
require_once 与 include_once 表示只执行一次, 不重复引入
php-fpm 的工作模式？进程数量配置依据是什么？
说说 PHP 数组中的数据结构是怎么样的？
Redis 相关
平常使用 Redis 都是在哪些场景？
Redis 是单线程还是多线程?
遇到过Redis缓存穿透吗？
遇到过Redis缓存击穿吗？
遇到过Redis 雪崩吗?请简述一下
缓存是如何回收的(删除过期key)?
如何进行缓存预热
数据库与缓存不一致?
简述一下主从不一致的问题?
简述下主从不一致的问题?
Redis 的持久化有哪几种？有什么区别？实现的原理是怎样的？
1. AOF
2. RDB
Redis 的事务了解吗？事务都有哪些注意的地方？
Redis 都有哪些数据类型？你是怎么选择数据类型的？底层的数据结构是怎么样的？
Redis 能够实现命令批处理吗？
Redis 的哨兵机制了解吗？实现原理是怎么样的？
Redis 的主从复制实现原理是怎么样的？如何保证数据一致性？数据延迟又该如何处理？
利用 Redis 如何实现队列功能？
消息发布与订阅有使用过吗？怎么使用的？中间又遇到过什么问题吗？
如何解决缓存穿透、击穿和雪崩问题？
Redis 作为一个内存型数据库，如何更好的解决内存的占用？
Redis 与 memcached 的区别？什么时候会选择 memcached？
redis相比与memcached 更适合做存储
memcached因为数据结构是key-value的形式适合做缓存
MySQL
列举几个 MySQL 索引失效的情况？该如何优化这些情况？
MySQL 索引都有哪些？InnoDB 索引是用的什么数据结构，为什么使用这种数据结构？
全文索引
-- 用于文章
唯一索引
-- 主键索引
-- 唯一索引
联合索引
-- 当where 条件中为联合查询时,使用联合索引
普通索引
-- 用于提高查询效率
MySQL设计规范? 常见的设计小问题?
MySQL 主从复制是如何实现的？如果从节点挂了，重新启动从节点，如何保持数据一致性？如何解决数据同步延迟问题？
说说你优化 SQL 语句的几种思路有哪些？
说说 MySQL 中的锁有哪些？之间的区别？
MySQL 中的事务了解吗？说说其 4 大特性？
事务中隔离性，有几种情况？这几种情况分别会产生什么问题？
MySQL 中 MVVC 实现的原理是怎么样的？
mongodb 与 mysql 的关系，为什么日志系统会选择 mongodb？
RabbitMQ
主要使用的场景在哪些地方？
工作模式都有哪些？之间的区别是怎么样的？
如何保证消息的可靠性？
日志存储在 RabbitMQ，如果同步到 MongoDB 里面，如何解决新旧数据问题？(这里提到了一个公司实际业务问题，公司日志会存储到 MongoDB，如何保证每次存的都是最新的消息)
你知道哪些消息队列？这些消息队列有什么区别？
Redis(简单的消息队列)
Kafka()
RocketMQ
软件设计
有一个电商营销活动系统，你该如何去设计这个系统，保证系统不会出现问题？
项目中哪些地方用到了消息队列？是如何设计的？
1、事务四大特性
原子性（Atomicity）：事务开始后所有操作，要么全部做完，要么全部不做，不可能停滞在中间环节。事务执行过程中出错，会回滚到事务开始前的状态，所有的操作就像没有发生一样。
一致性（Consistency）：事务开始前和结束后，数据库的完整性约束没有被破坏 。
隔离性（Isolation）：同一时间，只允许一个事务请求同一数据，不同的事务之间彼此没有任何干扰。
持久性（Durability）：事务完成后，事务对数据库的所有更新将被保存到数据库，不能回滚。
2、事务的并发问题
脏读：事务 A 读取了事务 B 更新的数据，然后 B 回滚操作，那么 A 读取到的数据是脏数据
不可重复读：（事务 A 多次读取同一数据，事务 B 在事务 A 多次读取的过程中，对数据作了更新并提交，导致事务 A 多次读取同一数据时，结果 不一致。）（重点：数据修改）
幻读：系统管理员 A 将数据库中所有学生的成绩从具体分数改为 ABCDE 等级，但是系统管理员 B 就在这个时候插入了一条具体分数的记录，当系统管理员 A 改结束后发现还有一条记录没有改过来，就好像发生了幻觉一样，这就叫幻读。（重点：数据新增或删除）
小结：不可重复读的和幻读很容易混淆，不可重复读侧重于修改，幻读侧重于新增或删除。解决不可重复读的问题只需锁住满足条件的行，解决幻读需要锁表
3、MySQL 事务隔离级别
未提交读（READ UNCOMMITED）（没提交的数据可读，脏读，这些数据称为脏数据）
已提交读（READ COMMITED）（已提交的数据可读，不可重复读）
可重复读（RePEATABLE READ）一个事务执行过程中看到的数据，总是跟这个事务在启动时看到的数据是一致的。当然在可重复读隔离级别下，未提交变更对其他事务也是不可见的。
可串行化（SERIALIZABLE）（读操作会隐式获取共享锁，可以保证不同事务间的互斥，锁表，别想搞什么鬼，缺点也很明显，看到锁表你就懂的哈，效率问题）
面试官问的面试题：
1.php一些基础的数组使用，
2.linux操作命令统计pv,uv这些，
3.git命令的使用，
4.redis如何实现延迟队列，分布式锁这些，
5.php的结构，fpm配置这些。
6.主要问对技术层面的把控度，比如如何设计高并发系统，需要考虑什么问题？可能会现在的问题，如何去预防，有什么方案处理？
7.职业规划
nginx:
epoll模型
nginx和fpm的交互流程
有哪些优化项
负载均衡策略和对比
限流
mysql：
锁机制，索引，事务，隔离级别和对应解决的问题。
sql查询优化，以及explain计划。
mysql比较常见的细节问题，比如：innodb的特点，Hash索引和B+树区别，非聚簇索引和回表查询，以及写sql能力的考察。
算法：
全排列，各种排序，二分查找。
操作系统：
进程状态，IPC，调度算法，线程和协程，死锁。
计算机网络：
五层分别哪些。tcp、udp区别。同源测略和跨域。
一个网页从输入地址回车，到完整展示网页内容这段时间里，做了哪些工作。
keepalived是什么，有什么作用（tcp）。
cdn如何防篡改，https如何安全。
Redis：
使用场景，淘汰策略，持久化，主从哨兵和底层实现。
php：
zval结构，垃圾回收，7新特性，get|post，session，cookie，字符串，数组函数的用法，命名空间，composer
fpm的优化，三种配置方式，静态方式如何确定最大worker数
业务相关的问题：
接口设计，鉴权部分设计，单点，单用户，高并发，防超卖，Saas项目架构设计。
开放式的问题:
请简单介绍一下你做的这个项目
近期遇到比较棘手的问题、有挑战性的问题，你是如何去解决这个问题的。
什么是引用变量?在php中,用什么符号来定义引用变量?
概念: &
查看zval变量容器 xdebug_debug_zval($a)
is_ref 变量内存空间是否重新赋值
refcount 运用该空间的变量个数
说一下session与cookie的区别?
因为http 是无状态的,前后没有联系,所以我们使用session进行会话控制.
Cookie:
设置setcookie($name,$value,$expire,$domain);
读取:$_COOKIE
存贮不敏感重要信息
不会占用服务器资源
Session:
Session是基于cookie,session 是存储在服务器端.
session_start();
$_SESSION = []
session_destroy();销毁
Cookie中存储了session_id,如果禁用掉的话,session_id无法正常传递.那么就要到url中去拼接或echo 常量SID
若会话多台服务器,那么我们将会把session存储到redis,memcache中
session_set_save_handler()
你是否使用过版本控制器?
集中式
都放在一台服务器中
分布式
Nginx + php-fpm
cgi: 通用网关接口,是一种通信协议
fastcgi: 是cgi的升级版,保留进程,处理多个进程
php-fpm: fastcgi 的进程管理器,一般一个master进程,多个worker进程.master端口主要进行监听端口负责接收来自web的请求,worker进程解析请求.
php常见配置项
register_globals 接收来自客户端的变量,默认关闭
allow_url_fopen 打开远程文件
allow_url_include 引用外部资源
date.timezone 设置时区
display_errors bug展示
error_reporting 错误级别
safe_mode 安全模式
upload_max_filesize 最大上传文件大小
max_upload_file 最大上传文件数量
正则表达式考点
至少写出一种验证139开头的正则表达式
preg_match();
preg_match_all();
正则表达式的作用: 分割,查找,匹配,替换字符串
分隔符:正斜线(/),hash符号(#)以及取反符号(~)
通用原子:
\d, 数字0-9
\D, 除了0-9
\w, _
\W, 除了_
\s, 空白符
\S 除了空白符
元字符: . 除了换行符外的任意符号
* 匹配前面的内容出现一次或多次
? 零次或者一次
^ 必须以它开头
$ 必须以他结尾
+ 出现一次及以上
{n} 出现n次
{n,} 大于n次
{n,m}, 大于n次,小于m次
[] 集合,匹配括号内的字符集
()
[^] 取反,除了集合内的字符
| 或者
[-] 范围
模式修正符:
i 不区分大小写
m
e
s
U
x
A
D
u
匹配中文: '/[x{4e00}-\x{9fa5}]+/u'
请写出以139开头的11位手机号码的正则表达式:
.*? 忽略中间元素
文件读取/写入操作
fopen()函数
打开模式：
r 只读方式打开(文件指针指向开头)
r+ 读写方式打开
w 只写方式打开(会先清空文件)
w+ 读写方式打开(若文件不存在会创建文件)
a 追加的写入方式
a+ 读写的追加方式(将文件指针指向文件末尾)
x 以写入的方式打开(将文件指针指向文件开头)
x+
fread() 读取文件
fwrite() 写入文件
fclose() 关闭文件
写入函数 file_put_contents()
读取函数 file_get_contents()
访问远程文件
开启allow_url_fopen,
名称相关:basename(),dirname()
目录读取:opendir(),readdir(),closedir()
删除目录:rmdir()
目录创建:mkdir()
文件大小:filesize()
删除文件:unlink()
重命名文件或目录:rename()
文件属性:file_exists()
面向对象
网络协议
HTTP状态码
osi七层模型
http的工作特点及工作原理
http 是无状态协议
基于B/S模式
通信开销小,简单快速
客户端发送给服务器,创建一个tcp连接,指定端口号为80,当服务器监听操到浏览器发送的请求将会进行分析解析然后返回.
http协议常见的请求头
http的请求方法
GET与POST 的区别
常见网络协议及端口
php数据类型
JavaScript 基本语法
jQuery 基本语法
代码实例
- document.getElementById('test').className = 'good'
- $('#test').className = 'good';
- $(function(){
$('#test').click(function(){
})
})
Mysql
数据类型
常用操作
mysql -u -p -h -P
Mysql数据表引擎
InnoDB
- 默认事务型,最重要最广泛的存储引擎,性能优秀的数据存储在共享表空间.
- 读取数据时会在内存中构建hash索引
- 插入数据时会自动构建插入缓冲区
支持热备份
支持崩溃后安全修复
支持行级锁
支持外键
事务处理
数据存储在共享表空间
MyISAM
其他表引擎
MySQL锁机制
读锁
-
写锁
锁粒度
表锁,系统性能开销最小,直接锁定整张表
行锁,
MySQL索引
类型
- 主键索引
- 普通索引
- 唯一索引
- 联合索引
- 全文索引
影响
减少服务器开销
将随机I/O变顺序I/O
提高查询速度,降低写入速度
场景
- 对于非常小的表,直接全表扫描
注意
查询语句
联合查询
union 会合并重复的列
union all 会查询出所有的列
select * from a union select * from b
连表查询
嵌套查询
select * from where id in (select id from b where ...)
查询优化
explain
show profiles
set profiling =1;开启,服务器上执行的所有语句会检测消耗的时间,存到临时表
show profiles 查询执行sql日志
show profile for query 临时表ID
show status
show processlist
查询是否有大量线程处于不正常的状态或特征
查询不需要的记录,使用limit解决
多表关联取出全部列, 少用select *
查询相同的数据,可以只用缓存
分解关联查询, 将关联语句差分为多条SQL来执行
优化limit 分页, 记录上次查询的id添加到where条件中
union all 的效率高于union
分库分表
算法的概念
时间复杂度
问题规模n的函数f(n),算法的时间复杂度记为T(n) = O(f(n))
随着n越大,算法执行的时间的增长率与f(n)的增长率正相关,称作为渐进时间复杂度
时间复杂度为循环递归次数
O(n^2)
O(1)
O(n)
空间复杂度
算法需要消耗的内存空间,基座S(n) = O(f(n))
常见数据结构
真题
//1,1,2,3,5,8,13,21,34,....
$arr = [1,1]
for($i=2;$i<30;$i++){
$arr[$i] = $arr[$i-1] + $arr[$i-2];
}
var_dump($arr[30]);
请写一个函数,实现open_door转换为OpenDoor
<?php
function strHandle($str){
$res = '';
$arr = explode('_',$str);
foreach($arr as $val){
$res = ucfirst($val)
}
return $res;
}
?>
字符串反转
<?php
function str_rev($str)
{
$i = 0;
while(true){
if(isset($str[$i])){
break;
}
$i++
}
$res = '';
for($j=$i-1;$j>=0;$j--){
$res = .= $str[$j];
}
return $res;
}
高并发和大流量解决方案
php如何解决网站大流量与高并发
QPS分析优化
流量优化
防盗链
HTTP连接产生的开销
域名解析--TCP连接--发送请求--等待--下载资源--解析时间
DNS 缓存
Keep-Alive
图片地图
使图标的图片都在一张图片上
合并js,css
静态化,开启缓冲区
开启epoll模型
php高并发解决
php 的swoole
mq
并发调度
mysql的查询缓存
query_cache_type 为2 时即可使用查询缓存
query_cache_size 查询缓存预留的内存
nginx负责均衡策略
功能强大,运行稳定
配置简单灵活
能够自动剔除工作不正常的后端服务器
上传文件使用异步模式
支持多重分配策略,可以分配权重,分配方式灵活
nginx策略
内置策略: IP Hash ,加权轮询
扩展策略:
加权轮询策略: 首先将请求都分给高权重的机器
IP Hash策略: Nginx内置的另一个负载均衡
fair: 根据后端服务器的响应时间判断负载策略,选择最轻的机器进行分流
通用Hash ,一致性Hash策略
http {
upstream cluster {
server srv1;
server srv2;
server srv3;
}
server {
listen 80;
location / {
proxy_pass http://cluster
}
}
}
😘 Enjoy~
]]>