python怎么运行单个接口方法

一、构建环境

1.安装虚拟机和mysql

使用vm和centos7.9的镜像安装一个虚拟机,然后安装一个docker,启动docker

使用命令，拉取一个mysql

docker pull mysql

创建一个mysql配置文件(因为要把容器内的配置文件映射到宿主机，实现通过修改宿主机的配置文件的配置来实现修改配置)

mkdir /home/mysql //自行创建,或用已有的目录，这个是我创建的目录
cd /home/mysql
touch my.cnf
echo "# For advice on how to change settings please see
# http://dev.mysql.com/doc/refman/8.2/en/server-configuration-defaults.html

[mysqld]
#
# Remove leading # and set to the amount of RAM for the most important data
# cache in MySQL. Start at 70% of total RAM for dedicated server, else 10%.
# innodb_buffer_pool_size = 128M
#
# Remove leading # to turn on a very important data integrity option: logging
# changes to the binary log between backups.
# log_bin
#
# Remove leading # to set options mainly useful for reporting servers.
# The server defaults are faster for transactions and fast SELECTs.
# Adjust sizes as needed, experiment to find the optimal values.
# join_buffer_size = 128M
# sort_buffer_size = 2M
# read_rnd_buffer_size = 2M

# Remove leading # to revert to previous value for default_authentication_plugin,
# this will increase compatibility with older clients. For background, see:
# https://dev.mysql.com/doc/refman/8.2/en/server-system-variables.html#sysvar_default_authentication_plugin
# default-authentication-plugin=mysql_native_password
skip-host-cache
skip-name-resolve
datadir=/var/lib/mysql
socket=/var/run/mysqld/mysqld.sock
secure-file-priv=/var/lib/mysql-files
user=mysql

pid-file=/var/run/mysqld/mysqld.pid
#skip-grant-tables
[client]
socket=/var/run/mysqld/mysqld.sock
" > my.cnf

初始化容器中的Mysql，并映射端口和文件到宿主机

docker run --name mysql –-restart=always  -e MYSQL_ROOT_PASSWORD=123456 -v /home/mysql/my.cnf:/etc/my.cnf -p 13306:3306 -d mysql

* --name 参数用于指定容器的名称，这里将容器命名为 mysql

* -e 参数用于设置容器的环境变量，这里设置了 MySQL 的 root 用户密码为 123456。

* -p 参数用于将容器的端口映射到宿主机的端口，这里将容器的 3306 端口映射到宿主机的 13306 端口，格式为：宿主机端口:容器端口

* -d 参数用于指定容器以后台模式运行。

* -v 目录映射，-v /home/mysql/my.cnf:/etc/my.cnf     /home/mysql/my.cnf 宿主机的文件, /etc/my.cnf 容器文件，宿主机要先在指定目录创建一个文件

* --restart=always 设置开启自启，前提是docker开机自启，如果初始化时没有配置可通过如下命令配置开机启动

docker update --restart=always 容器ID(或者容器名)

2.初始化数据库

进入docker中的Mysql,通过docker ps可以看到启动到的容器

docker exec -it 容器名/容器id bash

编写数据库创建脚本

create database practice;
CREATE TABLE `user` (
  `id` int NOT NULL AUTO_INCREMENT,
  `username` varchar(100) NOT NULL,
  `password` varchar(100) NOT NULL,
  `birthday` varchar(100) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

INSERT INTO practice.`user` (username,password) VALUES
	 ('zhangsan','zhangsan'),
	 ('zhangsi','zhangsi'),
	 ('lisi','sdg'),
	 ('lisi','sdg'),
	 ('lisidsfsd','sdg');

然后在数据库中执行。

3.安装flask,pymysql，sqlalchemy

先自行安装一个python,我下载的是3.10.2版本

然后修改pip镜像源为国内的

在C:\Users/用户名/AppData/Roaming/pip,没有就创建这个目录

在pip目录下创建一个pip.ini

把这些写进去

[global]
timeout = 6000
index-url = https://pypi.douban.com/simple
trusted-host = pypi.douban.com

打开一个新的cmd,使用pip config list查看配置是否修改

然后执行如下命令安装pymysql和flask

pip install pymysql
pip install flask
pip install sqlalchemy

注：如果不想修改镜像源，可以使用pip install -i 镜像地址 包名 ,下载的时候临时使用你想使用的镜像源，安装完成后就可以开始下一步

二、编写代码

我使用的是vscode，至于vscode怎么配置python环境，可以上网查一下

创建一个文件夹，然后使用vscode打开这个文件

创建一个实体类

models.py

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer,String,Text,ForeignKey,DateTime
import datetime

Base = declarative_base()

class User(Base):
    __tablename__ = 'user'
    id=Column(Integer, primary_key=True)
    username=Column(String(20), nullable=False)
    password=Column(String(20), nullable=False)

databaseconn.py

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker,scoped_session
from sqlalchemy.exc import SQLAlchemyError
import configparser
from models import User

config=configparser.ConfigParser()

config.read('app.config')

HOSTNAME=config.get('config','host')

PORT=config.get('config','port')

DATABASE=config.get('config','database')

USERNAME=config.get('config','username')

PASSWORD=config.get('config','password')


DB_URL='mysql+pymysql://{username}:{pwd}@{host}:{port}/{db}?charset=utf8'\
        .format(username=USERNAME,pwd=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
#创建数据库引擎

engine=create_engine(DB_URL,
                        max_overflow=2, # 超过连接池大小外最多创建的连接
                        pool_size=10, # 连接池大小
                        pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
                        pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
                        )


Session=sessionmaker(bind=engine)
db_session = scoped_session(Session)
# '''
# 因为全局都使用同一个Session对象，会有线程并发安全问题
# 于是需要scoped_session来解决这个问题
# db_session = scoped_session(Session) 这样就解决了
# 这样就可以全局使用这个db_session
# '''

class DatabaseOperations:
    def __init__(self):
        self.session=db_session()
        
    def close_connection(self):
        try:
            self.session.close()
        except SQLAlchemyError as e:
            print("Error closing the session:",e)
            pass

    def query_users(self):
        try:
            users = self.session.query(User).filter(User.id > 2).all()
            return users
        except SQLAlchemyError as e:
            print("Error querying users:",e.args)
            return None

    def add_user(self,user):
        get_username=user.get("username")
        get_password=user.get("password")
        i=User(username=get_username,password=get_password)
        try:
            self.session.add(i)
            self.session.commit()
            return True
        except SQLAlchemyError as e:
            print("Error querying users:",e.args)
            return False
        
    def update_user(self,user):
        get_id=user.get("id")
        get_username=user.get("username")

        try:
            result=self.session.query(User).filter_by(id=get_id).update({'username':get_username})
            self.session.commit()
        except SQLAlchemyError as e:
            print("Error querying users:",e.args)
        return result
        
    def delete_user_byid(self,user):
        get_id=user.get("id")
        try:
            result=self.session.query(User).filter_by(id=get_id).delete()
            self.session.commit()
        except SQLAlchemyError as e:
            print("Error querying users:",e.args)
        print(result)
        return result

app.config

[config]
host=192.168.211.129  
port=13306  
database=practice  
username=root  
password=123456

app.py

from flask import Flask,jsonify,request
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy.orm import sessionmaker
from databaseconn import DatabaseOperations
import json



app = Flask(__name__)
database_Operations=DatabaseOperations()


@app.route('/',methods=['GET'])
def search():
    users=database_Operations.query_users()
    database_Operations.close_connection()
    if users is not None:
        for user in users:
            print("User:",user.username,user.password)
        user_list = [user.to_dict() for user in users]
        user_json=json.dumps(user_list)
        return user_json
    else:
        print("An error occurred while querying users.")
    
    
 
@app.route('/add',methods=['POST'])
def add_it():
    my_json=request.get_json()
    print(my_json)
    result=database_Operations.add_user(my_json)
    database_Operations.close_connection()
    if result:
        return "添加成功"
    else:
        return "添加失败"

@app.route('/update',methods=['POST'])
def update_it():
    my_json=request.get_json()
    result=database_Operations.update_user(my_json)
    database_Operations.close_connection()
    if result:
        return "修改成功"
    else:
        return "修改失败"

@app.route('/delete',methods=['POST'])
def delete_it():
    my_json=request.get_json()
    result=database_Operations.delete_user_byid(my_json)
    
    database_Operations.close_connection()
    if result:
        return "删除成功"
    else:
        return "删除失败"


if __name__ == '__main__':
    app.run(host='0.0.0.0',port=5000,debug=True)

然后开始运行，通过localhost:5000/ 来调用接口测试（未完）