@@ -703,38 +703,6 @@ def index():
703703if __name__ == '__main__':
704704 app.run(debug=True)
705705```
706- ---------------------
707- index.html
708- ```
709- <!DOCTYPE html>
710- <html lang="en">
711- <head>
712- <meta charset="UTF-8">
713- <meta http-equiv="X-UA-Compatible" content="IE=edge">
714- <meta name="viewport" content="width=device-width">
715- <title>Title</title>
716- </head>
717- <body>
718- <ul>
719- {% for foo in v2 %}
720- <li>{{ foo }}</li>
721- {% endfor %}
722- {{ v2.1 }}
723- {% for k,v in v3.items() %}
724- <li>{{ k }} {{ v }}</li>
725- {% endfor %}
726- {{ v3.k1 }}
727- {{ v3.get("k1") }}
728- {{ v4|safe }}
729- {{ v5 }}
730- <h1>{{ test(1,2) }}</h1>
731- <p>{{ sb(1,2) }}</p>
732- <p>{{ 1| db(2,3) }}</p>
733- </ul>
734- </body>
735- </html>
736- ```
737-
738706PS:模板继承的方法和django的一样。
739707
7407083.宏
759727并且对 Cookies 进行密钥签名要使用会话,你需要设置一个密钥。
760728设置:session[ 'username'] = 'xxx'
761729删除:session.pop('username', None)
762- ```
730+ ```
763731from flask import Flask,url_for,session
764732
765733app = Flask(__name__)
@@ -826,133 +794,134 @@ def logout():
826794
827795# set the secret key. keep this really secret:
828796app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
829-
830- 自定义Session
797+ ```
798+ 自定义Session
799+ ```
831800pip3 install Flask-Session
832801
833- run.py
834- from flask import Flask
835- from flask import session
836- from pro_flask.utils.session import MySessionInterface
837- app = Flask(__name__)
838-
839- app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
840- app.session_interface = MySessionInterface()
841-
842- @app.route('/login.html', methods=['GET', "POST"])
843- def login():
844- print(session)
845- session['user1'] = 'alex'
846- session['user2'] = 'alex'
847- del session['user2']
848-
849- return "内容"
850-
851- if __name__ == '__main__':
852- app.run()
853-
854- session.py
855- #!/usr/bin/env python
856- # -*- coding:utf-8 -*-
857- import uuid
858- import json
859- from flask.sessions import SessionInterface
860- from flask.sessions import SessionMixin
861- from itsdangerous import Signer, BadSignature, want_bytes
862-
863-
864- class MySession(dict, SessionMixin):
865- def __init__(self, initial=None, sid=None):
866- self.sid = sid
867- self.initial = initial
868- super(MySession, self).__init__(initial or ())
869-
870-
871- def __setitem__(self, key, value):
872- super(MySession, self).__setitem__(key, value)
873-
874- def __getitem__(self, item):
875- return super(MySession, self).__getitem__(item)
876-
877- def __delitem__(self, key):
878- super(MySession, self).__delitem__(key)
879-
880-
881-
882- class MySessionInterface(SessionInterface):
883- session_class = MySession
884- container = {}
885-
886- def __init__(self):
887- import redis
888- self.redis = redis.Redis()
889-
890- def _generate_sid(self):
891- return str(uuid.uuid4())
892-
893- def _get_signer(self, app):
894- if not app.secret_key:
895- return None
896- return Signer(app.secret_key, salt='flask-session',
897- key_derivation='hmac')
898-
899- def open_session(self, app, request):
900- """
901- 程序刚启动时执行,需要返回一个session对象
902- """
903- sid = request.cookies.get(app.session_cookie_name )
904- if not sid:
905- sid = self._generate_sid()
906- return self.session_class(sid=sid )
907-
908- signer = self._get_signer(app )
909- try:
910- sid_as_bytes = signer.unsign(sid)
911- sid = sid_as_bytes.decode ()
912- except BadSignature:
913- sid = self._generate_sid()
914- return self.session_class(sid=sid)
915-
916- # session保存在redis中
917- # val = self.redis .get(sid)
918- # session保存在内存中
919- val = self.container.get(sid)
920-
921- if val is not None:
922- try:
923- data = json.loads(val)
924- return self.session_class(data, sid=sid)
925- except:
926- return self.session_class(sid=sid)
927- return self.session_class(sid=sid)
928-
929- def save_session(self, app, session, response):
930- """
931- 程序结束前执行,可以保存session中所有的值
932- 如:
933- 保存到resit
934- 写入到用户cookie
935- """
936- domain = self.get_cookie_domain (app)
937- path = self.get_cookie_path (app)
938- httponly = self.get_cookie_httponly (app)
939- secure = self.get_cookie_secure(app)
940- expires = self.get_expiration_time(app, session)
941-
942- val = json.dumps(dict(session))
943-
944- # session保存在redis中
945- # self.redis.setex(name= session.sid, value= val, time=app.permanent_session_lifetime )
946- # session保存在内存中
947- self.container.setdefault( session.sid, val )
948-
949- session_id = self._get_signer (app).sign(want_bytes(session.sid))
950-
951- response.set_cookie(app.session_cookie_name, session_id,
952- expires=expires, httponly=httponly,
953- domain=domain, path=path, secure=secure)
954-
955- 第三方session
802+ run.py
803+ from flask import Flask
804+ from flask import session
805+ from pro_flask.utils.session import MySessionInterface
806+ app = Flask(__name__)
807+
808+ app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'
809+ app.session_interface = MySessionInterface()
810+
811+ @app.route('/login.html', methods=['GET', "POST"])
812+ def login():
813+ print(session)
814+ session['user1'] = 'alex'
815+ session['user2'] = 'alex'
816+ del session['user2']
817+ return "内容"
818+
819+ if __name__ == '__main__':
820+ app.run()
821+ ```
822+ session.py
823+ ```
824+ #!/usr/bin/env python
825+ # -*- coding:utf-8 -*-
826+ import uuid
827+ import json
828+ from flask.sessions import SessionInterface
829+ from flask.sessions import SessionMixin
830+ from itsdangerous import Signer, BadSignature, want_bytes
831+
832+
833+ class MySession(dict, SessionMixin):
834+ def __init__(self, initial=None, sid=None):
835+ self.sid = sid
836+ self.initial = initial
837+ super(MySession, self).__init__(initial or ())
838+
839+
840+ def __setitem__(self, key, value):
841+ super(MySession, self).__setitem__(key, value)
842+
843+ def __getitem__(self, item):
844+ return super(MySession, self).__getitem__(item)
845+
846+ def __delitem__(self, key):
847+ super(MySession, self).__delitem__(key)
848+
849+ class MySessionInterface(SessionInterface):
850+ session_class = MySession
851+ container = {}
852+
853+ def __init__(self):
854+ import redis
855+ self.redis = redis.Redis()
856+
857+ def _generate_sid(self):
858+ return str(uuid.uuid4())
859+
860+ def _get_signer(self, app):
861+ if not app.secret_key:
862+ return None
863+ return Signer( app.secret_key, salt='flask-session',
864+ key_derivation='hmac')
865+
866+ def open_session(self, app, request):
867+ """
868+ 程序刚启动时执行,需要返回一个session对象
869+ """
870+ sid = request.cookies.get(app.session_cookie_name)
871+ if not sid:
872+ sid = self._generate_sid( )
873+ return self.session_class( sid=sid)
874+
875+ signer = self._get_signer(app )
876+ try:
877+ sid_as_bytes = signer.unsign(sid )
878+ sid = sid_as_bytes.decode()
879+ except BadSignature:
880+ sid = self._generate_sid ()
881+ return self.session_class(sid=sid)
882+
883+ # session保存在redis中
884+ # val = self.redis.get(sid)
885+ # session保存在内存中
886+ val = self.container .get(sid)
887+
888+ if val is not None:
889+ try:
890+ data = json.loads( val)
891+ return self.session_class(data, sid=sid)
892+ except:
893+ return self.session_class(sid=sid)
894+ return self.session_class(sid=sid)
895+
896+ def save_session(self, app, session, response):
897+ """
898+ 程序结束前执行,可以保存session中所有的值
899+ 如:
900+ 保存到resit
901+ 写入到用户cookie
902+ """
903+ domain = self.get_cookie_domain(app)
904+ path = self.get_cookie_path(app)
905+ httponly = self.get_cookie_httponly (app)
906+ secure = self.get_cookie_secure (app)
907+ expires = self.get_expiration_time (app, session )
908+
909+ val = json.dumps(dict( session) )
910+
911+ # session保存在redis中
912+ # self.redis.setex(name=session.sid, value=val, time=app.permanent_session_lifetime)
913+ # session保存在内存中
914+ self.container.setdefault( session.sid, val)
915+
916+ session_id = self._get_signer(app).sign(want_bytes( session.sid) )
917+
918+ response.set_cookie (app.session_cookie_name, session_id,
919+ expires=expires, httponly=httponly,
920+ domain=domain, path=path, secure=secure)
921+ ```
922+
923+ 第三方session
924+ ```
956925#!/usr/bin/env python
957926# -*- coding:utf-8 -*-
958927"""
0 commit comments