uniapp—H5 上传图片,拍照上传的问题总结

一、uniapp-H5上传图片会出现那些问题尼?

uniapp官方背大锅,h5端与其他小程序、app在这个地方的处理方式不同,filePath支持其他,唯独h5不行

——h5端上传前必须转为file对象上传,其他端直接filePath就ok;

uni.uploadFile()上传blob文件给服务端后,后端获取file对象的时候,没法获取后缀名(小程序,app上面有后缀名),从而上传失败

通过uni.chooseimage() 选择图片,将blob路径传递给后端

将base编码图片转成blob文件路径,上传

将图片进行处理(譬如图片压缩,或者uni.canvasToTempFilePath() 处理后),转成blob上传

用第三方插件处理的图片返回的blob,直接上传

——h5端上传前必须转为file对象上传

在ios真机在调试过程中会出现后端成功返回数据,但是前端接受不到数据的情况就报错了,原因是文件过大

——方法一:uploadFile直接设置超时请求(时间长) 方法二:对图片进行压缩处理(像素降低)

        /**
         * 上传到服务器
         * @description 这块需要您自行处理
         * @param {Object} file - 要上传的file对象
         * @return void
         */
        upload(file) {
            uni.uploadFile({
                name: 'file',
                url: '您的上传接口!!',
                
                // 这块需要额外注意,h5必须使用"file",并且只接受file对象
                file: file,
                // END
                
                fileType: 'image', 
                success: (res) => {
                    console.log('上传成功', res)
                    uni.showToast({
                        title: '上传成功',
                        icon: 'none'
                    })
                }
            })
        },

sa-token 配置自定义 Token 前缀后cookie无效问题

自定义 Token 前缀
需求场景

在某些系统中,前端提交token时会在前面加个固定的前缀,例如:

{

"satoken": "Bearer xxxx-xxxx-xxxx-xxxx"

}

此时后端如果不做任何特殊处理,框架将会把Bearer 视为token的一部分,无法正常读取token信息,导致鉴权失败。

为此,我们需要在yml中添加如下配置:

sa-token:

# token前缀
token-prefix: Bearer

此时 Sa-Token 便可在读取 Token 时裁剪掉 Bearer,成功获取xxxx-xxxx-xxxx-xxxx。

注意点

Token前缀 与 Token值 之间必须有一个空格。
一旦配置了 Token前缀,则前端提交 Token 时,必须带有前缀,否则会导致框架无法读取 Token。
由于Cookie中无法存储空格字符,所以配置 Token 前缀后,Cookie 模式将会失效,此时只能将 Token 提交到header里进行传输。

@EnableDubbo @SpringBootApplication

  1. @EnableDubbo

@EnableDubbo 是 Apache Dubbo 提供的注解,用来启用 Dubbo 的功能。它告诉 Spring 容器扫描并加载 Dubbo 的相关组件,包括 服务提供者 和 服务消费者。
作用

启用 Dubbo 自动配置:加载 Dubbo 的核心功能,比如注册服务、消费服务等。
扫描指定包路径下的 Dubbo 注解:
    @DubboService:标记服务提供者(即要暴露给其他服务的接口实现)。
    @DubboReference:标记服务消费者(即调用远程接口)。

常见使用

@EnableDubbo
@SpringBootApplication
public class DubboApplication {

public static void main(String[] args) {
    SpringApplication.run(DubboApplication.class, args);
}

}

功能细节

默认扫描主类(@SpringBootApplication 所在类)所在包及其子包中的 Dubbo 注解。
可以指定扫描路径:

@EnableDubbo(scanBasePackages = "com.example.dubbo.service")
@SpringBootApplication
public class DubboApplication {
    public static void main(String[] args) {
        SpringApplication.run(DubboApplication.class, args);
    }
}
  1. @SpringBootApplication

@SpringBootApplication 是 Spring Boot 提供的核心注解,用于标记一个 Spring Boot 应用的启动类。
作用

标记应用入口:这是 Spring Boot 应用的启动类(即 main 方法所在类)。
启用 Spring Boot 自动配置:
    自动加载与应用相关的 Spring 配置(如 DataSource, JPA, RestController)。
    简化开发,无需手动配置 XML 或 Java 配置类。
组件扫描:
    默认扫描当前类所在包及其子包中的所有组件(如 @Controller, @Service, @Component 等)。

注解组合

@SpringBootApplication 是以下 3 个注解的组合:

@Configuration:声明当前类是一个配置类。
@EnableAutoConfiguration:启用 Spring Boot 的自动配置机制。
@ComponentScan:扫描当前包及子包中的组件。

常见使用

@SpringBootApplication
public class MyApplication {

public static void main(String[] args) {
    SpringApplication.run(MyApplication.class, args);
}

}

  1. @EnableDubbo + @SpringBootApplication 的联合使用

当 @EnableDubbo 和 @SpringBootApplication 一起使用时:

@SpringBootApplication:
    加载 Spring Boot 的核心配置。
    提供一个运行时环境(包括 Web 服务、配置文件加载等)。
@EnableDubbo:
    启用 Dubbo 的服务注册与发现功能。
    自动扫描并加载 Dubbo 的服务提供者和消费者。
  1. 示例
    服务提供者

@EnableDubbo
@SpringBootApplication
public class ProviderApplication {

public static void main(String[] args) {
    SpringApplication.run(ProviderApplication.class, args);
}

}

@DubboService(version = "1.0.0") // 暴露 Dubbo 服务
public class HelloServiceImpl implements HelloService {

@Override
public String sayHello(String name) {
    return "Hello, " + name;
}

}

服务消费者

@EnableDubbo
@SpringBootApplication
public class ConsumerApplication {

public static void main(String[] args) {
    SpringApplication.run(ConsumerApplication.class, args);
}

}

@RestController
public class HelloController {

@DubboReference(version = "1.0.0") // 引用 Dubbo 服务
private HelloService helloService;

@GetMapping("/sayHello")
public String sayHello(@RequestParam String name) {
    return helloService.sayHello(name);
}

}

配置示例

application.yml 配置 Dubbo:

dubbo:
application:

name: dubbo-example

registry:

address: zookeeper://127.0.0.1:2181

provider:

timeout: 3000

consumer:

check: false

总结

@EnableDubbo:启用 Dubbo 的功能,负责加载和扫描 Dubbo 的相关组件。
@SpringBootApplication:Spring Boot 的核心注解,用来加载 Spring 的配置,构建运行时环境。
两者结合使用,可以快速启动一个基于 Spring Boot 的 Dubbo 分布式服务应用。

您说:
为啥有些启动类不加@EnableDubbo也能被注册和发现
ChatGPT 说:
ChatGPT

有些启动类在没有显式加 @EnableDubbo 的情况下,仍然能注册和发现 Dubbo 服务,通常是因为以下原因:

  1. Spring Boot 和 Dubbo 自动配置

Spring Boot 和 Dubbo 集成时,使用了 Spring Boot Starter 和 自动配置机制。当项目中引入了 Dubbo 的 Starter 依赖(如 dubbo-spring-boot-starter),以下机制会自动启用 Dubbo 的功能:
关键点

Dubbo 的自动配置类:
    org.apache.dubbo.config.spring.context.annotation.DubboComponentScanRegistrar
    org.apache.dubbo.config.spring.beans.factory.annotation.ReferenceAnnotationBeanPostProcessor

这些自动配置类会扫描项目中的 Dubbo 注解(如 @DubboService, @DubboReference),并注册相关的服务。
触发条件

当 dubbo-spring-boot-starter 被引入,Spring Boot 的自动配置机制会:

加载 DubboAutoConfiguration 类。
自动启用 Dubbo 的核心功能,包括注册服务和消费服务。

结论

因此,即使没有手动加 @EnableDubbo,Dubbo 也可以通过 Spring Boot 的自动配置机制正常工作。

  1. Spring Boot 主类默认扫描包

在 Spring Boot 应用中,@SpringBootApplication 默认会扫描当前类所在包及其子包中的所有组件,包括标注了 Dubbo 注解的类,例如:

@DubboService:Dubbo 服务提供者。
@DubboReference:Dubbo 服务消费者。

如果 Dubbo 注解的类位于默认扫描路径中,Spring Boot 会自动发现并加载它们,无需额外配置。

  1. 隐式加载 Dubbo 的功能

一些情况下,Dubbo 的功能被隐式加载:

spring.factories 机制:
    Dubbo 的 Spring Boot Starter 通过 spring.factories 文件,加载自动配置类。
    例如,DubboAutoConfiguration 类会隐式启用 Dubbo 的相关功能。
@DubboService 或 @DubboReference 自动触发:
    这些注解本身会触发服务注册和发现,即使没有显式使用 @EnableDubbo。
  1. 使用了默认的注解扫描路径

在没有 @EnableDubbo 的情况下,Dubbo Starter 默认会扫描主类所在包和子包中包含的注解(如 @DubboService, @DubboReference),因此:

如果启动类所在包路径和服务类一致,Dubbo 的注解会被正常加载。
  1. @EnableDubbo 作用的补充说明

虽然 @EnableDubbo 显式启用 Dubbo 的注解扫描,但在以下情况下可以省略:

项目中已经引入了 dubbo-spring-boot-starter,并且默认扫描路径包含了服务类。
没有特殊的扫描路径需求(如需要扫描其他非默认包路径的 Dubbo 注解)。

但加上 @EnableDubbo 的好处是:

明确表明应用依赖 Dubbo 功能。
可以自定义扫描路径,例如:

@EnableDubbo(scanBasePackages = "com.example.services")
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

如何确认 Dubbo 的自动配置生效?

可以通过以下方法确认 Dubbo 的自动配置是否生效:

查看 Spring Boot 日志:
    如果 Dubbo 的自动配置生效,启动时日志会显示类似:

[Dubbo] The Dubbo application [xxx] has been registered to Zookeeper [127.0.0.1:2181]

启用 Debug 日志: 在 application.yml 中启用自动配置调试:

logging:
  level:
    org.apache.dubbo: DEBUG
    org.springframework.boot.autoconfigure: DEBUG

排查自动装配状态: 使用 Spring Boot 的 ConditionEvaluationReport 检查自动装配状态:
    启动项目后访问 /actuator/conditions。
    查看 DubboAutoConfiguration 是否为 matched。

总结

没有显式加 @EnableDubbo 的启动类能正常工作,是因为 Spring Boot 自动配置机制 和 Dubbo Starter 的自动装配。
如果服务类或消费者类位于默认扫描路径中,Dubbo 会自动扫描并加载它们。
建议:显式加上 @EnableDubbo 可以增强可读性,尤其是需要自定义扫描路径时。

上传本地文件夹上传到minio

import os
import boto3
from mimetypes import guess_type

# MinIO 配置信息
MINIO_ENDPOINT = "http://xx:9000"  # MinIO 地址
MINIO_ACCESS_KEY = "AT03z5LqjDlaJ4fjn"      # MinIO Access Key
MINIO_SECRET_KEY = "jOjWgkDhOc3zC8RgRYLzm4wKP3q4rnR"      # MinIO Secret Key
BUCKET_NAME = "lanyuancc"          # MinIO 中的桶名

# 本地文件夹路径
LOCAL_FOLDER = r"D:\Backup\Documents\Downloads\蓝源产城图片"  # 替换为本地文件夹路径

# 初始化 MinIO 客户端
s3_client = boto3.client(
    's3',
    endpoint_url=MINIO_ENDPOINT,
    aws_access_key_id=MINIO_ACCESS_KEY,
    aws_secret_access_key=MINIO_SECRET_KEY
)

def upload_to_minio(local_folder, bucket_name, target_directory=""):
    """
    将本地文件夹中的文件上传到 MinIO,支持指定桶内的文件夹路径

    :param local_folder: 本地文件夹路径
    :param bucket_name: MinIO 中的桶名称
    :param target_directory: MinIO 中目标文件夹路径(子目录,例如 "specific-directory")
    """
    for root, dirs, files in os.walk(local_folder):
        for file_name in files:
            local_path = os.path.join(root, file_name)  # 本地文件路径
            relative_path = os.path.relpath(local_path, local_folder)  # 相对路径
            
            # 在 MinIO 中的目标路径,加入指定目录前缀
            minio_path = os.path.join(target_directory, relative_path).replace("\\", "/")

            mime_type, _ = guess_type(local_path)  # 推测文件的 MIME 类型

            try:
                # 上传文件到 MinIO
                s3_client.upload_file(
                    local_path,
                    bucket_name,
                    minio_path,
                    ExtraArgs={"ContentType": mime_type or "application/octet-stream"}
                )
                print(f"上传成功: {minio_path}")
            except Exception as e:
                print(f"上传失败: {minio_path},错误: {e}")

# 调用函数进行文件上传
if __name__ == "__main__":
    # 修改 target_directory 为桶中希望的子目录路径
    target_directory = ""  # 示例子目录:上传到 BUCKET_NAME/specific-directory/
    upload_to_minio(LOCAL_FOLDER, BUCKET_NAME, target_directory)

springboot cloud项目数据库导出并新建数据库

使用步骤
安装依赖模块
确保安装 mysql-connector-python:

pip install mysql-connector-python

确保 mysqldump 和 mysql 命令可用
此脚本依赖于系统中安装的 mysqldump 和 mysql 命令。请确保它们已安装并配置在系统路径中。

配置参数
替换脚本中的 host、user、password、original_db 和 new_db 变量,使用你自己的数据库连接信息和数据库名称。

运行脚本:

    python clone_database.py

检查结果
脚本运行后,原始数据库的数据将被复制到一个新数据库中。

import mysql.connector
import subprocess
import os

def export_and_clone_databases(host, user, password, databases, suffix):
    try:
        # Step 1: 创建 MySQL 连接
        connection = mysql.connector.connect(
            host=host,
            user=user,
            password=password
        )
        cursor = connection.cursor()

        for original_db in databases:
            # Step 2: 检查原始数据库是否存在(使用反引号转义数据库名)
            cursor.execute(f"SHOW DATABASES LIKE '{original_db}';")
            if not cursor.fetchone():
                print(f"Error: Database '{original_db}' does not exist.")
                continue

            # Step 3: 创建新数据库(用反引号转义数据库名)
            new_db = f"{original_db}_{suffix}"
            cursor.execute(f"CREATE DATABASE IF NOT EXISTS `{new_db}`;")
            print(f"New database '{new_db}' created successfully.")

            # Step 4: 使用 mysqldump 导出原数据库
            dump_file = f"{original_db}.sql"
           # dump_command = f"mysqldump -h {host} -u {user} -p{password} `{original_db}` > {dump_file}"
            dump_command = f'"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysqldump.exe" -h {host} -u {user} -p{password} {original_db} > {dump_file}'
            print(f"Executing: {dump_command}")
            subprocess.run(dump_command, shell=True, check=True)
            print(f"Database '{original_db}' exported to '{dump_file}'.")

            # Step 5: 导入 SQL 文件到新数据库
           # import_command = f"mysql -h {host} -u {user} -p{password} `{new_db}` < {dump_file}"
            import_command = f'"C:\\Program Files\\MySQL\\MySQL Server 8.0\\bin\\mysql.exe" -h {host} -u {user} -p{password} {new_db} < {dump_file}'

            print(f"Executing: {import_command}")
            subprocess.run(import_command, shell=True, check=True)
            print(f"Data imported into new database '{new_db}' successfully.")

            # Step 6: 删除临时文件(可选)
            if os.path.exists(dump_file):
                os.remove(dump_file)
                print(f"Temporary file '{dump_file}' deleted.")
    except mysql.connector.Error as err:
        print(f"Error: {err}")
    except subprocess.CalledProcessError as err:
        print(f"Command failed: {err}")
    finally:
        if connection.is_connected():
            cursor.close()
            connection.close()
            print("MySQL connection closed.")

# 使用示例
if __name__ == "__main__":
    host = "localhost"       # 数据库地址
    user = "root"            # 数据库用户名
    password = "xxx"    # 数据库密码

    # 定义需要复制的数据库列表
    databases = [
        "industry-xxx"
    ]

    # 新数据库的后缀
    suffix = "xxx"  # 可更改为需要的后缀

    export_and_clone_databases(host, user, password, databases, suffix)