电脑/python/Flask/精通flask.html

<!DOCTYPE html>
<html>
<head>
<!-- 2016-07-30 六 23:06 -->
<meta  charset="utf-8">
<meta  name="viewport" content="width=device-width, initial-scale=1">
<title>精通flask框架</title>
<meta  name="generator" content="Org-mode">
<meta  name="author" content="万泽(德山书生)">
<meta  name="description" content="制作者邮箱：a358003542@gmail.com"
>
<style type="text/css">
body {
    margin-right: auto;
    margin-left: auto;
}

.title {
    display: block;
    text-align: center;
    padding: 10px;
}

.center-block {
    display: block;
    margin-left: auto;
    margin-right: auto;
}

.underline{
    text-decoration: underline;
}
   html, body {
    margin: 0;
    padding: 0;
    font-family:"Microsoft YaHei",Arial,Helvetica,sans-serif,"宋体";
    font-size: 1em;
}

#content {
    display: block;
    margin-left: auto;
    margin-right: auto;
    background:#fcfcfc;
    height:100%;
    margin-left:300px;
    max-width:800px;
    min-height:100%;
    padding:1.618em 3.236em;
}

code {
    padding: 2px 4px;
    color: #c7254e;
    background-color: #f9f2f4;
    border-radius: 4px;
}

pre {
    max-width: 100%;
    display: block;
    padding: 9.5px;
    margin: 0 0 10px;
    font-size: 13px;
    line-height: 1.42857143;
    color: #333;
    background-color: #f5f5f5;
    border: 1px solid #ccc;
    border-radius: 4px;
    overflow : auto;
}


blockquote {
    padding: 10px 20px;
    margin: 0 0 20px;
    font-size: 17.5px;
    border-left: 5px solid #eee;
}

li{
    margin-top: 0.5em;
    margin-bottom: 0.5em;
}

p{
    text-indent:2em;
    line-height:150%;
}

/* dl */
dl {
    margin-top: 0;
    margin-bottom: 20px;
}
dt {
    font-weight: 700;
    line-height: 150%;
    margin-top: 0.5em;
    margin-bottom: 0.5em;
}
dd {
    line-height: 150%;
}

@media (min-width: 768px) {
  dt {
    white-space: nowrap;
  }
}

video{
    max-width: 100%;
    margin-left: auto;
    margin-right: auto;
}

figure p{
    text-indent:0em;
}
img{
    max-width: 100%;
}

embed{
    max-width: 100%;
    margin-left: auto;
    margin-right: auto;
}

figure{
    text-align: center;
}

/*  class  */
.FRAMED{
    max-width:100%;
    border:1px solid ;
    padding: 1em;
    -webkit-box-sizing: border-box;
    -moz-box-sizing: border-box;
    box-sizing: border-box;
}

.NOTECARD{
    width: 35%;
    position:relative;
    right: -30%;
    padding: 1em;
    margin:0 auto;
    border: solid 1px;
    -webkit-box-sizing: border-box;
    -moz-box-sizing: border-box;
    box-sizing: border-box;
}

/*
table
*/
table {
    border-collapse: collapse;
    border-spacing: 0;
    margin: 16px 0;
    empty-cells: show;
    border: 1px solid #ccc;
    width: 100%;
    display: table;
}

table tr {
    border-bottom: 1px solid #ddd;
}
table th,table td{
    padding:8px;
}

table tr:nth-child(even) {
    background-color: #f1f1f1;
}


ul,ol,dl{
    line-height:24px;
    list-style-image:none;
    /* list-style:none; */
    margin:0px 0px 24px 0px;
    padding:0;
}

li{
    margin-left: 24px;
}

dd{
    margin:0;
}

#content .section ul,#content .toctree-wrapper ul,article ul{
    list-style:disc;
    line-height:24px;
    margin-bottom:24px}

#content .section ul li,#content .toctree-wrapper ul li,article ul li{
    list-style:disc;
    margin-left:24px}

#content .section ul li p:last-child,#content .toctree-wrapper ul li p:last-child,article ul li p:last-child{
                                                                                                                                  margin-bottom:0}

#content .section ul li ul,#content .toctree-wrapper ul li ul,article ul li ul{
    margin-bottom:0}

#content .section ul li li,#content .toctree-wrapper ul li li,article ul li li{
    list-style:circle}

#content .section ul li li li,#content .toctree-wrapper ul li li li,article ul li li li{
    list-style:square}

#content .section ul li ol li,#content .toctree-wrapper ul li ol li,article ul li ol li{
    list-style:decimal}

#content .section ol,#content ol,article ol{
    list-style:decimal;
    line-height:24px;
    margin-bottom:24px}

#content .section ol li,#content ol li,article ol li{
    list-style:decimal;
    margin-left:24px}

#content .section ol li p:last-child,#content ol li p:last-child,article ol li p:last-child{
                                                                                                                           margin-bottom:0}

#content .section ol li ul,#content ol li ul,article ol li ul{
    margin-bottom:0}

#content .section ol li ul li,#content ol li ul li,article ol li ul li{
    list-style:disc}

dl dt{
    font-weight:bold;
}

dl p,dl table,dl ul,dl ol{
    margin-bottom:12px !important;
}

dl dd{
    margin:0 0 12px 24px;
}

@media print{
    .codeblock,pre.src{
        white-space:pre.src-wrap}
}

@media print{
    html,body,section{
        background:none !important}

    *{
        box-shadow:none !important;
        text-shadow:none !important;
        filter:none !important;
        -ms-filter:none !important}

    a,a:visited{
          text-decoration:underline}

    pre.src,blockquote{
        page-break-inside:avoid}

    thead{
        display:table-header-group}

    tr,img{
        page-break-inside:avoid}

    img{
        max-width:100% !important}

    @page{
        margin:0.5cm}

    p,h2,h3{
        orphans:3;
        widows:3}

    h2,h3{
        page-break-after:avoid}
}

@media print{
    #postamble{
        display:none}

    #content{
        margin-left:0}
}

@media print{
    #table-of-contents{
        display:none}

    @page{
        size: auto;
        margin: 25mm 25mm 25mm 25mm;}

    body {
        margin: 0px;}
}

@media screen and (max-width: 768px){
}

@media only screen and (max-width: 480px){
}

@media screen and (max-width: 768px){
    .tablet-hide{
        display:none}
}

@media screen and (max-width: 480px){
    .mobile-hide{
        display:none}
}

@media screen and (max-width: 480px){
}

@media screen and (max-width: 768px){
    #content{
        margin-left:0;
        padding: 1em 1em;}

    #content #content{
        padding:1.618em}

    #content.shift{
        position:fixed;
        min-width:100%;
        left:85%;
        top:0;
        height:100%;
        overflow:hidden}
}

@media screen and (min-width: 1400px){
    #content{
        background:rgba(0,0,0,0.05)}

    #content{
        background:#fcfcfc}
}

@media screen and (max-width: 768px){
    #copyright{
        width:85%;
        display:none}

    #copyright.shift{
        display:block}

    img{
        width:100%;
        height:auto}
}

@media screen and (max-width: 480px){
    #content .sidebar{
        width:100%}
}


.figure p{
    color:#000;
    font:italic 85%/1 arial,sans-serif;
    padding:1em 0;
}

.rotate-90{
    -webkit-transform:rotate(90deg);
    -moz-transform:rotate(90deg);
    -ms-transform:rotate(90deg);
    -o-transform:rotate(90deg);
    transform:rotate(90deg);
}

.rotate-270{
    -webkit-transform:rotate(270deg);
    -moz-transform:rotate(270deg);
    -ms-transform:rotate(270deg);
    -o-transform:rotate(270deg);
    transform:rotate(270deg);
}

#toggle-sidebar,
#table-of-contents .close-sidebar {
    display: none;
}

@media screen and (max-width: 768px) {
    #table-of-contents {
        display: none;
        width: 60%;
    }

    #table-of-contents h2 a {
        display: block;
    }

    #table-of-contents:target {
        display: block;
    }

    #copyright, #postamble {
        display: none;
    }

    #toggle-sidebar {
        background-color: #2980B9;
        display: block;
        margin-bottom: 1.6em;
        padding: 0.6em;
        text-align: center;
    }

    #toggle-sidebar h2 {
        color: white;
        font-size: 100%;
        line-height: 50px;
        margin: 0;
        padding: 0;
    }

    #table-of-contents .close-sidebar {
       color: rgba(255, 255, 255, 0.3);
       display: inline-block;
       margin: 0px 10px 0px 45px;
       padding: 10px;
    }
}

*{
    -webkit-box-sizing:border-box;
    -moz-box-sizing:border-box;
    box-sizing:border-box;
}

figcaption,figure,footer,header,hgroup,nav{
    display:block}

ins{
    background:#ff9;
    color:#000;
    text-decoration:none}

mark{
    background:#ff0;
    color:#000;
    font-style:italic;
    font-weight:bold}

small{
    font-size:85%}

sub,sup{
    font-size:75%;
    line-height:0;
    position:relative;
    vertical-align:baseline}

sup{
    top:-0.5em}

sub{
    bottom:-0.25em}

img{
    -ms-interpolation-mode:bicubic;
    vertical-align:middle;
    max-width:100%}

svg:not(:root){
    overflow:hidden}

figure{
    margin:0}

label{
    cursor:pointer}

legend{
    border:0;
    margin-left:-7px;
    padding:0;
    white-space:normal}

#content .danger,#content .error{
    background:#fdf3f2}

legend{
    display:block;
    width:100%;
    border:0;
    padding:0;
    white-space:normal;
    margin-bottom:24px;
    font-size:150%;
    *margin-left:-7px}

label{
    display:block;
    margin:0 0 0.3125em 0;
    color:#333;
    font-size:90%}

a{
    color:#2980B9;
    text-decoration:none;
    cursor:pointer}


a:hover,a:active{
    outline:0;
}

a:hover{
    color:#3091d1}

a:visited{
    color:#9B59B6}

.left{
    text-align:left}

.center{
    text-align:center}

.right{
    text-align:right}

hr{
    display:block;
    height:1px;
    border:0;
    border-top:1px solid #e1e4e5;
    margin:24px 0;
    padding:0}

#table-of-contents li{
    list-style:none;
    margin-left: 0px;
}

#table-of-contents header{
    height:32px;
    display:inline-block;
    line-height:32px;
    padding:0 1.618em;
    display:block;
    font-weight:bold;
    text-transform:uppercase;
    font-size:80%;
    color:#2980B9;
    white-space:nowrap}

#table-of-contents ul{
    margin-bottom:0}

#table-of-contents li.divide-top{
    border-top:solid 1px #404040}

#table-of-contents li.divide-bottom{
    border-bottom:solid 1px #404040}

#table-of-contents li.current{
    background:#e3e3e3}

#table-of-contents li.current a{
    color:gray;
    border-right:solid 1px #c9c9c9;
    padding:0.4045em 2.427em}

#table-of-contents li.current a:hover{
    background:#d6d6d6}

#table-of-contents li a{
    /* color:#404040; */
    padding:0.4045em 1.618em;
    position:relative;
    /* background:#fcfcfc; */
    border:none;
    /* border-bottom:solid 1px #c9c9c9; */
    /* border-top:solid 1px #c9c9c9; */
    padding-left:1.618em -4px}

#table-of-contents li.on a:hover,#table-of-contents li.current>a:hover{
    background:#fcfcfc}

#table-of-contents li ul li a{
    /* background:#c9c9c9; */
    padding:0.4045em 2.427em}

#table-of-contents li ul li ul li a{
    padding:0.4045em 3.236em}

#table-of-contents li.current ul{
    display:block}

/* #table-of-contents li ul{ */
/*     margin-bottom:0; */
/*     display:none} */

#table-of-contents .local-toc li ul{
    display:block}

#table-of-contents li ul li a{
    margin-bottom:0;
    color:#b3b3b3;
    font-weight:normal}

#table-of-contents a{
    display:inline-block;
    line-height:18px;
    padding:0.4045em 1.618em;
    display:block;
    position:relative;
    font-size:90%;
    color:#b3b3b3;
    direction: ltr;
}

#table-of-contents a:hover{
    background-color:#4e4a4a;
    cursor:pointer}

/* #text-table-of-contents { */
/*     overflow:scroll; */
/* } */

#table-of-contents{
    position:fixed;
    top:0;
    left:0;
    width:300px;
    overflow-x:hidden;
    overflow-y:scroll;
    height:100%;
    background:#343131;
    z-index:200;
    scrollbar-base-color: #1F1D1D;
    scrollbar-arrow-color: #b3b3b3;
    scrollbar-shadow-color: #1F1D1D;
    scrollbar-track-color : #343131;
}

#table-of-contents h2{
    z-index:200;
    background-color:#2980B9;
    text-align:center;
    padding:0.809em;
    display:block;
    color:#fcfcfc;
    font-size: 100%;
    margin-bottom:0.809em}

ul.nav li ul li {
    display: none;
}

ul.nav li ul li ul li {
    display: none;
}

ul.nav li.active ul li {
    display: inline;
}

ul.nav li.active ul li ul li {
    display: inline;
}

ul.nav li.active ul li a {
    background-color: #E3E3E3;
    color: #8099B0;
    border-right:solid 1px #c9c9c9 !important;
}

ul.nav li.active ul li.active a {
    background-color: #C9C9C9;
    color: black !important;
    font-weight: bold !important;
}

ul.nav li.active ul li.active ul li.active a {
    color: black !important;
    font-weight: bold !important;
    display: block !important;
}

ul.nav li.active ul li.active ul li a {
    color: #808080 !important;
    font-weight: normal !important;
    display: block !important;
}

ul.nav li.active ul li ul li a {
    display: none !important;
}


ul.nav li ul li ul li ul li {
    display: none !important; /* as long as nav is on multiple levels of ul */
    /* display: none; /* as long as nav is on multiple levels of ul *\/ */
}

ul.nav li.active > a {
    border-bottom:solid 1px #c9c9c9 !important; /* XXX Restrict it to 2nd level */
    border-right:solid 1px #c9c9c9 !important;
}

ul.nav li.active a {
    color: gray !important;
    font-weight:bold;
    background-color: white;
    border-right:solid 0px white !important;
}

ul.nav > li.active > a {
    color: black !important;
}

footer{
    color:#999}

footer p{
    margin-bottom:12px}

#copyright, #postamble{
    position:fixed;
    bottom:0;
    left:0;
    width:300px;
    color:#fcfcfc;
    background:#1f1d1d;
    border-top:solid 10px #343131;
    font-family:"Lato","proxima-nova","Helvetica Neue",Arial,sans-serif;
    font-size: 90%;
    z-index:400;
    padding:12px;
}

#postamble .author {
    font-size: 100%;
    margin-bottom: 0px;
}

#postamble .date {
    font-size: 90%;
    margin-bottom: 0px;
    color: #27AE60;
}

#postamble .creator,#postamble .validation {
    display:none;
}

#copyright a{
    color:#2980B9;
    text-decoration:none}

#copyright .rst-current-version{
    padding:12px;
    background-color:#272525;
    display:block;
    text-align:right;
    font-size:90%;
    cursor:pointer;
    color:#27AE60;
    *zoom:1}

#content img{
    max-width:100%;
    height:auto !important}

#content div.figure{
    margin-bottom:24px}

#content div.figure.align-center{
    text-align:center}

#content .section>img,#content .section>a>img{
    margin-bottom:24px}

.verse{
    border-left:5px solid #6AB0DE;
    background-color: #E7F2FA;
    padding: 6px 20px;
    font-style:italic;
}

#content .note .last,#content .attention .last,#content .caution .last,#content .danger .last,#content .error .last,#content .hint .last,#content .important .last,#content .tip .last,#content .warning .last,#content .seealso .last,#content .admonitiontodo .last{
    margin-bottom:0}

#content .admonition-title:before{
    margin-right:4px}

#content .section ol p,#content .section ul p{
    margin-bottom:12px}

#content h1 .headerlink,#content h2 .headerlink,#content h3 .headerlink,#content h4 .headerlink,#content h5 .headerlink,#content h6 .headerlink,#content dl dt .headerlink{
    display:none;
    visibility:hidden;
    font-size:14px}

#content h1 .headerlink:after,#content h2 .headerlink:after,#content h3 .headerlink:after,#content h4 .headerlink:after,#content h5 .headerlink:after,#content h6 .headerlink:after,#content dl dt .headerlink:after{
    visibility:visible;
    content:"";
    font-family:FontAwesome;
    display:inline-block}

#content h1:hover .headerlink,#content h2:hover .headerlink,#content h3:hover .headerlink,#content h4:hover .headerlink,#content h5:hover .headerlink,#content h6:hover .headerlink,#content dl dt:hover .headerlink{
    display:inline-block}

#content .sidebar{
    float:right;
    width:40%;
    display:block;
    margin:0 0 24px 24px;
    padding:24px;
    background:#f3f6f6;
    border:solid 1px #e1e4e5}

#content .sidebar p,#content .sidebar ul,#content .sidebar dl{
    font-size:90%}

#content .sidebar .last{
    margin-bottom:0}

#content .sidebar .sidebar-title{
    display:block;
    font-family:"Roboto Slab","ff-tisa-web-pro","Georgia",Arial,sans-serif;
    font-weight:bold;
    background:#e1e4e5;
    padding:6px 12px;
    margin:-24px;
    margin-bottom:24px;
    font-size:100%}

#content .footnote-reference,#content .citation-reference{
    vertical-align:super;
    font-size:90%}

span[id*='MathJax-Span']{
    color:#404040}

.math{
    text-align:center}

#footnotes{
    border-top:1px solid #e1e4e5;
    padding-top: 36px;
}

h2.footnotes{
    display:none;
}


.footnum:before, .footref:before{
    content:"[";
}

.footnum:after, .footref:after{
    content:"]";
}

.footpara {
    color: #999;
    font-size: 90%;
    font-family:"Lato","proxima-nova","Helvetica Neue",Arial,sans-serif;
    padding-bottom: 8px;
    padding-left: 16px;
    padding-right: 16px;
    padding-top: 8px;
    line-height: 1.25em;
    /* display: inline; */
}
.highlight .hll { background-color: #ffffcc }
.highlight  { background: #f8f8f8; }
.highlight .c { color: #8f5902; font-style: italic } /* Comment */
.highlight .err { color: #a40000; border: 1px solid #ef2929 } /* Error */
.highlight .g { color: #000000 } /* Generic */
.highlight .k { color: #204a87; font-weight: bold } /* Keyword */
.highlight .l { color: #000000 } /* Literal */
.highlight .n { color: #000000 } /* Name */
.highlight .o { color: #ce5c00; font-weight: bold } /* Operator */
.highlight .x { color: #000000 } /* Other */
.highlight .p { color: #000000; font-weight: bold } /* Punctuation */
.highlight .ch { color: #8f5902; font-style: italic } /* Comment.Hashbang */
.highlight .cm { color: #8f5902; font-style: italic } /* Comment.Multiline */
.highlight .cp { color: #8f5902; font-style: italic } /* Comment.Preproc */
.highlight .cpf { color: #8f5902; font-style: italic } /* Comment.PreprocFile */
.highlight .c1 { color: #8f5902; font-style: italic } /* Comment.Single */
.highlight .cs { color: #8f5902; font-style: italic } /* Comment.Special */
.highlight .gd { color: #a40000 } /* Generic.Deleted */
.highlight .ge { color: #000000; font-style: italic } /* Generic.Emph */
.highlight .gr { color: #ef2929 } /* Generic.Error */
.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
.highlight .gi { color: #00A000 } /* Generic.Inserted */
.highlight .go { color: #000000; font-style: italic } /* Generic.Output */
.highlight .gp { color: #8f5902 } /* Generic.Prompt */
.highlight .gs { color: #000000; font-weight: bold } /* Generic.Strong */
.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
.highlight .gt { color: #a40000; font-weight: bold } /* Generic.Traceback */
.highlight .kc { color: #204a87; font-weight: bold } /* Keyword.Constant */
.highlight .kd { color: #204a87; font-weight: bold } /* Keyword.Declaration */
.highlight .kn { color: #204a87; font-weight: bold } /* Keyword.Namespace */
.highlight .kp { color: #204a87; font-weight: bold } /* Keyword.Pseudo */
.highlight .kr { color: #204a87; font-weight: bold } /* Keyword.Reserved */
.highlight .kt { color: #204a87; font-weight: bold } /* Keyword.Type */
.highlight .ld { color: #000000 } /* Literal.Date */
.highlight .m { color: #0000cf; font-weight: bold } /* Literal.Number */
.highlight .s { color: #4e9a06 } /* Literal.String */
.highlight .na { color: #c4a000 } /* Name.Attribute */
.highlight .nb { color: #204a87 } /* Name.Builtin */
.highlight .nc { color: #000000 } /* Name.Class */
.highlight .no { color: #000000 } /* Name.Constant */
.highlight .nd { color: #5c35cc; font-weight: bold } /* Name.Decorator */
.highlight .ni { color: #ce5c00 } /* Name.Entity */
.highlight .ne { color: #cc0000; font-weight: bold } /* Name.Exception */
.highlight .nf { color: #000000 } /* Name.Function */
.highlight .nl { color: #f57900 } /* Name.Label */
.highlight .nn { color: #000000 } /* Name.Namespace */
.highlight .nx { color: #000000 } /* Name.Other */
.highlight .py { color: #000000 } /* Name.Property */
.highlight .nt { color: #204a87; font-weight: bold } /* Name.Tag */
.highlight .nv { color: #000000 } /* Name.Variable */
.highlight .ow { color: #204a87; font-weight: bold } /* Operator.Word */
.highlight .w { color: #f8f8f8; text-decoration: underline } /* Text.Whitespace */
.highlight .mb { color: #0000cf; font-weight: bold } /* Literal.Number.Bin */
.highlight .mf { color: #0000cf; font-weight: bold } /* Literal.Number.Float */
.highlight .mh { color: #0000cf; font-weight: bold } /* Literal.Number.Hex */
.highlight .mi { color: #0000cf; font-weight: bold } /* Literal.Number.Integer */
.highlight .mo { color: #0000cf; font-weight: bold } /* Literal.Number.Oct */
.highlight .sb { color: #4e9a06 } /* Literal.String.Backtick */
.highlight .sc { color: #4e9a06 } /* Literal.String.Char */
.highlight .sd { color: #8f5902; font-style: italic } /* Literal.String.Doc */
.highlight .s2 { color: #4e9a06 } /* Literal.String.Double */
.highlight .se { color: #4e9a06 } /* Literal.String.Escape */
.highlight .sh { color: #4e9a06 } /* Literal.String.Heredoc */
.highlight .si { color: #4e9a06 } /* Literal.String.Interpol */
.highlight .sx { color: #4e9a06 } /* Literal.String.Other */
.highlight .sr { color: #4e9a06 } /* Literal.String.Regex */
.highlight .s1 { color: #4e9a06 } /* Literal.String.Single */
.highlight .ss { color: #4e9a06 } /* Literal.String.Symbol */
.highlight .bp { color: #3465a4 } /* Name.Builtin.Pseudo */
.highlight .vc { color: #000000 } /* Name.Variable.Class */
.highlight .vg { color: #000000 } /* Name.Variable.Global */
.highlight .vi { color: #000000 } /* Name.Variable.Instance */
.highlight .il { color: #0000cf; font-weight: bold } /* Literal.Number.Integer.Long */
</style>
</head>
<body>
<div id="content">
<header>
<h1 class="title">精通flask框架</h1>
</header><nav id="table-of-contents">
<h2>Table of Contents</h2>
<div id="text-table-of-contents">
<ul>
<li><a href="#orgheadline2">1. 前言</a>
<ul>
<li><a href="#orgheadline1">1.1. 第一个例子</a></li>
</ul>
</li>
<li><a href="#orgheadline27">2. flask基础</a>
<ul>
<li><a href="#orgheadline6">2.1. 路径分发和对应的视图函数</a>
<ul>
<li><a href="#orgheadline3">2.1.1. 路径分发带变量</a></li>
<li><a href="#orgheadline4">2.1.2. 构建自己的刷url的参量类型</a></li>
<li><a href="#orgheadline5">2.1.3. HTTP Methods</a></li>
</ul>
</li>
<li><a href="#orgheadline7">2.2. url_for函数</a></li>
<li><a href="#orgheadline8">2.3. request对象</a></li>
<li><a href="#orgheadline14">2.4. session对象和g对象和简单的登录机制</a>
<ul>
<li><a href="#orgheadline9">2.4.1. 测试用</a></li>
<li><a href="#orgheadline10">2.4.2. 应用添加数据库</a></li>
<li><a href="#orgheadline11">2.4.3. 应用用户登录识别</a></li>
<li><a href="#orgheadline12">2.4.4. secret_key的设置</a></li>
<li><a href="#orgheadline13">2.4.5. flash函数</a></li>
</ul>
</li>
<li><a href="#orgheadline15">2.5. app的配置</a></li>
<li><a href="#orgheadline16">2.6. jinja2模板</a></li>
<li><a href="#orgheadline17">2.7. 静态文件</a></li>
<li><a href="#orgheadline18">2.8. redirect函数</a></li>
<li><a href="#orgheadline23">2.9. abort函数抛出某个异常</a>
<ul>
<li><a href="#orgheadline19">2.9.1. 404 Not Found</a></li>
<li><a href="#orgheadline20">2.9.2. 403 Forbidden</a></li>
<li><a href="#orgheadline21">2.9.3. 410 Gone</a></li>
<li><a href="#orgheadline22">2.9.4. 500 Internal Server Error</a></li>
</ul>
</li>
<li><a href="#orgheadline24">2.10. 异常捕捉</a></li>
<li><a href="#orgheadline25">2.11. logger</a></li>
<li><a href="#orgheadline26">2.12. 文件上传</a></li>
</ul>
</li>
<li><a href="#orgheadline31">3. 组织你的项目</a>
<ul>
<li><a href="#orgheadline28">3.1. 配置文件的补充说明</a></li>
<li><a href="#orgheadline30">3.2. 使用蓝图来管理你的视图</a>
<ul>
<li><a href="#orgheadline29">3.2.1. url_prefix</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#orgheadline32">4. 表单</a></li>
<li><a href="#orgheadline33">5. 用户管理规范</a></li>
<li><a href="#orgheadline40">6. restful api设计</a>
<ul>
<li><a href="#orgheadline37">6.1. restful api简介</a>
<ul>
<li><a href="#orgheadline34">6.1.1. REST软件架构风格</a></li>
<li><a href="#orgheadline35">6.1.2. REST系统设计规范</a></li>
<li><a href="#orgheadline36">6.1.3. RESTful API</a></li>
</ul>
</li>
<li><a href="#orgheadline38">6.2. 我对restful api的反思</a></li>
<li><a href="#orgheadline39">6.3. flask-restful插件</a></li>
</ul>
</li>
<li><a href="#orgheadline41">7. 缓存</a></li>
<li><a href="#orgheadline58">8. 附录</a>
<ul>
<li><a href="#orgheadline42">8.1. 用gunicorn和nginx配置</a></li>
<li><a href="#orgheadline51">8.2. 在heroku上部署项目</a>
<ul>
<li><a href="#orgheadline43">8.2.1. 指定python2或python3</a></li>
<li><a href="#orgheadline44">8.2.2. 安装第三方模块</a></li>
<li><a href="#orgheadline45">8.2.3. Procfile文件</a></li>
<li><a href="#orgheadline46">8.2.4. hello.py文件</a></li>
<li><a href="#orgheadline47">8.2.5. 安装heroku或者不？</a></li>
<li><a href="#orgheadline48">8.2.6. 通过网页新建项目得到一个好名字</a></li>
<li><a href="#orgheadline49">8.2.7. 或者更简单直接通过github来管理</a></li>
<li><a href="#orgheadline50">8.2.8. 如何在heroku上加入数据库</a></li>
</ul>
</li>
<li><a href="#orgheadline56">8.3. 和apache2一起</a>
<ul>
<li><a href="#orgheadline52">8.3.1. 简单的apache2配置</a></li>
<li><a href="#orgheadline53">8.3.2. Require做了什么</a></li>
<li><a href="#orgheadline54">8.3.3. what.wsgi文件</a></li>
<li><a href="#orgheadline55">8.3.4. 更复杂点的配置</a></li>
</ul>
</li>
<li><a href="#orgheadline57">8.4. 参考资料</a></li>
</ul>
</li>
</ul>
</div>
</nav>


<div class="outline-2">
<h2 id="orgheadline2">前言</h2>
<div class="outline-text-2" id="text-1">
<p>
flask框架底层基于Werkzeug模块和jinja2模块，关于这两个模块的知识将另行讨论。当然本文一开始就假设读者至少已经算得上精通python语言了，然后对网络编程的一些基础知识已有所了解，那么我们继续吧。
</p>
</div>


<div class="outline-3">
<h3 id="orgheadline1">第一个例子</h3>
<div class="outline-text-3" id="text-1-1">
<p>
安装推荐就简单用pip2或pip3安装之，然后一个简单的helloworld例子如下所示，读者可以先运行一下看看flask框架安装上去了没有。
</p>

<div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">flask</span> <span class="kn">import</span> <span class="n">Flask</span>
<span class="n">app</span> <span class="o">=</span> <span class="n">Flask</span><span class="p">(</span><span class="n">__name__</span><span class="p">)</span>

<span class="nd">@app.route</span><span class="p">(</span><span class="s1">&#39;/&#39;</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">hello_world</span><span class="p">():</span>
    <span class="k">return</span> <span class="s1">&#39;Hello World!&#39;</span>

<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s1">&#39;__main__&#39;</span><span class="p">:</span>
    <span class="n">app</span><span class="o">.</span><span class="n">run</span><span class="p">()</span>
</pre></div>

<p>
Flask类提供了所谓的Web Server Gateway Interface，也就是WSGI application。上面代码第一第二行基本上都是这样写的，其中Flask接受的 <code>__name__</code> 也就是本py文件作为模块被引入时的名字或者是当前执行py文件 <code>__main__</code> ，这样设置是方便flask找到静态文件（比如通过 <code>rend_template</code> 函数加载的模板文件，名字是index.html的，flask会在这个app所在的目录下的templates文件夹下面查找这个index.html文件。）等。
</p>

<p>
然后下面hello_world函数加上了装饰器 <code>@app.route('/')</code> ，意义是明显是在分发url路径。那么这个函数的返回将作为这个url路径的返回值。
</p>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline27">flask基础</h2>
<div class="outline-text-2" id="text-2">
</div><div class="outline-3">
<h3 id="orgheadline6">路径分发和对应的视图函数</h3>
<div class="outline-text-3" id="text-2-1">
<p>
在上面最简单的那个例子中，就已经包含了flask web框架的最核心部分。其包括如下任务: 第一，我们定义该网站的子路径（具体就是对应HTTP协议的GET方法）；第二，如果用户浏览器请求到该路径，那么我们应该给用户浏览器传回去点什么东西。
</p>

<p>
一般路径分发就是直接把子路径写上去即可，这自不用多说。下面演示分发路径带变量的情况: 
</p>
</div>

<div class="outline-4">
<h4 id="orgheadline3">路径分发带变量</h4>
<div class="outline-text-4" id="text-2-1-1">
<pre>
@app.route('/user/&lt;user&gt;')
def get_user(user):
    return "user {}".format(user)
</pre>

<p>
用尖括号&lt;&gt;来包围具体的变量名，注意相应的函数应该接受这个参数（装饰器做了一个字典值环境，然后对下面的视图函数对应的变量名进行填充）。具体这个变量在函数中具体数据类型可以用 <code>&lt;int:id&gt;</code> 这样的形式来控制，默认是字符串类型。具体如下所示:
</p>

<dl class="org-dl">
<dt>string</dt><dd>接受任意文本除了url的斜线"/"。</dd>
<dt>int</dt><dd>整型</dd>
<dt>float</dt><dd>浮点型</dd>
<dt>path</dt><dd>类似string，不过也可以接受斜线"/"</dd>
</dl>

<p>
这里的视图函数是理解flask框架的关键，比如说后面要谈论的静态文件和模板文件，一个和视图函数内的具体引用有关，一个和视图函数具体输出有关。然后再后面要谈论的重定向和HTTP错误处理也不过是一些对一些特殊的情况进行了特殊的视图函数封装。而上面谈及，这个 <code>@app.route</code> 装饰器函数可以接受路径中的变量参数，其通过一个字典值环境变量传递进来，实际上这个字典值环境变量里面还有更多的东西，比如说客户浏览器HTTP的请求，将会封装成为一个request对象。这个 <strong>request</strong> 对象你在视图函数里面一样可以直接用。比如 <code>request.headers</code> 就是我们熟知的HTTP请求头文件的字典值。然后 <code>request.headers.get('User-Agent')</code> 你就可以获得输入HTTP请求头文件的"User-Agent" 这一行的值。
</p>

<p>
视图函数最后需要返回一个response对象，其可以是一个简单的字符串或者一个简单的网页文件，你也可以用 <code>make_response</code> 函数来构建自己的response对象。
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline4">构建自己的刷url的参量类型</h4>
<div class="outline-text-4" id="text-2-1-2">
<p>
path类型已经可以接受斜线了，所以只适合某个子节点下面全是路径的情况，如 <code>/dir/some/path</code> ，因为后面所有的子节点都将传入到那个path参量上去。然后就是虽然flask也允许 <code>/project/</code> 这样的url，而且具体和 <code>/project</code> 是两个不同的url，我很不喜欢这种url，实际上我们应该完全避免 <code>/</code> 结尾的url的情况，包括restful api里面也是。
</p>

<p>
然后就是我们可以深度定制自己的刷url的参量类型。比如:
</p>
<pre>
from werkzeug.routing import BaseConverter

class ListConverter(BaseConverter):
    def to_python(self, value):
        return value.split('+')

    def to_url(self, values):
        return '+'.join(BaseConverter.to_url(value)
            for value in values)

app.url_map.converters['list'] = ListConverter
</pre>

<p>
主要就是向 <code>url_map</code> 的 <code>converters</code> 这个字典值里面添加你想要的额外的类型转换，这里是一个列表转换。你需要做的就是子类化 <code>BaseConverter</code> 这个类，然后定义好 <code>to_python</code> 和 <code>to_url</code> 这两个方法。具体一个是根据url刷python变量，另外一个是根据python量返回url中的字符串。
</p>

<p>
上面这个转换器大体实现了 <code>/a+b</code> 刷成 ['a','b'] ，然后反之。这个了解下即可，实在有需要才考虑使用，因为这种转换器是越少越好，写了一些自己的转换器混进去，会让你的程序代码更难读和更难理解，同时自己如果驾驭不好的，会出各种bug吧。
</p>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline5">HTTP Methods</h4>
<div class="outline-text-4" id="text-2-1-3">
<p>
如下所示:
</p>
<pre>
@app.route('/login', methods=['GET', 'POST'])
</pre>
<p>
你可以在分发URL的时候，确定该URL要处理的一些HTTP方法。如果你不加上 <strong>methods</strong> 参数，那么默认是GET方法，而多个方法你需要如下来确定具体视图函数等下要处理的HTTP方法类型:
</p>
<pre>
if request.method == 'POST':
</pre>

<p>
这个 <strong>request</strong> 参量是每个视图函数自动都会接受的一个变量。这个 <strong>request</strong> 变量是个非常重要的概念，请看下面这个小例子:
</p>
<div class="highlight"><pre><span></span><span class="nd">@app.route</span><span class="p">(</span><span class="s1">&#39;/&#39;</span><span class="p">,</span><span class="n">methods</span><span class="o">=</span><span class="p">[</span><span class="s1">&#39;GET&#39;</span><span class="p">,</span><span class="s1">&#39;POST&#39;</span><span class="p">])</span>
<span class="k">def</span> <span class="nf">index</span><span class="p">():</span>
    <span class="k">if</span> <span class="n">request</span><span class="o">.</span><span class="n">method</span> <span class="o">==</span> <span class="s1">&#39;GET&#39;</span><span class="p">:</span>
        <span class="n">query</span> <span class="o">=</span> <span class="n">request</span><span class="o">.</span><span class="n">args</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s1">&#39;query&#39;</span><span class="p">)</span>

        <span class="o">...</span>

        <span class="k">return</span> <span class="n">render_template</span><span class="p">(</span><span class="s1">&#39;index.html&#39;</span><span class="p">,</span><span class="o">**</span><span class="nb">locals</span><span class="p">())</span>
</pre></div>

<p>
这里GET方法中URL传递的如 <code>?key=value</code> 这些参数对应的就是request对象的args这个字典值，然后你用get方法取之即可。
</p>
</div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline7">url_for函数</h3>
<div class="outline-text-3" id="text-2-2">
<p>
<code>url_for</code> 函数是一个很有用的函数，你在jinja2模板系统里面也是可以继续使用的。比如你定义的视图函数
</p>
<pre>
@app.route('/')
def index():
    return 'hello'
</pre>

<p>
该网页对应的路径就可以这样生成: <code>url_for('index')</code> 
</p>

<p>
再比如你定义的视图函数里面有参量:
</p>
<pre>
@app.route('/user/&lt;int:userid&gt;')
def user(userid):
    return str(userid)
</pre>
<p>
该视图函数对应的url请求路径是: <code>url_for('user',userid=3)</code>
</p>

<p>
然后静态文件也可以用 <code>url_for</code> 来快速生成引用地址，这个在下面的静态文件一章里面有详细说明。
</p>

<p>
然后比如说利用 flask-restful 插件搭建你的restful api ，其中有个设置 <code>endpoint</code> 的参数，你可以用那里具体设置的endpoint的名字来对应该api的url，如:
</p>

<pre>
api.add_resource(FoldersAPI,'/api/v1/folders',endpoint='folders')
</pre>

<p>
对应的就是 <code>url_for('folders')</code> ，然后值得一提的是，这生成的是相对主站的相对路径，如这样的形式 <code>/api/v1/folders</code> ，我不清楚ajax技术会如何，但如果你使用requests模块来进行请求的话，则需要加上 <code>_external</code> 选项:
</p>
<pre>
requests.get(url_for('get_subfolders',path=path,_external=True))
</pre>

<p>
然后如果你加入的其他参数没有在url里面的话则会作为查询参数加入进构建的url中。
</p>
<pre>
&gt;&gt;&gt; @app.route('/login')
... def login(): pass
</pre>
<pre>
...  print url_for('login', next='/')
/login?next=/
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline8">request对象</h3>
<div class="outline-text-3" id="text-2-3">
<p>
因为request对象在flask框架中非常重要，而且里面的变量的值flask都会自动帮你处理好，下面详细介绍之（更多信息请参看<a href="https://flask.readthedocs.org/en/latest/api/#flask.Request">这里</a>）:
</p>

<p>
request对象是一个请求上下文环境下的变量，也就是每一个不同的请求request变量的值都不同、
</p>

<dl class="org-dl">
<dt>form</dt><dd>在网页表单中通过定义 <code>value</code> 可以获得一个变量，具体填入的值可以通过 <code>request.form.get('what')</code> 来获得。</dd>
<dt>files</dt><dd>网页表单中上传文件的input <code>type=file</code> 将传到这里。具体返回对象和python的文件对象类似，除了还提供额外的 <code>save</code> 方法用于保存文件。</dd>
<dt>args</dt><dd>就是URL中各个参数。</dd>
<dt>values</dt><dd>相当于上面谈及的form和args这两个字典的合并字典</dd>

<dt>cookies</dt><dd>一个字典值，request传输的cookies值</dd>
<dt>headers</dt><dd>字典值，request请求的headers</dd>
</dl>


<dl class="org-dl">
<dt>get_json</dt><dd>request的data如果mimetype是json时（ <code>application/json</code> ），接受之后会自动刷成字典值。如果设置 <code>force=True</code> ，那么就算mimetype不是json也如此强制执行。</dd>
<dt>is_json</dt><dd>判断请求发送的数据是否是json格式。</dd>
<dt>data</dt><dd>处理request过来的data，如果请求体发送过来的mimetype是json，那么推荐用 <code>get_json</code> 方法来处理之。否则用这个 <code>request.data</code> 将不做任何处理只是返回字符串。</dd>

<dt>max_content_length</dt><dd>HTTP协议里面的 <code>MAX_CONTENT_LENGTH</code> 字段值，也就是发送的content的size。具体文件上传情况和json处理情况后面到时再详细讨论之。</dd>
<dt>method</dt><dd>POST GET等</dd>
<dt>path</dt><dd>具体分发的路径，也就是 <code>@route</code> 的第一个参数。这里值得一提的是如果用gunicorn和nginx这样的架构，具体server_name的解析会出错，如果你想要表达当前url，用 <code>request.url</code> 可能不是你希望的结果，推荐使用 <code>request.path</code> 这样的相对表达方式。</dd>
<dt>url</dt><dd>完整url</dd>
</dl>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline14">session对象和g对象和简单的登录机制</h3>
<div class="outline-text-3" id="text-2-4">
<p>
每一个请求都会自动新建一个request对象，这是容易理解的，此外每一个视图函数里面还可以使用 <code>flask.session</code> 和 <code>flask.g</code> 这两个变量。要深刻理解这两个变量就需要理解flask的两种环境: 应用环境和请求环境。
</p>

<p>
我们看到flask与之相关的 <code>globals.py</code> 的源码:
</p>
<div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">functools</span> <span class="kn">import</span> <span class="n">partial</span>
<span class="kn">from</span> <span class="nn">werkzeug.local</span> <span class="kn">import</span> <span class="n">LocalStack</span><span class="p">,</span> <span class="n">LocalProxy</span>

<span class="k">def</span> <span class="nf">_lookup_req_object</span><span class="p">(</span><span class="n">name</span><span class="p">):</span>
    <span class="n">top</span> <span class="o">=</span> <span class="n">_request_ctx_stack</span><span class="o">.</span><span class="n">top</span>
    <span class="k">if</span> <span class="n">top</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">:</span>
        <span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="n">_request_ctx_err_msg</span><span class="p">)</span>
    <span class="k">return</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">top</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>


<span class="k">def</span> <span class="nf">_lookup_app_object</span><span class="p">(</span><span class="n">name</span><span class="p">):</span>
    <span class="n">top</span> <span class="o">=</span> <span class="n">_app_ctx_stack</span><span class="o">.</span><span class="n">top</span>
    <span class="k">if</span> <span class="n">top</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">:</span>
        <span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="n">_app_ctx_err_msg</span><span class="p">)</span>
    <span class="k">return</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">top</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>


<span class="k">def</span> <span class="nf">_find_app</span><span class="p">():</span>
    <span class="n">top</span> <span class="o">=</span> <span class="n">_app_ctx_stack</span><span class="o">.</span><span class="n">top</span>
    <span class="k">if</span> <span class="n">top</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">:</span>
        <span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="n">_app_ctx_err_msg</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">top</span><span class="o">.</span><span class="n">app</span>


<span class="c1"># context locals</span>
<span class="n">_request_ctx_stack</span> <span class="o">=</span> <span class="n">LocalStack</span><span class="p">()</span>
<span class="n">_app_ctx_stack</span> <span class="o">=</span> <span class="n">LocalStack</span><span class="p">()</span>
<span class="n">current_app</span> <span class="o">=</span> <span class="n">LocalProxy</span><span class="p">(</span><span class="n">_find_app</span><span class="p">)</span>
<span class="n">request</span> <span class="o">=</span> <span class="n">LocalProxy</span><span class="p">(</span><span class="n">partial</span><span class="p">(</span><span class="n">_lookup_req_object</span><span class="p">,</span> <span class="s1">&#39;request&#39;</span><span class="p">))</span>
<span class="n">session</span> <span class="o">=</span> <span class="n">LocalProxy</span><span class="p">(</span><span class="n">partial</span><span class="p">(</span><span class="n">_lookup_req_object</span><span class="p">,</span> <span class="s1">&#39;session&#39;</span><span class="p">))</span>
<span class="n">g</span> <span class="o">=</span> <span class="n">LocalProxy</span><span class="p">(</span><span class="n">partial</span><span class="p">(</span><span class="n">_lookup_app_object</span><span class="p">,</span> <span class="s1">&#39;g&#39;</span><span class="p">))</span>
</pre></div>

<p>
首先我们看到 <code>from werkzeug.local import LocalStack, LocalProxy</code> ，那里有解释信息:
</p>

<blockquote>
<p>
The Python standard library has a concept called “thread locals” (or thread-local data). A thread local is a global object in which you can put stuff in and get back later in a thread-safe and thread-specific way. That means that whenever you set or get a value on a thread local object, the thread local object checks in which thread you are and retrieves the value corresponding to your thread (if one exists). So, you won’t accidentally get another thread’s data.
</p>
</blockquote>

<p>
他说的意思是python就有一个 <code>线程本地</code> 的概念，也就是在该线程内的全局变量。然后 <code>werkzeug</code> 提到:
</p>
<blockquote>
<p>
Werkzeug provides its own implementation of local data storage called werkzeug.local. This approach provides a similar functionality to thread locals but also works with greenlets.
</p>
</blockquote>

<p>
也就是 <code>werkzeug</code> 提供了他自己的线程全局变量支持，其同时也支持 <code>greenlets</code> 。这里使用到的 <code>LocalStack</code> 和 <code>LocalProxy</code> 类我们不需要深入了解，一个是堆栈结构有push , pop 方法之类的，一个有类似字典的api。然后flask就是利用这两个类来建立了两个环境: 两个线程本地全局变量。 一个是应用环境，一个是请求环境。
</p>

<p>
其中session , request 这两个变量是于请求环境堆栈的，也就是每一个新到的请求都是重新创建的。然后 current_app 和 g 是位于应用环境堆栈的，新建的app都是重新创建的。flask是支持多线程模式的，如这样设置 <code>app.run(threaded=True)</code> ，这样每一个线程都有各自的 <code>flask.g</code> ，然后flask是通过 <code>current_app</code> 来获取当前app的。请参看 <a href="https://stackoverflow.com/questions/14672753/handling-multiple-requests-in-flask">这个网页</a> ，推荐还是用 <code>gunicorn</code> 来解决多线程多请求问题。一般这种需求不太明显的，除非你的网站流量请求特别大了，但如果你的app有特别费时的IO，比如上传或下载大型文件，那么就可能阻塞整个app，这个时候就必须用gunicorn做多线程了。
</p>

<p>
好吧，为了简单起见我们用 <code>gunicorn</code> 来管理多线程，然后flask内部我们认为一个app，一个线程，则这个 <code>flask.g</code> 就可以看作一个方便的全局变量管理方式。而 <code>request</code> 和 <code>session</code> 则是每次请求都不同的，至于 <code>session</code> 其每次请求环境搭建时都会自动加载你的 cookies，大体就是这样。
</p>
</div>


<div class="outline-4">
<h4 id="orgheadline9">测试用</h4>
<div class="outline-text-4" id="text-2-4-1">
<p>
在测试的时候你需要自己创建一个应用上下文环境，然后请求通过requests模块来做。如下所示，调用 <code>app.app_content()</code> :
</p>

<pre>
from flask import Flask, current_app

app = Flask(__name__)
with app.app_context():
    # within this block, current_app points to app.
    print current_app.name
</pre>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline10">应用添加数据库</h4>
<div class="outline-text-4" id="text-2-4-2">
<p>
这个例子来自官方文档:
</p>
<pre>
import sqlite3
from flask import g

def get_db():
    db = getattr(g, '_database', None)
    if db is None:
        db = g._database = connect_to_database()
    return db

@app.teardown_appcontext
def teardown_db(exception):
    db = getattr(g, '_database', None)
    if db is not None:
        db.close()
</pre>

<p>
这里的 <code>@app.teardown_appcontent</code> 用于上下文环境销毁时需要额外做的动作。
</p>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline11">应用用户登录识别</h4>
<div class="outline-text-4" id="text-2-4-3">
<pre>
@app.before_request
def get_current_user():
    g.user = None
    email = session.get('email')
    if email is not None:
        g.user = email
</pre>

<p>
这里的逻辑是每次请求先都初始化 <code>g.user</code> ，然后尝试从session中获取cookies中保存的用户的值。
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline12">secret_key的设置</h4>
<div class="outline-text-4" id="text-2-4-4">
<p>
你需要为你的session的cookies设置一个密钥，就像这样:
</p>
<pre>
app.secret_key = 'what...'
</pre>

<p>
可以通过这样获得:
</p>
<pre>
&gt;&gt;&gt; import os
&gt;&gt;&gt; os.urandom(24)
</pre>

<p>
具体登录的例子请参看  <a href="https://github.com/a358003542/flask-examples">flask-examples</a> 的 <code>session.py</code> 。
</p>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline13">flash函数</h4>
<div class="outline-text-4" id="text-2-4-5">
<p>
具体登录的例子请参看  <a href="https://github.com/a358003542/flask-examples">flask-examples</a> 的 <code>session_flash.py</code> 。
</p>

<p>
首先在python脚本中通过 <code>flash</code> 函数刷如一些信息，然后在 <code>render_template</code> 函数在处理模板的时候，request那个参量也传递进去了，这里不是重点。重点是 <code>get_flashed_messages</code> 这个函数也传递进去了，这里就是利用这个函数在jinja2模板中获取flash进入的那些信息，这个函数返回的是一个可迭代对象（可能就是一个列表吧）。
</p>
</div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline15">app的配置</h3>
<div class="outline-text-3" id="text-2-5">
<p>
前面也接触过一些了，比如 <code>app.config['DEBUG'] = True</code> ，这个 <code>app.config</code> 是一个类似字典对象的对象。一些重要的配置下面列出来，更多的请参看 <a href="http://docs.jinkan.org/docs/flask/config.html">这个网页</a> 。
</p>

<dl class="org-dl">
<dt>DEBUG</dt><dd>调试模式</dd>
<dt>SECRET_KEY</dt><dd>密钥</dd>
<dt>SERVER_NAME</dt><dd>服务器名和端口，如果你想让flask支持子域名，则需要设置这个。</dd>
<dt>SEND_FILE_MAX_AGE_DEFAULT</dt><dd>缓存控制的最大期限，默认是12小时。</dd>
<dt>MAX_CONTENT_LENGTH</dt><dd>最大content长度，当你需要上传和下载文件的时候，最好把这个设置得大一点。</dd>
</dl>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline16">jinja2模板</h3>
<div class="outline-text-3" id="text-2-6">
<p>
具体jinja2模块的基本知识这里就不说了，这里主要说一下jinja2模板系统在flask框架中额外的东西。
</p>

<ol class="org-ol">
<li>config</li>
</ol>

<p>
request
当模版不是在活动的请求上下文中渲染时这个变量不可用。
session
</p>

<p>
当模版不是在活动的请求上下文中渲染时这个变量不可用。
</p>

<p>
g
当模版不是在活动的请求上下文中渲染时这个变量不可用。
</p>

<p>
url_for()
flask.url_for() 函数
</p>

<p>
get_flashed_messages()
flask.get_flashed_messages() 函数
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline17">静态文件</h3>
<div class="outline-text-3" id="text-2-7">
<p>
静态文件有很多解决方案，比如说在你的flask项目里面新建一个 <strong>static</strong> 文件夹，然后在css文件夹里面要引用"boostrap.min.css"文件，那么可以在模板文件中如下引用之:
</p>
<pre>
&lt;link rel="stylesheet" href="{{ url_for('static',filename='css/bootstrap.min.css') }}"&gt;
</pre>

<p>
如果你打开网页，可以看作最终生成的实际是这样的形式:
</p>
<pre>
&lt;link rel="stylesheet" href="/static/css/bootstrap.min.css"&gt;
</pre>

<p>
其他文件的引用大致类似。
</p>

<p>
然后就是模板文件，你需要在你的flask项目中新建一个 <strong>templates</strong> 文件，然后在里面新建一个index.html文件，那么通过 <code>render_template</code> 渲染该文件时你只需要写上"index.html"文件即可，具体如下所示:
</p>
<pre>
render_template('index.html')
</pre>

<p>
<code>render_template</code> 函数后面接受的参数都将刷入模板系统，一个不错的做法如下所示:
</p>
<pre>
render_template('index.html', **locals())
</pre>
<p>
这样将把本视图函数中所有的本地变量都刷进去，毕竟模板文件有时要刷如的参量太多了，要一个个写实在太麻烦了。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline18">redirect函数</h3>
<div class="outline-text-3" id="text-2-8">
<p>
页面重定向函数。
</p>
<pre>
@app.route('/')
def index():
    return redirect(url_for('login'))
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline23">abort函数抛出某个异常</h3>
<div class="outline-text-3" id="text-2-9">
<p>
抛出某个HTTP状态异常
</p>
<pre>
abort(404)
</pre>
</div>


<div class="outline-4">
<h4 id="orgheadline19">404 Not Found</h4>
<div class="outline-text-4" id="text-2-9-1">
<p>
经典的“哎呦，您输入的 URL 当中有错误”消息。这个消息太常见了，即使是 互联网的新手也知道 404 代号的意义: 该死，我寻找的东西不在那儿。确保 404 页面上有一些有用的信息是一个好主意，至少应该提供一个返回主页的链接。
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline20">403 Forbidden</h4>
<div class="outline-text-4" id="text-2-9-2">
<p>
如果您的网站包含一些类型的访问控制，您必须向非法的请求返回 403 错误代号。 所以请确保用户不会在试图访问了一个禁止访问的资源后不知所措。
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline21">410 Gone</h4>
<div class="outline-text-4" id="text-2-9-3">
<p>
您知道 404 Not Found 代号还有一个兄弟名为 410 Gone 么? 很少有人真正实现 它，您可以考虑将其返回给对以前曾经存在、但是现在已经删除的资源的请求，而 不是直接返回 404 。 如果您还没有从数据库里永久删除这个文档，仅仅是将他们 标记为删除。那么可以为用户展示一个消息，说明他们寻找的东西已经永远删除了。
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline22">500 Internal Server Error</h4>
<div class="outline-text-4" id="text-2-9-4">
<p>
通常在出现编程错误或者服务器过载的时候会返回这个错误代号。在这里放一个 漂亮的页面是一个非常好的主意。因为您的应用 总有一天 会出现错误(请参考 记录应用错误 )
</p>
</div>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline24">异常捕捉</h3>
<div class="outline-text-3" id="text-2-10">
<p>
如下所示:
</p>
<div class="highlight"><pre><span></span><span class="nd">@app.errorhandler</span><span class="p">(</span><span class="mi">404</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">page_not_found</span><span class="p">(</span><span class="n">error</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">render_template</span><span class="p">(</span><span class="s1">&#39;404.html&#39;</span><span class="p">),</span> <span class="mi">404</span>
</pre></div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline25">logger</h3>
<div class="outline-text-3" id="text-2-11">
<pre>
app.logger.debug('A value for debugging')
</pre>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline26">文件上传</h3>
<div class="outline-text-3" id="text-2-12">
<p>
具体例子请参看我写的 <a href="https://github.com/a358003542/flask-examples">flask-examples</a> 那里，具体是 upload.py 。
</p>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline31">组织你的项目</h2>
<div class="outline-text-2" id="text-3">
<p>
这里主要讨论更加成熟和稍微复杂点的那种做法。这个参看 <a href="http://spacewander.github.io/explore-flask-zh/4-organizing_your_project.html">这个网页</a> 。
</p>

<pre>
run.py
config.py
instance/
  /config.py
project/
  /__init__.py
  /views.py
  /models.py
  /forms.py
  /static/
  /templates/
</pre>

<p>
<code>run.py</code> 是作为启动开发服务器的脚本，里面内容一般很简单，大体是:
</p>
<div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">project</span> <span class="kn">import</span> <span class="n">app</span>

<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s1">&#39;__main__&#39;</span><span class="p">:</span>
    <span class="n">app</span><span class="o">.</span><span class="n">run</span><span class="p">()</span>
</pre></div>

<p>
这样运行根据后面讲到的两个 <code>config.py</code> 的不同的设置来获得开发和工作不同的配置环境。比如这里具体是先加载顶层目录的config.py，然后再加载instance里面的config.py
</p>
<pre>
config loaded
instance config loaded
 * Debugger is active!
 * Debugger pin code: 916-109-430
</pre>


<p>
然后 <code>instance/config.py</code> 里面一般放着密钥，不纳入git版本控制，具体就是在 <code>.gitignore</code> 文件里面加入 <code>instance/</code> 。这样的话为了保证远程服务器那边能够正常运行，你需要在那边手工添加这个文件夹和文件，然后在里面加入你的密钥。因为其没有进入版本控制，所以我们还需要加入另外一个不太重要的 <code>config.py</code> 文件，其放着关于flask app的不太重要的一些配置信息。然后推荐最后确认加上 <code>debug=False</code> ，确保生产环境debug模式没有打开。
</p>

<p>
在project文件夹里面， <code>static</code> 文件夹和 <code>templates</code> 文件夹就如上这样放置，然后通过 <code>run.py</code> 来运行是可以正常启动的。而在生产环境下，比如通过gunicorn来启动flask的app，则执行如下命令:
</p>

<pre>
gunicorn -w 4 -b localhost:8001 project:app
</pre>

<p>
这样将直接调用你的project里面的app对象，并且没有打开debug。
</p>

<p>
<code>config.py</code> 和instance里面的config我们如下引入进来，具体在project的 <code>__init__.py</code> 里面:
</p>
<pre>
from flask import *
app = Flask(__name__, instance_relative_config=True)
app.config.from_object('config')
app.config.from_pyfile('config.py')
</pre>
<p>
其中 <code>instance_relative_config=True</code> 和 <code>app.config.from_pyfile('config.py')</code> 来引入instance文件夹里面的 <code>config.py</code> ，然后 <code>app.config.from_object('config')</code> 引入顶层目录下的 <code>config.py</code> 。
</p>

<p>
然后 <code>views.py</code> 和 <code>models.py</code> 里面的含义是很明显的，其中models.py里面一般定义一些数据库的模型，这个在project里面直接引入进来即可，而在 <code>views.py</code> 里面定义的一些视图函数我们也需要引入进来。这里值得一提的就是相对引入的用法:
</p>

<p>
在project的 <code>__init__.py</code> 里面有:
</p>
<pre>
#### more views
from .views import *
</pre>

<p>
在 <code>views.py</code> 里面有:
</p>
<pre>
from flask import *
from . import app

@app.route('/')
def index():
    return render_template('index.html', **locals())
</pre>

<p>
这种相对引入语法不支持直接运行脚本了，而需要在外面，通过 <code>run.py</code> 来运行，然后gunicorn那边也一切运行正常。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline28">配置文件的补充说明</h3>
<div class="outline-text-3" id="text-3-1">
<p>
上面提及的 <code>config.py</code> 里面大体放着这种形式的配置信息:
</p>
<pre>
DEBUG = True
</pre>

<p>
然后我们知道关于这些配置变量我们都可以通过 <code>app.config['WHAT']</code> 来加载。
</p>

<p>
上面提及的:
</p>
<pre>
app.config.from_object('config')
app.config.from_pyfile('config.py')
</pre>

<p>
先加载顶层目录的 <code>config.py</code> 然后再加载instance下的 <code>config.py</code> 。这样将形成一种覆盖机制，按照 <a href="http://spacewander.github.io/explore-flask-zh/5-configuration.html">这个网页</a> 的描述，我们可以在顶层设置:
</p>
<pre>
DEBUG = False
SQLALCHEMY_ECHO = False
</pre>

<p>
然后instance那边设置:
</p>
<pre>
DEBUG = True
SQLALCHEMY_ECHO = True
</pre>

<p>
生产环境那边将这两行不加上即可。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline30">使用蓝图来管理你的视图</h3>
<div class="outline-text-3" id="text-3-2">
<p>
随着你的项目变大，你可能需要使用蓝图来重构你的项目代码。蓝图有两种风格，一种是功能式架构，只是简单的新建一个视图views文件夹，然后在里面放着你的蓝图或说视图定义；另一种是各自独立的分区式，视图，模板，静态文件都在某个文件夹下面。这里只讨论稍显简单的功能式架构。
</p>

<p>
最简单的一个蓝图定义文件如下所示:
</p>
<div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">flask</span> <span class="kn">import</span> <span class="o">*</span>
<span class="kn">from</span> <span class="nn">..</span> <span class="kn">import</span> <span class="n">app</span>

<span class="n">index</span> <span class="o">=</span> <span class="n">Blueprint</span><span class="p">(</span><span class="s1">&#39;index&#39;</span><span class="p">,</span> <span class="n">__name__</span><span class="p">)</span>

<span class="nd">@index.route</span><span class="p">(</span><span class="s1">&#39;/&#39;</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">view_index</span><span class="p">():</span>
    <span class="k">return</span> <span class="n">render_template</span><span class="p">(</span><span class="s1">&#39;index.html&#39;</span><span class="p">,</span> <span class="o">**</span><span class="nb">locals</span><span class="p">())</span>
</pre></div>

<p>
大体和之前接触的flask的视图函数定义类似，只是额外新建了一个Blueprint对象，然后使用 <code>@index.route()</code> 这样的装饰器来装饰该蓝图的视图函数。
</p>

<p>
然后在project也就是 <code>__init__.py</code> 文件那里，把这个蓝图注册进来。
</p>

<div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">.views.index</span> <span class="kn">import</span> <span class="n">index</span>
<span class="n">app</span><span class="o">.</span><span class="n">register_blueprint</span><span class="p">(</span><span class="n">index</span><span class="p">)</span>
</pre></div>

<p>
最基本的情况就是这样，其他一切照旧。
</p>
</div>

<div class="outline-4">
<h4 id="orgheadline29">url_prefix</h4>
<div class="outline-text-4" id="text-3-2-1">
<p>
<code>url_prefix</code> 是你定义一个Blueprint对象是很有用的一个可选参数，意义很明显，就是该蓝图下所有的url都加上了这个前缀。
</p>
</div>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline32">表单</h2>
<div class="outline-text-2" id="text-4">
<p>
请参看 <a href="flask-wtf.html">flask-wtf</a> 一文。
</p>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline33">用户管理规范</h2>
<div class="outline-text-2" id="text-5">
<p>
本小节主要参考了 <a href="http://spacewander.github.io/explore-flask-zh/12-handling_users.html">这个网页</a> 。更成熟的方案请参看 flask-user
</p>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline40">restful api设计</h2>
<div class="outline-text-2" id="text-6">
<p>
这里主要参看了 <a href="http://www.pythondoc.com/flask-restful/index.html">这个网页</a> ，但原创者在 <a href="https://github.com/sixu05202004/Flask-RESTful-cn">这里</a> 。
</p>
</div>

<div class="outline-3">
<h3 id="orgheadline37">restful api简介</h3>
<div class="outline-text-3" id="text-6-1">
</div><div class="outline-4">
<h4 id="orgheadline34">REST软件架构风格</h4>
<div class="outline-text-4" id="text-6-1-1">
<p>
REST(Representational State Transfer) 表征性状态传输是Roy Fielding在2000年提出的一种软件架构风格。目前在三种主流Web服务实现方案中，因为REST模式和复杂的SOAP和XML-RPC相比更加简洁，越来越多的web服务开始采用REST风格设计和实现。
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline35">REST系统设计规范</h4>
<div class="outline-text-4" id="text-6-1-2">
<dl class="org-dl">
<dt>客户端-服务器</dt><dd>客户端和服务器之间隔离，服务器提供服务，客户端进行消费。</dd>
<dt>无状态</dt><dd>从客户端到服务器的每个请求都必须包含理解请求所必需的信息。换句话说，服务器不会存储客户端上一次请求的信息用来给下一次使用。</dd>
<dt>可缓存</dt><dd>服务器必须明示客户端请求能否缓存。</dd>
<dt>分层系统</dt><dd>客户端和服务器之间的通信应该以一种标准的方式，就是中间层代替服务器做出响应的时候，客户端不需要做任何变动。</dd>
<dt>统一的接口</dt><dd>服务器和客户端的通信方法必须是统一的。</dd>
<dt>按需编码</dt><dd>服务器可以提供可执行代码或脚本，为客户端在它们的环境中执行。这个约束是唯一一个是可选的。</dd>
</dl>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline36">RESTful API</h4>
<div class="outline-text-4" id="text-6-1-3">
<p>
符合REST设计风格的Web API称为RESTful API。RESTful API的核心概念是 <strong>资源</strong> 。资源可用URI表示，客户端用HTTP协议所定义的方法来请求这些URIs，当然也包括被访问资源状态的改变。
</p>

<p>
具体HTTP方法和对资源的操作如下所示:
</p>

<table>


<colgroup>
<col  class="org-left">

<col  class="org-left">

<col  class="org-left">
</colgroup>
<thead>
<tr>
<th scope="col" class="org-left">HTTP方法</th>
<th scope="col" class="org-left">行为</th>
<th scope="col" class="org-left">URI示例</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-left">GET</td>
<td class="org-left">获取资源信息</td>
<td class="org-left"><a href="http://example.com/api/orders">http://example.com/api/orders</a></td>
</tr>

<tr>
<td class="org-left">GET</td>
<td class="org-left">获取某个特定资源</td>
<td class="org-left"><a href="http://example.com/api/orders/123">http://example.com/api/orders/123</a></td>
</tr>

<tr>
<td class="org-left">POST</td>
<td class="org-left">创建新的资源</td>
<td class="org-left"><a href="http://example.com/api/orders">http://example.com/api/orders</a></td>
</tr>

<tr>
<td class="org-left">PUT</td>
<td class="org-left">更新资源</td>
<td class="org-left"><a href="http://example.com/api/orders/123">http://example.com/api/orders/123</a></td>
</tr>

<tr>
<td class="org-left">DELETE</td>
<td class="org-left">删除资源</td>
<td class="org-left"><a href="http://example.com/api/orders/123">http://example.com/api/orders/123</a></td>
</tr>
</tbody>
</table>


<p>
REST设计不需要特定的数据格式。在请求中数据可以以JSON形式, 或者有时候作为url中查询参数项。
</p>
</div>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline38">我对restful api的反思</h3>
<div class="outline-text-3" id="text-6-2">
<p>
我觉得目前的restful api 设计有问题，不够实用。我同意api的描述应该偏资源，但应该再增加一类纯动作型api。实际上动作也是一种资源有的时候，但是动作作为资源的时候资源名一定要清晰的显示出来。然后资源的描述应该是URI风格的，弄个id挂在上面没什么用处还没有达到描述资源特征的目的。我们应该用统一的资源URL描述，下面简称为&lt;path:path&gt;
</p>

<p>
资源应该统一到一个URI上，弄个 <code>/res</code> 又还弄个 <code>/res/id</code> 纯属浪费。于是我提出建议如下:
</p>

<ol class="org-ol">
<li>资源的描述URI应该侧重位置，然后跟上一个特征词，如下所示:</li>
</ol>
<pre>
/resource_name/&lt;path:res_uri&gt;
</pre>

<ol class="org-ol">
<li>我们应该彻底杜绝 <code>/</code> 尾的URL。</li>

<li>不用使用 <code>/resource_name</code> 这种形式来返回全部uri，推荐使用 <code>/resource_name/main</code> 来表达全部资源。其他名字如 <code>all</code> 等也是欢迎的，自己内部约定好即可。</li>

<li>方法可以使用如下四种: get post put delete ，其中:

<ul class="org-ul">
<li>get 用于查询某个资源 （可以接受更多的查询参数 包括uri）</li>
<li>post 用于insert某个资源</li>
<li>put 用于更新某个资源</li>
<li>delete 用于删除某个资源</li>
</ul></li>
</ol>

<p>
然后delete可能会被 <code>/delete_resname/&lt;name&gt;</code> 这样的URL取代，甚至可能某些资源不需要删除操作，则上面的delete方法不需要编写。
</p>

<p>
put方法可能被 <code>/update_resname/&lt;name&gt;</code> 这样的URL取代，甚至可能insert和update逻辑都融合在post操作里面，则上面的put方法也不需要编写。
</p>

<p>
在视图层是推荐用上面的 <code>/delete_resname/&lt;name&gt;</code> 这样的风格，然后表单提交的时候更改 <code>formaction</code> 即可。而formmethod我们知道只能是 get 和 post 。然后如果insert和update逻辑好合并的则推荐合并为upsert逻辑，统一用post方法调用。
</p>

<p>
restfulapi则可以上面四个方法都编写出来，调用者清晰的知道意义就行了。
</p>

<ol class="org-ol">
<li>返回json统一用如下格式:</li>
</ol>
<pre>
{
    "resource_name" : [
                {
                       .....
                }
}
</pre>

<p>
即使只返回一个资源也用这种格式，只是resource_name列表里面只包含一个元素罢了，更好的风格，没有元素也保持这种格式，只是里面的列表为空罢了。
</p>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline39">flask-restful插件</h3>
<div class="outline-text-3" id="text-6-3">
<p>
请参看 <a href="flask-restful.html">flask-restful</a> 一文。
具体原生态的flask restful api代码编写就不在这里做了，有兴趣的可以看下本节开头提及参考资料的地一小节部分。
</p>
</div>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline41">缓存</h2>
<div class="outline-text-2" id="text-7">
<p>
<a href="http://spacewander.github.io/explore-flask-zh/6-advanced_patterns_for_views_and_routing.html">http://spacewander.github.io/explore-flask-zh/6-advanced_patterns_for_views_and_routing.html</a>
</p>
</div>
</div>


<div class="outline-2">
<h2 id="orgheadline58">附录</h2>
<div class="outline-text-2" id="text-8">
</div><div class="outline-3">
<h3 id="orgheadline42">用gunicorn和nginx配置</h3>
<div class="outline-text-3" id="text-8-1">
<p>
gunicorn没啥好说的，就是命令行开个本地端口运行即可，主要是nginx那边的配置需要说一下。
</p>

<p>
首先nginx的配置文件编辑在这里: <code>/etc/nginx/sites-available</code>
</p>

<p>
然后你需要激活这个网站，则如下在 <code>sites-enabled</code> 那里创建一个符号链接即可:
</p>
<pre>
sudo ln -s /etc/nginx/sites-available/books /etc/nginx/sites-enabled/books
</pre>

<p>
然后nginx配置有很多内容，这里就最简单的说一下:
</p>

<pre>
server{
	listen 80;
	server_name books.cdwanze.org;

	location /{
		 proxy_pass http://localhost:5000;
		 }
</pre>

<p>
这是最简单的配置了，设置简单对外端口 <code>listen</code> ，然后设置 <code>server_name</code> 。然后 <code>location /</code> 那里设置 <code>proxy_pass</code> ，对应的就是具体你的guniron那边开的本地端口。参考了 <a href="https://www.digitalocean.com/community/tutorials/how-to-serve-flask-applications-with-gunicorn-and-nginx-on-ubuntu-14-04">这个网页</a> 和 <a href="https://realpython.com/blog/python/kickstarting-flask-on-ubuntu-setup-and-deployment/">这个网页</a> 。
</p>

<p>
更复杂的配置需要进一步学习nginx相关知识。
</p>
</div>
</div>

<div class="outline-3">
<h3 id="orgheadline51">在heroku上部署项目</h3>
<div class="outline-text-3" id="text-8-2">
<p>
在heroku上部署项目其实很简单，只是感觉就是官方教程也谈论得干扰因素有点多了，比如说virtualenv，我会用，但总不喜欢用，不知道怎么回事。官方上手教程把virtualenv引进来一开始给我的感觉就是heroku而运作机制是依赖于virtualenv或者说本地的模块的，这其实是错误的。heroku在远程安装各个python的第三方模块都是通过pip命令来完成的，和你本地virtualenv具体的安装毫无关系，当然了有人会说通过pip freeze命令会很方便，但我真没看出这有多方便，如果这个项目是你自己写的，具体用了那几个模块你自己还不清楚吗。好了，闲话少说，首先谈谈python2和python3的问题。。
</p>
</div>

<div class="outline-4">
<h4 id="orgheadline43">指定python2或python3</h4>
<div class="outline-text-4" id="text-8-2-1">
<p>
在主文件夹目录下你新建一个 <code>runtime.txt</code> 文件，里面简单写上：
</p>
<pre>
python-3.4.3
</pre>

<p>
这样，远程heroku会帮你确定python运行环境为python-3.4.3。
</p>
<pre>
remote: -----&gt; Installing runtime (python-3.4.3)
</pre>

<p>
就这么简单，同时要注意简写 <code>python3</code> 或者其他书写格式等都不支持，就作为python3里面还有其他版本号，按照 <a href="https://devcenter.heroku.com/articles/python-runtimes">heroku官方文档这里</a> 的说法，pypy-1.9或者python-2.4.6或者python-3.3.3等这些都是支持的，但他们只确保python-2.7.10和python-3.4.3能够被很好地支持。【2015-06-09】
</p>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline44">安装第三方模块</h4>
<div class="outline-text-4" id="text-8-2-2">
<p>
这个也很简单，就在 <code>requirements.txt</code> 文件里面上写上模块名字即可。 比如：
</p>
<pre>
flask
gunicorn
</pre>

<p>
这样heroku远程会自动利用pip来安装对应的第三方模块，如下所示：
</p>
<pre>
remote:        Installing collected packages: Werkzeug, markupsafe, Jinja2, itsdangerous, flask, gunicorn
</pre>

<p>
我们看到flask依赖的其他第三方模块也安装上去了，然后这样自动安装的就是最新的模块的版本号，而我们不用virtualenv的话，本地也安装的是最新的版本号，这样也能起到检验的效果，而且也更简单。只有某些极个别的情况才会考虑固定模块的版本号，毕竟让模块更新到最近的版本号总是好的。当然了，这是我个人的体验，如果读者确实觉得virtualenv很好用，就当我没说。
</p>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline45">Procfile文件</h4>
<div class="outline-text-4" id="text-8-2-3">
<p>
这是主文件夹和heroku配置相关的第三个文件，官方教程的是这样一行：
</p>
<pre>
web: gunicorn hello:app --log-file=-
</pre>

<p>
我们大致可以猜到这是heroku的初始化配置参数，比如web引擎用gunicorn，然后hello是app主入口等。这个后面再详细讨论。
</p>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline46">hello.py文件</h4>
<div class="outline-text-4" id="text-8-2-4">
<p>
这个hello.py对应的就是上面的 <code>hello:app</code> 这句，告诉heroku了本app的主入口在哪里。
</p>

<p>
其内容就是最简单的flask演示hello world例子：
</p>
<pre>
import os
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello World!'
</pre>

<p>
heroku远程是如何编译源文件的我们不管，然后接下来就是利用git把你写的源码推到heroku服务器上去，推上去之后heroku会自动编译一次源文件。
</p>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline47">安装heroku或者不？</h4>
<div class="outline-text-4" id="text-8-2-5">
<p>
按照官方文档的说明来，不赘述了。在ubuntu下的是：
</p>
<pre>
wget -qO- https://toolbelt.heroku.com/install-ubuntu.sh | sh
</pre>


<p>
本终端要登录一次，就是运行命令：
</p>
<pre>
heroku login
</pre>

<p>
登录的目的是什么？是为了有权限在heroku服务器上新建项目，也就是让你能够运行 <code>heroku create</code> 命令。但是我们日常用git推送是不需要heroku登录的，而且实际上这个 <code>heroku create</code> 命令你也可以不使用，你可以在heroku的网页上新建一个项目。 
</p>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline48">通过网页新建项目得到一个好名字</h4>
<div class="outline-text-4" id="text-8-2-6">
<p>
通过网页我们新建的项目名字可以稍微取得好看点，然后新建完之后我们如何利用git将你的目标源码推送到那里去呢？首先git init ，然后git commit 这些我就不废话了，那么最关键的问题是heroku这个远程目的地地址在那里呢？
</p>

<p>
十分有趣的是我在网页上找了一下竟然找不到，但这又不是什么秘密。在.git的config里面，一个项目名 <code>secret-shore-9329</code> 的url是：
</p>
<pre>
url = https://git.heroku.com/secret-shore-9329.git
</pre>

<p>
再比如 <code>myheroku-1</code> 对应的是：
</p>
<pre>
git remote add heroku  https://git.heroku.com/myheroku-1.git
</pre>

<p>
然后接下来你就随意进行git管理项目和推送了。
</p>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline49">或者更简单直接通过github来管理</h4>
<div class="outline-text-4" id="text-8-2-7">
<p>
heroku还提供了一种更简单的项目管理方式，你可以在github上创建一个项目，然后在heroku上连接好这个github项目，然后推荐把下面那个 <strong>自动部署</strong> 也点上。然后你就可以如同往常一样 <code>git push origin master</code> ，将源码推送到github上即可。这样真是方便极了！
</p>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline50">如何在heroku上加入数据库</h4>
<div class="outline-text-4" id="text-8-2-8">
<pre>
heroku  pg:psql --app cheminfo
</pre>


<pre>
heroku addons:add heroku-postgresql:dev --app cheminfo
</pre>
</div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline56">和apache2一起</h3>
<div class="outline-text-3" id="text-8-3">
<p>
apache2是支持flask框架编写网络服务器的，更确切的表达是，apache2有一个模块，安装上它apache2就支持wsgi接口了。对于python2，在ubuntu下要安装的是:
</p>
<div class="highlight"><pre><span></span>sudo apt-get install  libapache2-mod-wsgi
</pre></div>

<p>
对于python3，要安装的是:
</p>

<div class="highlight"><pre><span></span>sudo apt-get install  libapache2-mod-wsgi-py3
</pre></div>

<p>
默认那个 <code>wsgi</code> 模块安装之后就激活了，你可以通过 <code>a2dismod</code> 来看一下，就是那个 <code>wsgi</code> 模块。 这里参考了 <a href="http://stackoverflow.com/questions/28019310/running-django-python-3-4-on-mod-wsgi-with-apache2">这个网页</a> 。
</p>

<p>
但是等一等，还有一些东西你需要配置，更多细节请参看flask框架官方文档的 <a href="http://flask.pocoo.org/docs/0.10/deploying/mod_wsgi/">这里</a> ，下面简单介绍之。
</p>
</div>

<div class="outline-4">
<h4 id="orgheadline52">简单的apache2配置</h4>
<div class="outline-text-4" id="text-8-3-1">
<p>
最简单的配置就是如下所示:
</p>

<pre>
WSGIScriptAlias / /home/wanze/workspace/cdwanze/cdwanze.wsgi

    &lt;Directory /home/wanze/workspace/cdwanze &gt;
    Require all granted
    &lt;/Directory&gt;
</pre>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline53">Require做了什么</h4>
<div class="outline-text-4" id="text-8-3-2">
<p>
其中 <code>Require all granted</code> 前面我们已谈到，是对访问权限的控制。参看apache2.2到apache2.4的 <a href="http://httpd.apache.org/docs/current/upgrading.html">升级文档</a> ，
原2.2配置:
</p>
<pre>
Order deny,allow
Deny from all
</pre>
<p>
等同于2.4配置:
</p>
<pre>
Require all denied
</pre>


<p>
原2.2配置:
</p>
<pre>
Order allow,deny
Allow from all
</pre>
<p>
等同于2.4配置:
</p>
<pre>
Require all granted
</pre>


<p>
原2.2配置:
</p>
<pre>
Order Deny,Allow
Deny from all
Allow from example.org
</pre>
<p>
等同于2.4配置:
</p>
<pre>
Require host example.org
</pre>

<p>
关于这里Order什么的配置更详细的说明参看 <a href="http://www.fwolf.com/blog/post/191">这个网页</a> 。其第一行就两种写法，逗号之间不能有空格。
</p>
<ol class="org-ol">
<li><code>Order Deny,Allow</code></li>
</ol>
<p>
在这个写法后面，后面先写允许谁谁谁访问，然后写禁止谁谁谁访问。如下所示:
</p>
<pre>
Order Deny,Allow
Deny from all
Allow from example.org
</pre>
<p>
这个写法的意思是禁止谁，允许谁，禁止所有只允许example.org访问。
</p>


<ol class="org-ol">
<li><code>Order Allow,Deny</code></li>
</ol>
<p>
和上面描述类似，除了先写允许再写禁止。
</p>

<p>
新的apache2.4的 <code>require</code> 语法更多细节请参看apache2官方文档的 <a href="http://httpd.apache.org/docs/2.4/howto/access.html">这里</a> 。接着前面的描述，还有如下表达:
</p>

<p>
允许某个具体的ip地址:
</p>
<pre>
Require ip ip.address
</pre>

<p>
在前面有了，全部都允许、全部都禁止、全部都禁止只允许谁。还有如下，全部都允许只禁止谁:
不允许某个ip地址。
</p>
<pre>
Require all granted
Require not ip 10.252.46.165
</pre>
</div>
</div>

<div class="outline-4">
<h4 id="orgheadline54">what.wsgi文件</h4>
<div class="outline-text-4" id="text-8-3-3">
<p>
这一行具体设置那个what.wsgi文件在那里，一般就放在flask框架源码第一目录下吧。
</p>
<pre>
WSGIScriptAlias / /home/wanze/workspace/cdwanze/cdwanze.wsgi
</pre>

<p>
然后这个what.wsig文件主要就是说明flask程序app对象在哪里。
</p>

<p>
这里首先把python的搜索路径加上，然后从你的flask主app对象所谓的文件中引入app，然后 <code>as application</code> 。
</p>
<pre>
import sys
sys.path.insert(0, '/home/wanze/workspace/cdwanze')

from cdwanze import app as application
</pre>
</div>
</div>


<div class="outline-4">
<h4 id="orgheadline55">更复杂点的配置</h4>
<div class="outline-text-4" id="text-8-3-4">
<p>
flask官方文档给出了更复杂点的配置如下所示:
</p>
<pre>
WSGIDaemonProcess cdwanze user=wanze group=wanze threads=5
WSGIScriptAlias / /home/wanze/workspace/cdwanze/cdwanze.wsgi

    &lt;Directory /home/wanze/workspace/cdwanze &gt;
    WSGIProcessGroup cdwanze
    WSGIApplicationGroup %{GLOBAL}

    Require all granted
    &lt;/Directory&gt;
</pre>

<p>
具体其似乎和用户权限管理有关，这里的细节我还不太懂，不过大体就是用户和群组的控制吧，然后还有一个线程控制。这里暂时先就这样了。
</p>
</div>
</div>
</div>


<div class="outline-3">
<h3 id="orgheadline57">参考资料</h3>
<div class="outline-text-3" id="text-8-4">
<ol class="org-ol">
<li>当然是flask的官方文档。 这里有一个 <a href="http://docs.jinkan.org/docs/flask/">中文翻译网页</a> ，这个网页左侧写着译者，应该是原创吧。</li>
<li><a href="https://exploreflask.com/">https://exploreflask.com/</a> 这里有一个 <a href="http://spacewander.github.io/explore-flask-zh/index.html">中文翻译网页</a> ，是原创者。</li>
<li>Flask Web Development; Author:Miguel Grinberg; Version:2014（我并不太喜欢这本书的喜欢用各种flask第三方插件的编码风格，大体翻看了一下，主要是看flask官方文档和官方example。）</li>
</ol>
</div>
</div>
</div>
</div>
</body>
</html>