java复制代码protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

   // 先将方法传入的name转换成容器真实的beanName
   // 之前可以通过三种形式获取beanName
   // 一个是原始的beanName，一个是加了&的，一个是别名
   final String beanName = transformedBeanName(name);
   Object bean;

   // Eagerly check singleton cache for manually registered singletons.
   Object sharedInstance = getSingleton(beanName);
   // 加果先前已经创建过单例Bean的实例，并且调用的getBean方法传入的参数为空，则执行理面的逻辑
   // args之所以要求为空是因为如果有args，则需要做进一步赋值，因此无法直接返回
   if (sharedInstance != null && args == null) {
      if (logger.isTraceEnabled()) {
         // 如果Bean还在创建中，则说明是循环引用
         if (isSingletonCurrentlyInCreation(beanName)) {
            logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                  "' that is not fully initialized yet - a consequence of a circular reference");
         }
         else {
            logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
         }
      }
      // 如果是普通bean，直接返回，如果是FactoryBean，则返回他的getObject
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
   }

   else {
      // Fail if we're already creating this bean instance:
      // We're assumably within a circular reference.
      if (isPrototypeCurrentlyInCreation(beanName)) {
         throw new BeanCurrentlyInCreationException(beanName);
      }

      // Check if bean definition exists in this factory.
      BeanFactory parentBeanFactory = getParentBeanFactory();
      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
         // Not found -> check parent.
         String nameToLookup = originalBeanName(name);
         if (parentBeanFactory instanceof AbstractBeanFactory) {
            return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                  nameToLookup, requiredType, args, typeCheckOnly);
         }
         else if (args != null) {
            // Delegation to parent with explicit args.
            return (T) parentBeanFactory.getBean(nameToLookup, args);
         }
         else if (requiredType != null) {
            // No args -> delegate to standard getBean method.
            return parentBeanFactory.getBean(nameToLookup, requiredType);
         }
         else {
            return (T) parentBeanFactory.getBean(nameToLookup);
         }
      }

      if (!typeCheckOnly) {
         markBeanAsCreated(beanName);
      }

      try {
         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         checkMergedBeanDefinition(mbd, beanName, args);

         // Guarantee initialization of beans that the current bean depends on.
         String[] dependsOn = mbd.getDependsOn();
         if (dependsOn != null) {
            for (String dep : dependsOn) {
               if (isDependent(beanName, dep)) {
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
               }
               registerDependentBean(dep, beanName);
               try {
                  getBean(dep);
               }
               catch (NoSuchBeanDefinitionException ex) {
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
               }
            }
         }

         // Create bean instance.
         // 如果BeanDefinition为单例
         if (mbd.isSingleton()) {
            // 这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象
            sharedInstance = getSingleton(beanName, () -> {
               try {
                  return createBean(beanName, mbd, args);
               }
               catch (BeansException ex) {
                  // Explicitly remove instance from singleton cache: It might have been put there
                  // eagerly by the creation process, to allow for circular reference resolution.
                  // Also remove any beans that received a temporary reference to the bean.
                  destroySingleton(beanName);
                  throw ex;
               }
            });
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
         }

         else if (mbd.isPrototype()) {
            // It's a prototype -> create a new instance.
            Object prototypeInstance = null;
            try {
               beforePrototypeCreation(beanName);
               prototypeInstance = createBean(beanName, mbd, args);
            }
            finally {
               afterPrototypeCreation(beanName);
            }
            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
         }

         else {
            String scopeName = mbd.getScope();
            final Scope scope = this.scopes.get(scopeName);
            if (scope == null) {
               throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
            }
            try {
               Object scopedInstance = scope.get(beanName, () -> {
                  beforePrototypeCreation(beanName);
                  try {
                     return createBean(beanName, mbd, args);
                  }
                  finally {
                     afterPrototypeCreation(beanName);
                  }
               });
               bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
            }
            catch (IllegalStateException ex) {
               throw new BeanCreationException(beanName,
                     "Scope '" + scopeName + "' is not active for the current thread; consider " +
                     "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                     ex);
            }
         }
      }
      catch (BeansException ex) {
         cleanupAfterBeanCreationFailure(beanName);
         throw ex;
      }
   }

   // Check if required type matches the type of the actual bean instance.
   if (requiredType != null && !requiredType.isInstance(bean)) {
      try {
         T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
         if (convertedBean == null) {
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
         }
         return convertedBean;
      }
      catch (TypeMismatchException ex) {
         if (logger.isTraceEnabled()) {
            logger.trace("Failed to convert bean '" + name + "' to required type '" +
                  ClassUtils.getQualifiedName(requiredType) + "'", ex);
         }
         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
      }
   }
   return (T) bean;
}

java复制代码if (isPrototypeCurrentlyInCreation(beanName)) {
   throw new BeanCurrentlyInCreationException(beanName);
}

java复制代码protected boolean isPrototypeCurrentlyInCreation(String beanName) {
   Object curVal = this.prototypesCurrentlyInCreation.get();
   return (curVal != null &&
         (curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}

java复制代码// typeCheckOnly 是用来判断调用 getBean() 是否仅仅是为了类型检查获取 bean，而不是为了创建Bean
if (!typeCheckOnly) {
   // 如果不是仅仅做类型检查则是创建bean
   markBeanAsCreated(beanName);
}

java复制代码protected void markBeanAsCreated(String beanName) {
   // 双重检查锁机制
   if (!this.alreadyCreated.contains(beanName)) {
      synchronized (this.mergedBeanDefinitions) {
         if (!this.alreadyCreated.contains(beanName)) {
            // Let the bean definition get re-merged now that we're actually creating
            // the bean... just in case some of its metadata changed in the meantime.
            // 将原先合并之后的RootBeanDefinition的需要重新合并的状态设置为true
            // 表示需要重新合并一遍，以防原数据的改动
            clearMergedBeanDefinition(beanName);
            // 将已经创建好的或者正在创建的Bean的名称加到alreadyCreated这个缓存中
            this.alreadyCreated.add(beanName);
         }
      }
   }
}

java复制代码protected void clearMergedBeanDefinition(String beanName) {
   RootBeanDefinition bd = this.mergedBeanDefinitions.get(beanName);
   if (bd != null) {
      bd.stale = true;
   }
}

java复制代码protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
   // Quick check on the concurrent map first, with minimal locking.
   RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
   if (mbd != null && !mbd.stale) {
      return mbd;
   }
   return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

java复制代码checkMergedBeanDefinition(mbd, beanName, args);

java复制代码protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, @Nullable Object[] args)
      throws BeanDefinitionStoreException {

   if (mbd.isAbstract()) {
      throw new BeanIsAbstractException(beanName);
   }
}

java复制代码registerDependentBean(dep, beanName);

java复制代码public void registerDependentBean(String beanName, String dependentBeanName) {
   String canonicalName = canonicalName(beanName);

   synchronized (this.dependentBeanMap) {
      // computeIfAbsent：若key对应的value为空，会将第二个参数的返回值存入并返回
      // dependentBeanMap中存放着当前Bean被引用的Bean的集合
      // 比如当前需要实例化的是Bean的名字是userInfo，userInfo中有个Human类型的属性human
      // 那么就有human被userInfo引用的关系 human=[userInfo]
      Set<String> dependentBeans =
            this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
      if (!dependentBeans.add(dependentBeanName)) {
         return;
      }
   }

   synchronized (this.dependenciesForBeanMap) {
      Set<String> dependenciesForBean =
            this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
      dependenciesForBean.add(canonicalName);
   }
}

java复制代码Object get(String name, ObjectFactory<?> objectFactory);

java复制代码if (mbd.isSingleton()) {
   // 这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象
   sharedInstance = getSingleton(beanName, () -> {
      try {
         return createBean(beanName, mbd, args);
      }
      catch (BeansException ex) {
         // Explicitly remove instance from singleton cache: It might have been put there
         // eagerly by the creation process, to allow for circular reference resolution.
         // Also remove any beans that received a temporary reference to the bean.
         // 显式从单例缓存中删除 bean实例
         // 因为单例模式下为了解决循环依赖，可能它已经存在了，所以将其销毁
         destroySingleton(beanName);
         throw ex;
      }
   });
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

java复制代码protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException;

java复制代码public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(beanName, "Bean name must not be null");
   synchronized (this.singletonObjects) {
      Object singletonObject = this.singletonObjects.get(beanName);
      if (singletonObject == null) {
         if (this.singletonsCurrentlyInDestruction) {
            throw new BeanCreationNotAllowedException(beanName,
                  "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                  "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
         }
         if (logger.isDebugEnabled()) {
            logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
         }
         beforeSingletonCreation(beanName);
         boolean newSingleton = false;
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
         if (recordSuppressedExceptions) {
            this.suppressedExceptions = new LinkedHashSet<>();
         }
         try {
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
         }
         catch (IllegalStateException ex) {
            // Has the singleton object implicitly appeared in the meantime ->
            // if yes, proceed with it since the exception indicates that state.
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
               throw ex;
            }
         }
         catch (BeanCreationException ex) {
            if (recordSuppressedExceptions) {
               for (Exception suppressedException : this.suppressedExceptions) {
                  ex.addRelatedCause(suppressedException);
               }
            }
            throw ex;
         }
         finally {
            if (recordSuppressedExceptions) {
               this.suppressedExceptions = null;
            }
            afterSingletonCreation(beanName);
         }
         if (newSingleton) {
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}

java复制代码protected void beforeSingletonCreation(String beanName) {
    //inCreationCheckExclusions 直接缓存当前不能加载的bean，
    //主要用在web容器的拦截器里，所以这里可以忽略，因为肯定是不存在的
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
      throw new BeanCurrentlyInCreationException(beanName);
   }
}

java复制代码protected void afterSingletonCreation(String beanName) {
   if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
      throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
   }
}

java复制代码protected void addSingleton(String beanName, Object singletonObject) {
   synchronized (this.singletonObjects) {
      // Bean实例完成创建之后，只保留一级缓存以及注册beanName的顺序，其余的清除
      this.singletonObjects.put(beanName, singletonObject);
      this.singletonFactories.remove(beanName);
      this.earlySingletonObjects.remove(beanName);
      this.registeredSingletons.add(beanName);
   }
}

java复制代码// 如果是普通bean，直接返回，是FactoryBean，返回他的getObject
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

java复制代码protected void beforePrototypeCreation(String beanName) {
   Object curVal = this.prototypesCurrentlyInCreation.get();
   if (curVal == null) {
      this.prototypesCurrentlyInCreation.set(beanName);
   }
   else if (curVal instanceof String) {
      Set<String> beanNameSet = new HashSet<>(2);
      beanNameSet.add((String) curVal);
      beanNameSet.add(beanName);
      this.prototypesCurrentlyInCreation.set(beanNameSet);
   }
   else {
      Set<String> beanNameSet = (Set<String>) curVal;
      beanNameSet.add(beanName);
   }
}

java复制代码afterPrototypeCreation(beanName);

java复制代码protected void afterPrototypeCreation(String beanName) {
   Object curVal = this.prototypesCurrentlyInCreation.get();
   if (curVal instanceof String) {
      this.prototypesCurrentlyInCreation.remove();
   }
   else if (curVal instanceof Set) {
      Set<String> beanNameSet = (Set<String>) curVal;
      beanNameSet.remove(beanName);
      if (beanNameSet.isEmpty()) {
         this.prototypesCurrentlyInCreation.remove();
      }
   }
}

java复制代码bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

java复制代码if (requiredType != null && !requiredType.isInstance(bean)) {
   try {
      T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
      if (convertedBean == null) {
         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
      }
      return convertedBean;
   }
   catch (TypeMismatchException ex) {
      if (logger.isTraceEnabled()) {
         logger.trace("Failed to convert bean '" + name + "' to required type '" +
               ClassUtils.getQualifiedName(requiredType) + "'", ex);
      }
      throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
   }
}
return (T) bean;

cmd复制代码git config --global user.name "xxx"

cmd复制代码git config --global user.email "xxx@qq.com"

cmd复制代码git config user.name yourname
git config user.email yourname@163.com

cmd复制代码 ssh-keygen -t rsa

js复制代码cat ~/.ssh/id_rsa.pub

cmd复制代码 git clone git@github.com:xxx/java8.git

php复制代码<?php
/*
 * 该方法是把数据库读出的数据进行CSV文件输出，能接受百万级别的数据输出，因为用生成器，不用担心内存溢出。
 * @param string $sql 需要导出的数据SQL
 * @param string $mark 生成文件的名字前缀
 *
 */
function exportCsv($sql,$fileName)
{
    //让程序一直运行
    set_time_limit(0);
//设置程序运行内存
    ini_set('memory_limit', '128M');

    header('Content-Encoding: UTF-8');
    header("Content-type:application/vnd.ms-excel;charset=UTF-8");
    header('Content-Disposition: attachment;filename="' . $fileName . '.csv"');

    //打开php标准输出流
    $fp = fopen('php://output', 'a');

    //添加BOM头，以UTF8编码导出CSV文件，如果文件头未添加BOM头，打开会出现乱码。
    fwrite($fp, chr(0xEF).chr(0xBB).chr(0xBF));

    //添加导出标题
    fputcsv($fp, ['id', 'username', 'phone','city']);

    foreach (getExportData($sql) as $item) {
        //向csv表格中添加每一行数据
        fputcsv($fp, $item);
    }
    fclose($fp);  //每生成一个文件关闭
}


/**
 * 获取要导出的数据
 * 使用迭代生成器来缓存mysql查询结果，返回类型为数组
 * @param $sql
 * @return Generator
 */
function getExportData($sql){
    //连接数据库
    $con = mysqli_connect("localhost", "root", "");
    //连接数据库报错信息
    if (!$con) {
        die('Could not connect: ' . mysqli_error());
    }
    mysqli_select_db($con, "demo");
    mysqli_query($con,'set names utf8');
    //该处用MYSQLI_USE_RESULT 就是不缓存结果集中，也是为了避免内存溢出，相当于mysql_unbuffered_query
    foreach (mysqli_query($con, $sql,MYSQLI_USE_RESULT) as $row ){  //
        yield $row;
    }
    $con->close();
}

//要导出的数据
$sql = 'SELECT id,username,phone,city FROM `user`  where id < 1000000';
$mark = 'export';
exportCsv($sql,$mark);

?>

php复制代码<?php

/*
 * 该方法是把数据库读出的数据进行CSV文件输出，能接受百万级别的数据输出，因为用生成器，不用担心内存溢出。
 * @param string $sql 需要导出的数据SQL
 * @param string $mark 生成文件的名字前缀
 *
 */
function putCsv($sql, $mark)
{
    set_time_limit(0);
    $file_num = 0;  //文件名计数器
    $fileNameArr = array();
    $fp = fopen($mark .'_'.$file_num .'.csv', 'w'); //生成临时文件
    $fileNameArr[] = $mark .'_'.$file_num .'.csv';
    fwrite($fp, chr(0xEF).chr(0xBB).chr(0xBF));//转码,防止乱码
    //添加导出标题
    fputcsv($fp, ['id', 'type_id', 'state','addtime','usetime']);

    foreach (query($sql) as $a) {
        fputcsv($fp, $a);
    }
    fclose($fp);  //每生成一个文件关闭
}


//生成器来缓存mysql查询结果，返回类型为数组
function query($sql){
    //连接数据库
    $con = mysqli_connect("localhost", "root", "");
    //连接数据库报错信息
    if (!$con) {
        die('Could not connect: ' . mysqli_error());
    }
    mysqli_select_db($con, "demo");
    mysqli_query($con,'set names utf8');
    //该处用MYSQLI_USE_RESULT 就是不缓存结果集中，也是为了避免内存溢出，相当于mysql_unbuffered_query
    foreach (mysqli_query($con, $sql,MYSQLI_USE_RESULT) as $row ){  //
        yield $row;
    }
    $con->close();
}

//数据库总数据
$count = 1000000;

//文件名称
$mark = 'test';
//一个excel保存的条数
$limit = 500000;
$page = 1;

$i = 0;
do
{
    $i+= $limit;
    //计算偏移量
    $start = ($page-1)*$limit;
    $sql = "SELECT id,type_id,state,addtime,usetime FROM `shop_ercode_records` limit {$start}".','."{$limit}";
    putCsv($sql,$mark.$i);
    $page++;
} while ($i<$count);

?>

php复制代码$dataReader=$command->query();
//返回CDbDataReader对象，注意这代表结果集而不是记录，可以通过以下方法来获取（遍历）记录：
// CDbDataReader::read()可以一次获取一行数据，到末尾时返回false
while(($row=$dataReader->read())!==false) 
// CDbDataReader实现了迭代器接口因此可以使用foreach遍历
foreach($dataReader as $row)
// 一次性返回所有的记录(数组)
    $rows=$dataReader->readAll();

php复制代码// sql语句
        $sql_queryAll = "SELECT * FROM art_category";
        // 创建查询对象
        $command=Yii::$app->db->createCommand($sql_queryAll);
        // 执行查询所有数据
        $result = $command->queryAll();
  
        echo "<pre>";
        var_dump($result);

php复制代码// sql语句
        $sql_queryAll = "SELECT * FROM art_category ";
        // 创建查询对象
        $command=Yii::$app->db->createCommand($sql_queryAll);
        // 执行查询所有数据
        // $result = $command->queryAll();
        // 执行查询一行数据
        $result = $command->queryOne();
     
        echo "<pre>";
        var_dump($result);

php复制代码// 批量写入
        $insertSql = "INSERT INTO art_category (cat_name,cat_pid) 
                        values ('xxx','32'), ('aaaaaaa','963')";
  
        $command=Yii::$app->db->createCommand($insertSql);
  
        // 返回写入成功条数。
        $result = $command->execute();
  
        echo "<pre>";
        var_dump($result);

php复制代码// 修改语句
        $sql = "UPDATE art_category SET cat_name = 'camellia' WHERE id = 10";
  
        $command=Yii::$app->db->createCommand($sql);
  
        // 返回修改成功条数。
        $result = $command->execute();
  
        echo "<pre>";
        var_dump($result);

php复制代码// 删除语句
        $sql = "DELETE FROM art_category WHERE id = '10'";
  
        $command=Yii::$app->db->createCommand($sql);
  
        // 返回删除成功条数。
        $result = $command->execute();
  
        echo "<pre>";
        var_dump($result);

php复制代码$db = Yii::app()->db;
$dbTrans = $db->beginTransaction();      //开始事物
$dbTrans->commit();                      //提交
$dbTrans->rollback();                    //回滚

php复制代码/** 
* 加密 
* @param string $string     要加密或解密的字符串 
* @param string $operation 加密 ''  解密 DECODE 
* @param string $key        密钥，加密解密时保持一致 
* @param int    $expiry 有效时长，单位：秒 
* @return string 
*/  
function encrypt_code($string, $expiry = 0, $key = '1234567890') {  
    $ckey_length = 1;  
    $key = md5($key ? $key : UC_KEY); //加密解密时这个是不变的  
    $keya = md5(substr($key, 0, 16)); //加密解密时这个是不变的  
    $keyb = md5(substr($key, 16, 16)); //加密解密时这个是不变的  
    $keyc = $ckey_length ?  substr(md5(microtime()), -$ckey_length) : '';  
    $cryptkey = $keya . md5($keya . $keyc); //64  
    $key_length = strlen($cryptkey); //64  
   
    $string =sprintf('%010d', $expiry ? $expiry + time() : 0) . substr(md5($string . $keyb), 0, 16) . $string;  
    $string_length = strlen($string);  
   
    $result = '';  
    $box = range(0, 255);  
   
    $rndkey = array();  
    for ($i = 0; $i <= 255; $i++) { //字母表 64位后重复 数列 范围为48~122  
        $rndkey[$i] = ord($cryptkey[$i % $key_length]);  
    }  
   
    for ($j = $i = 0; $i < 256; $i++) { //这里是一个打乱算法  
        $j = ($j + $box[$i] + $rndkey[$i]) % 256;  
        $tmp = $box[$i];  
        $box[$i] = $box[$j];  
        $box[$j] = $tmp;  
    }  
    for ($a = $j = $i = 0; $i < $string_length; $i++) {  
        $result .= chr(ord($string[$i]) ^ ($box[$i]));  
       
    }  
     $str =  $keyc . str_replace('=', '', base64_encode($result));    
                //  $str =htmlentities($str, ENT_QUOTES, "UTF-8"); // curl 访问出错  
                  return $str ;  
}  
  
               
/** 
* 解密 
* @param string $string     要加密或解密的字符串 
* @param string $operation 加密 ''  解密 DECODE 
* @param string $key        密钥，加密解密时保持一致 
* @param int    $expiry 有效时长，单位：秒 
* @return string 
*/  
function encrypt_decode($string, $expiry = 0,$key = '1234567890') {    
    $ckey_length = 1;  
    $key = md5($key ? $key : UC_KEY); //加密解密时这个是不变的  
    $keya = md5(substr($key, 0, 16)); //加密解密时这个是不变的  
    $keyb = md5(substr($key, 16, 16)); //加密解密时这个是不变的  
                
    $keyc = $ckey_length ?  substr($string, 0, $ckey_length)   : '';  
  
    $cryptkey = $keya . md5($keya . $keyc); //64  
    $key_length = strlen($cryptkey); //64  
    $string = base64_decode(substr($string, $ckey_length)) ;  
               $string_length = strlen($string);  
    $result = '';  
    $box = range(0, 255);  
  
    $rndkey = array();  
    for ($i = 0; $i <= 255; $i++) { //字母表 64位后重复 数列 范围为48~122  
        $rndkey[$i] = ord($cryptkey[$i % $key_length]);  
    }  
    for ($j = $i = 0; $i < 256; $i++) { //这里是一个打乱算法  
        $j = ($j + $box[$i] + $rndkey[$i]) % 256;  
  
        $tmp = $box[$i];  
        $box[$i] = $box[$j];  
        $box[$j] = $tmp;  
    }  
    for($a = $j = $i = 0; $i < $string_length; $i++) {  
        $result .= chr(ord($string[$i]) ^ ($box[$i]));  
    }  
    if((substr($result, 0, 10) == 0 || substr($result, 0, 10) - time() > 0) && substr($result, 10, 16) == substr(md5(substr($result, 26) . $keyb), 0, 16)) {  
       return substr($result, 26);  
    }else{  
       return false;  
    }  
}

arduino复制代码/**
 * 设置每条消息消费的最大超时时间,超过这个时间,这条消息将会被视为消费失败,等下次重新投递再次消费. 每个业务需要设置一个合理的值. 单位(分钟)
 */
public static final String ConsumeTimeout = "consumeTimeout";

ini复制代码@Data
public static class Customize {
    /**
     * 消息监听类
     *
     * @see AbstractMessageListener
     */
    private String listenerClassName = "tech.baoyun.starter.ons.comsume.DefaultMessageListener";
    /**
     * @see com.aliyun.openservices.ons.api.PropertyKeyConst#ConsumeTimeout
     */
    private Integer consumeTimeout = 1;
    /**
     * @see com.aliyun.openservices.ons.api.PropertyKeyConst#MaxReconsumeTimes
     */
    private Integer maxReconsumeTimes = 5;
    /**
     * @see com.aliyun.openservices.ons.api.PropertyKeyConst#ConsumeThreadNums
     */
    private Integer consumeThreadNums = 10;
    /**
     * @see com.aliyun.openservices.ons.api.PropertyKeyConst#SuspendTimeMillis
     */
    private Integer suspendTimeMillis = 60 * 1000;
}

less复制代码@FeignClient(name = "testService1", contextId = "testService1Client")
public interface TestService1Client {
    @GetMapping("/anything")
    HttpBinAnythingResponse anything();
}
@FeignClient(name = "testService2", contextId = "testService2Client")
    public interface TestService2Client {
        @GetMapping("/anything")
        HttpBinAnythingResponse anything();
}

less复制代码//SpringExtension也包含了 Mockito 相关的 Extension，所以 @Mock 等注解也生效了
@ExtendWith(SpringExtension.class)
@SpringBootTest(properties = {
        //默认请求重试次数为 3
        "resilience4j.retry.configs.default.maxAttempts=3",
        // testService2Client 里面的所有方法请求重试次数为 2
        "resilience4j.retry.configs.testService2Client.maxAttempts=2",
        //默认断路器配置
        "resilience4j.circuitbreaker.configs.default.slidingWindowSize=5",
        "resilience4j.circuitbreaker.configs.default.minimumNumberOfCalls=2",
        //testService2Client 的 断路器配置
        "resilience4j.circuitbreaker.configs.testService2Client.failureRateThreshold=30",
        "resilience4j.circuitbreaker.configs.testService2Client.minimumNumberOfCalls=10",
        
})
@Log4j2
public class OpenFeignClientTest {
    @SpringBootApplication
    @Configuration
    public static class App {
        @Bean
        public DiscoveryClient discoveryClient() {
            //模拟两个服务实例
            ServiceInstance service1Instance1 = Mockito.spy(ServiceInstance.class);
            ServiceInstance service2Instance2 = Mockito.spy(ServiceInstance.class);
            Map<String, String> zone1 = Map.ofEntries(
                    Map.entry("zone", "zone1")
            );
            when(service1Instance1.getMetadata()).thenReturn(zone1);
            when(service1Instance1.getInstanceId()).thenReturn("service1Instance1");
            when(service1Instance1.getHost()).thenReturn("www.httpbin.org");
            when(service1Instance1.getPort()).thenReturn(80);
            when(service2Instance2.getInstanceId()).thenReturn("service1Instance2");
            when(service2Instance2.getHost()).thenReturn("httpbin.org");
            when(service2Instance2.getPort()).thenReturn(80);
            DiscoveryClient spy = Mockito.spy(DiscoveryClient.class);
            Mockito.when(spy.getInstances("testService1"))
                    .thenReturn(List.of(service1Instance1));
            Mockito.when(spy.getInstances("testService2"))
                    .thenReturn(List.of(service2Instance2));
            return spy;
        }
    }
}

scss复制代码@Test
    public void testConfigureCircuitBreaker() {
        //防止断路器影响
        circuitBreakerRegistry.getAllCircuitBreakers().asJava().forEach(CircuitBreaker::reset);
        //调用下这两个 FeignClient 确保对应的 NamedContext 被初始化
        testService1Client.anything();
        testService2Client.anything();
        //验证断路器的实际配置，符合我们的填入的配置
        List<CircuitBreaker> circuitBreakers = circuitBreakerRegistry.getAllCircuitBreakers().asJava();
        Set<String> collect = circuitBreakers.stream().map(CircuitBreaker::getName)
                .filter(name -> {
                    try {
                        return name.contains(TestService1Client.class.getMethod("anything").toGenericString())
                                || name.contains(TestService2Client.class.getMethod("anything").toGenericString());
                    } catch (NoSuchMethodException e) {
                        return false;
                    }
                }).collect(Collectors.toSet());
        Assertions.assertEquals(collect.size(), 2);
        circuitBreakers.forEach(circuitBreaker -> {
            if (circuitBreaker.getName().contains(TestService1Client.class.getName())) {
                Assertions.assertEquals((int) circuitBreaker.getCircuitBreakerConfig().getFailureRateThreshold(), (int) DEFAULT_FAILURE_RATE_THRESHOLD);
                Assertions.assertEquals(circuitBreaker.getCircuitBreakerConfig().getMinimumNumberOfCalls(), DEFAULT_MINIMUM_NUMBER_OF_CALLS);
            } else if (circuitBreaker.getName().contains(TestService2Client.class.getName())) {
                Assertions.assertEquals((int) circuitBreaker.getCircuitBreakerConfig().getFailureRateThreshold(), (int) TEST_SERVICE_2_FAILURE_RATE_THRESHOLD);
                Assertions.assertEquals(circuitBreaker.getCircuitBreakerConfig().getMinimumNumberOfCalls(), TEST_SERVICE_2_MINIMUM_NUMBER_OF_CALLS);
            }
        });
    }

less复制代码@GetMapping("/status/500")
String testCircuitBreakerStatus500();

scss复制代码@Test
public void testCircuitBreakerOpenBasedOnServiceAndMethod() {
    //防止断路器影响
    circuitBreakerRegistry.getAllCircuitBreakers().asJava().forEach(CircuitBreaker::reset);
    AtomicBoolean passed = new AtomicBoolean(false);
    for (int i = 0; i < 10; i++) {
        //多次调用会导致断路器打开
        try {
            System.out.println(testService1Client.testCircuitBreakerStatus500());
        } catch(Exception e) {}
        List<CircuitBreaker> circuitBreakers = circuitBreakerRegistry.getAllCircuitBreakers().asJava();
        circuitBreakers.stream().filter(circuitBreaker -> {
            return circuitBreaker.getName().contains("testCircuitBreakerStatus500")
                    && circuitBreaker.getName().contains("TestService1Client");
        }).findFirst().ifPresent(circuitBreaker -> {
            //验证对应微服务和方法的断路器被打开
            if (circuitBreaker.getState().equals(CircuitBreaker.State.OPEN)) {
                passed.set(true);
                //断路器打开后，调用其他方法，不会抛出断路器打开异常
                testService1Client.testAnything();
            }
        });
    }
    
    Assertions.assertTrue(passed.get());
}

复制代码ngx_http_gzip_module模块
ngx_http_gzip_static_module模块
ngx_http_gunzip_module模块

csharp复制代码http{
   gzip on;
}

bash复制代码http{
    gzip_types application/javascript;
}

ini复制代码http{
    gzip_comp_level 6;
}

bash复制代码gzip_buffers 4 16K;   #缓存空间大小

ini复制代码gzip_disable "MSIE [1-6].";

css复制代码nignx计量大小的单位：bytes[字节] / kb[千字节] / M[兆]
例如: 1024 / 10k|K / 10m|M

csharp复制代码gzip on;              #开启gzip功能
gzip_types *;         #压缩源文件类型,根据具体的访问资源类型设定
gzip_comp_level 6;    #gzip压缩级别
gzip_min_length 1024; #进行压缩响应页面的最小长度,content-length
gzip_buffers 4 16K;   #缓存空间大小
gzip_http_version 1.1; #指定压缩响应所需要的最低HTTP请求版本
gzip_vary  on;        #往头信息中添加压缩标识
gzip_disable "MSIE [1-6]."; #对IE6以下的版本都不进行压缩
gzip_proxied  off； #nginx作为反向代理压缩服务端返回数据的条件

ini复制代码gzip on;
gzip_types *;
gzip_comp_level 6;
gzip_min_length 1024;
gzip_buffers 4 16K;
gzip_http_version 1.1;
gzip_vary  on;
gzip_disable "MSIE [1-6].";
gzip_proxied  off;

makefile复制代码include nginx_gzip.conf

复制代码nginx -V

bash复制代码cd /usr/local/nginx/sbin
mv nginx nginxold

bash复制代码cd /root/nginx/core/nginx-1.16.1

go复制代码make clean

bash复制代码./configure --with-http_gzip_static_module

go复制代码make

bash复制代码mv objs/nginx /usr/local/nginx/sbin

go复制代码make upgrade

bash复制代码cd /usr/local/nginx/html
gzip jquery.js

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
                                         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory>
  <!-- <property name="hibernate.connection.datasource">java:comp/env/jdbc/dstest</property> -->
  <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=UTF-8</property>
  <property name="hibernate.connection.username">[你登录mysql数据库的用户名]</property>
  <property name="hibernate.connection.password">[你登录mysql数据库的密码]</property>
  <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
  <property name="hibernate.show_sql">true</property>
  <property name="hibernate.hbm2ddl.auto">update</property>
  <property name="hibernate.c3p0.max_size">200</property>
  <property name="hibernate.c3p0.min_size">2</property>
  <property name="hibernate.c3p0.timeout">1800</property>
  <property name="hibernate.c3p0.max_statements">50</property>
  
  <mapping resource="db/dao/News.hbm.xml"></mapping>
  <mapping resource="db/dao/User.hbm.xml"></mapping>
 </session-factory>
</hibernate-configuration>

typescript复制代码package db.dao;

// default package
// Generated 2015-8-24 18:39:26 by Hibernate Tools 4.3.1

/**
 * User generated by hbm2java
 */
public class User implements java.io.Serializable {

	private Integer id;
	private String name;

	public User() {
	}

	public User(String name) {
		this.name = name;
	}

	public Integer getId() {
		return this.id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}

}

less复制代码@Entity
@Table(name="user")
public class User implements java.io.Serializable 
{
	@Id @Column(name="id")
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	......(以下代码略去)
}

xml复制代码<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2015-8-24 18:49:15 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="db.dao.User" table="USER">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="assigned" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
    </class>
</hibernate-mapping>

java复制代码package db.dao;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

public class UserMgr {

	public static void main(String[] args) 
	{
		// Configuation实例代表了应用程序到SQL数据库的配置信息
		// 加载默认的hibernate.cfg.xml文件,若设置config()中的参数，则表示加载其他的配置文件
		Configuration conf = new Configuration().configure();

		@SuppressWarnings("deprecation")
		ServiceRegistry serviceReg = new ServiceRegistryBuilder()
				.applySettings(conf.getProperties()).buildServiceRegistry();

		// 以Configuration实例创建不可变SessionFactory实例
		SessionFactory sessionFac = conf.buildSessionFactory(serviceReg);

		// 创建Session
		Session session = sessionFac.openSession();

		// 开始事务
		Transaction trans = session.beginTransaction();

		// 创建消息对象
		User user = new User();

		user.setName("测试用户名1");

		// 保存信息
		session.save(user);

		// 提交事务
		trans.commit();

		// 关闭session
		session.close();
		sessionFac.close();
	}
}

ini复制代码<property name="hibernate.c3p0.timeout">1800</property>
<property name="hibernate.c3p0.max_size">30</property>
<property name="hibernate.c3p0.min_size">1</property>
<property name="hibernate.c3p0.max_statements">100</property>
<property name="hibernate.c3p0.idle_test_period">3000</property>
<property name="hibernate.c3p0.acquire_increment">2</property>
<property name="hibernate.c3p0.validate">true</property>