Django框架之会话技术之Cookie与Session

会话(Session)跟踪是Web程序中常用的技术，用来跟踪用户的整个会话。常用的会话跟踪技术是Cookie与Session。Cookie通过在客户端记录信息确定用户身份，Session通过在服务器端记录信息确定用户身份。

专注于为中小企业提供成都网站设计、做网站服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业海城免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了数千家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

会话跟踪技术

什么是会话跟踪技术

我们可以把会话理解为客户端与服务器之间的一次会晤，在一次会晤中可能会包含多次请求和响应。

例如，我们给10086打电话，我就是客户端，而10086服务人员就是服务端。从双方接通电话那一刻起，会话就开始了，到某一方挂断电话标识会话结束。在通话过程中，我们会向10086发出多个请求，那么多个请求都在一个会话中。

在Web中，客户使用浏览器向某一服务器发出第一个请求开始，会话就开始了，直到客户关闭了浏览器会话结束。

在一个会话的多个请求中共享数据，这就是会话跟踪技术。

例如，在一个会话中的请求如下：请求银行主页。

1)请求登录(请求参数是用户名和密码);

2)请求转账(请求参数与转账相关的数据);

3)请求信用卡还款(请求参数与还款相关的数据)。

在上面会话中，当前用户信息必须在这个会话中共享的，因为登录的是张三，那么在转账和还款时一定是张三的转账和还款，这就说明我们必须在一个会话过程中共享数据的能力。

会话路径技术使用Cookie或session完成

在Web应用中，HTTP协议是无状态的，即每次请求都是独立的，无法记录前一次请求的状态，每次请求都是一次新的请求。

无状态原因：浏览器与服务器是使用Socket套接字进行通信的，服务器将请求结果返回给浏览器之后，会关闭当前的Socket连接，而且服务器也会在处理页面完毕之后销毁页面对象。

但是，有时候我们需要知道上次请求状态，比如用户是否登录过，浏览过哪些商品等。可以使用会话跟踪，可以使用Cookie、Session、token(自定义的session)。

Cookie

什么叫做Cookie

Cookie，翻译成中文小甜点，小饼干的意思。在HTTP中它表示服务器送给客户端浏览器的小甜点。

Cookie是客户端会话技术，数据都存储在客户端，以key-value进行存储。支持过期时间max_age，默认请求会携带本网站的所有cookie，cookie不能跨域名，不能跨浏览器，cookie默认不支持中文，base64。

Cookie是由服务器创建，通过服务端的响应发送给客户端浏览器的一个键值对，然后浏览器会把Cookie保存起来，并标注出Cookie的来源(哪个服务器的Cookie)，当客户端下一次再访问服务器时，默认请求会携带本这个服务器的所有Cookie，这样服务器就可以识别客户端了。

设置cookie应该是服务器response，获取cookie应该在浏览器request，删除cookie应该在服务器response。

Cookie规范

  • Cookie大小上限为4KB;
  • 一个服务器最多在客户端浏览器上保存20个Cookie;
  • 一个浏览器最多保存300个Cookie;

上面的数据只是HTTP的Cookie规范，但是，在浏览器百家争鸣的当下，一些浏览器为了争夺一份份额，展现自己的优势，可能对Cookie的规范扩展，例如每个Cookie的大小为8KB，最多可保存500个Cookie等!但也不会出现把你硬盘占满的可能!

注意，不同浏览器之间是不共享Cookie的。也就是说在你使用IE访问服务器时，服务器会把Cookie发给IE，然后由IE保存起来，当你在使用FireFox访问服务器时，不可能把IE保存的Cookie发送给服务器

Cookie与HTTP头

Cookie是通过HTTP请求头和响应头在客户端和服务器端传递的：

Set-Cookie：响应头，服务器端发送给客户端;

Cookie：请求头，客户端发送给服务器端;格式：Cookie: a=A; b=B; c=C。即多个Cookie用分号隔开;

一个Cookie对象一个Set-Cookie：Set-Cookie: a=A Set-Cookie: b=B Set-Cookie: c=C;

Cookie的覆盖

如果服务器端发送重复的Cookie那么会覆盖原有的Cookie，例如客户端的第一个请求服务器端发送的Cookie是：Set-Cookie: a=A;第二请求服务器端发送的是：Set-Cookie: a=AA，那么客户端只留下一个Cookie，即：a=AA。

请求流程

第一次请求：

① 浏览器第一次请求服务器的时候，不会携带任何cookie信息，，请求头中没有任何cookie信息;

② 当服务器接受到这个请求之后，会做一些验证，例如进行用户名和密码的验证，验证没有问题则可以设置cookie信息。

③ 服务器会为响应设置cookie信息，响应头中有set_cookie信息。

③ 我们的浏览器接收到这个响应之后，发现响应中有cookie信息，浏览器会将cookie信息保存起来。

后续请求：① 第二次或之后的请求都会携带cookie信息，请求头中有cookie信息;

② 服务器接受到请求之后，会发现请求中携带cookie信息，这样就认识是谁的请求了。

代码实现

login.html文件：

 
 
 
 
    
  
  
  
  
  1. 
  
  
  
  
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.     
    5. 
  
  
  
  
  5.     登录界面
    6. 
  
  
  
  
  6.     
    7. 
  
  
  
  
  7. 
  
  
  
  
  8. 
  
  
  
  
  9. 
  
  
  
  
  10.     
    11. 
  
  
  
  
  11.         
    登录界面
    12. 
  
  
  
  
  12.         
    13. 
  
  
  
  
  13.             {% csrf_token %}
    14. 
  
  
  
  
  14.             帐 号：
    15. 
  
  
  
  
  15.             
    16. 
  
  
  
  
  16.             密 码：
    17. 
  
  
  
  
  17.             
    18. 
  
  
  
  
  18.             
    19. 
  
  
  
  
  19.               
    20. 
  
  
  
  
  20.             
    21. 
  
  
  
  
  21.         
    22. 
  
  
  
  
  22.     

  • home.html文件：

     
 
 
 
      
  
  
  
  
    1. 
  
  
  
  
      3. 
  
  
  
  
    3. 
  
  
  
  
    4.     
      5. 
  
  
  
  
    5.     首页
      6. 
  
  
  
  
    6. 
  
  
  
  
    7. 
  
  
  
  
    8. 
  
  
  
  
    9.     欢迎
      10. 
  
  
  
  
    10.     {% if username %}
      11. 
  
  
  
  
    11.         {{ username }}
      12. 
  
  
  
  
    12.     {% else %}
      13. 
  
  
  
  
    13.         游客
      14. 
  
  
  
  
    14.     {% endif %}
      15. 
  
  
  
  
    15.     访问~~
      16. 
  
  
  
  
    16.     
      17. 
  
  
  
  
    17.     退出
      18. 
  
  
  
  
    18. 
  
  
  
  
    19.

    views.py：

     
 
 
 
      
  
  
  
  
    1. def login(request):
      2. 
  
  
  
  
    2.     if request.method == 'GET':
      3. 
  
  
  
  
    3.         return render(request, 'login.html')
      4. 
  
  
  
  
    4. 
  
  
  
  
    5.     elif request.method == 'POST':
      6. 
  
  
  
  
    6.         username = request.POST.get('username')
      7. 
  
  
  
  
    7.         password = request.POST.get('password')
      8. 
  
  
  
  
    8. 
  
  
  
  
    9.         if username and password:   # 此处为了方便测试，没有去数据库进行校验，实际的需要去数据库校验用户名和密码之类的
      10. 
  
  
  
  
    10.             '''
      11. 
  
  
  
  
    11.                 响应体：
      12. 
  
  
  
  
    12.                 return HttpResponse()
      13. 
  
  
  
  
    13.                 return render()
      14. 
  
  
  
  
    14.                 return redirect()    
      15. 
  
  
  
  
    15.                都可以           
      16. 
  
  
  
  
    16.             
      17. 
  
  
  
  
    17.             '''
      18. 
  
  
  
  
    18.             response = redirect(reverse('user:home'))
      19. 
  
  
  
  
    19. 
  
  
  
  
    20.             # 设置cookie信息
      21. 
  
  
  
  
    21.             response.set_cookie('username', username)
      22. 
  
  
  
  
    22.             is_login = True
      23. 
  
  
  
  
    23.             response.set_cookie('is_login', is_login)
      24. 
  
  
  
  
    24. 
  
  
  
  
    25.             return response
      26. 
  
  
  
  
    26. 
  
  
  
  
    27.         return render(request, 'login.html')
      28. 
  
  
  
  
    28. 
  
  
  
  
    29. def home(request):
      30. 
  
  
  
  
    30.     # 获取cookie信息
      31. 
  
  
  
  
    31.     is_login = request.COOKIES.get('is_login')
      32. 
  
  
  
  
    32.     username = request.COOKIES.get('username')
      33. 
  
  
  
  
    33. 
  
  
  
  
    34.     if is_login:
      35. 
  
  
  
  
    35.         return render(request, 'home.html', {'username': username})
      36. 
  
  
  
  
    36. 
  
  
  
  
    37.     return redirect(reverse('user:login'))
      38. 
  
  
  
  
    38. 
  
  
  
  
    39. def logout(request):
      40. 
  
  
  
  
    40.     response = redirect(reverse('user:login'))
      41. 
  
  
  
  
    41.     # 删除cookie信息
      42. 
  
  
  
  
    42.     response.delete_cookie('is_login')
      43. 
  
  
  
  
    43.     response.delete_cookie('username')  # 注销，最好都删除，避免注册之后下次还会携带未删除的信息
      44. 
  
  
  
  
    44. 
  
  
  
  
    45.     return response
      46.

    我们可以看到第一次打开登录页面的时候，不携带Cookie信息(csrf暂忽略)：

    我们再登录，即提交表单之后，服务器设置了Cookie(可参考上面设置Cookie信息代码)：

    退出，即删除Cookie信息，这里只删除is_login的信息

    上面是以明文的方式显示，我们可以进行加盐设置，以加密形式显示：

     
 
 
 
      
  
  
  
  
    1. def login(request):
      2. 
  
  
  
  
    2.     if request.method == 'GET':
      3. 
  
  
  
  
    3.         return render(request, 'login.html')
      4. 
  
  
  
  
    4. 
  
  
  
  
    5.     elif request.method == 'POST':
      6. 
  
  
  
  
    6.         username = request.POST.get('username')
      7. 
  
  
  
  
    7.         response = redirect(reverse('user:home'))
      8. 
  
  
  
  
    8.         #response.set_cookie('username', username)
      9. 
  
  
  
  
    9.         #set_signed_cookie(key,value,salt='加密盐',...) 
      10. 
  
  
  
  
    10.         response.set_signed_cookie('username', username, 'qmpython')
      11. 
  
  
  
  
    11. 
  
  
  
  
    12.         return response
      13. 
  
  
  
  
    13. 
  
  
  
  
    14. 
  
  
  
  
    15. def home(request):
      16. 
  
  
  
  
    16.     username = request.COOKIES.get('username')
      17. 
  
  
  
  
    17.     # 解密
      18. 
  
  
  
  
    18.     #username = request.get_signed_cookie('username', 'qmpython')    
      19. 
  
  
  
  
    19.     response = HttpResponse(f'{username}登录成功')
      20. 
  
  
  
  
    20.     return response
      21.

    Cookie：具体一个浏览器针对一个服务器存储key-value。

    注意，不同浏览器之间是不共享Cookie的。也就是说在你使用IE访问服务器时，服务器会把Cookie发给IE，然后由IE保存起来，当你在使用Chrome访问服务器时，不可能把IE保存的Cookie发送给服务器。

    同一个浏览器访问A网站，又去访问B网站，不可能将A的cookie信息携带发送给B服务器。

    默认情况下，Cookie只在浏览器的内存中存活，也就是说，当你关闭浏览器后，Cookie就会消失!

    问题一：如果只是关闭网站(关闭标签页)，没有退出浏览器呢?

    A：并不会，如果在不关闭浏览器，只关闭页面时，清除cookie。可以使用js事件处理：

     
 
 
 
      
  
  
  
  
      2.

    set_cookie参数：

     
 
 
 
      
  
  
  
  
    1. class HttpResponseBase:
      2. 
  
  
  
  
    2.     def set_cookie(self, 
      3. 
  
  
  
  
    3.                    key,  # 键
      4. 
  
  
  
  
    4.                    value='', # 值
      5. 
  
  
  
  
    5.                    max_age=None, # cookie有效时长，单位为秒，默认为None表示关闭浏览器失效，指定          为有效数值100表示100秒后自动失效
      6. 
  
  
  
  
    6.                    
      7. 
  
  
  
  
    7.                    expires=None, # 支持一个datetime或timedelta，可以指定一个具体的日期，           expires=timedelta(days=10)表示十天后过期。
      8. 
  
  
  
  
    8.                    # max-age和exepires两个指定一个。
      9. 
  
  
  
  
    9.                    
      10. 
  
  
  
  
    10.                    path='/',  # Cookie生效的路径，浏览器只会把cookie回传给带有该路径的页面，这样可以避免将；cookie传给站点中的其他的应用。；/ 表示根路径，特殊的：根路径的cookie可以被任何url的页面访问
      11. 
  
  
  
  
    11.                    
      12. 
  
  
  
  
    12.                    domain=None,  ''' Cookie生效的域名；你可用这个参数来构造一个跨站cookie。
      13. 
  
  
  
  
    13.                      如， domain=".cdxwcx.com"
      14. 
  
  
  
  
    14.                      所构造的cookie对下面这些站点都是可读的：
      15. 
  
  
  
  
    15.                      www.cdxwcx.com 、 www2.cdxwcx.com 
      16. 
  
  
  
  
    16.                 和an.other.sub.domain.cdxwcx.com 。
      17. 
  
  
  
  
    17.                      如果该参数设置为 None ，cookie只能由设置它的站点读取。
      18. 
  
  
  
  
    18.                    '''
      19. 
  
  
  
  
    19.                    
      20. 
  
  
  
  
    20.                    secure=False,  # 如果设置为True,浏览器将通过HTTPS来回传cookie
      21. 
  
  
  
  
    21.                    httponly=False, # 只能http协议传输，无法被js获取（不是绝对的，底层抓包可以获取到也可以被覆盖）
      22. 
  
  
  
  
    22.                    samesite=None
      23. 
  
  
  
  
    23.                   ):pass
      24.

    练习：使用cookie实现上次登录时间

     
 
 
 
      
  
  
  
  
    1. def home(request):
      2. 
  
  
  
  
    2.     # 获取cookie信息
      3. 
  
  
  
  
    3.     username = request.COOKIES.get('username')
      4. 
  
  
  
  
    4.     last_login_time = request.COOKIES.get('last_login_time', '')
      5. 
  
  
  
  
    5.     response = render(request, 'home.html', {'username': username, 'last_login_time': last_login_time})
      6. 
  
  
  
  
    6. 
  
  
  
  
    7.     from datetime import datetime
      8. 
  
  
  
  
    8.     now = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
      9. 
  
  
  
  
    9.     response.set_cookie('last_login_time', now)
      10. 
  
  
  
  
    10. 
  
  
  
  
    11.     return response
      12.

    Session

    前面介绍了Cookie，为什么还需要Session呢?其实很多情况下，只使用Cookie便能完成大部分需求。但是，只使用Cookie往往是不够的，考虑用户登录信息或一些重要的敏感信息，用Cookie存储的话会带来一些问题，最明显的是由于Cookie会把信息保存到本地，因此信息的安全性可能受到威胁。Session的出现很好地解决的这个问题，Session与Cookie类似。

    Session是服务器端技术，利用这个技术，服务器在运行时可以为每一个用户的浏览器创建一个其独享的session对象，由于session为用户浏览器独享，所以用户在访问服务器的web资源时，可以把各自的数据放在各自的session中，当用户再去访问该服务器中的其他web资源时，其他WEB资源再从用户各自session中取出数据为用户服务。

    Session是服务端会话技术，依赖于Cookie，如果在浏览器中**禁用cookie**的话，那么session就失效了，因为它需要浏览器的cookie值去session里做对比。

    1. 启用Session

    Django默认启用Session，可以在设置文件settings.py：

     
 
 
 
      
  
  
  
  
    1. MIDDLEWARE = [
      2. 
  
  
  
  
    2.     
      3. 
  
  
  
  
    3.     'django.contrib.sessions.middleware.SessionMiddleware',
      4. 
  
  
  
  
    4. 
  
  
  
  
    5. ]
      6.

    如果禁用session，则注释即可。

    2. 存储方式

    在settings.py文件中，可以设置session数据的存储方式，可以保存在数据库、本地缓存等。

    2.1 数据库

    默认是存储在数据库中的。

     
 
 
 
      
  
  
  
  
    1. SESSION_ENGINE='django.contrib.sessions.backends.db'
      2.

    如果存储在数据库中，则需要安装Session应用，默认已设置：

     
 
 
 
      
  
  
  
  
    1. INSTALLED_APPS = [
      2. 
  
  
  
  
    2. 
  
  
  
  
    3.     'django.contrib.sessions',
      4. 
  
  
  
  
    4. ]
      5.

    在进行数据库迁移的时候，Django自动帮我们生成了django_session表，有3个字段，分别为session_key，session_data，expris_date，Django中session的默认过期时间是14天。

    迁移数据库后，就会生成django_session表：

    3. 请求流程

    第一次请求：

    ① 我们第一次请求的时候可能会携带一些信息(例如用户名/密码)，cookie中没有任何信息。

    ② 当服务器接受到这个请求之后，会做一些验证，例如进行用户名和密码的验证，验证没有问题则可以设置session信息。

    ③ 在设置session信息的同时(session信息保存在服务器端)，服务器会在响应头中设置一个sessionid的cookie信息。

    ④ 客户端(浏览器)在接收到响应之后，会将cookie信息保存起来(保存sessionid的信息)。

    后续请求：

    ① 第二次或之后的请求都会携带sessionid的cookie信息

    ② 当服务器接收到这个请求之后，获取到sessionid信息，然后进行验证，验证成功，则可以获取session信息(session信息保存在服务器端)

    4. 代码实现

     
 
 
 
      
  
  
  
  
    1. def login(request):
      2. 
  
  
  
  
    2.     if request.method == 'GET':
      3. 
  
  
  
  
    3.         return render(request, 'login.html')
      4. 
  
  
  
  
    4. 
  
  
  
  
    5.     elif request.method == 'POST':
      6. 
  
  
  
  
    6.         '''
      7. 
  
  
  
  
    7.         响应体：
      8. 
  
  
  
  
    8.             return HttpResponse()
      9. 
  
  
  
  
    9.             return render()
      10. 
  
  
  
  
    10.             return redirect()    
      11. 
  
  
  
  
    11.            都可以
      12. 
  
  
  
  
    12.         '''
      13. 
  
  
  
  
    13.         username = request.POST.get('username')
      14. 
  
  
  
  
    14.         password = request.POST.get('password')
      15. 
  
  
  
  
    15. 
  
  
  
  
    16.         if username and password:  # 此处为了方便测试，没有去数据库进行校验，实际的需要去数据库校验用户名和密码之类的
      17. 
  
  
  
  
    17.             # 设置session信息
      18. 
  
  
  
  
    18.             request.session['is_login'] = True
      19. 
  
  
  
  
    19.             request.session['username'] = username
      20. 
  
  
  
  
    20.             '''
      21. 
  
  
  
  
    21.             以上设置，实际执行以下操作：
      22. 
  
  
  
  
    22.             1、生成随机字符串，例如：123abc!@#
      23. 
  
  
  
  
    23.             2、response.set_cookie("sessionid", 123abc!@#)
      24. 
  
  
  
  
    24.             3、在django_session表中创建一条记录：
      25. 
  
  
  
  
    25.                 session_key         session_data
      26. 
  
  
  
  
    26.                 123abc!@#           {"is_login":True, "username": "admin"}        
      27. 
  
  
  
  
    27.             
      28. 
  
  
  
  
    28.             '''
      29. 
  
  
  
  
    29. 
  
  
  
  
    30.         return redirect(reverse('user:home'))
      31. 
  
  
  
  
    31. 
  
  
  
  
    32.     
      33. 
  
  
  
  
    33. def home(request):
      34. 
  
  
  
  
    34.     is_login = request.session['is_login']
      35. 
  
  
  
  
    35.     username = request.session['username']
      36. 
  
  
  
  
    36.     '''
      37. 
  
  
  
  
    37.     以上执行以下操作：
      38. 
  
  
  
  
    38.     1)  request.COOKIES.get('sessionid')，获得session_key
      39. 
  
  
  
  
    39.     2) 通过上面得到的session_key，在django_session表中获取对应的session_data
      40. 
  
  
  
  
    40.     3) 从session_data获取is_login值。    
      41. 
  
  
  
  
    41.     '''
      42. 
  
  
  
  
    42. 
  
  
  
  
    43.     if is_login:
      44. 
  
  
  
  
    44.         return render(request, 'home.html', {'username': username})
      45. 
  
  
  
  
    45. 
  
  
  
  
    46.     return redirect(reverse('user:login'))
      47. 
  
  
  
  
    47. 
  
  
  
  
    48. def logout(request):
      49. 
  
  
  
  
    49.     response = redirect(reverse('user:login'))
      50. 
  
  
  
  
    50.     
      51. 
  
  
  
  
    51.     # 删除session数据，即删除了session_data字段值中对应键和值，但是cookie信息还存在，请求还会携带cookie信息，也就成了脏数据，通过cookie再找session，已经找不到了。
      52. 
  
  
  
  
    52.     #del request.session['is_login'] 
      53. 
  
  
  
  
    53.     
      54. 
  
  
  
  
    54.     # 清除所有session，禁用！！！
      55. 
  
  
  
  
    55.     request.session.clear()     
      56. 
  
  
  
  
    56.     # 清除当前的会话数据并删除会话的cookie，session，cookie一起干掉，删除session表中session的整条数据。
      57. 
  
  
  
  
    57.     request.session.flush()
      58. 
  
  
  
  
    58.     '''
      59. 
  
  
  
  
    59.     执行以下操作：
      60. 
  
  
  
  
    60.     1) request.COOKIE.get('sessionid')，获得session_key
      61. 
  
  
  
  
    61.     2) django_session表中删除session_key对应的记录
      62. 
  
  
  
  
    62.     3) response.delete_cookie('sessionid')
      63. 
  
  
  
  
    63.     '''
      64. 
  
  
  
  
    64. 
  
  
  
  
    65.     return response
      66.

    打开登录页面，没有携带任何cookie信息(csrf那个先不管)

    发起登录请求，设置session信息，其中会生成随机字符串比如mjx9gsq47ofwmcg2ubxtg28uk6idbq2a，然后以这个sessionid为key，这个字符串为value，设置cookie信息。

    并且在django_session插入记录，其中session_key字段的值就是sessionid的值，session_data字段的值就是上面设置的session键值对。

    然后跳转到home页，就会携带cookie信息，获取sessionid的值，在数据库django_session表中查找是否有相关记录。

    如果退出，则删除session信息

    从DJANGO角度来看：

    第一次请求：

    ① 第一次请求，在请求头中没有携带任何cookie信息。

    ② 我们在设置session的时候，session会做2件事。

    第一件：将数据保存在数据库中。

    第二件：设置一个cookie信息，这个cookie信息是以sessionid为key，value为xxxx，cookie肯定会以响应的形式在响应头中出现。

    第二次以及之后的请求：

    ③ 都会携带cookie信息，特别是sessionid。

    如果换了浏览器，还能获取到session信息吗?

    解：不可以，因为session依赖于cookie，换了浏览器，都没有cookie信息了。

    网站题目：Django框架之会话技术之Cookie与Session
    本文路径：http://www.mswzjz.com/qtweb/news44/168644.html

    网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

    广告

    声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

    猜你还喜欢下面的内容

    响应式网站知识

    行业网站建设

    创新互联重庆　　 　搜索引擎优化　　 　成都做网站　　 　主动防护网　　 　彭山网站制作　　 　正泰动物　　 　全网营销　　 　成都发电机维修　　 　手机网站开发　　 　护栏打桩机　　 　成都网络推广　　 　重庆网络营销　　 　手机网站制作　　 　成都茶叶销售　　 　成都免费做网站公司　　 　和正源建设　　 　高端网站建设　　 　微博营销　　 　网站建设改版　　 　圣月阀门