整合營銷服務商

          電腦端+手機端+微信端=數據同步管理

          免費咨詢熱線:

          SpringBoot整合FastJson過程解析

          SpringBoot整合FastJson過程解析

          篇文章主要介紹了SpringBoot整合FastJson過程解析,文中通過示例代碼介紹得非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

          一、Maven依賴

             <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.33</version>
              </dependency>
          

          二、配置類

          @Configuration
          public class WebMvcConfig implements WebMvcConfigurer {
            /**
             * 使用fastjson代替jackson
             *
             * @param
             */
          
            @Override
            public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
              configurer.enable();
            }
          ?
            @Override
          ?
            public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
          ?
            /*
             先把JackSon的消息轉換器刪除.
             備注: (1)源碼分析可知,返回json的過程為:
                  Controller調用結束后返回一個數據對象,for循環遍歷conventers,找到支持application/json的HttpMessageConverter,然后將返回的數據序列化成json。
                  具體參考org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor的writeWithMessageConverters方法
                (2)由于是list結構,我們添加的fastjson在最后。因此必須要將jackson的轉換器刪除,不然會先匹配上jackson,導致沒使用fastjson
          
            */
              for (int i=converters.size() - 1; i >=0; i--) {
                if (converters.get(i) instanceof MappingJackson2HttpMessageConverter) {
                  converters.remove(i);
                }
              }
              FastJsonHttpMessageConverter fastJsonHttpMessageConverter=new FastJsonHttpMessageConverter();
              //自定義fastjson配置
              FastJsonConfig config=new FastJsonConfig();
              config.setSerializerFeatures(
                  SerializerFeature.WriteMapNullValue,    // 是否輸出值為null的字段,默認為false,我們將它打開
                  SerializerFeature.WriteNullListAsEmpty,   // 將Collection類型字段的字段空值輸出為[]
                  SerializerFeature.WriteNullStringAsEmpty,  // 將字符串類型字段的空值輸出為空字符串
                  SerializerFeature.WriteNullNumberAsZero,  // 將數值類型字段的空值輸出為0
                  SerializerFeature.WriteDateUseDateFormat,
                  SerializerFeature.DisableCircularReferenceDetect  // 禁用循環引用
          ?
              );
          ?
              fastJsonHttpMessageConverter.setFastJsonConfig(config);
          ?
              // 添加支持的MediaTypes;不添加時默認為*/*,也就是默認支持全部
          ?
              // 但是MappingJackson2HttpMessageConverter里面支持的MediaTypes為application/json
          ?
          ?
              List<MediaType> fastMediaTypes=new ArrayList<>();
              MediaType mediaType=MediaType.parseMediaType("text/html;charset=UTF-8");
              fastMediaTypes.add(mediaType);
              fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
              fastJsonHttpMessageConverter.setSupportedMediaTypes(fastMediaTypes);
              // fastJsonHttpMessageConverter.setDefaultCharset(Charset.forName("UTF-8"));
              converters.add(fastJsonHttpMessageConverter);
            }
          }
          

          三、使用

          @JSONField(serialize=false)
          private String delFlag;  // 數據刪除標記, 0-已刪除 1-有效
          

          以上就是本文的全部內容,希望對大家的學習有所幫助,喜歡本文的小伙伴記得點贊關注收藏哦~
          么么么么么么么么么么噠!老子愛你們!?( ′???
          )比心?( ′??? )比心?( ′???` )比心

          我們從一段代碼說起,假設有一段這樣的 JSON 數據:

          var json={
          	name: '流火',
          	blog: 'ued.taobao.org'
          };
          

          我們需要根據這段 JSON 生成這樣的 HTML 代碼:

          流火 (blog: ued.taobao.org)
          

          傳統的 JavaScript 代碼一定是這個樣子:

          var html;
          html='' + json.name + ' (blog: ' + json.blog + ')';
          

          不言而喻,這樣的代碼混雜了 HTML 結構和代碼邏輯,而且代碼不具可讀性,不便于后期維護,于是便有了這樣一個函數:

          function sub(str, data) {
           return str.replace(/{(.*?)}/igm, function($, $1) {
           return data[$1] ? data[$1] : $;
           });
          }
          

          有了這個函數,我們拼接字符串的工作就可以簡化為:

          var tpl='{name} (blog: {blog})';
          var html=sub(tpl, json);
          

          看到這里,不用我多說,我想通過這個例子直觀的展現出前端模板引擎的好處所在,這么做能夠完全剝離 HTML 和代碼邏輯,便于多人協作和后期的代碼維護。當然,當我們的業務邏輯需要對數據源進行循環遍歷,if 判斷等的時候,這個簡明的函數很顯然并不能滿足我們的需求,于是便有了如今這市面上眾多的模板引擎,諸如 Mustache,jQuery tmpl,Kissy template,ejs,doT,nTenjin 等等。

          “如無必要,勿增實體?!?/p>

          這是著名的奧卡姆剃須刀法則,簡單的說就是避免重復造輪子。那么就會有童鞋質疑,既然已然有這么多現成的東西可用,為什么還要重新打造一個呢?

          我個人認為一個完善的模板引擎應該兼顧這幾點:

          • 語法簡明
          • 執行效率高
          • 安全性
          • 錯誤處理機制
          • 多語言通用性

          而市面上現有的模板引擎沒有做到兼顧以上幾點,比如 Mustache 支持多種語言,通用性不錯,不過性能稍差,而且語法不支持高級特性,例如遍歷的時候無法做 if 判斷,也無法獲得 index 索引值,jQuery tmpl 依賴 jQuery,缺乏可移植性,Kissy template 雖然依賴 Kissy, 不過性能和語法都值得推薦,doT/nTenjin 性能和靈活性都很不錯,但是語法需要用原生的js來寫,寫好的模板代碼可讀性稍差。

          魚和熊掌不可兼得,語法的處理,安全性的輸出過濾和錯誤處理機制的引入在一定程度上都會或多或少降低模板引擎的性能,因此就需要我們權衡。Juicer 在實現上首先將性能看做第一個重要的指標,畢竟性能好壞直接影響用戶的感知,同時兼顧了安全性和錯誤處理機制(即便這樣會導致性能的略微下降)。

          首先來看下 jsperf 上同幾個主流模板引擎的性能對比。

          可以看到,性能上比傳統模板引擎均有提升,下邊的介紹主要從語法、安全性和錯誤處理,以及如何使用這幾個方面介紹下 Juicer.

          語法

          • 循環 {@each}…{@/each}
          • 判斷 {@if}…{@else if}…{@else}…{@/if}
          • 變量(支持函數)${varname|function}
          • 注釋 {# comment here}

          詳細的語法請參考 Juicer Docs.

          安全性

          安全性,簡單地說就是對輸出數據在輸出前進行一次轉義過濾,避免 XSS 這樣的腳本注入攻擊,簡單掃下盲,舉個 XSS 的例子。

          var json={
          	output: 'alert("XSS");'
          };
          

          如果 JSON 數據是第三方接口返回或者含有用戶輸入(像 BBS、評價)的內容,我們如果赤裸裸的將 output 寫到頁面上就會執行惡意的js代碼,所以 Juicer 默認是對數據輸出做了安全轉義的,當然如果不想被轉義,可以使用 $${varname}。

          juicer.to_html('${output}',json); 
          //輸出:<script>alert("XSS");</script>
          juicer.to_html('$${output}',json); 
          //輸出:<script>alert("XSS");</script>
          

          錯誤處理

          如果沒有錯誤處理,當模板引擎編譯(Compile)或者渲染(Render)出錯時候就會引起后續js代碼停止執行,可想而知,如果因為一個逗號或者 JSON 數據的偶發錯誤導致整個頁面掛掉,是我們不能接受的。但是 Juicer 在遇到這些錯誤的時候不會影響后續代碼的執行,只會在控制臺打出一句警告(Warn)告知開發者模板解析出現錯誤。

          juicer.to_html('${varname,,,,,,,}', json);
          alert('hello, juicer!');
          

          執行上邊的代碼就會看到控制臺打出的 Juicer Compile Exception: Unexpected token ,,但是不會因為錯誤導致后續的 alert被阻塞掉。

          實現原理

          Juicer 對一個模板的編譯和渲染的過程主要有以下幾個步驟:

          • 對模板代碼進行語法分析
          • 分析后生成原生的 JavaScript 代碼字符串
          • 將生成的代碼轉為可重用的 Function(Compiled Template)
          var json={
           list: [
           { name: 'benben' },
           { name: 'liuhuo' }
           ]
          };
          juicer.set('errorhandling', false); // pre-set option
          var tpl='{@each list as value,key}$${value.name}{@/each}';
          var compiled_tpl=juicer(tpl);
          

          我們通過compiled_tpl.render.toString()看下編譯后的代碼:

          function anonymous(data) {
           var data=data || {};
           var out='';
           out +='';
           for (var i0=0, l=data.list.length; i0 < l; i0++) {
           var value=data.list[i0];
           var key=i0;
           out +='';
           out +=((value.name));
           out +='';
           }
           out +='';
           return out;
          }
          

          是不是已經明白了 Juicer 的原理?這個編譯后的函數就會每次幫我們完成從數據到 HTML 代碼的拼裝操作。

          這里有幾點優化的地方值得分享下:

          • using +=instead of array.push
          • avoid using with {}
          • cache the compiled template (function)

          這幾點優化在大數據量循環渲染時候性能提升顯著,不過正因為放棄了 with{} 語句,所以 Juicer 會在編譯函數之前對模板進行詞法分析,將用到的變量實現聲明,這樣就能避免 JSON 數據外層必須指定 data. 前綴,如果你覺得這點性能的提升不重要,也可以在 options 中指定 loose: false(禁用松散模式),這樣就可以不省去 data. 前綴,這樣做的好處就是性能會更好一些。

          最后介紹下 Options 配置項,左側為參數默認值。

          {
          	cache: true/false,
          	loose: true/false,
          	strip: true/false,
          	errorhandling: true/false
          }
          

          cache 默認為 true,即同一個模板編譯后是否被 Juicer 緩存,也就是說如果緩存開啟的情況下,同一個模板第一次編譯后,為了縮短耗時提升性能,后續不會再次執行編譯的操作而是直接從緩存中去取編譯好的模板函數。

          Juicer 的 API

          Juicer 有兩種使用方法,一種是通過

          juicer(tpl, data);
          // 或者
          juicer.to_html(tpl, data);
          

          直接根據提供的數據將模板轉為 HTML 代碼,另一種是通過 compile 方法先將模板編譯好,在需要的時候再對模板進行數據的 Render 操作:

          var compiled_tpl=juicer(tpl);
          compiled_tpl.render(data);
          // 或者
          var compiled_tpl=juicer.compile(tpl);
          compiled_tpl.render(data);
          

          希望本文能幫助到您!

          點贊+轉發,讓更多的人也能看到這篇內容(收藏不點贊,都是耍流氓-_-)

          關注 {我},享受文章首發體驗!

          每周重點攻克一個前端技術難點。更多精彩前端內容私信 我 回復“教程”

          原文鏈接:

          作者:admin

          于總結了太多的東西,所以篇幅有點長,這也是作者"縫縫補補"總結了好久的東西,強烈建議收藏再慢慢看~

          Py2 VS Py3

          Py2 和 Py3 的差別

          • print 成為了函數,python2 是關鍵字
          • 不再有 unicode 對象,默認 str 就是 unicode
          • python3 除號返回浮點數
          • 沒有了long類型
          • xrange 不存在,range 替代了 xrange
          • 可以使用中文定義函數名變量名
          • 高級解包和*解包
          • 限定關鍵字參數 *后的變量必須加入名字=值
          • raise from
          • iteritems 移除變成 items()
          • yield from 鏈接子生成器
          • asyncio,async/await 原生協程支持異步編程
          • 新增 enum, mock, ipaddress, concurrent.futures, asyncio urllib, selector
            • 不同枚舉類間不能進行比較
            • 同一枚舉類間只能進行相等的比較
            • 枚舉類的使用(編號默認從1開始)
            • 為了避免枚舉類中相同枚舉值的出現,可以使用@unique裝飾枚舉類
          #枚舉的注意事項
          from enum import Enum
          
          class COLOR(Enum):
              YELLOW=1
          #YELLOW=2#會報錯
              GREEN=1#不會報錯,GREEN可以看作是YELLOW的別名
              BLACK=3
              RED=4
          print(COLOR.GREEN)#COLOR.YELLOW,還是會打印出YELLOW
          for i in COLOR:#遍歷一下COLOR并不會有GREEN
              print(i)
          #COLOR.YELLOW\nCOLOR.BLACK\nCOLOR.RED\n怎么把別名遍歷出來
          for i in COLOR.__members__.items():
              print(i)
          # output:('YELLOW', <COLOR.YELLOW: 1>)\n('GREEN', <COLOR.YELLOW: 1>)\n('BLACK', <COLOR.BLACK: 3>)\n('RED', <COLOR.RED: 4>)
          for i in COLOR.__members__:
              print(i)
          # output:YELLOW\nGREEN\nBLACK\nRED
          
          #枚舉轉換
          #最好在數據庫存取使用枚舉的數值而不是使用標簽名字字符串
          #在代碼里面使用枚舉類
          a=1
          print(COLOR(a))# output:COLOR.YELLOW
          

          py2/3 轉換工具

          • six 模塊:兼容 pyton2 和 pyton3 的模塊
          • 2to3 工具:改變代碼語法版本
          • __future__:使用下一版本的功能


          類庫相關

          常用庫

          • 必須知道的 collections https://segmentfault.com/a/1190000017385799
          • python排 序操作及 heapq 模塊 https://segmentfault.com/a/1190000017383322
          • itertools 模塊超實用方法 https://segmentfault.com/a/1190000017416590

          不常用但很重要的庫

          • dis(代碼字節碼分析)
          • inspect(生成器狀態)
          • cProfile(性能分析)
          • bisect(維護有序列表)
          • fnmatch
          • fnmatch(string,"*.txt") # win下不區分大小寫
          • fnmatch 根據系統決定
          • fnmatchcase 完全區分大小寫
          • timeit(代碼執行時間)
          def isLen(strString):
              #還是應該使用三元表達式,更快
              return True if len(strString)>6 else False
          
          def isLen1(strString):
              #這里注意false和true的位置
              return [False,True][len(strString)>6]
          import timeit
          print(timeit.timeit('isLen1("5fsdfsdfsaf")',setup="from __main__ import isLen1"))
          
          print(timeit.timeit('isLen("5fsdfsdfsaf")',setup="from __main__ import isLen"))
          
          • contextlib
            • @contextlib.contextmanager 使生成器函數變成一個上下文管理器
          • types(包含了標準解釋器定義的所有類型的類型對象,可以將生成器函數修飾為異步模式)
          import types
          types.coroutine #相當于實現了__await__
          
          • html(實現對html的轉義)
          import html
          html.escape("<h1>I'm Jim</h1>") # output:'<h1>I'm Jim</h1>'
          html.unescape('<h1>I'm Jim</h1>') # <h1>I'm Jim</h1>
          
          • mock(解決測試依賴)
          • concurrent(創建進程池和線程池)
          from concurrent.futures import ThreadPoolExecutor
          
          pool=ThreadPoolExecutor()
          task=pool.submit(函數名,(參數)) #此方法不會阻塞,會立即返回
          task.done()#查看任務執行是否完成
          task.result()#阻塞的方法,查看任務返回值
          task.cancel()#取消未執行的任務,返回True或False,取消成功返回True
          task.add_done_callback()#回調函數
          task.running()#是否正在執行     task就是一個Future對象
          
          for data in pool.map(函數,參數列表):#返回已經完成的任務結果列表,根據參數順序執行
              print(返回任務完成得執行結果data)
          
          from concurrent.futures import as_completed
          as_completed(任務列表)#返回已經完成的任務列表,完成一個執行一個
          
          wait(任務列表,return_when=條件)#根據條件進行阻塞主線程,有四個條件
          
          • selector(封裝select,用戶多路復用io編程)
          • asyncio
          future=asyncio.ensure_future(協程)  等于后面的方式  future=loop.create_task(協程)
          future.add_done_callback()添加一個完成后的回調函數
          loop.run_until_complete(future)
          future.result()查看寫成返回結果
          
          asyncio.wait()接受一個可迭代的協程對象
          asynicio.gather(*可迭代對象,*可迭代對象)    兩者結果相同,但gather可以批量取消,gather對象.cancel()
          
          一個線程中只有一個loop
          
          在loop.stop時一定要loop.run_forever()否則會報錯
          loop.run_forever()可以執行非協程
          最后執行finally模塊中 loop.close()
          
          asyncio.Task.all_tasks()拿到所有任務 然后依次迭代并使用任務.cancel()取消
          
          偏函數partial(函數,參數)把函數包裝成另一個函數名  其參數必須放在定義函數的前面
          
          loop.call_soon(函數,參數)
          call_soon_threadsafe()線程安全    
          loop.call_later(時間,函數,參數)
          在同一代碼塊中call_soon優先執行,然后多個later根據時間的升序進行執行
          
          如果非要運行有阻塞的代碼
          使用loop.run_in_executor(executor,函數,參數)包裝成一個多線程,然后放入到一個task列表中,通過wait(task列表)來運行
          
          通過asyncio實現http
          reader,writer=await asyncio.open_connection(host,port)
          writer.writer()發送請求
          async for data in reader:
              data=data.decode("utf-8")
              list.append(data)
          然后list中存儲的就是html
          
          as_completed(tasks)完成一個返回一個,返回的是一個可迭代對象    
          
          協程鎖
          async with Lock():
          

          Python 進階

          • 進程間通信:
            • Manager(內置了好多數據結構,可以實現多進程間內存共享)
          from multiprocessing import Manager,Process
          def add_data(p_dict, key, value):
              p_dict[key]=value
          
          if __name__=="__main__":
              progress_dict=Manager().dict()
              from queue import PriorityQueue
          
              first_progress=Process(target=add_data, args=(progress_dict, "bobby1", 22))
              second_progress=Process(target=add_data, args=(progress_dict, "bobby2", 23))
          
              first_progress.start()
              second_progress.start()
              first_progress.join()
              second_progress.join()
          
              print(progress_dict)
          
          • Pipe(適用于兩個進程)
          from multiprocessing import Pipe,Process
          #pipe的性能高于queue
          def producer(pipe):
              pipe.send("bobby")
          
          def consumer(pipe):
              print(pipe.recv())
          
          if __name__=="__main__":
              recevie_pipe, send_pipe=Pipe()
              #pipe只能適用于兩個進程
              my_producer=Process(target=producer, args=(send_pipe, ))
              my_consumer=Process(target=consumer, args=(recevie_pipe,))
          
              my_producer.start()
              my_consumer.start()
              my_producer.join()
              my_consumer.join()
          
          • Queue(不能用于進程池,進程池間通信需要使用Manager().Queue())
          from multiprocessing import Queue,Process
          def producer(queue):
              queue.put("a")
              time.sleep(2)
          
          def consumer(queue):
              time.sleep(2)
              data=queue.get()
              print(data)
          
          if __name__=="__main__":
              queue=Queue(10)
              my_producer=Process(target=producer, args=(queue,))
              my_consumer=Process(target=consumer, args=(queue,))
              my_producer.start()
              my_consumer.start()
              my_producer.join()
              my_consumer.join()
          
          • 進程池
          def producer(queue):
              queue.put("a")
              time.sleep(2)
          
          def consumer(queue):
              time.sleep(2)
              data=queue.get()
              print(data)
          
          if __name__=="__main__":
              queue=Manager().Queue(10)
              pool=Pool(2)
          
              pool.apply_async(producer, args=(queue,))
              pool.apply_async(consumer, args=(queue,))
          
              pool.close()
              pool.join()
          
          • sys 模塊幾個常用方法
            • argv 命令行參數list,第一個是程序本身的路徑
            • path 返回模塊的搜索路徑
            • modules.keys() 返回已經導入的所有模塊的列表
            • exit(0) 退出程序
          • a in s or b in s or c in s簡寫
            • 采用any方式:all() 對于任何可迭代對象為空都會返回 True
          # 方法一
          True in [i in s for i in [a,b,c]]
          # 方法二
          any(i in s for i in [a,b,c])
          # 方法三
          list(filter(lambda x:x in s,[a,b,c]))
          
          • set集合運用
            • {1,2}.issubset({1,2,3})#判斷是否是其子集
            • {1,2,3}.issuperset({1,2})
            • {}.isdisjoint({})#判斷兩個set交集是否為空,是空集則為True
          • 代碼中中文匹配
            • [u4E00-u9FA5]匹配中文文字區間[一到龥]
          • 查看系統默認編碼格式
          import sys
          sys.getdefaultencoding()    # setdefaultencodeing()設置系統編碼方式
          
          • getattr VS getattribute
          class A(dict):
              def __getattr__(self,value):#當訪問屬性不存在的時候返回
                  return 2
              def __getattribute__(self,item):#屏蔽所有的元素訪問
                  return item
          
          • 類變量是不會存入實例__dict__中的,只會存在于類的__dict__中
          • globals/locals(可以變相操作代碼)
            • globals中保存了當前模塊中所有的變量屬性與值
            • locals中保存了當前環境中的所有變量屬性與值
          • python變量名的解析機制(LEGB)
            • 本地作用域(Local)
            • 當前作用域被嵌入的本地作用域(Enclosing locals)
            • 全局/模塊作用域(Global)
            • 內置作用域(Built-in)
          • 實現從1-100每三個為一組分組
          print([[x for x in range(1,101)][i:i+3] for i in range(0,100,3)])
          
          • 什么是元類?
            • 即創建類的類,創建類的時候只需要將metaclass=元類,元類需要繼承type而不是object,因為type就是元類
          type.__bases__  #(<class 'object'>,)
          object.__bases__    #()
          type(object)    #<class 'type'>
          
          class Yuan(type):
                  def __new__(cls,name,base,attr,*args,**kwargs):
                      return type(name,base,attr,*args,**kwargs)
              class MyClass(metaclass=Yuan):
                  pass
          
          • 什么是鴨子類型(即:多態)?
            • Python在使用傳入參數的過程中不會默認判斷參數類型,只要參數具備執行條件就可以執行
          • 深拷貝和淺拷貝
            • 深拷貝拷貝內容,淺拷貝拷貝地址(增加引用計數)
            • copy模塊實現神拷貝
          • 單元測試
            • 一般測試類繼承模塊unittest下的TestCase
            • pytest模塊快捷測試(方法以test_開頭/測試文件以test_開頭/測試類以Test開頭,并且不能帶有 init 方法)
            • coverage統計測試覆蓋率
          class MyTest(unittest.TestCase):
              def tearDown(self):# 每個測試用例執行前執行
                  print('本方法開始測試了')
          
              def setUp(self):# 每個測試用例執行之前做操作
                  print('本方法測試結束')
          
              @classmethod
              def tearDownClass(self):# 必須使用 @ classmethod裝飾器, 所有test運行完后運行一次
                  print('開始測試')
              @classmethod
              def setUpClass(self):# 必須使用@classmethod 裝飾器,所有test運行前運行一次
                  print('結束測試')
          
              def test_a_run(self):
                  self.assertEqual(1, 1)  # 測試用例
          
          • gil 會根據執行的字節碼行數以及時間片釋放 gil,gil 在遇到 io 的操作時候主動釋放
          • 什么是 monkey patch?
            • 猴子補丁,在運行的時候替換掉會阻塞的語法修改為非阻塞的方法
          • 什么是自省(Introspection)?
            • 運行時判斷一個對象的類型的能力,id,type,isinstance
          • python 是值傳遞還是引用傳遞?
            • 都不是,python是共享傳參,默認參數在執行時只會執行一次
          • try-except-else-finally中 else 和 finally 的區別
            • else在不發生異常的時候執行,finally無論是否發生異常都會執行
            • except一次可以捕獲多個異常,但一般為了對不同異常進行不同處理,我們分次捕獲處理
          • GIL 全局解釋器鎖
            • 同一時間只能有一個線程執行,CPython(IPython)的特點,其他解釋器不存在
            • cpu 密集型:多進程+進程池
            • io 密集型:多線程/協程
          • 什么是 Cython
            • 將 python 解釋 成 C 代碼工具
          • 生成器和迭代器
            • 實現__next__和__iter__方法的對象就是迭代器
            • 可迭代對象只需要實現__iter__方法
            • 使用生成器表達式或者yield的生成器函數(生成器是一種特殊的迭代器)
          • 什么是協程
            • 比線程更輕量的多任務方式
            • 實現方式
            • yield
            • async-awiat
          • dict 底層結構
            • 為了支持快速查找使用了哈希表作為底層結構
            • 哈希表平均查找時間復雜度為o(1)
            • CPython 解釋器使用二次探查解決哈希沖突問題
          • Hash擴容和Hash沖突解決方案
            • 循環復制到新空間實現擴容
            • 沖突解決:
            • 鏈接法
            • 二次探查(開放尋址法):python使用
          for gevent import monkey
          monkey.patch_all()  #將代碼中所有的阻塞方法都進行修改,可以指定具體要修改的方法
          
          • 判斷是否為生成器或者協程
          co_flags=func.__code__.co_flags
          
          # 檢查是否是協程
          if co_flags & 0x180:
              return func
          
          # 檢查是否是生成器
          if co_flags & 0x20:
              return func
          
          • 斐波那契解決的問題及變形
          #一只青蛙一次可以跳上1級臺階,也可以跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
          #請問用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形,總共有多少種方法?
          #方式一:
          fib=lambda n: n if n <=2 else fib(n - 1) + fib(n - 2)
          #方式二:
          def fib(n):
              a, b=0, 1
              for _ in range(n):
                  a, b=b, a + b
              return b
          
          #一只青蛙一次可以跳上1級臺階,也可以跳上2級……它也可以跳上n級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
          fib=lambda n: n if n < 2 else 2 * fib(n - 1)
          
          • 獲取電腦設置的環境變量
          import os
          os.getenv(env_name,None)#獲取環境變量如果不存在為None
          
          • 垃圾回收機制
            • 引用計數
            • 標記清除
            • 分代回收
          #查看分代回收觸發
          import gc
          gc.get_threshold()  #output:(700, 10, 10)
          
          • True 和 False 在代碼中完全等價于1和0,可以直接和數字進行計算,inf 表示無窮大
          • C10M/C10K
            • C10M:8核心cpu,64G內存,在10gbps的網絡上保持1000萬并發連接
            • C10K:1GHz CPU,2G內存,1gbps網絡環境下保持1萬個客戶端提供FTP服務
          • yield from 與 yield 的區別:
            • yield from 跟的是一個可迭代對象,而 yield 后面沒有限制
            • GeneratorExit 生成器停止時觸發
          • 單下劃線的幾種使用
            • 在定義變量時,表示為私有變量
            • 在解包時,表示舍棄無用的數據
            • 在交互模式中表示上一次代碼執行結果
            • 可以做數字的拼接(111_222_333)
          • 使用 brea k就不會執行 else
          • 10進制轉2進制
          def conver_bin(num):
              if num==0:
                  return num
              re=[]
              while num:
                  num, rem=divmod(num,2)
                  re.append(str(rem))
              return "".join(reversed(re))
            conver_bin(10)
          
          • list1=['A', 'B', 'C', 'D'] 如何才能得到以list中元素命名的新列表 A=[],B=[],C=[],D=[]呢
          list1=['A', 'B', 'C', 'D']
          
          # 方法一
          for i in list1:
              globals()[i]=[]   # 可以用于實現python版反射
          
          # 方法二
          for i in list1:
              exec(f'{i}=[]')   # exec執行字符串語句
          
          • memoryview與bytearray不常用,只是看到了記載一下
          # bytearray是可變的,bytes是不可變的,memoryview不會產生新切片和對象
          a='aaaaaa'
          ma=memoryview(a)
          ma.readonly  # 只讀的memoryview
          mb=ma[:2]  # 不會產生新的字符串
          
          a=bytearray('aaaaaa')
          ma=memoryview(a)
          ma.readonly  # 可寫的memoryview
          mb=ma[:2]      # 不會會產生新的bytearray
          mb[:2]='bb'    # 對mb的改動就是對ma的改動
          
          • Ellipsis類型
          # 代碼中出現...省略號的現象就是一個Ellipsis對象
          L=[1,2,3]
          L.append(L)
          print(L)    # output:[1,2,3,[…]]
          
          • lazy惰性計算
          class lazy(object):
              def __init__(self, func):
                  self.func=func
          
              def __get__(self, instance, cls):
                  val=self.func(instance)    #其相當于執行的area(c),c為下面的Circle對象
                  setattr(instance, self.func.__name__, val)
                  return val`
          
          class Circle(object):
              def __init__(self, radius):
                  self.radius=radius
          
              @lazy
              def area(self):
                  print('evalute')
                  return 3.14 * self.radius ** 2
          
          • 遍歷文件,傳入一個文件夾,將里面所有文件的路徑打印出來(遞歸)
          all_files=[]    
          def getAllFiles(directory_path):
              import os                                       
              for sChild in os.listdir(directory_path):                
                  sChildPath=os.path.join(directory_path,sChild)
                  if os.path.isdir(sChildPath):
                      getAllFiles(sChildPath)
                  else:
                      all_files.append(sChildPath)
              return all_files
          
          • 文件存儲時,文件名的處理
          #secure_filename將字符串轉化為安全的文件名
          from werkzeug import secure_filename
          secure_filename("My cool movie.mov") # output:My_cool_movie.mov
          secure_filename("../../../etc/passwd") # output:etc_passwd
          secure_filename(u'i contain cool \xfcml\xe4uts.txt') # output:i_contain_cool_umlauts.txt
          
          • 日期格式化
          from datetime import datetime
          
          datetime.now().strftime("%Y-%m-%d")
          
          import time
          #這里只有localtime可以被格式化,time是不能格式化的
          time.strftime("%Y-%m-%d",time.localtime())
          
          • tuple使用+=奇怪的問題
          # 會報錯,但是tuple的值會改變,因為t[1]id沒有發生變化
          t=(1,[2,3])
          t[1]+=[4,5]
          # t[1]使用append\extend方法并不會報錯,并可以成功執行
          
          • __missing__你應該知道
          class Mydict(dict):
              def __missing__(self,key): # 當Mydict使用切片訪問屬性不存在的時候返回的值
                  return key
          
          • +與+=
          # +不能用來連接列表和元祖,而+=可以(通過iadd實現,內部實現方式為extends(),所以可以增加元組),+會創建新對象
          #不可變對象沒有__iadd__方法,所以直接使用的是__add__方法,因此元祖可以使用+=進行元祖之間的相加
          
          • 如何將一個可迭代對象的每個元素變成一個字典的所有鍵?
          dict.fromkeys(['jim','han'],21) # output:{'jim': 21, 'han': 21}


          網絡知識

          • 什么是 HTTPS?
            • 安全的 HTTP 協議,https 需要 cs 證書,數據加密,端口為443,安全,同一網站 https seo 排名會更高
          • 常見響應狀態碼
          204 No Content //請求成功處理,沒有實體的主體返回,一般用來表示刪除成功
          206 Partial Content //Get范圍請求已成功處理
          303 See Other //臨時重定向,期望使用get定向獲取
          304 Not Modified //請求緩存資源
          307 Temporary Redirect //臨時重定向,Post不會變成Get
          401 Unauthorized //認證失敗
          403 Forbidden //資源請求被拒絕
          400 //請求參數錯誤
          201 //添加或更改成功
          503 //服務器維護或者超負載
          
          • http 請求方法的冪等性及安全性
          • WSGI
          # environ:一個包含所有HTTP請求信息的dict對象
          # start_response:一個發送HTTP響應的函數
          def application(environ, start_response):
              start_response('200 OK', [('Content-Type', 'text/html')])
              return '<h1>Hello, web!</h1>'
          
          • RPC
          • CDN
          • SSL(Secure Sockets Layer 安全套接層),及其繼任者傳輸層安全(Transport Layer Security,TLS)是為網絡通信提供安全及數據完整性的一種安全協議。
          • SSH(安全外殼協議) 為 Secure Shell 的縮寫,由 IETF 的網絡小組(Network Working Group)所制定;SSH 為建立在應用層基礎上的安全協議。SSH 是目前較可靠,專為遠程登錄會話和其他網絡服務提供安全性的協議。利用 SSH 協議可以有效防止遠程管理過程中的信息泄露問題。SSH最初是UNIX系統上的一個程序,后來又迅速擴展到其他操作平臺。SSH在正確使用時可彌補網絡中的漏洞。SSH客戶端適用于多種平臺。幾乎所有UNIX平臺—包括HP-UX、Linux、AIX、Solaris、Digital UNIX、Irix,以及其他平臺,都可運行SSH。
          • TCP/IP
            • 雖然按道理,四個報文都發送完畢,我們可以直接進入CLOSE狀態了,但是我們必須假象網絡是不可靠的,有可以最后一個ACK丟失。所以TIME_WAIT狀態就是用來重發可能丟失的ACK報文。
            • 因為當Server端收到Client端的SYN連接請求報文后,可以直接發送SYN+ACK報文。其中ACK報文是用來應答的,SYN報文是用來同步的。但是關閉連接時,當Server端收到FIN報文時,很可能并不會立即關閉SOCKET,所以只能先回復一個ACK報文,告訴Client端,"你發的FIN報文我收到了"。只有等到我Server端所有的報文都發送完了,我才能發送FIN報文,因此不能一起發送。故需要四步握手。
            • 三次握手(SYN/SYN+ACK/ACK)
            • 四次揮手(FIN/ACK/FIN/ACK)
            • TCP:面向連接/可靠/基于字節流
            • UDP:無連接/不可靠/面向報文
            • 三次握手四次揮手
            • 為什么連接的時候是三次握手,關閉的時候卻是四次握手?
            • 為什么TIME_WAIT狀態需要經過2MSL(最大報文段生存時間)才能返回到CLOSE狀態?
          • XSS/CSRF
          • HttpOnly 禁止 js 腳本訪問和操作 Cookie,可以有效防止 XSS


          Mysql

          • 索引改進過程
            • 線性結構->二分查找->hash->二叉查找樹->平衡二叉樹->多路查找樹->多路平衡查找樹(B-Tree)
          • Mysql面試總結基礎篇
          • https://segmentfault.com/a/1190000018371218
          • Mysql面試總結進階篇
            • https://segmentfault.com/a/1190000018380324
          • 深入淺出Mysql
            • http://ningning.today/2017/02/13/database/深入淺出mysql/
          • 清空整個表時,InnoDB是一行一行的刪除,而MyISAM則會從新刪除建表
          • text/blob數據類型不能有默認值,查詢時不存在大小寫轉換
          • 什么時候索引失效
            • 應盡量避免在 where 子句中使用 !=或 <> 操作符,否則引擎將放棄使用索引而進行全表掃描
            • 盡量避免在 where 子句中使用 or 來連接條件,否則將導致引擎放棄使用索引而進行全表掃描,即使其中有條件帶索引也不會使用,這也是為什么盡量少用 or 的原因
            • 如果列類型是字符串,那一定要在條件中將數據使用引號引用起來,否則不會使用索引
            • 應盡量避免在 where 子句中對字段進行函數操作,這將導致引擎放棄使用索引而進行全表掃描
            • 對于多列索引,不是使用的第一部分,則不會使用索引
            • 以%開頭的like模糊查詢
            • 出現隱式類型轉換
            • 沒有滿足最左前綴原則
            • 失效場景:
          例如:
          select id from t where substring(name,1,3)='abc' – name;
          以abc開頭的,應改成:
          select id from t where name like 'abc%' 
          例如:
          select id from t where datediff(day, createdate, '2005-11-30')=0 – '2005-11-30';
          應改為:
          

          不要在 where 子句中的 “=” 左邊進行函數、算術運算或其他表達式運算,否則系統將可能無法正確使用索引

          應盡量避免在 where 子句中對字段進行表達式操作,這將導致引擎放棄使用索引而進行全表掃描

          如:
          select id from t where num/2=100 
          應改為:
          select id from t where num=100*2;
          

          不適合鍵值較少的列(重復數據較多的列)比如:set enum列就不適合(枚舉類型(enum)可以添加null,并且默認的值會自動過濾空格集合(set)和枚舉類似,但只可以添加64個值)

          如果MySQL估計使用全表掃描要比使用索引快,則不使用索引

          • 什么是聚集索引
            • B+Tree葉子節點保存的是數據還是指針
            • MyISAM索引和數據分離,使用非聚集
            • InnoDB數據文件就是索引文件,主鍵索引就是聚集索引


          Redis 命令總結

          • 為什么這么快?
            • 因為Redis是基于內存的操作,CPU不是Redis的瓶頸,Redis的瓶頸最有可能是機器內存的大小或者網絡帶寬。既然單線程容易實現,而且CPU不會成為瓶頸,那就順理成章地采用單線程的方案了(畢竟采用多線程會有很多麻煩?。?/span>
            • 基于內存,由 C 語言編寫
            • 使用多路I/O復用模型,非阻塞 IO
            • 使用單線程減少線程間切換
            • 數據結構簡單
            • 自己構建了 VM 機制,減少調用系統函數的時間
          • 優勢
            • 性能高 – Redis 能讀的速度是110000次/s,寫的速度是81000次/s
            • 豐富的數據類型
            • 原子 – Redis 的所有操作都是原子性的,同時 Redis 還支持對幾個操作全并后的原子性執行
            • 豐富的特性 – Redis 還支持 publish/subscribe(發布/訂閱), 通知, key 過期等等特性
          • 什么是 redis 事務?
            • 將多個請求打包,一次性、按序執行多個命令的機制
            • 通過 multi,exec,watch 等命令實現事務功能
            • Python redis-py pipeline=conn.pipeline(transaction=True)
          • 持久化方式
            • save(同步,可以保證數據一致性)
            • bgsave(異步,shutdown時,無AOF則默認使用)
            • RDB(快照)
            • AOF(追加日志)
          • 怎么實現隊列
            • push
            • rpop
          • 常用的數據類型(Bitmaps,Hyperloglogs,范圍查詢等不常用)
            • skiplist(跳躍表)
            • intset或hashtable
            • ziplist(連續內存塊,每個entry節點頭部保存前后節點長度信息實現雙向鏈表功能)或double linked list
            • 整數或sds(Simple Dynamic String)
            • String(字符串):計數器
            • List(列表):用戶的關注,粉絲列表
            • Hash(哈希):
            • Set(集合):用戶的關注者
            • Zset(有序集合):實時信息排行榜
          • 與 Memcached 區別
            • Memcached只能存儲字符串鍵
            • Memcached用戶只能通過APPEND的方式將數據添加到已有的字符串的末尾,并將這個字符串當做列表來使用。但是在刪除這些元素的時候,Memcached采用的是通過黑名單的方式來隱藏列表里的元素,從而避免了對元素的讀取、更新、刪除等操作
            • Redis和Memcached都是將數據存放在內存中,都是內存數據庫。不過Memcached還可用于緩存其他東西,例如圖片、視頻等等
            • 虛擬內存–Redis當物理內存用完時,可以將一些很久沒用到的Value 交換到磁盤
            • 存儲數據安全–Memcached掛掉后,數據沒了;Redis可以定期保存到磁盤(持久化)
            • 應用場景不一樣:Redis出來作為NoSQL數據庫使用外,還能用做消息隊列、數據堆棧和數據緩存等;Memcached適合于緩存SQL語句、數據集、用戶臨時性數據、延遲查詢數據和Session等
          • Redis實現分布式鎖
            • 使用setnx實現加鎖,可以同時通過expire添加超時時間
            • 鎖的value值可以是一個隨機的uuid或者特定的命名
            • 釋放鎖的時候,通過uuid判斷是否是該鎖,是則執行delete釋放鎖
          • 常見問題
            • 當訪問量劇增、服務出現問題(如響應時間慢或不響應)或非核心服務影響到核心流程的性能時,仍然需要保證服務還是可用的,即使是有損服務。系統可以根據一些關鍵數據進行自動降級,也可以配置開關實現人工降級
            • 數據過期,進行更新緩存數據
            • 初始化項目,將部分常用數據加入緩存
            • 請求訪問數據時,查詢緩存中不存在,數據庫中也不存在
            • 短時間內緩存數據過期,大量請求訪問數據庫
            • 緩存雪崩
            • 緩存穿透
            • 緩存預熱
            • 緩存更新
            • 緩存降級
          • 一致性Hash算法
            • 使用集群的時候保證數據的一致性
          • 基于redis實現一個分布式鎖,要求一個超時的參數
            • setnx
          • 虛擬內存
          • 內存抖動


          Linux

          • Unix五種i/o模型
            • select
            • poll
            • epoll
            • 并發不高,連接數很活躍的情況下
            • 比select提高的并不多
            • 適用于連接數量較多,但活動鏈接數少的情況
            • 阻塞io
            • 非阻塞io
            • 多路復用io(Python下使用selectot實現io多路復用)
            • 信號驅動io
            • 異步io(Gevent/Asyncio實現異步)
          • 比 man 更好使用的命令手冊
            • tldr:一個有命令示例的手冊
          • kill -9和-15的區別
            • -15:程序立刻停止/當程序釋放相應資源后再停止/程序可能仍然繼續運行
            • -9:由于-15的不確定性,所以直接使用-9立即殺死進程
          • 分頁機制(邏輯地址和物理地址分離的內存分配管理方案):
            • 操作系統為了高效管理內存,減少碎片
            • 程序的邏輯地址劃分為固定大小的頁
            • 物理地址劃分為同樣大小的幀
            • 通過頁表對應邏輯地址和物理地址
          • 分段機制
            • 為了滿足代碼的一些邏輯需求
            • 數據共享/數據保護/動態鏈接
            • 每個段內部連續內存分配,段和段之間是離散分配的
          • 查看 cpu 內存使用情況?
            • top
            • free 查看可用內存,排查內存泄漏問題


          設計模式

          單例模式

          # 方式一
          def Single(cls,*args,**kwargs):
              instances={}
              def get_instance (*args, **kwargs):
                  if cls not in instances:
                      instances[cls]=cls(*args, **kwargs)
                  return instances[cls]
              return get_instance
          @Single
          class B:
              pass
          # 方式二
          class Single:
              def __init__(self):
                  print("單例模式實現方式二。。。")
          
          single=Single()
          del Single  # 每次調用single就可以了
          # 方式三(最常用的方式)
          class Single:
              def __new__(cls,*args,**kwargs):
                  if not hasattr(cls,'_instance'):
                      cls._instance=super().__new__(cls,*args,**kwargs)
                  return cls._instance
          

          工廠模式

          class Dog:
              def __init__(self):
                  print("Wang Wang Wang")
          class Cat:
              def __init__(self):
                  print("Miao Miao Miao")
          
          
          def fac(animal):
              if animal.lower()=="dog":
                  return Dog()
              if animal.lower()=="cat":
                  return Cat()
              print("對不起,必須是:dog,cat")
          

          構造模式

          class Computer:
              def __init__(self,serial_number):
                  self.serial_number=serial_number
                  self.memory=None
                  self.hadd=None
                  self.gpu=None
              def __str__(self):
                  info=(f'Memory:{self.memoryGB}',
                  'Hard Disk:{self.hadd}GB',
                  'Graphics Card:{self.gpu}')
                  return ''.join(info)
          class ComputerBuilder:
              def __init__(self):
                  self.computer=Computer('Jim1996')
              def configure_memory(self,amount):
                  self.computer.memory=amount
                  return self #為了方便鏈式調用
              def configure_hdd(self,amount):
                  pass
              def configure_gpu(self,gpu_model):
                  pass
          class HardwareEngineer:
              def __init__(self):
                  self.builder=None
              def construct_computer(self,memory,hdd,gpu)
                  self.builder=ComputerBuilder()
                  self.builder.configure_memory(memory).configure_hdd(hdd).configure_gpu(gpu)
              @property
              def computer(self):
                  return self.builder.computer
          



          數據結構和算法

          python實現各種數據結構

          快速排序

          def quick_sort(_list):
              if len(_list) < 2:
                  return _list
              pivot_index=0
              pivot=_list(pivot_index)
              left_list=[i for i in _list[:pivot_index] if i < pivot]
              right_list=[i for i in _list[pivot_index:] if i > pivot]
              return quick_sort(left) + [pivot] + quick_sort(right)
          

          選擇排序

          def select_sort(seq):
              n=len(seq)
              for i in range(n-1)
              min_idx=i
                  for j in range(i+1,n):
                      if seq[j] < seq[min_inx]:
                          min_idx=j
                  if min_idx !=i:
                      seq[i], seq[min_idx]=seq[min_idx],seq[i]
          

          插入排序

          def insertion_sort(_list):
              n=len(_list)
              for i in range(1,n):
                  value=_list[i]
                  pos=i
                  while pos > 0 and value < _list[pos - 1]
                      _list[pos]=_list[pos - 1]
                      pos -=1
                  _list[pos]=value
                  print(sql)
          

          歸并排序

          def merge_sorted_list(_list1,_list2):   #合并有序列表
              len_a, len_b=len(_list1),len(_list2)
              a=b=0
              sort=[]
              while len_a > a and len_b > b:
                  if _list1[a] > _list2[b]:
                      sort.append(_list2[b])
                      b +=1
                  else:
                      sort.append(_list1[a])
                      a +=1
              if len_a > a:
                  sort.append(_list1[a:])
              if len_b > b:
                  sort.append(_list2[b:])
              return sort
          
          def merge_sort(_list):
              if len(list1)<2:
                  return list1
              else:
                  mid=int(len(list1)/2)
                  left=mergesort(list1[:mid])
                  right=mergesort(list1[mid:])
                  return merge_sorted_list(left,right)
          

          堆排序heapq模塊

          from heapq import nsmallest
          def heap_sort(_list):
              return nsmallest(len(_list),_list)
          

          from collections import deque
          class Stack:
              def __init__(self):
                  self.s=deque()
              def peek(self):
                  p=self.pop()
                  self.push(p)
                  return p
              def push(self, el):
                  self.s.append(el)
              def pop(self):
                  return self.pop()
          

          隊列

          from collections import deque
          class Queue:
              def __init__(self):
                  self.s=deque()
              def push(self, el):
                  self.s.append(el)
              def pop(self):
                  return self.popleft()
          

          二分查找

          def binary_search(_list,num):
              mid=len(_list)//2
              if len(_list) < 1:
                  return Flase
              if num > _list[mid]:
                  BinarySearch(_list[mid:],num)
              elif num < _list[mid]:
                  BinarySearch(_list[:mid],num)
              else:
                  return _list.index(num)
          



          面試加強題

          • 關于數據庫優化及設計
            • 使用hash一致算法
            • setnx
            • setnx + expire
            • 使用redis
            • 如果InnoDB表的數據寫入順序能和B+樹索引的葉子節點順序一致的話,這時候存取效率是最高的。為了存儲和查詢性能應該使用自增長id做主鍵。
            • 對于InnoDB的主索引,數據會按照主鍵進行排序,由于UUID的無序性,InnoDB會產生巨大的IO壓力,此時不適合使用UUID做物理主鍵,可以把它作為邏輯主鍵,物理主鍵依然使用自增ID。為了全局的唯一性,應該用uuid做索引關聯其他表或做外鍵
            • https://segmentfault.com/a/1190000018426586
            • 如何使用兩個棧實現一個隊列
            • 反轉鏈表
            • 合并兩個有序鏈表
            • 刪除鏈表節點
            • 反轉二叉樹
            • 設計短網址服務?62進制實現
            • 設計一個秒殺系統(feed流)?
            • https://www.jianshu.com/p/ea0259d109f9
            • 為什么mysql數據庫的主鍵使用自增的整數比較好?使用uuid可以嗎?為什么?
            • 如果是分布式系統下我們怎么生成數據庫的自增id呢?
            • 基于redis實現一個分布式鎖,要求一個超時的參數
            • 如果redis單個節點宕機了,如何處理?還有其他業界的方案實現分布式鎖碼?

          緩存算法

          • LRU(least-recently-used):替換最近最少使用的對象
          • LFU(Least frequently used):最不經常使用,如果一個數據在最近一段時間內使用次數很少,那么在將來一段時間內被使用的可能性也很小

          服務端性能優化方向

          • 使用數據結構和算法
          • 數據庫
            • slow_query_log_file開啟并且查詢慢查詢日志
            • 通過explain排查索引問題
            • 調整數據修改索引
            • 索引優化
            • 慢查詢消除
            • 批量操作,從而減少io操作
            • 使用NoSQL:比如Redis
          • 網絡io
            • 批量操作
            • pipeline
          • 緩存
            • Redis
          • 異步
            • Asyncio實現異步操作
            • 使用Celery減少io阻塞
          • 并發
          • 多線程
          • Gevent

          好了,今天的分享就到這里,喜歡就點個贊吧!最后,如果你對軟件測試感興趣,歡迎百度搜索“特斯汀軟件測試騰訊課堂”或關注公眾號“特斯汀軟件測試”,里面涵蓋很多精彩免費視頻或干貨知識


          主站蜘蛛池模板: 伦理一区二区三区| 成人一区二区免费视频| 色噜噜AV亚洲色一区二区| 无码人妻少妇色欲AV一区二区| 波多野结衣AV一区二区三区中文| 2014AV天堂无码一区| 精品国产一区在线观看| 国模私拍福利一区二区| 麻豆一区二区在我观看| 国产乱码一区二区三区爽爽爽| 天天看高清无码一区二区三区 | 日韩美一区二区三区| 无码精品视频一区二区三区| 一区二区高清视频在线观看| 无码一区二区三区在线| 国精产品999一区二区三区有限 | 国产无码一区二区在线| 午夜爽爽性刺激一区二区视频| 国产福利一区二区三区在线观看| 亚洲A∨无码一区二区三区 | 日韩视频一区二区| 无码少妇一区二区三区芒果| 精品国产a∨无码一区二区三区 | 国产精品一区二区不卡| 国内精品一区二区三区东京 | 久久国产三级无码一区二区| 免费一区二区无码视频在线播放 | 欧美成人aaa片一区国产精品| 国内自拍视频一区二区三区| 成人久久精品一区二区三区| 国模吧一区二区三区精品视频| 无码一区二区三区亚洲人妻 | 国产情侣一区二区三区| 国产亚洲一区二区三区在线不卡| 国产午夜精品一区二区| 色久综合网精品一区二区| 国产精品视频一区麻豆| 日本一区二区三区日本免费| 亚洲第一区在线观看| 亚洲日韩精品一区二区三区无码 | 国产精品伦子一区二区三区 |