loquy

ASP.NET Core 使用教程

2024-05-27T08:37:28.000Z

一、应用启动

在 ASP.NET Core 应用程序中，启动过程由主机（Host）负责，它负责配置应用程序并启动运行时环境。以下是 ASP.NET Core 应用程序的启动过程及相关概念：

1. 主机（Host）

主机是 ASP.NET Core 应用程序的宿主环境，负责启动应用程序并提供运行时环境。主机可以是 Web 主机（如 IIS、Kestrel）、进程宿主（如 Console 应用）、自定义宿主等。

2. 应用程序启动

ASP.NET Core 应用程序的启动过程通常在 Program.cs 文件中进行配置和定义。以下是一个典型的 Program.cs 文件示例：

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Hosting;

namespace MyApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            CreateHostBuilder(args).Build().Run();
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup();
                });
    }
}

在 Main 方法中，通过调用 CreateHostBuilder 方法创建主机，并通过调用 Build() 方法构建主机，最后调用 Run() 方法启动应用程序。

3. 主机构建器（Host Builder）

Host.CreateDefaultBuilder(args) 方法创建了一个主机构建器，它会配置主机的默认行为。通常，主机构建器会加载配置、配置日志、设置主机环境等。

4. Web 主机配置

ConfigureWebHostDefaults 方法配置了 Web 主机的默认行为。在此处，可以配置 Web 主机的服务器（如 Kestrel）、应用程序配置、日志记录等。

5. 启动配置类（Startup Class）

Startup 类是 ASP.NET Core 应用程序的入口点，它包含了配置应用程序的逻辑。在 ConfigureServices 方法中，可以注册服务、配置中间件等；在 Configure 方法中，可以配置请求处理管道。

以下是一个典型的 Startup.cs 文件示例：

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace MyApp
{
    public class Startup
    {
        public IConfiguration Configuration { get; }

        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();
            // 添加其他服务配置
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
            }

            app.UseStaticFiles();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllerRoute(
                    name: "default",
                    pattern: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }
}

6. 启动过程总结

应用程序启动由主机负责，主机构建器配置默认行为。
ConfigureWebHostDefaults 方法配置 Web 主机的默认行为，包括服务器、应用程序配置等。
Startup 类是应用程序的入口点，负责配置应用程序的服务和请求处理管道。

通过以上启动过程，ASP.NET Core 应用程序能够在启动时正确配置和准备好运行时环境，并通过 Startup 类中的逻辑处理请求和提供服务。

二、依赖注入

依赖注入（Dependency Injection，简称 DI）是软件设计中的一种模式，通过将对象的依赖项（即其使用的其他对象）注入到该对象中，使得依赖关系更加明确和可控。ASP.NET Core 原生支持依赖注入，这使得服务的注册和管理变得简单和高效。

1. 依赖注入的核心概念

服务（Service）：可以被应用程序中的其他部分使用的组件或对象。
容器（Container）：用于管理服务的生命周期和解析服务依赖关系的对象。
注册（Registration）：将服务类型和其实现类型添加到容器中。

2. 服务的生命周期

在 ASP.NET Core 中，服务可以有以下几种生命周期：

瞬态（Transient）：每次请求服务时都会创建一个新的实例。适用于轻量级、无状态的服务。
作用域（Scoped）：在一个请求的生命周期内创建一个实例。适用于需要在单个请求内保持状态的服务。
单例（Singleton）：在应用程序的整个生命周期内只创建一个实例。适用于需要共享数据的服务。

3. 自定义扩展方法注册 Services

为了简化服务的注册过程，可以创建自定义扩展方法。通过自定义扩展方法，可以将服务的注册逻辑集中在一起，使 Startup.cs 文件更加简洁。

示例：ServiceCollectionExtensions.cs

using Microsoft.Extensions.DependencyInjection;

namespace Loquy.Services.Extensions
{
    public static class ServiceCollectionExtensions
    {
        public static IServiceCollection AddDependencyGroup(this IServiceCollection services)
        {
            services.AddScoped();
            return services;
        }
    }
}

在这个示例中，AddDependencyGroup 方法注册了一个作用域服务 IMyService 和其实现 MyService。

4. 在 Startup.cs 中注册服务

在 Startup.cs 文件的 ConfigureServices 方法中，调用我们定义的扩展方法来注册服务。

示例：Startup.cs

public void ConfigureServices(IServiceCollection services)
{
    // 注册 Services
    services.AddDependencyGroup();

    // 其他服务注册
}

通过这样的方法，我们可以将服务的注册逻辑分离到独立的扩展方法中，使得 Startup.cs 文件更加简洁。

三、中间件

在 ASP.NET Core 中，中间件是构建 Web 应用程序的核心组件之一，提供了灵活的机制来处理请求和生成响应。中间件允许您在请求到达终端处理程序之前或之后执行自定义操作，例如日志记录、身份验证、路由和错误处理等。

1. 自定义中间件

1.1. 编写基于约定的中间件

ASP.NET Core 中间件的约定如下：

公共构造函数:

中间件类应具有一个公共构造函数，该构造函数至少包含一个 RequestDelegate 类型的参数。

Invoke 或 InvokeAsync 方法:

中间件类应包含一个名为 Invoke 或 InvokeAsync 的公共方法。
该方法必须包含一个 HttpContext 类型的参数，并且必须返回一个 Task。

依赖注入（DI）支持:

构造函数的其他参数可以通过依赖注入（DI）进行填充。
Invoke 或 InvokeAsync 方法的其他参数也可以通过 DI 进行填充，可以是 Transient、Scoped 或 Singleton 类型的参数。

下面是一个示例，展示了如何编写一个基于约定的中间件：

public class CustomMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;

    // 构造函数，接收 RequestDelegate 和其他依赖项
    public CustomMiddleware(RequestDelegate next, ILogger logger)
    {
        _next = next;
        _logger = logger;
    }

    // InvokeAsync 方法
    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation("Handling request: " + context.Request.Path);
        
        // 在处理请求之前执行的逻辑
        await _next(context);
        
        // 在处理完请求之后执行的逻辑
        _logger.LogInformation("Finished handling request.");
    }
}

注册和使用基于约定的中间件

在 Program.cs 中注册并使用这个中间件：

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseMiddleware();

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello, World!");
});

app.Run();

1.2. 使用工厂模式的中间件

ASP.NET Core 还提供了一种使用工厂模式来激活中间件的方式，这种方式可以按请求创建中间件实例，提供更强的类型支持和灵活性。通过使用 IMiddleware 接口和中间件工厂，可以更好地控制中间件的生命周期和依赖项。

创建实现 IMiddleware 接口的中间件:

public class FactoryActivatedMiddleware : IMiddleware
{
    private readonly ILogger _logger;

    public FactoryActivatedMiddleware(ILogger logger)
    {
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        _logger.LogInformation("Handling request in factory activated middleware.");

        // 在处理请求之前执行的逻辑
        await next(context);

        // 在处理完请求之后执行的逻辑
        _logger.LogInformation("Finished handling request in factory activated middleware.");
    }
}

注册中间件:

在 Program.cs 中注册这个中间件：

var builder = WebApplication.CreateBuilder(args);

// 添加中间件到依赖注入容器
builder.Services.AddTransient();

var app = builder.Build();

// 使用中间件
app.UseMiddleware();

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello, World!");
});

app.Run();

通过这种方式，中间件实例可以在每个请求时创建和销毁，从而避免了单实例中间件可能带来的问题。

2. 分析中间件代码

中间件本质上是一个实现 RequestDelegate 委托的组件，接收一个 HttpContext 对象作为参数，并返回一个 Task。中间件的核心逻辑通过这个委托实现。您可以根据具体需求编写自定义中间件，以实现各种功能，如日志记录、异常处理等。

public class CustomMiddleware
{
    private readonly RequestDelegate _next;

    public CustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // 在处理请求之前执行的逻辑
        await _next(context);
        // 在处理完请求之后执行的逻辑
    }
}

3. 使用 WebApplication 创建中间件管道

您可以使用 WebApplication 类的 Use 方法来添加中间件到应用程序的请求处理管道中。中间件的顺序非常重要，它决定了它们在管道中的执行顺序。通常情况下，中间件按照它们添加到管道中的顺序依次执行。

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseMiddleware();

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello, World!");
});

app.Run();

4. 对请求管道进行短路

在 ASP.NET Core 中，当中间件决定不将请求传递给下一个中间件时，这被称为“让请求管道短路”。短路通常是必要的，因为它可以避免不必要的工作，从而提高性能。例如，静态文件中间件可以处理对静态文件的请求，并终止管道的进一步处理，成为终端中间件。

1. 为什么需要短路

性能优化：避免不必要的中间件执行。例如，静态文件中间件可以直接返回文件内容，而不需要其他中间件处理。
简化逻辑：确保特定条件下的请求得到适当处理，而无需经过所有中间件。
安全性：确保在某些情况下请求不会到达不应该处理它们的中间件。

2. 示例：静态文件中间件

以下示例展示了静态文件中间件如何短路请求管道：

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseStaticFiles(); // 静态文件中间件

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello, World!");
});

app.Run();

在这个示例中，如果请求匹配一个静态文件（例如 CSS 或图像），UseStaticFiles 中间件会处理请求并短路管道，不会调用后续的中间件。

3. 确保短路后正确处理

如果中间件决定短路请求，它应该确保响应已正确生成并发送到客户端。调用 next.Invoke 之后进行响应处理时要特别小心，因为在响应已经启动后，修改响应头或状态码会引发异常。

4. 示例：条件短路

以下示例展示了如何在自定义中间件中实现条件短路：

public class CustomMiddleware
{
    private readonly RequestDelegate _next;

    public CustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        if (ShouldShortCircuit(context))
        {
            context.Response.StatusCode = 403;
            await context.Response.WriteAsync("Forbidden");
            return; // 短路请求管道
        }

        await _next(context); // 调用下一个中间件

        // 注意：在调用 next 之后，避免修改响应头或状态码
    }

    private bool ShouldShortCircuit(HttpContext context)
    {
        // 这里可以加入实际的短路条件，例如身份验证或其他检查
        return !context.User.Identity.IsAuthenticated;
    }
}

51. 警告：避免在响应启动后调用 `next.Invoke`

在向客户端发送响应期间和之后，请勿调用 next.Invoke。响应一旦启动，更改响应头或状态码将引发异常。以下是一些可能的结果：

协议冲突：例如，写入超过 Content-Length 指定的字节数。
损坏正文格式：例如，将 HTML 页脚写入 CSS 文件中。

6. 检查响应是否已启动

HttpContext.Response.HasStarted 是一个有用的属性，它指示是否已经发送了响应头或写入了响应正文。可以在调用 next.Invoke 之前检查这个属性，确保在适当的时机执行必要的操作。

7. 示例：检查 `HasStarted`

public class CustomMiddleware
{
    private readonly RequestDelegate _next;

    public CustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // 执行一些逻辑，例如身份验证
        await _next(context);

        if (!context.Response.HasStarted)
        {
            // 在响应尚未开始时，安全地修改响应头或状态码
            context.Response.Headers.Add("X-Custom-Header", "Value");
        }
        else
        {
            // 日志记录或其他操作
            Console.WriteLine("响应已经启动，无法修改响应头");
        }
    }
}

5. 使用 Run 委托

Run 方法是 WebApplication 类中用于添加终端处理程序的方法。它接收一个 RequestDelegate 委托作为参数，表示处理请求的最终逻辑。您可以在这里编写应用程序的核心逻辑，例如返回页面或数据。

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello, World!");
});

6. 灵活的中间件调用

ASP.NET Core 中的 Use 方法有多个重载版本，其中一个重载版本允许您指定一个委托，该委托接收 HttpContext 对象和一个 RequestDelegate 委托作为参数。这使得您可以在中间件中手动调用下一个中间件，从而实现更灵活的请求处理逻辑。

app.Use(async (context, next) =>
{
    // 手动调用下一个中间件
    await next(context);
});

7. 确保中间件顺序正确

中间件的顺序在 ASP.NET Core 中非常重要，因为它决定了请求和响应在管道中的执行顺序。每个中间件都依次处理请求，并有机会对请求进行操作，然后决定是否将请求传递给下一个中间件。

如果中间件的顺序不正确，可能会导致意外的行为，例如：

无法进行适当的身份验证或授权。
无法正确处理静态文件。
缺少必要的错误处理。

例如，身份验证中间件通常需要在授权中间件之前执行，以便在授权之前正确设置 HttpContext.User。

public void Configure(IApplicationBuilder app)
{
    app.UseAuthentication(); // 必须在 UseAuthorization 之前
    app.UseAuthorization();
    app.UseStaticFiles(); // 必须在 UseRouting 之前
    app.UseRouting();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

示例：中间件顺序的重要性

以下示例展示了中间件顺序如何影响请求的处理：

日志记录中间件
身份验证中间件
自定义中间件
终端中间件

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage(); // 错误处理中间件应在管道的开头
    }
    else
    {
        app.UseExceptionHandler("/Home/Error"); // 错误处理中间件应在管道的开头
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles(); // 提供静态文件服务，应在路由中间件之前

    app.UseRouting();

    app.UseAuthentication(); // 身份验证中间件
    app.UseAuthorization(); // 授权中间件

    app.UseMiddleware(); // 自定义中间件

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers(); // 终端中间件，用于处理最终请求
    });
}

中间件执行顺序的示例

以下是一个更详细的示例，展示中间件执行顺序和请求处理的流程：

public class Startup
{
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        app.Use(async (context, next) =>
        {
            Console.WriteLine("Middleware 1: Before next()");
            await next.Invoke();
            Console.WriteLine("Middleware 1: After next()");
        });

        app.Use(async (context, next) =>
        {
            Console.WriteLine("Middleware 2: Before next()");
            await next.Invoke();
            Console.WriteLine("Middleware 2: After next()");
        });

        app.Run(async context =>
        {
            Console.WriteLine("Terminal Middleware: Handling request");
            await context.Response.WriteAsync("Hello, World!");
        });
    }
}

当您访问该应用时，控制台输出将如下所示：

Middleware 1: Before next()
Middleware 2: Before next()
Terminal Middleware: Handling request
Middleware 2: After next()
Middleware 1: After next()

这个输出展示了中间件的执行顺序。每个 Use 调用都会注册一个中间件组件，它们按照注册的顺序依次执行。

8. 对中间件管道进行分支

Map 扩展用作约定来创建管道分支。Map 基于给定请求路径的匹配项来创建请求管道分支。如果请求路径以给定路径开头，则执行分支。

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.Map("/map1", HandleMapTest1);
app.Map("/map2", HandleMapTest2);

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello from non-Map delegate.");
});

app.Run();

static void HandleMapTest1(IApplicationBuilder app)
{
    app.Run(async context =>
    {
        await context.Response.WriteAsync("Map Test 1");
    });
}

static void HandleMapTest2(IApplicationBuilder app)
{
    app.Run(async context =>
    {
        await context.Response.WriteAsync("Map Test 2");
    });
}

9. 使用 `MapWhen` 进行条件分支

MapWhen 基于给定谓词的结果创建请求管道分支。Func 类型的任何谓词均可用于将请求映射到管道的新分支。在以下示例中，谓词用于检测查询字符串变量是否存在。

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapWhen(context => context.Request.Query.ContainsKey("branch"), HandleBranch);

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello from non-Map delegate.");
});

app.Run();

static void HandleBranch(IApplicationBuilder app)
{
    app.Run(async context =>
    {
        var branchVer = context.Request.Query["branch"];
        await context.Response.WriteAsync($"Branch used = {branchVer}");
    });
}

10. 使用 `UseWhen` 进行条件分支

UseWhen 也基于给定谓词的结果创建请求管道分支。与 MapWhen 不同的是，如果这个分支不发生短路或包含终端中间件，则会重新加入主管道。例如，以下示例中，如果请求中包含查询字符串变量，会记录其值并重新加入主管道。

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseWhen(context => context.Request.Query.ContainsKey("branch"),
    appBuilder => HandleBranchAndRejoin(appBuilder));

app.Run(asynccontext =>
{
    await context.Response.WriteAsync("Hello from non-Map delegate.");
});

app.Run();

void HandleBranchAndRejoin(IApplicationBuilder app)
{
    var logger = app.ApplicationServices.GetRequiredService>(); 

    app.Use(async (context, next) =>
    {
        var branchVer = context.Request.Query["branch"];
        logger.LogInformation("Branch used = {branchVer}", branchVer);

        // Do work that doesn't write to the Response.
        await next();
        // Do other work that doesn't write to the Response.
    });
}

11. 内置中间件

ASP.NET Core 附带了许多内置中间件组件，它们提供了各种功能，例如身份验证、授权、静态文件服务等。这些中间件的顺序和特性对于应用程序的正确运行至关重要。以下是一些常用的内置中间件及其作用：

身份验证：提供身份验证支持，通常在需要访问 HttpContext.User 之前执行。
授权：提供授权支持，紧接在身份验证中间件之后执行。
静态文件：为提供静态文件和目录浏览提供支持，通常作为终端中间件，如果请求与文件匹配，则为终端。
MVC：使用 MVC/Razor Pages 处理请求，通常作为终端中间件，如果请求与路由匹配，则为终端。
开发者异常页面：生成一个页面，其中包含仅适用于开发环境的错误信息，通常在其他错误处理中间件之前执行。
运行状况检查：检查应用程序及其依赖项的运行状况，通常作为终端中间件，如果请求与运行状况检查终结点匹配，则为终端。

这些内置中间件在构建应用程序时提供了便利，但需要注意它们的顺序和条件以确保应用程序的正确运行。

四、配置

ASP.NET Core 提供了灵活且强大的配置系统，使开发者能够轻松地管理应用程序的配置设置。以下是关于 ASP.NET Core 中配置的一些关键概念和实现方法：

1. 配置源

ASP.NET Core 支持多种配置源，常见的包括：

文件：如 appsettings.json、appsettings.{Environment}.json。
环境变量：用于存储敏感数据或环境特定的配置。
命令行参数：在应用启动时传递参数。
内存中：用于在代码中直接设置配置。
用户机密：用于本地开发时存储敏感数据。
Azure Key Vault：用于在 Azure 环境中存储机密。
自定义配置源：可以实现 IConfigurationSource 接口来自定义配置源。

2. 配置文件

在 ASP.NET Core 项目中，最常见的配置文件是 appsettings.json。以下是一个示例配置文件：

{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft": "Warning",
            "Microsoft.Hosting.Lifetime": "Information"
        }
    },
    "AllowedHosts": "*",
    "ConnectionStrings": {
        "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=aspnet-CoreApp;Trusted_Connection=True;MultipleActiveResultSets=true"
    }
}

3. 配置加载顺序

ASP.NET Core 会按照以下顺序加载配置：

默认配置：应用程序的默认设置。
应用配置文件：如 appsettings.json 和 appsettings.{Environment}.json。
用户机密：仅在开发环境中加载。
环境变量：覆盖前面的配置。
命令行参数：覆盖所有前面的配置。

4. 读取配置

在 ASP.NET Core 中，通常使用 IConfiguration 接口来读取配置。以下是一个示例：

public class Startup
{
    public IConfiguration Configuration { get; }

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        // 读取配置值
        var mySetting = Configuration["MySetting"];
        var connectionString = Configuration.GetConnectionString("DefaultConnection");

        // 将配置对象注入到依赖注入容器中
        services.Configure(Configuration.GetSection("MySettings"));
    }
}

5. 强类型配置

为了更好地管理配置，可以将配置绑定到强类型对象中。以下是一个示例：

5.1 定义配置类

public class MySettings
{
    public string Setting1 { get; set; }
    public int Setting2 { get; set; }
}

5.2 绑定配置

在 Startup.cs 中绑定配置：

public void ConfigureServices(IServiceCollection services)
{
    services.Configure(Configuration.GetSection("MySettings"));
}

5.3 使用配置

通过依赖注入使用配置：

public class MyService
{
    private readonly MySettings _settings;

    public MyService(IOptions settings)
    {
        _settings = settings.Value;
    }

    public void PrintSettings()
    {
        Console.WriteLine($"Setting1: {_settings.Setting1}");
        Console.WriteLine($"Setting2: {_settings.Setting2}");
    }
}

6. 环境特定的配置

ASP.NET Core 支持环境特定的配置文件，例如 appsettings.Development.json 和 appsettings.Production.json。在启动时，根据当前环境加载相应的配置文件。

6.1 设置环境变量

在启动配置文件中设置环境变量，例如 launchSettings.json：

{
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "MyApp": {
      "commandName": "Project",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

7. 用户机密

在开发环境中，用户机密用于存储敏感信息。使用 dotnet user-secrets 命令管理机密。

7.1 启用用户机密

在项目文件（.csproj）中添加用户机密支持：

1
2
3

<PropertyGroup>
  <UserSecretsId>aspnet-CoreApp-123456UserSecretsId>
PropertyGroup>

7.2 添加用户机密

使用命令行工具添加用户机密：

1	`dotnet user-secrets set "MySecret" "secret_value"`

7.3 读取用户机密

在应用程序中读取用户机密：

public void ConfigureServices(IServiceCollection services)
{
    var mySecret = Configuration["MySecret"];
}

8. 自定义配置源

如果内置的配置源不能满足需求，可以实现自定义配置源。需要实现 IConfigurationSource 和 IConfigurationProvider 接口。

8.1 实现自定义配置提供程序

public class CustomConfigurationProvider : ConfigurationProvider
{
    public override void Load()
    {
        // 加载配置数据
        Data = new Dictionary<string, string>
        {
            { "CustomSetting:Setting1", "Value1" },
            { "CustomSetting:Setting2", "Value2" }
        };
    }
}

8.2 实现自定义配置源

public class CustomConfigurationSource : IConfigurationSource
{
    public IConfigurationProvider Build(IConfigurationBuilder builder)
    {
        return new CustomConfigurationProvider();
    }
}

8.3 注册自定义配置源

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public IConfiguration Configuration { get; }

    public void ConfigureServices(IServiceCollection services)
    {
        var builder = new ConfigurationBuilder();
        builder.Add(new CustomConfigurationSource());
        var configuration = builder.Build();

        var customSetting1 = configuration["CustomSetting:Setting1"];
    }
}

通过以上方法，开发者可以灵活地配置和管理 ASP.NET Core 应用程序的设置，确保应用程序能够根据不同的环境和需求进行正确的配置。

五、日志

在 ASP.NET Core 中，日志记录是一项重要的任务，它能够帮助开发人员在应用程序中追踪、调试和监控事件。本文将介绍 ASP.NET Core 内置的日志记录功能，以及如何安装、配置和使用第三方日志记录提供程序 NLog。

1. 内置日志记录提供程序

1.1 创建日志

在 ASP.NET Core 中，可以通过内置的 ILogger 接口创建日志记录器。例如：

private readonly ILogger _logger;

public MyController(ILogger logger)
{
    _logger = logger;
}

1.2 配置日志记录

ASP.NET Core 提供了灵活的日志记录配置选项，可以在 appsettings.json 文件中进行配置：

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  }
}

1.3 日志级别

ASP.NET Core 内置了多个日志级别，包括 Trace、Debug、Information、Warning、Error 和 Critical。每个级别用于不同类型的日志消息，具体如下表所示：

LogLevel	值	方法	说明
Trace	0	LogTrace	包含最详细的消息。
Debug	1	LogDebug	用于调试和开发。
Information	2	LogInformation	跟踪应用的常规流。
Warning	3	LogWarning	对于异常事件或意外事件。
Error	4	LogError	表示无法处理的错误和异常。
Critical	5	LogCritical	需要立即关注的失败。

1.4 日志消息模板

每个日志消息都使用消息模板，可以包含要填充的参数占位符。例如：

1	`_logger.LogInformation("Getting item {Id}", id);`

1.5 记录异常

记录异常时，可以将异常对象传递给日志记录器方法的重载版本：

try
{
    // Some code that may throw an exception
}
catch (Exception ex)
{
    _logger.LogError(ex, "An error occurred");
}

1.6 默认日志级别

如果未在配置中设置默认日志级别，则默认的日志级别为 Information。可以通过以下方式设置默认日志级别：

1 2	`var builder = WebApplication.CreateBuilder(); builder.Logging.SetMinimumLevel(LogLevel.Warning);`

通常，建议在配置文件中指定日志级别，而不是在代码中指定。

2. 第三方日志记录提供程序之 NLog

2.1. 安装

要使用 NLog 作为日志记录提供程序，首先需要安装 NLog 包：

1	`dotnet add package NLog.Web.AspNetCore`

2.2. 创建 `nlog.config` 文件：

"1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      autoReload="true"
      internalLogLevel="Info"
      internalLogFile="c:\temp\internal-nlog-AspNetCore.txt">

  
  <extensions>
    <add assembly="NLog.Web.AspNetCore"/>
  extensions>

  
  <targets>
    
    <target xsi:type="File" name="allfile" fileName="c:\temp\nlog-AspNetCore-all-${shortdate}.log"
            layout="${longdate}|${event-properties:item=EventId:whenEmpty=0}|${level:uppercase=true}|${logger}|${message} ${exception:format=tostring}" />

    
    <target xsi:type="File" name="ownFile-web" fileName="c:\temp\nlog-AspNetCore-own-${shortdate}.log"
            layout="${longdate}|${event-properties:item=EventId:whenEmpty=0}|${level:uppercase=true}|${logger}|${message} ${exception:format=tostring}|url: ${aspnet-request-url}|action: ${aspnet-mvc-action}" />

    
    <target xsi:type="Console" name="lifetimeConsole" layout="${MicrosoftConsoleLayout}" />
  targets>

  
  <rules>
    
    <logger name="*" minlevel="Trace" writeTo="allfile" />

    
    <logger name="Microsoft.Hosting.Lifetime" minlevel="Info" writeTo="lifetimeConsole, ownFile-web" final="true" />

    
    <logger name="Microsoft.*" maxlevel="Info" final="true" />
    <logger name="System.Net.Http.*" maxlevel="Info" final="true" />
    
    <logger name="*" minlevel="Trace" writeTo="ownFile-web" />
  rules>
nlog>

归档策略


<targets>


<target xsi:type="File" name="ownFile-web" fileName="${basedir}/logs/APP-${shortdate}.log"
layout="${longdate}|${event-properties:item=EventId:whenEmpty=0}|${level:uppercase=true}|${logger}|${message} ${exception:format=tostring}|url: ${aspnet-request-url}|action: ${aspnet-mvc-action}" 
archiveFileName="${basedir}/logs/archives/log.${shortdate}.{#}.log"
archiveAboveSize="10485760"
archiveEvery="Day"
archiveNumbering="Rolling"
maxArchiveFiles="300" />
targets>

2.3. 更新 `program.cs`

using NLog;
using NLog.Web;

// 提前初始化 NLog，以便在构建主机之前进行启动和异常记录
var logger = NLog.LogManager.Setup().LoadConfigurationFromAppSettings().GetCurrentClassLogger();
logger.Debug("初始化主程序");

try
{
    var builder = WebApplication.CreateBuilder(args);

    // 将服务添加到容器中。
    builder.Services.AddControllersWithViews();

    // NLog：设置 NLog 以进行依赖项注入
    builder.Logging.ClearProviders();
    builder.Host.UseNLog();

    var app = builder.Build();

    // 配置 HTTP 请求管道。
    if (!app.Environment.IsDevelopment())
    {
        app.UseExceptionHandler("/Home/Error");
        // 默认的 HSTS 值为 30 天。您可能希望针对生产环境更改此值，请参阅 https://aka.ms/aspnetcore-hsts。
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();

    app.UseRouting();

    app.UseAuthorization();

    app.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id?}");

    app.Run();
}
catch (Exception exception)
{
    // NLog：捕获设置错误
    logger.Error(exception, "由于异常停止程序");
    throw;
}
finally
{
    // 确保在应用程序退出之前刷新和停止内部计时器/线程（避免 Linux 上的分段错误）
    NLog.LogManager.Shutdown();
}

2.4. Microsoft 日志记录过滤器

使用 NLog 5.0 时，默认情况下 appsettings.json 会忽略 Microsoft 日志记录筛选器。只需确保正确配置 NLog 配置规则即可。

<rules>
    <logger name="System.*" finalMinLevel="Warn" />
    <logger name="Microsoft.*" finalMinLevel="Warn" />
    <logger name="Microsoft.Hosting.Lifetime*" finalMinLevel="Info" />
    <logger name="*" minlevel="Trace" writeTo="ownFile-web" />
rules>

如果指定 RemoveLoggerFactoryFilter = false 了 NLog 日志记录提供程序选项，则它将使用 appsettings.json 中指定的筛选器。请注意，也可以在 appsettings.json 中指定 NLog 配置。

{
  "Logging": {
    "LogLevel": {
      "Default": "Trace",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}

2.5. 使用

在 ASP.NET Core 中，NLog 作为第三方日志记录提供程序，使用起来非常简单。只需按照上述配置步骤进行配置，然后就可以在代码中直接使用 ILogger 接口来记录日志，NLog 将自动将日志消息路由到相应的目的地。

using Microsoft.Extensions.Logging;

public class HomeController : Controller
{
    private readonly ILogger _logger;

    public HomeController(ILogger logger)
    {
        _logger = logger;
        _logger.LogDebug(1, "NLog injected into HomeController");
    }

    public IActionResult Index()
    {
        _logger.LogInformation("Hello, this is the index!");
        return View();
    }
}

2.6. 示例输出

启动 ASP.NET Core 网站时，我们得到两个文件：

nlog-own-2024-05-29.log

2024-05-29 18:35:23.9930|14|INFO|Microsoft.Hosting.Lifetime|Now listening on: https://localhost:7125 |url: |action: |Microsoft.AspNetCore.Hosting.GenericWebHostService.StartAsync
2024-05-29 18:35:23.9930|14|INFO|Microsoft.Hosting.Lifetime|Now listening on: http://localhost:5125 |url: |action: |Microsoft.AspNetCore.Hosting.GenericWebHostService.StartAsync
2024-05-29 18:35:24.0084|0|INFO|Microsoft.Hosting.Lifetime|Application started. Press Ctrl+C to shut down. |url: |action: |Microsoft.Extensions.Hosting.Internal.ConsoleLifetime.OnApplicationStarted
2024-05-29 18:35:24.0084|0|INFO|Microsoft.Hosting.Lifetime|Hosting environment: Development |url: |action: |Microsoft.Extensions.Hosting.Internal.ConsoleLifetime.OnApplicationStarted
2024-05-29 18:35:24.0084|0|INFO|Microsoft.Hosting.Lifetime|Content root path: C:\Users\snakefoot\source\repos\NLog.Web\examples\ASP.NET Core 6\ASP.NET Core 6 NLog Example\ |url: |action: |Microsoft.Extensions.Hosting.Internal.ConsoleLifetime.OnApplicationStarted
2024-05-29 18:35:25.6656|1|DEBUG|ASP.NetCore6_NLog_Web_Example.Controllers.HomeController|NLog injected into HomeController |url: https://localhost/|action: Index|ASP.NetCore6_NLog_Web_Example.Controllers.HomeController..ctor
2024-05-29 18:35:25.6656|0|INFO|ASP.NetCore6_NLog_Web_Example.Controllers.HomeController|Hello, this is the index! |url: https://localhost/|action: Index|ASP.NetCore6_NLog_Web_Example.Controllers.HomeController.Index

nlog-all-2024-05-29.log

2024-05-29 18:35:15.1343|6|DEBUG|Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets|Connection id "0HMK16TVPK9JQ" received FIN. 
2024-05-29 18:35:15.1694|48|DEBUG|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16TVPK9JQ" is closed. The last processed stream ID was 29. 
2024-05-29 18:35:15.1694|7|DEBUG|Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets|Connection id "0HMK16TVPK9JQ" sending FIN because: "The client closed the connection." 
2024-05-29 18:35:15.1805|2|DEBUG|Microsoft.AspNetCore.Server.Kestrel.Connections|Connection id "0HMK16TVPK9JQ" stopped. 
2024-05-29 18:35:23.6686|3|DEBUG|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Initializing Razor view compiler with compiled view: '/Views/Home/Index.cshtml'. 
2024-05-29 18:35:23.7133|3|DEBUG|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Initializing Razor view compiler with compiled view: '/Views/Home/Privacy.cshtml'. 
2024-05-29 18:35:23.7133|3|DEBUG|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Initializing Razor view compiler with compiled view: '/Views/Shared/Error.cshtml'. 
2024-05-29 18:35:23.7133|3|DEBUG|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Initializing Razor view compiler with compiled view: '/Views/Shared/_ValidationScriptsPartial.cshtml'. 
2024-05-29 18:35:23.7133|3|DEBUG|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Initializing Razor view compiler with compiled view: '/Views/_ViewImports.cshtml'. 
2024-05-29 18:35:23.7133|3|DEBUG|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Initializing Razor view compiler with compiled view: '/Views/_ViewStart.cshtml'. 
2024-05-29 18:35:23.7133|3|DEBUG|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Initializing Razor view compiler with compiled view: '/Views/Shared/_Layout.cshtml'. 
2024-05-29 18:35:23.7133|12|DEBUG|Microsoft.AspNetCore.Mvc.ModelBinding.ModelBinderFactory|Registered model binder providers, in the following order: Microsoft.AspNetCore.Mvc.ModelBinding.Binders.BinderTypeModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.ServicesModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.BodyModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.HeaderModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.FloatingPointTypeModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.EnumTypeModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.DateTimeModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.SimpleTypeModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.CancellationTokenModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.ByteArrayModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.FormFileModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.FormCollectionModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.KeyValuePairModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.DictionaryModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.ArrayModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.CollectionModelBinderProvider, Microsoft.AspNetCore.Mvc.ModelBinding.Binders.ComplexObjectModelBinderProvider 
2024-05-29 18:35:23.7746|1|DEBUG|Microsoft.Extensions.Hosting.Internal.Host|Hosting starting 
2024-05-29 18:35:23.8067|63|INFO|Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager|User profile is available. Using 'C:\Users\XXX\AppData\Local\ASP.NET\DataProtection-Keys' as key repository and Windows DPAPI to encrypt keys at rest. 
2024-05-29 18:35:23.8067|37|DEBUG|Microsoft.AspNetCore.DataProtection.Repositories.FileSystemXmlRepository|Reading data from file 'C:\Users\XXX\AppData\Local\ASP.NET\DataProtection-Keys\key-237c4f12-6703-4dd8-8e04-b904f77128d3.xml'. 
2024-05-29 18:35:23.8067|37|DEBUG|Microsoft.AspNetCore.DataProtection.Repositories.FileSystemXmlRepository|Reading data from file 'C:\Users\XXX\AppData\Local\ASP.NET\DataProtection-Keys\key-6c9a4248-29ef-409e-9349-fe5e287b835d.xml'. 
2024-05-29 18:35:23.8067|37|DEBUG|Microsoft.AspNetCore.DataProtection.Repositories.FileSystemXmlRepository|Reading data from file 'C:\Users\XXX\AppData\Local\ASP.NET\DataProtection-Keys\key-750f4bc0-7cc0-4ad8-809a-39972a95298d.xml'. 
2024-05-29 18:35:23.8067|37|DEBUG|Microsoft.AspNetCore.DataProtection.Repositories.FileSystemXmlRepository|Reading data from file 'C:\Users\XXX\AppData\Local\ASP.NET\DataProtection-Keys\key-dab65855-4eb4-4890-a09b-93b48ace1718.xml'. 
2024-05-29 18:35:23.8067|18|DEBUG|Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager|Found key {237c4f12-6703-4dd8-8e04-b904f77128d3}. 
2024-05-29 18:35:23.8067|18|DEBUG|Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager|Found key {6c9a4248-29ef-409e-9349-fe5e287b835d}. 
2024-05-29 18:35:23.8067|18|DEBUG|Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager|Found key {750f4bc0-7cc0-4ad8-809a-39972a95298d}. 
2024-05-29 18:35:23.8067|18|DEBUG|Microsoft.AspNetCore.DataProtection.KeyManagement.XmlKeyManager|Found key {dab65855-4eb4-4890-a09b-93b48ace1718}. 
2024-05-29 18:35:23.8272|13|DEBUG|Microsoft.AspNetCore.DataProtection.KeyManagement.DefaultKeyResolver|Considering key {dab65855-4eb4-4890-a09b-93b48ace1718} with expiration date 2022-11-16 16:27:50Z as default key. 
2024-05-29 18:35:23.8272|0|DEBUG|Microsoft.AspNetCore.DataProtection.TypeForwardingActivator|Forwarded activator type request from Microsoft.AspNetCore.DataProtection.XmlEncryption.DpapiXmlDecryptor, Microsoft.AspNetCore.DataProtection, Version=6.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60 to Microsoft.AspNetCore.DataProtection.XmlEncryption.DpapiXmlDecryptor, Microsoft.AspNetCore.DataProtection, Culture=neutral, PublicKeyToken=adb9793829ddae60 
2024-05-29 18:35:23.8272|51|DEBUG|Microsoft.AspNetCore.DataProtection.XmlEncryption.DpapiXmlDecryptor|Decrypting secret element using Windows DPAPI. 
2024-05-29 18:35:23.8272|0|DEBUG|Microsoft.AspNetCore.DataProtection.TypeForwardingActivator|Forwarded activator type request from Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.AuthenticatedEncryptorDescriptorDeserializer, Microsoft.AspNetCore.DataProtection, Version=6.0.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60 to Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.ConfigurationModel.AuthenticatedEncryptorDescriptorDeserializer, Microsoft.AspNetCore.DataProtection, Culture=neutral, PublicKeyToken=adb9793829ddae60 
2024-05-29 18:35:23.8367|4|DEBUG|Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.CngCbcAuthenticatedEncryptorFactory|Opening CNG algorithm 'AES' from provider '(null)' with chaining mode CBC. 
2024-05-29 18:35:23.8367|3|DEBUG|Microsoft.AspNetCore.DataProtection.AuthenticatedEncryption.CngCbcAuthenticatedEncryptorFactory|Opening CNG algorithm 'SHA256' from provider '(null)' with HMAC. 
2024-05-29 18:35:23.8367|2|DEBUG|Microsoft.AspNetCore.DataProtection.KeyManagement.KeyRingProvider|Using key {dab65855-4eb4-4890-a09b-93b48ace1718} as the default key. 
2024-05-29 18:35:23.8367|65|DEBUG|Microsoft.AspNetCore.DataProtection.Internal.DataProtectionHostedService|Key ring with default key {dab65855-4eb4-4890-a09b-93b48ace1718} was loaded during application startup. 
2024-05-29 18:35:23.9534|0|DEBUG|Microsoft.AspNetCore.Server.Kestrel.Core.KestrelServer|Using development certificate: CN=localhost (Thumbprint: 3271A3360CD4E4DC9058F84E9FB3A1E651D0F7C9) 
2024-05-29 18:35:23.9930|14|INFO|Microsoft.Hosting.Lifetime|Now listening on: https://localhost:7125 
2024-05-29 18:35:23.9930|14|INFO|Microsoft.Hosting.Lifetime|Now listening on: http://localhost:5125 
2024-05-29 18:35:24.0084|13|DEBUG|Microsoft.AspNetCore.Hosting.Diagnostics|Loaded hosting startup assembly ASP.NetCore6_NLog_Web_Example 
2024-05-29 18:35:24.0084|13|DEBUG|Microsoft.AspNetCore.Hosting.Diagnostics|Loaded hosting startup assembly Microsoft.AspNetCore.Watch.BrowserRefresh 
2024-05-29 18:35:24.0084|13|DEBUG|Microsoft.AspNetCore.Hosting.Diagnostics|Loaded hosting startup assembly Microsoft.WebTools.BrowserLink.Net 
2024-05-29 18:35:24.0084|0|INFO|Microsoft.Hosting.Lifetime|Application started. Press Ctrl+C to shut down. 
2024-05-29 18:35:24.0084|0|INFO|Microsoft.Hosting.Lifetime|Hosting environment: Development 
2024-05-29 18:35:24.0084|0|INFO|Microsoft.Hosting.Lifetime|Content root path: C:\Users\XXX\source\repos\NLog.Web\examples\ASP.NET Core 6\ASP.NET Core 6 NLog Example\ 
2024-05-29 18:35:24.0084|2|DEBUG|Microsoft.Extensions.Hosting.Internal.Host|Hosting started 
2024-05-29 18:35:24.4292|39|DEBUG|Microsoft.AspNetCore.Server.Kestrel.Connections|Connection id "0HMK16UJ982TR" accepted. 
2024-05-29 18:35:24.4292|39|DEBUG|Microsoft.AspNetCore.Server.Kestrel.Connections|Connection id "0HMK16UJ982TQ" accepted. 
2024-05-29 18:35:24.4306|1|DEBUG|Microsoft.AspNetCore.Server.Kestrel.Connections|Connection id "0HMK16UJ982TQ" started. 
2024-05-29 18:35:24.4306|1|DEBUG|Microsoft.AspNetCore.Server.Kestrel.Connections|Connection id "0HMK16UJ982TR" started. 
2024-05-29 18:35:24.4533|6|DEBUG|Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets|Connection id "0HMK16UJ982TQ" received FIN. 
2024-05-29 18:35:24.4533|6|DEBUG|Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets|Connection id "0HMK16UJ982TR" received FIN. 
2024-05-29 18:35:25.5421|1|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request starting HTTP/2 GET https://localhost:7125/ - - 
2024-05-29 18:35:25.5892|0|DEBUG|Microsoft.AspNetCore.HostFiltering.HostFilteringMiddleware|Wildcard detected, all requests with hosts will be allowed. 
2024-05-29 18:35:25.5892|2|TRACE|Microsoft.AspNetCore.HostFiltering.HostFilteringMiddleware|All hosts are allowed. 
2024-05-29 18:35:25.5892|4|DEBUG|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|The request path / does not match a supported file type 
2024-05-29 18:35:25.6168|1001|DEBUG|Microsoft.AspNetCore.Routing.Matching.DfaMatcher|1 candidate(s) found for the request path '/' 
2024-05-29 18:35:25.6198|1005|DEBUG|Microsoft.AspNetCore.Routing.Matching.DfaMatcher|Endpoint 'ASP.NetCore6_NLog_Web_Example.Controllers.HomeController.Index (ASP.NetCore6_NLog_Web_Example)' with route pattern '{controller=Home}/{action=Index}/{id?}' is valid for the request path '/' 
2024-05-29 18:35:25.6198|1|DEBUG|Microsoft.AspNetCore.Routing.EndpointRoutingMiddleware|Request matched endpoint 'ASP.NetCore6_NLog_Web_Example.Controllers.HomeController.Index (ASP.NetCore6_NLog_Web_Example)' 
2024-05-29 18:35:25.6198|0|INFO|Microsoft.AspNetCore.Routing.EndpointMiddleware|Executing endpoint 'ASP.NetCore6_NLog_Web_Example.Controllers.HomeController.Index (ASP.NetCore6_NLog_Web_Example)' 
2024-05-29 18:35:25.6595|3|INFO|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Route matched with {action = "Index", controller = "Home"}. Executing controller action with signature Microsoft.AspNetCore.Mvc.IActionResult Index() on controller ASP.NetCore6_NLog_Web_Example.Controllers.HomeController (ASP.NetCore6_NLog_Web_Example). 
2024-05-29 18:35:25.6595|1|DEBUG|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Execution plan of authorization filters (in the following order): None 
2024-05-29 18:35:25.6595|1|DEBUG|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Execution plan of resource filters (in the following order): Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter 
2024-05-29 18:35:25.6595|1|DEBUG|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Execution plan of action filters (in the following order): Microsoft.AspNetCore.Mvc.Filters.ControllerActionFilter (Order: -2147483648), Microsoft.AspNetCore.Mvc.ModelBinding.UnsupportedContentTypeFilter (Order: -3000) 
2024-05-29 18:35:25.6595|1|DEBUG|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Execution plan of exception filters (in the following order): None 
2024-05-29 18:35:25.6595|1|DEBUG|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Execution plan of result filters (in the following order): Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter 
2024-05-29 18:35:25.6656|2|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Resource Filter: Before executing OnResourceExecuting on filter Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter. 
2024-05-29 18:35:25.6656|3|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Resource Filter: After executing OnResourceExecuting on filter Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter. 
2024-05-29 18:35:25.6656|1|DEBUG|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Executing controller factory for controller ASP.NetCore6_NLog_Web_Example.Controllers.HomeController (ASP.NetCore6_NLog_Web_Example) 
2024-05-29 18:35:25.6656|1|DEBUG|ASP.NetCore6_NLog_Web_Example.Controllers.HomeController|NLog injected into HomeController 
2024-05-29 18:35:25.6656|2|DEBUG|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Executed controller factory for controller ASP.NetCore6_NLog_Web_Example.Controllers.HomeController (ASP.NetCore6_NLog_Web_Example) 
2024-05-29 18:35:25.6656|2|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Action Filter: Before executing OnActionExecutionAsync on filter Microsoft.AspNetCore.Mvc.Filters.ControllerActionFilter. 
2024-05-29 18:35:25.6656|2|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Action Filter: Before executing OnActionExecuting on filter Microsoft.AspNetCore.Mvc.ModelBinding.UnsupportedContentTypeFilter. 
2024-05-29 18:35:25.6656|3|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Action Filter: After executing OnActionExecuting on filter Microsoft.AspNetCore.Mvc.ModelBinding.UnsupportedContentTypeFilter. 
2024-05-29 18:35:25.6656|1|INFO|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Executing action method ASP.NetCore6_NLog_Web_Example.Controllers.HomeController.Index (ASP.NetCore6_NLog_Web_Example) - Validation state: Valid 
2024-05-29 18:35:25.6656|0|INFO|ASP.NetCore6_NLog_Web_Example.Controllers.HomeController|Hello, this is the index! 
2024-05-29 18:35:25.6831|2|INFO|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Executed action method ASP.NetCore6_NLog_Web_Example.Controllers.HomeController.Index (ASP.NetCore6_NLog_Web_Example), returned result Microsoft.AspNetCore.Mvc.ViewResult in 2.7721ms. 
2024-05-29 18:35:25.6831|2|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Action Filter: Before executing OnActionExecuted on filter Microsoft.AspNetCore.Mvc.ModelBinding.UnsupportedContentTypeFilter. 
2024-05-29 18:35:25.6831|3|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Action Filter: After executing OnActionExecuted on filter Microsoft.AspNetCore.Mvc.ModelBinding.UnsupportedContentTypeFilter. 
2024-05-29 18:35:25.6831|3|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Action Filter: After executing OnActionExecutionAsync on filter Microsoft.AspNetCore.Mvc.Filters.ControllerActionFilter. 
2024-05-29 18:35:25.6831|2|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Result Filter: Before executing OnResultExecuting on filter Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter. 
2024-05-29 18:35:25.6831|3|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Result Filter: After executing OnResultExecuting on filter Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter. 
2024-05-29 18:35:25.6831|4|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Before executing action result Microsoft.AspNetCore.Mvc.ViewResult. 
2024-05-29 18:35:25.6831|1|DEBUG|Microsoft.AspNetCore.Mvc.Razor.RazorViewEngine|View lookup cache miss for view 'Index' in controller 'Home'. 
2024-05-29 18:35:25.6831|5|TRACE|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Located compiled view for view at path '/Views/Home/Index.cshtml'. 
2024-05-29 18:35:25.6831|7|TRACE|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Could not find a file for view at path '/Views/Home/_ViewStart.cshtml'. 
2024-05-29 18:35:25.6831|5|TRACE|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Located compiled view for view at path '/Views/_ViewStart.cshtml'. 
2024-05-29 18:35:25.6831|7|TRACE|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Could not find a file for view at path '/_ViewStart.cshtml'. 
2024-05-29 18:35:25.6960|1|INFO|Microsoft.AspNetCore.Mvc.ViewFeatures.ViewResultExecutor|Executing ViewResult, running view Index. 
2024-05-29 18:35:25.6960|2|DEBUG|Microsoft.AspNetCore.Mvc.ViewFeatures.ViewResultExecutor|The view path '/Views/Home/Index.cshtml' was found in 9.3119ms. 
2024-05-29 18:35:25.7393|1|DEBUG|Microsoft.AspNetCore.Mvc.Razor.RazorViewEngine|View lookup cache miss for view '_Layout' in controller 'Home'. 
2024-05-29 18:35:25.7393|7|TRACE|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Could not find a file for view at path '/Views/Home/_Layout.cshtml'. 
2024-05-29 18:35:25.7393|5|TRACE|Microsoft.AspNetCore.Mvc.Razor.Compilation.DefaultViewCompiler|Located compiled view for view at path '/Views/Shared/_Layout.cshtml'. 
2024-05-29 18:35:25.7816|100|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Found the endpoints Route: {controller=Home}/{action=Index}/{id?} for address Microsoft.AspNetCore.Routing.RouteValuesAddress 
2024-05-29 18:35:25.7899|102|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Successfully processed template {controller=Home}/{action=Index}/{id?} for Route: {controller=Home}/{action=Index}/{id?} resulting in  and  
2024-05-29 18:35:25.7899|105|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Link generation succeeded for endpoints Route: {controller=Home}/{action=Index}/{id?} with result / 
2024-05-29 18:35:25.7899|100|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Found the endpoints Route: {controller=Home}/{action=Index}/{id?} for address Microsoft.AspNetCore.Routing.RouteValuesAddress 
2024-05-29 18:35:25.7899|102|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Successfully processed template {controller=Home}/{action=Index}/{id?} for Route: {controller=Home}/{action=Index}/{id?} resulting in  and  
2024-05-29 18:35:25.7899|105|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Link generation succeeded for endpoints Route: {controller=Home}/{action=Index}/{id?} with result / 
2024-05-29 18:35:25.7899|100|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Found the endpoints Route: {controller=Home}/{action=Index}/{id?} for address Microsoft.AspNetCore.Routing.RouteValuesAddress 
2024-05-29 18:35:25.7899|102|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Successfully processed template {controller=Home}/{action=Index}/{id?} for Route: {controller=Home}/{action=Index}/{id?} resulting in /Home/Privacy and  
2024-05-29 18:35:25.7899|105|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Link generation succeeded for endpoints Route: {controller=Home}/{action=Index}/{id?} with result /Home/Privacy 
2024-05-29 18:35:25.7899|100|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Found the endpoints Route: {controller=Home}/{action=Index}/{id?} for address Microsoft.AspNetCore.Routing.RouteValuesAddress 
2024-05-29 18:35:25.7899|102|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Successfully processed template {controller=Home}/{action=Index}/{id?} for Route: {controller=Home}/{action=Index}/{id?} resulting in /Home/Privacy and  
2024-05-29 18:35:25.7899|105|DEBUG|Microsoft.AspNetCore.Routing.DefaultLinkGenerator|Link generation succeeded for endpoints Route: {controller=Home}/{action=Index}/{id?} with result /Home/Privacy 
2024-05-29 18:35:25.9178|4|INFO|Microsoft.AspNetCore.Mvc.ViewFeatures.ViewResultExecutor|Executed ViewResult - view Index executed in 231.1047ms. 
2024-05-29 18:35:25.9178|5|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|After executing action result Microsoft.AspNetCore.Mvc.ViewResult. 
2024-05-29 18:35:25.9178|2|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Result Filter: Before executing OnResultExecuted on filter Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter. 
2024-05-29 18:35:25.9178|3|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Result Filter: After executing OnResultExecuted on filter Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter. 
2024-05-29 18:35:25.9178|2|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Resource Filter: Before executing OnResourceExecuted on filter Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter. 
2024-05-29 18:35:25.9178|3|TRACE|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Resource Filter: After executing OnResourceExecuted on filter Microsoft.AspNetCore.Mvc.ViewFeatures.Filters.SaveTempDataFilter. 
2024-05-29 18:35:25.9178|2|INFO|Microsoft.AspNetCore.Mvc.Infrastructure.ControllerActionInvoker|Executed action ASP.NetCore6_NLog_Web_Example.Controllers.HomeController.Index (ASP.NetCore6_NLog_Web_Example) in 261.5085ms 
2024-05-29 18:35:25.9178|1|INFO|Microsoft.AspNetCore.Routing.EndpointMiddleware|Executed endpoint 'ASP.NetCore6_NLog_Web_Example.Controllers.HomeController.Index (ASP.NetCore6_NLog_Web_Example)' 
2024-05-29 18:35:25.9417|1|DEBUG|Microsoft.AspNetCore.Watch.BrowserRefresh.BrowserRefreshMiddleware|Response markup is scheduled to include browser refresh script injection. 
2024-05-29 18:35:25.9571|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending HEADERS frame for stream ID 1 with length 67 and flags END_HEADERS. 
2024-05-29 18:35:25.9571|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 1 with length 1024 and flags NONE. 
2024-05-29 18:35:25.9571|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 1 with length 1024 and flags NONE. 
2024-05-29 18:35:25.9571|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 1 with length 917 and flags NONE. 
2024-05-29 18:35:25.9571|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 1 with length 65 and flags NONE. 
2024-05-29 18:35:25.9571|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 1 with length 18 and flags NONE. 
2024-05-29 18:35:25.9749|2|DEBUG|Microsoft.AspNetCore.Watch.BrowserRefresh.BrowserRefreshMiddleware|Response markup was updated to include browser refresh script injection. 
2024-05-29 18:35:25.9834|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 1 with length 0 and flags END_STREAM. 
2024-05-29 18:35:25.9962|2|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request finished HTTP/2 GET https://localhost:7125/ - - - 200 - text/html;+charset=utf-8 456.1640ms 
2024-05-29 18:35:26.0191|37|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" received HEADERS frame for stream ID 3 with length 106 and flags END_STREAM, END_HEADERS, PRIORITY. 
2024-05-29 18:35:26.0257|37|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" received HEADERS frame for stream ID 5 with length 67 and flags END_STREAM, END_HEADERS, PRIORITY. 
2024-05-29 18:35:26.0257|37|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" received HEADERS frame for stream ID 7 with length 91 and flags END_STREAM, END_HEADERS, PRIORITY. 
2024-05-29 18:35:26.0257|1|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request starting HTTP/2 GET https://localhost:7125/css/site.css?v=AKvNjO3dCPPS0eSU1Ez8T2wI280i08yGycV9ndytL-c - - 
2024-05-29 18:35:26.0257|1|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request starting HTTP/2 GET https://localhost:7125/lib/bootstrap/dist/css/bootstrap.min.css - - 
2024-05-29 18:35:26.0257|2|TRACE|Microsoft.AspNetCore.HostFiltering.HostFilteringMiddleware|All hosts are allowed. 
2024-05-29 18:35:26.0257|2|TRACE|Microsoft.AspNetCore.HostFiltering.HostFilteringMiddleware|All hosts are allowed. 
2024-05-29 18:35:26.0257|37|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" received HEADERS frame for stream ID 9 with length 55 and flags END_STREAM, END_HEADERS, PRIORITY. 
2024-05-29 18:35:26.0257|37|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" received HEADERS frame for stream ID 11 with length 55 and flags END_STREAM, END_HEADERS, PRIORITY. 
2024-05-29 18:35:26.0257|37|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" received HEADERS frame for stream ID 13 with length 67 and flags END_STREAM, END_HEADERS, PRIORITY. 
2024-05-29 18:35:26.0257|37|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" received HEADERS frame for stream ID 15 with length 52 and flags END_STREAM, END_HEADERS, PRIORITY. 
2024-05-29 18:35:26.0257|37|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" received HEADERS frame for stream ID 17 with length 34 and flags END_STREAM, END_HEADERS, PRIORITY. 
2024-05-29 18:35:26.0257|1|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request starting HTTP/2 GET https://localhost:7125/ASP.NetCore6_NLog_Web_Example.styles.css?v=RE8iCRyLdOMjrQXlLNeo4W3xw0k_zNKqvYCiPxC_9nE - - 
2024-05-29 18:35:26.0257|2|TRACE|Microsoft.AspNetCore.HostFiltering.HostFilteringMiddleware|All hosts are allowed. 
2024-05-29 18:35:26.0416|1|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request starting HTTP/2 GET https://localhost:7125/lib/jquery/dist/jquery.min.js - - 
2024-05-29 18:35:26.0416|2|TRACE|Microsoft.AspNetCore.HostFiltering.HostFilteringMiddleware|All hosts are allowed. 
2024-05-29 18:35:26.0416|0|TRACE|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Range header's value is empty. 
2024-05-29 18:35:26.0416|0|TRACE|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Range header's value is empty. 
2024-05-29 18:35:26.0416|1|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request starting HTTP/2 GET https://localhost:7125/lib/bootstrap/dist/js/bootstrap.bundle.min.js - - 
2024-05-29 18:35:26.0416|2|TRACE|Microsoft.AspNetCore.HostFiltering.HostFilteringMiddleware|All hosts are allowed. 
2024-05-29 18:35:26.0416|0|TRACE|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Range header's value is empty. 
2024-05-29 18:35:26.0416|0|TRACE|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Range header's value is empty. 
2024-05-29 18:35:26.0416|0|TRACE|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Range header's value is empty. 
2024-05-29 18:35:26.0416|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending HEADERS frame for stream ID 7 with length 77 and flags END_HEADERS. 
2024-05-29 18:35:26.0416|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 7 with length 1146 and flags NONE. 
2024-05-29 18:35:26.0416|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending HEADERS frame for stream ID 9 with length 86 and flags END_HEADERS. 
2024-05-29 18:35:26.0416|2|INFO|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Sending file. Request path: '/ASP.NetCore6_NLog_Web_Example.styles.css'. Physical path: 'C:\Users\XXX\source\repos\NLog.Web\examples\ASP.NET Core 6\ASP.NET Core 6 NLog Example\obj\Debug\net6.0\scopedcss\bundle\ASP.NetCore6_NLog_Web_Example.styles.css' 
2024-05-29 18:35:26.0416|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 7 with length 0 and flags END_STREAM. 
2024-05-29 18:35:26.0416|2|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request finished HTTP/2 GET https://localhost:7125/ASP.NetCore6_NLog_Web_Example.styles.css?v=RE8iCRyLdOMjrQXlLNeo4W3xw0k_zNKqvYCiPxC_9nE - - - 200 1146 text/css 15.8363ms 
2024-05-29 18:35:26.0416|1|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request starting HTTP/2 GET https://localhost:7125/js/site.js?v=4q1jwFhaPaZgr8WAUSrux6hAuh0XDg9kPS3xIVq36I0 - - 
2024-05-29 18:35:26.0416|2|TRACE|Microsoft.AspNetCore.HostFiltering.HostFilteringMiddleware|All hosts are allowed. 
2024-05-29 18:35:26.0416|0|TRACE|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Range header's value is empty. 
2024-05-29 18:35:26.0416|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 9 with length 16384 and flags NONE. 
2024-05-29 18:35:26.0553|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending HEADERS frame for stream ID 11 with length 33 and flags END_HEADERS. 
2024-05-29 18:35:26.0553|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 11 with length 16384 and flags NONE. 
2024-05-29 18:35:26.0553|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending HEADERS frame for stream ID 3 with length 34 and flags END_HEADERS. 
2024-05-29 18:35:26.0553|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 3 with length 16384 and flags NONE. 
2024-05-29 18:35:26.0553|1|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request starting HTTP/2 GET https://localhost:7125/_framework/aspnetcore-browser-refresh.js - - 
2024-05-29 18:35:26.0553|1|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request starting HTTP/2 GET https://localhost:7125/_vs/browserLink - - 
2024-05-29 18:35:26.0553|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending HEADERS frame for stream ID 5 with length 31 and flags END_HEADERS. 
2024-05-29 18:35:26.0553|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending HEADERS frame for stream ID 13 with length 31 and flags END_HEADERS. 
2024-05-29 18:35:26.0553|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 11 with length 16384 and flags NONE. 
2024-05-29 18:35:26.0924|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 5 with length 194 and flags NONE. 
2024-05-29 18:35:26.0924|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 9 with length 16384 and flags NONE. 
2024-05-29 18:35:26.0924|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 13 with length 230 and flags NONE. 
2024-05-29 18:35:26.0924|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending HEADERS frame for stream ID 15 with length 60 and flags END_HEADERS. 
2024-05-29 18:35:26.0924|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 15 with length 12024 and flags NONE. 
2024-05-29 18:35:26.0924|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 3 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1097|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending HEADERS frame for stream ID 17 with length 119 and flags END_HEADERS. 
2024-05-29 18:35:26.1097|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 9986 and flags NONE. 
2024-05-29 18:35:26.1097|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1097|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1097|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1097|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1097|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1097|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1097|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 15 with length 0 and flags END_STREAM. 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 3 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 9 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 11 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1195|2|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request finished HTTP/2 GET https://localhost:7125/_framework/aspnetcore-browser-refresh.js - - - 200 12024 application/javascript;+charset=utf-8 55.1341ms 
2024-05-29 18:35:26.1195|2|INFO|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Sending file. Request path: '/css/site.css'. Physical path: 'C:\Users\XXX\source\repos\NLog.Web\examples\ASP.NET Core 6\ASP.NET Core 6 NLog Example\wwwroot\css\site.css' 
2024-05-29 18:35:26.1195|2|INFO|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Sending file. Request path: '/js/site.js'. Physical path: 'C:\Users\XXX\source\repos\NLog.Web\examples\ASP.NET Core 6\ASP.NET Core 6 NLog Example\wwwroot\js\site.js' 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 5 with length 0 and flags END_STREAM. 
2024-05-29 18:35:26.1195|2|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request finished HTTP/2 GET https://localhost:7125/css/site.css?v=AKvNjO3dCPPS0eSU1Ez8T2wI280i08yGycV9ndytL-c - - - 200 194 text/css 94.5017ms 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 11 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 13 with length 0 and flags END_STREAM. 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 3 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 9 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1195|2|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request finished HTTP/2 GET https://localhost:7125/js/site.js?v=4q1jwFhaPaZgr8WAUSrux6hAuh0XDg9kPS3xIVq36I0 - - - 200 230 application/javascript 77.4123ms 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 9 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1195|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 3 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 11 with length 12938 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 9 with length 7558 and flags NONE. 
2024-05-29 18:35:26.1329|2|INFO|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Sending file. Request path: '/lib/jquery/dist/jquery.min.js'. Physical path: 'C:\Users\XXX\source\repos\NLog.Web\examples\ASP.NET Core 6\ASP.NET Core 6 NLog Example\wwwroot\lib\jquery\dist\jquery.min.js' 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 9 with length 0 and flags END_STREAM. 
2024-05-29 18:35:26.1329|2|INFO|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Sending file. Request path: '/lib/bootstrap/dist/js/bootstrap.bundle.min.js'. Physical path: 'C:\Users\XXX\source\repos\NLog.Web\examples\ASP.NET Core 6\ASP.NET Core 6 NLog Example\wwwroot\lib\bootstrap\dist\js\bootstrap.bundle.min.js' 
2024-05-29 18:35:26.1329|2|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request finished HTTP/2 GET https://localhost:7125/lib/jquery/dist/jquery.min.js - - - 200 89478 application/javascript 93.8938ms 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 11 with length 0 and flags END_STREAM. 
2024-05-29 18:35:26.1329|2|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request finished HTTP/2 GET https://localhost:7125/lib/bootstrap/dist/js/bootstrap.bundle.min.js - - - 200 78474 application/javascript 93.0748ms 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 3 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 10240 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 9975 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 3 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 3 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 3 with length 16384 and flags NONE. 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 3 with length 15270 and flags NONE. 
2024-05-29 18:35:26.1329|2|INFO|Microsoft.AspNetCore.StaticFiles.StaticFileMiddleware|Sending file. Request path: '/lib/bootstrap/dist/css/bootstrap.min.css'. Physical path: 'C:\Users\XXX\source\repos\NLog.Web\examples\ASP.NET Core 6\ASP.NET Core 6 NLog Example\wwwroot\lib\bootstrap\dist\css\bootstrap.min.css' 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 3 with length 0 and flags END_STREAM. 
2024-05-29 18:35:26.1329|2|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request finished HTTP/2 GET https://localhost:7125/lib/bootstrap/dist/css/bootstrap.min.css - - - 200 162726 text/css 109.3089ms 
2024-05-29 18:35:26.1329|49|TRACE|Microsoft.AspNetCore.Server.Kestrel.Http2|Connection id "0HMK16UJ982TT" sending DATA frame for stream ID 17 with length 0 and flags END_STREAM. 
2024-05-29 18:35:26.1329|2|INFO|Microsoft.AspNetCore.Hosting.Diagnostics|Request finished HTTP/2 GET https://localhost:7125/_vs/browserLink - - - 200 - text/javascript;+charset=UTF-8 71.3116ms

六、模型绑定

下面是对应的 URL 示例：

1. 路由参数

接收单个参数

[HttpGet("api/products/{id}")]
public IActionResult GetProductById([FromRoute] int id)
{
    return Ok();
}

对应的 URL 示例：/api/products/123

2. URL 参数

接收单个参数

[HttpGet("api/products")]
public IActionResult GetProducts([FromQuery] int page)
{
    return Ok();
}

对应的 URL 示例：/api/products?page=1

接收数组参数

[HttpGet("api/products")]
public IActionResult GetProducts([FromQuery(Name = "ids[]")] int[] ids)
{
    return Ok();
}

对应的 URL 示例：/api/products?ids[]=1&ids[]=2&ids[]=3

接收对象参数

[HttpGet("api/products")]
public IActionResult GetProducts([FromQuery] Product product)
{
    return Ok();
}

对应的 URL 示例：/api/products?Name=ProductName&Price=99.99

3. 请求体参数

接收单个参数

[HttpPost("api/products")]
public IActionResult CreateProduct([FromBody] string productName)
{
    return Ok();
}

对应的请求体示例：

1
2
3

{
    "productName": "Product Name"
}

接收数组参数

[HttpPost("api/products")]
public IActionResult CreateProducts([FromBody] List<string> productNames)
{
    return Ok();
}

对应的请求体示例：

1	`["Product 1", "Product 2", "Product 3"]`

接收对象参数

[HttpPost("api/products")]
public IActionResult CreateProduct([FromBody] Product product)
{
    return Ok();
}

对应的请求体示例：

{
    "id": 123,
    "name": "Product Name",
    "price": 99.99
}

这些示例展示了在 ASP.NET Core Web API 中如何从路由、URL 和请求体中接收参数，并进行相应的参数绑定。

七、模型验证

在 Web API 中，模型验证是确保客户端提供的数据符合预期的关键部分之一。这不仅有助于保护应用程序免受恶意输入的影响，还可以提高应用程序的健壮性和可靠性。

1. 内置验证特性

ASP.NET Core 提供了一系列内置的验证特性，可以直接应用于模型的属性上。通过在模型的属性上应用这些特性，我们可以定义属性的验证规则和错误消息，以确保接收到的数据是有效的和完整的。

示例：

using System.ComponentModel.DataAnnotations;

public class UserModel
{
    [Required(ErrorMessage = "用户名不能为空")]
    public string Username { get; set; }

    [Required(ErrorMessage = "密码不能为空")]
    [StringLength(20, MinimumLength = 6, ErrorMessage = "密码长度必须在6到20个字符之间")]
    public string Password { get; set; }

    [EmailAddress(ErrorMessage = "无效的邮箱地址")]
    public string Email { get; set; }

    [Range(18, 100, ErrorMessage = "年龄必须在18到100岁之间")]
    public int Age { get; set; }

    [Phone(ErrorMessage = "无效的电话号码")]
    public string PhoneNumber { get; set; }

    [RegularExpression(@"^[A-Za-z0-9]+(?:[_-][A-Za-z0-9]+)*$", ErrorMessage = "用户名只能包含字母、数字、下划线和短横线")]
    public string Username { get; set; }

    [Compare("Password", ErrorMessage = "确认密码与密码不匹配")]
    public string ConfirmPassword { get; set; }

    [Url(ErrorMessage = "无效的 URL 地址")]
    public string Website { get; set; }

    [CreditCard(ErrorMessage = "无效的信用卡号")]
    public string CreditCardNumber { get; set; }

    [DataType(DataType.Date, ErrorMessage = "请输入有效的日期")]
    public DateTime BirthDate { get; set; }
}

2. 手动验证获取参数绑定失败的消息

有时候，我们需要手动获取参数绑定失败的消息。为了实现这一点，我们可以创建一个静态的 AspNetCoreHelper 类，其中包含一个 ValidateModelStateForApi 方法，用于验证模型的状态并获取绑定失败的消息。

public static class AspNetCoreHelper
{
    public static void ValidateModelStateForApi(ModelStateDictionary modelState)
    {
        if (!modelState.IsValid)
        {
            var errorMessages = string.Join(Environment.NewLine,
                modelState.Values.SelectMany(v => v.Errors.Select(e => !string.IsNullOrEmpty(e.ErrorMessage) ? e.ErrorMessage : e.Exception?.Message)));

            if (!string.IsNullOrEmpty(errorMessages))
            {
                throw new Exception(errorMessages);
            }
        }
    }
}

3. 进阶使用 FluentValidation 自定义规则更灵活的验证参数

FluentValidation 是一个强大且灵活的验证库，可以用于定义复杂的验证规则。以下是使用 FluentValidation 进行模型验证的简单教程：

3.1. 安装 FluentValidation 包

首先，使用 NuGet 包管理器或 .NET CLI 安装 FluentValidation 包。

1	`dotnet add package FluentValidation`

3.2. 创建验证器类

创建一个验证器类，用于定义模型验证规则。例如，如果我们有一个名为 Product 的模型类，可以创建一个 ProductValidator 的验证器类来定义验证规则。

using FluentValidation;

public class ProductValidator : AbstractValidator<Product>
{
    public ProductValidator()
    {
        RuleFor(product => product.Name).NotEmpty().WithMessage("Name is required.");
        RuleFor(product => product.Price).GreaterThan(0).WithMessage("Price must be greater than 0.");
    }
}

3.3. 在控制器中使用验证器

在控制器中使用验证器类来执行模型验证。在控制器的相应动作方法中，实例化验证器并对模型对象进行验证。

using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    [HttpPost]
    public IActionResult CreateProduct([FromBody] Product product)
    {
        var validator = new ProductValidator();
        var validationResult = validator.Validate(product);

        if (!validationResult.IsValid)
        {
            var errors = validationResult.Errors.Select(error => error.ErrorMessage);
            return BadRequest(errors);
        }

        // 执行创建产品的逻辑
        return Ok("Product created successfully!");
    }
}

3.4. 测试模型验证

通过发送 POST 请求来测试模型验证。可以使用 Postman 或其他 HTTP 客户端来发送请求。

URL：POST /api/products
请求体：JSON 格式的产品数据

{
    "name": "Product Name",
    "price": 99.99
}

八、使用 Swagger 构建 Web API 文档

Swagger 是一个流行的 Web API 文档工具，可以帮助开发人员设计、构建、记录和使用 API。在 ASP.NET Core 中，使用 Swagger 可以轻松地生成易懂的 Web API 文档，并解决一些常见的问题。下面是一份通俗易懂的使用 Swagger 的指南，同时也提供了一些常见问题的解决方案。

1. 安装 Swagger

首先，我们需要在 ASP.NET Core 项目中安装 Swagger 相关的 NuGet 包。

打开 NuGet 包管理器控制台。
运行以下命令来安装 Swashbuckle.AspNetCore：

1	`Install-Package Swashbuckle.AspNetCore`

2. 配置 Swagger

在项目的 Startup.cs 文件中配置 Swagger 服务。

在 ConfigureServices 方法中，添加 Swagger 服务的配置：

services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo { Title = "Your API Name", Version = "v1" });
});

在 Configure 方法中启用 Swagger 中间件：

app.UseSwagger();
app.UseSwaggerUI(c =>
{
    c.SwaggerEndpoint("/swagger/v1/swagger.json", "Your API V1");
});

3. 添加中文注释

如果你希望在 Swagger 文档中显示中文注释，可以进行如下配置。

在项目的属性中，启用 XML 文档生成。
在 ConfigureServices 方法中，添加 XML 文档的注释路径：

services.AddSwaggerGen(c =>
{
    var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
    c.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, xmlFilename), true);
});

5. 添加身份验证令牌

在 ConfigureServices 方法中配置 Swagger。

services.AddSwaggerGen(c =>
{
    // 配置 Swagger 文档的安全定义
    c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
    {
        Description = "JWT授权token前面需要加上字段Bearer与一个空格,如Bearer token",
        Name = "Authorization",
        In = ParameterLocation.Header,
        Type = SecuritySchemeType.ApiKey,
        Scheme = "Bearer"
    });

    // 添加 Swagger 文档的全局安全要求
    c.AddSecurityRequirement(new OpenApiSecurityRequirement
    {
        {
            new OpenApiSecurityScheme
            {
                Reference = new OpenApiReference { Type = ReferenceType.SecurityScheme, Id = "Bearer" }
            },
            new string[] {}
        }
    });
});

4. 解决常见问题

4.1. 使用相同类名的 Schema 会导致报错

如果在项目中存在相同类名的情况，可以通过配置避免这个问题。

在 ConfigureServices 方法中，添加如下配置：

services.AddSwaggerGen(c =>
{
    c.CustomSchemaIds(type => SwaggerHelper.GetSchemaId(type));
})

自定义 SchemaId 如下：

public static class SwaggerHelper
{
    private static readonly ConcurrentDictionary<string, int> _schemaNameRepetition = new();

    private static string DefaultSchemaIdSelector(Type modelType)
    {
        if (!modelType.IsConstructedGenericType) return modelType.Name.Replace("[]", "Array");

        var prefixBuilder = new StringBuilder();
        foreach (var genericArg in modelType.GetGenericArguments())
        {
            prefixBuilder.Append(DefaultSchemaIdSelector(genericArg));
        }

        var prefix = prefixBuilder.ToString();
        return prefix + modelType.Name.Split('`').First();
    }

    public static string GetSchemaId(Type modelType)
    {
        string id;
        id = DefaultSchemaIdSelector(modelType);
        _schemaNameRepetition.AddOrUpdate(id, 1, (_, count) => count + 1);

        int count = _schemaNameRepetition[id];


        return $"{id}{(count > 1 ? count.ToString() : "")}";
    }
}

4.2. 接口返回数据字段变成小写

有时接口返回的数据字段会变成小写，可以通过配置解决。

在 Startup.cs 文件的 ConfigureServices 方法中，添加如下配置：

services.AddControllers()
    .AddNewtonsoftJson(op =>
    {
        // 解决接口返回的字段变成小写问题，还原模型原本的字段名
        op.SerializerSettings.ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver();
    });

4.2. 超过 1MB 的 JSON 响应数据导致 Swagger 一直加载

在 Startup.cs 文件的 Configure 方法中，添加如下配置：

app.UseSwaggerUI(c =>
{
    c.ConfigObject.AdditionalItems["syntaxHighlight"] = new Dictionary<string, object>
    {
        ["activated"] = false
    };
});

九、使用 EF Core 操作数据库

当使用 CLI 工具初始化模型并从配置文件中读取数据库连接字符串时，可以按照以下步骤进行操作：

1. 安装 Entity Framework Core CLI 工具

首先，确保已经安装了 Entity Framework Core 工具。你可以通过以下命令来全局安装 EF Core 工具：

1	`dotnet tool install --global dotnet-ef`

这将安装 EF Core 工具，使你可以在命令行或终端中使用 dotnet ef 命令。

2. 安装 EF Core 包

在项目目录中安装 Entity Framework Core 包。可以使用 NuGet 包管理器或 .NET CLI 来安装。

1
2
3

dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools

3. 使用 CLI 工具初始化模型

常用选项

选项	Short	说明
`--json`		显示 JSON 输出。
`--context`	`-c`	要使用的 `DbContext` 类。仅类名或完全限定命名的空间。如果省略此选项，EF Core 将查找上下文类。如果有多个上下文类，则此选项是必需的。
`--project`	`-p`	目标项目的项目文件夹的相对路径。默认值是当前文件夹。
`--startup-project`	`-s`	启动项目的项目文件夹的相对路径。默认值是当前文件夹。
`--framework`		目标框架的目标框架名字对象。当项目文件指定了多个目标框架，并且你想要选择其中一个目标框架时，请使用此选项。
`--configuration`		生成配置，例如 `Debug` 或 `Release`。
`--runtime`		要为其还原包的目标运行时的标识符。有关运行时标识符 (RID) 的列表，请参阅 RID 目录。
`--no-build`		请勿生成项目。旨在在生成处于最新状态时使用。
`--help`	`-h`	显示帮助信息。
`--verbose`	`-v`	显示详细输出。
`--no-color`		请勿为输出着色。
`--prefix-output`		具有级别的前缀输出。

首先，在项目的根目录下打开命令行或终端窗口，并使用 EF Core CLI 工具来初始化模型类。

1	`dotnet ef dbcontext scaffold "connection_string_here" Microsoft.EntityFrameworkCore.SqlServer -o Models -c ApplicationDbContext --data-annotations -f --no-pluralize`

替换 "connection_string_here" 为你的数据库连接字符串，-o Models 参数指定了模型类文件的输出目录。这个命令会根据数据库的结构自动生成模型类文件。

`dotnet ef dbcontext scaffold`

为 DbContext 生成代码，并为数据库生成实体类型。为了让此命令生成实体类型，数据库表必须具有主键。

参数：

参数	说明
	用于连接到数据库的连接字符串。对于 ASP.NET Core 2.x 项目，值可以是 name=。在这种情况下，名称来自为项目设置的配置源。
	要使用的提供程序。通常，这是 NuGet 包的名称，例如：`Microsoft.EntityFrameworkCore.SqlServer`。

选项：

选项	Short	说明
`--data-annotations`	`-d`	使用属性配置模型（如果可能）。如果省略此选项，则仅使用 Fluent API。
`--context`	`-c`	要生成的 `DbContext` 类的名称。
`--context-dir`		要在其中放置 `DbContext` 类文件的目录。路径相对于项目目录。命名空间派生自文件夹名称。
`--context-namespace`		要用于生成的 `DbContext` 类的命名空间。注意：重写 `--namespace`。
`--force`	`-f`	覆盖现有文件。
`--output-dir`	`-o`	要在其中放置实体类文件的目录。路径相对于项目目录。
`--namespace`	`-n`	要用于所有生成的类的命名空间。默认设置为从根命名空间和输出目录生成。
`--schema ...`		要为其生成实体类型的表和视图的架构。若要指定多个架构，请为每个架构重复 `--schema`。如果省略此选项，则包含所有架构。如果使用此选项，架构中的所有表和视图都将包含在模型中，即使未使用 –table 显式包含它们也是如此。
`--table ...`	`-t`	要为其生成实体类型的表和视图。若要指定多个表，请为每个表重复 `-t` 或 `--table`。可以使用“schema.table”或“schema.view”格式包含特定架构中的表或视图。如果省略此选项，则包含所有表和视图。
`--use-database-names`		使用与数据库中显示的名称完全相同的表、视图、序列和列名称。如果省略此选项，数据库名称将更改为更符合 C# 名称样式约定。
`--no-onconfiguring`		禁止在生成的 `DbContext` 类中生成 `OnConfiguring` 方法。
`--no-pluralize`		请勿使用复数化程序。

4. 配置数据库连接字符串

在 appsettings.json 文件中配置数据库连接字符串。

{
  "ConnectionStrings": {
    "DefaultConnection": "your_connection_string_here"
  }
}

5. 配置服务

在 Startup.cs 文件的 ConfigureServices 方法中配置数据库上下文服务。

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
}

确保在 Startup.cs 文件的顶部添加了 using 声明：

1	`using Microsoft.EntityFrameworkCore;`

6. 使用数据库上下文

现在，你可以在控制器或其他服务中注入数据库上下文，并使用它来执行数据库操作。

public class ProductsController : ControllerBase
{
    private readonly ApplicationDbContext _context;

    public ProductsController(ApplicationDbContext context)
    {
        _context = context;
    }

    [HttpGet]
    public async Task GetProducts()
    {
        var products = await _context.Products.ToListAsync();
        return Ok(products);
    }
}

7. 调用存储过程与原生SQL

7.1. 准备工作

在使用 EF Core 调用存储过程与原生 SQL 之前，需要做以下准备工作：

在新建的数据库上下文的分部类中添加相应的 DbSet，确保上下文在 CLI 自动生成模型后不会被覆盖。

// 数据库上下文
public partial class MyDbContext : DbContext
{
    public MyDbContext(DbContextOptions options)
        : base(options)
    {
    }
}

// 数据库上下文分部类
public partial class MyDbContext
{
      public DbSet MyEntities { get; set; }
}

7.2. 代码示例

// 参数值
var param1Value = "value1";
var param2Value = "value2";

// 直接使用内插字符串
var sqlQuery = $"EXEC MyStoredProcedure '{param1Value}', '{param2Value}'";

// 使用参数化查询
var sqlQuery1 = "EXEC MyStoredProcedure @param1, @param2";
var sqlQuery2 = "EXEC MyStoredProcedure {0}, {1}";

// 示例：FromSql（EF Core 7.0 引入和 FromSqlInterpolated 使用一致）
var resultFromSql = dbContext.MyEntity.FromSql(sqlQuery).ToList();

// 示例：FromSqlRaw
var resultFromSqlRaw = dbContext.MyEntity.FromSqlRaw(sqlQuery1,
    new SqlParameter("@param1", param1Value),
    new SqlParameter("@param2", param2Value)).ToList();

var result1FromSqlRaw = dbContext.MyEntity.FromSqlRaw(sqlQuery2,
    new SqlParameter("@param1", param1Value),
    new SqlParameter("@param2", param2Value)).ToList();

// 示例：FromSqlInterpolated（自动处理参数化）
var resultFromSqlInterpolated = dbContext.MyEntity.FromSqlInterpolated(sqlQuery).ToList();

// 示例：ExecuteSql（EF Core 7.0 引入和 ExecuteSqlInterpolated 使用一致）
int resultExecuteSql = dbContext.Database.ExecuteSql(sqlQuery);

// 示例：ExecuteSqlRaw
int resultExecuteSqlRaw = dbContext.Database.ExecuteSqlRaw(sqlQuery1,
    new SqlParameter("@param1", param1Value),
    new SqlParameter("@param2", param2Value));

int result1ExecuteSqlRaw = dbContext.Database.ExecuteSqlRaw(sqlQuery2,
    new SqlParameter("@param1", param1Value),
    new SqlParameter("@param2", param2Value));

// 示例：ExecuteSqlInterpolated（自动处理参数化）
int resultExecuteSqlInterpolated = dbContext.Database.ExecuteSqlInterpolated(sqlQuery);

7.3. 调用方法和区别

下表列出了各种调用方法的区别：

方法名称	描述	参数类型	备注
FromSql	创建基于插值字符串表示的 SQL 查询的 LINQ 查询。返回`IQueryable`	`FormattableString`	使用插值字符串，自动处理参数化
FromSqlRaw	创建基于原始 SQL 查询的 LINQ 查询。返回`IQueryable`	`string` 和 `params object[]`	接收原始 SQL 字符串和可选参数。
FromSqlInterpolated	创建基于插值字符串表示的 SQL 查询的 LINQ 查询。返回`IQueryable`	`FormattableString`	使用插值字符串，自动处理参数化。
ExecuteSql	执行给定的 SQL 并返回受影响的行数。	`FormattableString`	使用插值字符串，自动处理参数化
ExecuteSqlRaw	执行给定的 SQL 并返回受影响的行数。	`string` 和 `params object[]`	接收原始 SQL 字符串和可选参数。
ExecuteSqlInterpolated	执行给定的 SQL 并返回受影响的行数。	`FormattableString`	使用插值字符串，自动处理参数化。

详细说明

FromSql 和 FromSqlInterpolated：EF Core 7.0 引入，两者功能和实现方式一致，都可以自动处理参数化，都用于创建基于插值字符串的 SQL 查询的 LINQ 查询。
FromSqlRaw：接收原始 SQL 字符串和参数列表。
ExecuteSql 和 ExecuteSqlInterpolated：EF Core 7.0 引入，两者功能和实现方式一致，都可以自动处理参数化，都用于执行给定的 SQL 并返回受影响的行数。
ExecuteSqlRaw：接收原始 SQL 字符串和参数列表，用于执行给定的 SQL 并返回受影响的行数。
以上 API 方法，与任何接受 SQL 的 API 一样，重要的是将任何用户输入参数化，以防止 SQL 注入
攻击。您可以在 SQL 查询字符串中包含参数占位符，然后提供额外的参数值
参数。您提供的任何参数值都将自动转换为 DbParameter。

7.4. 调用带有输出参数的存储过程

要调用带有输出参数的存储过程，可以使用 ExecuteSql 或 ExecuteSqlInterpolated 方法，并通过参数传递输出参数。

var outputParam = new SqlParameter("@outputParam", SqlDbType.Int)
{
    Direction = ParameterDirection.Output
};

dbContext.Database.ExecuteSqlRaw("EXEC MyStoredProcedure @inputParam, @outputParam OUTPUT", 
    new SqlParameter("@inputParam", param1),
    outputParam);

int result = (int)outputParam.Value;

8. 自定义 EfCoreHelper 类，方便动态构建 Lambda 表达式进行查询，并执行分页、排序、过滤等数据库操作

Sort 方法

根据提供的 orderBy 字符串对 IQueryable 集合进行排序。

方法签名

1	`public static IQueryable<T> Sort<T>(this IQueryable query, string orderBy)`

query: 要排序的 IQueryable 集合。
orderBy: 以 “属性方向” 格式表示的排序条件。

示例

1	`var sortedQuery = dbContext.Users.Sort("Name ascending");`

Filter 方法

根据提供的条件组列表对 IQueryable 集合进行过滤。

方法签名

1	`public static IQueryable<T> Filter<T>(this IQueryable query, List? groupedConditions)`

query: 要过滤的 IQueryable 集合。
groupedConditions: 要应用的条件组列表。

示例

1	`var filteredQuery = dbContext.Products.Filter(conditionGroups);`

GetPageList 方法

从数据库中检索元素的分页列表。

方法签名

1	`public static Page<T> GetPageList<T>(DbContext context, int pageNumber, int pageSize, string orderBy = "", List? conditionGroups = null) where T : class`

context: 数据库上下文。
pageNumber: 要检索的页码。
pageSize: 每页的大小。
orderBy: 排序条件。
conditionGroups: 用于过滤的条件组列表。

示例

1	`var page = EfCoreHelper.GetPageList(dbContext, 1, 10, "Name ascending", conditionGroups);`

GetPageListByNativeSql 方法

使用本机 SQL 查询检索元素的分页列表。

方法签名

public static Page<T> GetPageListByNativeSql<T>(DbContext context, string sql, int pageNumber, int pageSize, string orderBy = "", List? conditionGroups = null, object[]? sqlParameters = null) where T : class

context: 数据库上下文。
sql: SQL 查询。
pageNumber: 要检索的页码。
pageSize: 每页的大小。
orderBy: 排序条件。
conditionGroups: 用于过滤的条件组列表。
sqlParameters: SQL 查询的可选参数。

示例

1	`var page = EfCoreHelper.GetPageListByNativeSql(dbContext, "SELECT * FROM Users", 1, 10, "Name ascending", conditionGroups);`

DeleteAll 方法

删除符合条件的所有记录。

方法签名

1	`public static int DeleteAll<T>(DbContext context, Expressionbool>> filter) where T : class`

context: 数据库上下文。
filter: 要应用的过滤器表达式。

示例

1	`var deletedCount = EfCoreHelper.DeleteAll(dbContext, u => u.Age > 50);`

UpdateRecords 方法

根据条件更新记录。

方法签名

1	`public static int UpdateRecords<T>(DbContext context, Funcbool> predicate, Action updateAction) where T : class`

context: 数据库上下文。
predicate: 要应用的条件谓词。
updateAction: 更新记录的操作。

示例

1	`var updatedCount = EfCoreHelper.UpdateRecords(dbContext, u => u.IsActive, u => u.IsActive = false);`

EfCoreHelper 完整代码

using System.Linq.Expressions;
using System.Reflection;
using Microsoft.EntityFrameworkCore;

namespace Loquy.Common.Helpers
{
    public static class EfCoreHelper
    {
       public class Page<T>
       {
           public List pageList { get; set; }

           public int pageNumber { get; set; }

           public int pageSize { get; set; }

           public int total { get; set; }

           public Page()
           {
               pageList = new List();
           }
       }
   
        public static IQueryable<T> Sort<T>(this IQueryable query, string orderBy)
        {
            if (string.IsNullOrEmpty(orderBy))
            {
                return query;
            }
            string[] orderByParts = orderBy.Split(' ');
            if (orderByParts.Length == 2)
            {
                string column = orderByParts[0].Trim();
                string sort = orderByParts[1].Trim().ToLower();

                // 校验排序方式是否为 "ascending" 或 "descending"
                if (sort == "ascending" || sort == "descending")
                {
                    // 检查实体是否具有提供的列名属性
                    var entityType = typeof(T);
                    var property = entityType.GetProperty(column);
                    if (property != null)
                    {
                        query = sort == "ascending" ? query.OrderBy(t => EF.Property<object>(t!, column))
                            : query.OrderByDescending(t => EF.Property<object>(t!, column));
                    }
                }
            }
            return query;
        }

        public class Condition
        {
            public string PropertyName { get; set; }
            public Comparison Comparison { get; set; }
            public object? Value { get; set; }
            public object? MinValue { get; set; }
            public object? MaxValue { get; set; }
        }

        public class ConditionGroup
        {
            public List Conditions { get; set; }
            public LogicOperator Logic { get; set; }
        }

        public enum LogicOperator
        {
            AND,
            OR
        }

        public enum Comparison
        {
            Equal = 1,
            GreaterThan = 2,
            GreaterThanOrEqual = 3,
            LessThan = 4,
            LessThanOrEqual = 5,
            Contains = 6,
            StartWith = 7,
            EndWith = 8,
            Between = 9
        }

        public static IQueryable<T> Filter<T>(this IQueryable query, List? groupedConditions)
        {
            var parameter = Expression.Parameter(typeof(T), "t");
            List groupExpressions = new List(); // 用于存储所有分组的表达式

            if (groupedConditions == null)
            {
                return query;
            }

            foreach (var group in groupedConditions)
            {
                List conditions = group.Conditions;
                LogicOperator groupLogic = group.Logic;

                List conditionExpressions = new List(); // 用于存储每个分组内的条件表达式

                foreach (Condition condition in conditions)
                {
                    Type type = typeof(T);
                    PropertyInfo? propertyInfo = type.GetProperty(condition.PropertyName);
                    if (propertyInfo == null ||
                        condition.Comparison != Comparison.Between && condition.Value == null ||
                        condition.Comparison == Comparison.Between && (condition.MinValue == null || condition.MaxValue == null) ||
                        condition.Value is string strValue && string.IsNullOrEmpty(strValue))
                    {
                        continue;
                    }

                    Expression property = Expression.Property(parameter, propertyInfo);

                    Expression valueExpression = ConvertToPropertyType(condition.Value, propertyInfo.PropertyType);

                    Expression comparisonExpression;

                    switch (condition.Comparison)
                    {
                        case Comparison.Equal:
                            comparisonExpression = Expression.Equal(property, valueExpression);
                            break;
                        case Comparison.GreaterThan:
                            comparisonExpression = Expression.GreaterThan(property, valueExpression);
                            break;
                        case Comparison.GreaterThanOrEqual:
                            comparisonExpression = Expression.GreaterThanOrEqual(property, valueExpression);
                            break;
                        case Comparison.LessThan:
                            comparisonExpression = Expression.LessThan(property, valueExpression);
                            break;
                        case Comparison.LessThanOrEqual:
                            comparisonExpression = Expression.LessThanOrEqual(property, valueExpression);
                            break;
                        case Comparison.Contains:
                            comparisonExpression = Expression.Call(property, typeof(string).GetMethod("Contains", new[] { typeof(string) })!, valueExpression);
                            break;
                        case Comparison.StartWith:
                            comparisonExpression = Expression.Call(property, typeof(string).GetMethod("StartsWith", new[] { typeof(string) })!, valueExpression);
                            break;
                        case Comparison.EndWith:
                            comparisonExpression = Expression.Call(property, typeof(string).GetMethod("EndsWith", new[] { typeof(string) })!, valueExpression);
                            break;
                        case Comparison.Between:
                            Expression minValueExpression = ConvertToPropertyType(condition.MinValue, propertyInfo.PropertyType);
                            Expression maxValueExpression = ConvertToPropertyType(condition.MaxValue, propertyInfo.PropertyType);

                            var min = Expression.GreaterThanOrEqual(property, minValueExpression);
                            var max = Expression.LessThanOrEqual(property, maxValueExpression);

                            comparisonExpression = Expression.And(min, max);
                            break;
                        default:
                            throw new ArgumentException("无效的比较运算符。");
                    }

                    conditionExpressions.Add(comparisonExpression);
                }

                // 根据分组的逻辑操作，将条件合并为总的表达式
                Expression? groupCombinedExpression = null;
                if (conditionExpressions.Any())
                {
                    groupCombinedExpression = conditionExpressions.Aggregate(groupLogic == LogicOperator.AND ? Expression.And : Expression.Or);
                }
                if (groupCombinedExpression != null)
                {
                    groupExpressions.Add(groupCombinedExpression);
                }
            }

            // 使用 AND 逻辑操作，合并所有分组表达式
            Expression? combinedExpression = null;
            if (groupExpressions.Any())
            {
                combinedExpression = groupExpressions.Aggregate(Expression.And);
            }

            // 如果没有任何条件，则返回原始查询
            if (combinedExpression == null)
            {
                return query;
            }
            // 构建 Lambda 表达式，并将其应用到查询上
            var lambdaExpression = Expression.Lambdabool>>(combinedExpression, parameter);
            var expressionString = lambdaExpression.ToString();

            return query.Where(lambdaExpression);
        }

        public static Expression ConvertToPropertyType<T>(T value, Type propertyType)
        {
            return Expression.Constant(value, propertyType);
        }


        public static Page<T> GetPageList<T>(DbContext context, int pageNumber, int pageSize, string orderBy = "", List? conditionGroups = null) where T : class
        {
            var query = context.Set().AsQueryable().Filter(conditionGroups).Sort(orderBy);
            var totalCount = query.Count();
            var pageList = query.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList();

            return new Page
            {
                pageList = pageList,
                pageNumber = pageNumber,
                pageSize = pageSize,
                total = totalCount
            };
        }

        public static Page<T> GetPageListByNativeSql<T>(DbContext context, string sql, int pageNumber, int pageSize, string orderBy = "", List? conditionGroups = null, object[]? sqlParameters = null) where T : class
        {
            IQueryable query;

            if (sqlParameters != null)
            {
                query = context.Set().FromSqlRaw(sql, sqlParameters);
            }
            else
            {
                query = context.Set().FromSqlRaw(sql);
            }

            query = query.Filter(conditionGroups).Sort(orderBy);

            var totalCount = query.Count();
            var pageList = query.Skip((pageNumber - 1) * pageSize).Take(pageSize).ToList();

            return new Page
            {
                pageList = pageList,
                pageNumber = pageNumber,
                pageSize = pageSize,
                total = totalCount
            };
        }

        public static int DeleteAll<T>(DbContext context, Expressionbool>> filter) where T : class
        {
            using (var transaction = context.Database.BeginTransaction())
            {
                var recordsToDelete = context.Set().Where(filter).ToList();

                if (recordsToDelete.Any())
                {
                    context.Set().RemoveRange(recordsToDelete);
                    int affectedRows = context.SaveChanges();

                    if (affectedRows != recordsToDelete.Count)
                    {
                        transaction.Rollback();
                        throw new Exception($"部分数据删除失败，总共 {recordsToDelete.Count} 条，删除 {affectedRows} 条记录，进行回滚");
                    }

                    transaction.Commit();

                    return affectedRows;
                }
                else
                {
                    transaction.Rollback();
                    throw new Exception($"数据库查询不到符合条件的记录");
                }
            }
        }

        public static int UpdateRecords<T>(DbContext context, Funcbool> predicate, Action updateAction) where T : class
        {
            int affectedRows = 0;

            using (var transaction = context.Database.BeginTransaction())
            {
                var recordsToUpdate = context.Set().Where(predicate).ToList();

                if (recordsToUpdate.Any())
                {
                    foreach (var record in recordsToUpdate)
                    {
                        updateAction(record);
                    }

                    affectedRows = context.SaveChanges();

                    if (affectedRows > 0)
                    {
                        transaction.Commit();
                    }
                    else
                    {
                        transaction.Rollback();
                        throw new Exception("更新操作未能影响任何记录");
                    }
                }
                else
                {
                    throw new Exception("数据库查询不到符合条件的记录");
                }
            }
            return affectedRows;
        }
    }
}

十、使用 AutoMapper 进行对象映射

AutoMapper 是一个自动执行对象到对象之间的映射的工具，用于简化在不同层之间的对象转换。在 ASP.NET Core 中，AutoMapper Profile 是用于配置和定义映射规则的类。通过继承 Profile 类，你可以集中管理所有映射配置，保持代码清晰和易维护。

1. 安装 AutoMapper

要在 ASP.NET Core 项目中使用 AutoMapper，你需要安装两个 NuGet 包：AutoMapper 和 AutoMapper.Extensions.Microsoft.DependencyInjection。

使用 NuGet 包管理器控制台：

1	`Install-Package AutoMapper`

使用 .NET CLI：

1	`dotnet add package AutoMapper`

2. 配置 AutoMapper Profile

创建一个继承自 Profile 的类，在其中定义对象之间的映射规则。

示例：DtoMapper.cs

using AutoMapper;
using Loquy.Dtos;
using Loquy.Models;

namespace Loquy.Services.Mapper
{
    public class DtoMapper : Profile
    {
        public DtoMapper()
        {
            CreateMap();
        }
    }
}

在这个示例中，DtoMapper 类定义了从 User 到 UserDto 的映射规则。

3. 创建自定义扩展方法注册 AutoMapper

为了简化 AutoMapper 的注册过程，可以创建自定义扩展方法。

示例：ServiceCollectionExtensions.cs

using AutoMapper;
using Microsoft.Extensions.DependencyInjection;

namespace Loquy.Services.Extensions
{
    public static class ServiceCollectionExtensions
    {
        public static IServiceCollection AddCustomAutoMapper(this IServiceCollection services)
        {
            var mapperConfiguration = new MapperConfiguration(cfg =>
            {
                cfg.AddProfile();
            });

            IMapper mapper = mapperConfiguration.CreateMapper();
            services.AddSingleton(mapper);

            return services;
        }
    }
}

在这个示例中，AddCustomAutoMapper 方法配置了 AutoMapper，并将其注册为单例服务。

4. 在 Startup.cs 中注册 AutoMapper

在 Startup.cs 文件的 ConfigureServices 方法中调用我们定义的扩展方法来注册 AutoMapper。

示例：Startup.cs

public void ConfigureServices(IServiceCollection services)
{
    // 注册 Services
    services.AddDependencyGroup();
    // 注册 AutoMapper
    services.AddCustomAutoMapper();

    // 其他服务注册
}

通过这样的方法，我们可以将 AutoMapper 的配置和注册逻辑分离到独立的扩展方法中，使得 Startup.cs 文件更加简洁。

5. 使用 AutoMapper

现在你可以在你的控制器或服务中使用 AutoMapper 进行对象映射。你只需要通过构造函数注入 IMapper 接口，并使用 Map 方法进行对象转换。

示例：UsersController.cs

using AutoMapper;
using Microsoft.AspNetCore.Mvc;

public class UsersController : ControllerBase
{
    private readonly IMapper _mapper;

    public UsersController(IMapper mapper)
    {
        _mapper = mapper;
    }

    [HttpGet("{id}")]
    public ActionResult GetUser(int id)
    {
        // 模拟从数据库获取用户
        User user = GetUserById(id);

        // 使用 AutoMapper 将 User 转换为 UserDto
        UserDto userDto = _mapper.Map(user);

        return Ok(userDto);
    }

    private User GetUserById(int id)
    {
        // 模拟数据获取
        return new User { Id = id, FirstName = "John", LastName = "Doe" };
    }
}

在这个示例中，通过构造函数注入 IMapper 实例，并使用 _mapper.Map(user) 将 User 对象转换为 UserDto 对象。

十一、使用 JWTBearer 进行身份验证

1. 安装所需的包：首先，你需要安装必要的 NuGet 包。

1	`dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer`

2. 配置 JWTBearer 身份验证：在 `Startup.cs` 文件的 `ConfigureServices` 方法中配置 JWTBearer 身份验证，并读取 `appsettings.json` 提供的配置。

{
  "JwtSettings": {
    "SecretKey": "YourSecretKeyHere",
    "Issuer": "YourIssuerHere",
    "Audience": "YourAudienceHere",
    "ExpirationMinutes": 30 // 令牌过期时间，单位为分钟
  }
}

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.IdentityModel.Tokens;
using System;
using System.Text;

public class Startup
{
    public IConfiguration Configuration { get; }

    // 构造函数，接收 IConfiguration 对象用于读取配置
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    // 配置服务
    public void ConfigureServices(IServiceCollection services)
    {
        // 从配置中读取 JWT 相关设置
        var jwtSettings = Configuration.GetSection("JwtSettings");

        // 从配置中获取密钥、发布者、订阅者和令牌过期时间
        var secretKey = jwtSettings["SecretKey"];
        var issuer = jwtSettings["Issuer"];
        var audience = jwtSettings["Audience"];
        var expirationMinutes = Convert.ToInt32(jwtSettings["ExpirationMinutes"]);

        // 添加身份验证服务
        services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
            .AddJwtBearer(options =>
            {
                // 设置令牌验证参数
                options.TokenValidationParameters = new TokenValidationParameters
                {
                    ValidateIssuer = true, // 验证发布者
                    ValidateAudience = true, // 验证订阅者
                    ValidateLifetime = true, // 验证令牌生命周期
                    ValidateIssuerSigningKey = true, // 验证签名密钥
                    ValidIssuer = issuer, // 设置有效的发布者
                    ValidAudience = audience, // 设置有效的订阅者
                    IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secretKey)), // 设置签名密钥
                    ClockSkew = TimeSpan.Zero // 不允许任何时钟偏差
                };
            });

        // 添加控制器服务
        services.AddControllers();
    }

    // 配置应用程序请求管道
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // 省略其他配置...

        // 使用身份验证中间件
        app.UseAuthentication();
        app.UseAuthorization();

        // 配置端点路由
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

3. 保护你的 API 端点：在需要保护的 API 控制器或方法上使用 `[Authorize]` 特性。

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

[Authorize]
[ApiController]
[Route("api/[controller]")]
public class YourController : ControllerBase
{
    // 你的受保护 API 端点
}

4. 生成和验证 JWT 令牌：当需要生成 JWT 令牌时，你可以使用 `System.IdentityModel.Tokens.Jwt` 或其他相关库。你可以使用提供的配置中的过期时间来设置令牌的有效期。

using Microsoft.IdentityModel.Tokens;
using System;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

public class TokenService
{
    private readonly IConfiguration _configuration;

    // 构造函数，接收 IConfiguration 对象用于读取配置
    public TokenService(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    // 生成 JWT 令牌
    public string GenerateToken()
    {
        // 从配置中获取 JWT 相关设置
        var jwtSettings = _configuration.GetSection("JwtSettings");

        // 创建 JWT 令牌处理器
        var tokenHandler = new JwtSecurityTokenHandler();
        // 从配置中获取密钥，并转换为字节数组
        var secretKey = jwtSettings["SecretKey"];
        var key = Encoding.ASCII.GetBytes(secretKey);
        // 获取发布者和订阅者信息
        var issuer = jwtSettings["Issuer"];
        var audience = jwtSettings["Audience"];
        // 获取令牌过期时间（分钟）
        var expirationMinutes = Convert.ToInt32(jwtSettings["ExpirationMinutes"]);

        // 构建令牌描述信息
        var tokenDescriptor = new SecurityTokenDescriptor
        {
            // 设置主题，这里可以添加用户声明等信息
            Subject = new ClaimsIdentity(new Claim[]
            {
                new Claim(ClaimTypes.Name, "username"),
                // 添加其他声明
            }),
            // 设置令牌过期时间
            Expires = DateTime.UtcNow.AddMinutes(expirationMinutes),
            // 设置令牌的订阅者信息
            Audience = audience,
            // 设置令牌的发布者信息
            Issuer = issuer,
            // 设置签名凭据，使用对称密钥进行签名
            SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
        };

        // 创建 JWT 令牌
        var token = tokenHandler.CreateToken(tokenDescriptor);
        // 将令牌序列化为字符串并返回
        return tokenHandler.WriteToken(token);
    }

    // 从令牌中解析出用户主体
    public ClaimsPrincipal GetPrincipalFromToken(string token)
    {
        // 创建 JWT 令牌处理器
        var tokenHandler = new JwtSecurityTokenHandler();
        // 从配置中获取 JWT 相关设置
        var jwtSettings = _configuration.GetSection("JwtSettings");
        // 从配置中获取密钥，并转换为字节数组
        var secretKey = jwtSettings["SecretKey"];
        var key = Encoding.ASCII.GetBytes(secretKey);

        try
        {
            // 设置令牌验证参数
            var tokenValidationParameters = new TokenValidationParameters
            {
                ValidateIssuerSigningKey = true, // 验证签名密钥
                IssuerSigningKey = new SymmetricSecurityKey(key), // 设置签名密钥
                ValidateIssuer = true, // 验证发布者信息
                ValidIssuer = jwtSettings["Issuer"], // 设置有效的发布者
                ValidateAudience = true, // 验证订阅者信息
                ValidAudience = jwtSettings["Audience"], // 设置有效的订阅者
                ValidateLifetime = true, // 验证令牌的生命周期
                ClockSkew = TimeSpan.Zero // 不允许任何时钟偏差
            };

            // 验证令牌并获取用户主体信息
            var principal = tokenHandler.ValidateToken(token, tokenValidationParameters, out var validatedToken);
            // 返回用户主体信息
            return principal;
        }
        catch
        {
            // 令牌无效，返回 null
            return null;
        }
    }
}

5. 实际使用示例

5.1 通用返回格式

统一后端返回结果

namespace Loquy.Common.Dtos.Base
{
    /// 
    /// 通用返回结果
    /// 
    /// 
    public class ResultModel<T>
    {
        /// 
        /// 代码（0成功，-1失败）
        /// 
        public int code { get; set; }

        /// 
        /// 消息
        /// 
        public string message { get; set; }

        /// 
        /// 数据
        /// 
        public T? data { get; set; }

        public ResultModel()
        {
            // 默认构造函数
        }

        public static ResultModel Success()
        {
            return new ResultModel
            {
                code = ResultEnums.SUCCESS.code,
                message = ResultEnums.SUCCESS.message,
                data = default
            };
        }

        public static ResultModel Success(T data)
        {
            return new ResultModel
            {
                code = ResultEnums.SUCCESS.code,
                message = ResultEnums.SUCCESS.message,
                data = data
            };
        }

        public static ResultModel Success(string message)
        {
            return new ResultModel
            {
                code = ResultEnums.SUCCESS.code,
                message = message,
                data = default
            };
        }

        public static ResultModel Success(T data, string message)
        {
            return new ResultModel
            {
                code = ResultEnums.SUCCESS.code,
                message = message,
                data = data
            };
        }

        public static ResultModel Fail(string message)
        {
            return new ResultModel
            {
                code = ResultEnums.FAIL.code,
                message = message,
                data = default
            };
        }

        public static ResultModel Fail(int code, string message)
        {
            return new ResultModel
            {
                code = code,
                message = message,
                data = default
            };
        }

        public static ResultModel Fail(int code, string message, T data)
        {
            return new ResultModel
            {
                code = code,
                message = message,
                data = data
            };
        }

        public class ResultEnums
        {
            public static readonly ResultEnums FAIL = new ResultEnums(-1, "失败");

            public static readonly ResultEnums SUCCESS = new ResultEnums(0, "成功");

            public int code { get; private set; }

            public string message { get; private set; }

            private ResultEnums(int code, string message)
            {
                this.code = code;
                this.message = message;
            }
        }
    }
}

5.2 封装 JWT工具类

JWT 工具类接口，可注入到其他服务使用

using Loquy.Common.WMS.Dtos.UserMan;
using Loquy.Models;

namespace Loquy.Common.Authorization
{
    public interface IJwtUtils
    {
        string GenerateJwtToken(User user);
        string? ValidateJwtToken(string? token);
        string? GetCurrentToken();
        User? GetUserByToken();
        User? GetCurrentUser();
        int GetExpiresMinutes();
    }
}

JWT 工具类实现类，提供方法：根据用户生成 Token、验证 Token、获取当前 Token、根据 Token 获取用户、获取当前用户、获取 Token 过期分钟数

using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using Loquy.Common.WMS.Dtos.UserMan;
using Loquy.Models;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Configuration;
using Microsoft.IdentityModel.Tokens;

namespace Loquy.Common.Authorization
{
    public class JwtUtils : IJwtUtils
    {
        private readonly IConfiguration _configuration;
        private readonly IHttpContextAccessor _httpContextAccessor;
        private readonly AppDbContext _context;

        public JwtUtils(IConfiguration configuration, IHttpContextAccessor httpContextAccessor, AppDbContext context)
        {
            _configuration = configuration;
            _httpContextAccessor = httpContextAccessor;
            _context = context;

            string secret = _configuration["JwtSettings:SecretKey"] ?? "";
            if (string.IsNullOrEmpty(secret))
                throw new Exception("未配置 JWT 密钥");
        }

        public string GenerateJwtToken(User user)
        {
            var tokenHandler = new JwtSecurityTokenHandler();
            var key = Encoding.ASCII.GetBytes(_configuration["JwtSettings:SecretKey"]!);
            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(new[] { new Claim("id", user.id.ToString()) }),
                Expires = DateTime.UtcNow.AddMinutes(Convert.ToInt32(_configuration["JwtSettings:ExpirationMinutes"])),
                Issuer = _configuration["JwtSettings:Issuer"],
                Audience = _configuration["JwtSettings:Audience"],
                SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
            };
            var token = tokenHandler.CreateToken(tokenDescriptor);
            return tokenHandler.WriteToken(token);
        }

        public string? ValidateJwtToken(string? token)
        {
            if (token == null)
                return null;

            var tokenHandler = new JwtSecurityTokenHandler();
            var key = Encoding.ASCII.GetBytes(_configuration["Secret:SecretKey"]!);
            try
            {
                tokenHandler.ValidateToken(token, new TokenValidationParameters
                {
                    ValidateIssuerSigningKey = true,
                    IssuerSigningKey = new SymmetricSecurityKey(key),
                    ValidateIssuer = true,
                    ValidateAudience = true,
                    ValidIssuer = _configuration["JwtSettings:Issuer"], 
                    ValidAudience = _configuration["JwtSettings:Audience"], 
                    // 将clockskew设置为0，这样令牌就会在令牌过期时间过期(而不是5分钟后)
                    ClockSkew = TimeSpan.Zero
                }, out SecurityToken validatedToken);

                var jwtToken = (JwtSecurityToken)validatedToken;
                var userId = jwtToken.Claims.First(x => x.Type == "id").Value;

                // 如果验证成功，则从JWT令牌返回用户id
                return userId;
            }
            catch
            {
                return null;
            }
        }

        public string? GetCurrentToken()
        {
            string? token = _httpContextAccessor.HttpContext?.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
            return token;
        }

        public User? GetUserByToken()
        {
            string? token = GetCurrentToken();
            string? userId = ValidateJwtToken(token);
            User? user = _context.User.Where(u => u.id == userId).FirstOrDefault();
            return user;
        }

        public User? GetCurrentUser()
        {
            var context = _httpContextAccessor.HttpContext;
            if (context != null && context.Items.ContainsKey("User"))
            {
                return (User?)context.Items["User"];
            }
            return null;
        }

        public int GetExpiresMinutes()
        {
            return Convert.ToInt32(_configuration["JwtSettings:ExpirationMinutes"]);
        }
    }
}

5.3 新增过滤器全局验证 Token

只有标注 [AllowAnonymous] 特性的方法或者类才会跳过 Token 验证

using Loquy.Common.Dtos.Base;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;

namespace Loquy.Common.Authorization
{
    public class JwtFilter : IAuthorizationFilter
    {
        private readonly IJwtUtils _jwtUtils;
        public JwtFilter(IJwtUtils jwtUtils)
        {
            _jwtUtils = jwtUtils;
        }

        public void OnAuthorization(AuthorizationFilterContext context)
        {
            // 如果动作带有[AllowAnonymous]属性，则跳过授权
            var allowAnonymous = context.ActionDescriptor.EndpointMetadata.OfType().Any();
            if (allowAnonymous)
                return;

            // 授权
            var token = context.HttpContext.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
            var userId = _jwtUtils.ValidateJwtToken(token);
            if (userId == null)
            {
                // 用户未登录或token不正确
                var resultModel = ResultModel<string>.Fail("用户未登录或token不正确");
                context.Result = new JsonResult(resultModel) { StatusCode = StatusCodes.Status401Unauthorized };
            }
            else
            {
                context.HttpContext.Items["User"] = _jwtUtils.GetUserByToken();
            }
        }
    }
}

5.4 把 JWT 工具类和过滤器增加至项目启动文件

在 Startup 中的 ConfigureServices 方法中添加以下配置：

Services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
    options.TokenValidationParameters = new TokenValidationParameters
    {
        SaveSigninToken = true, // 保存 token,后台验证 token 是否生效(重要)
        ValidateIssuer = true, // 是否验证 Issuer
        ValidateAudience = true, // 是否验证 Audience
        ValidateLifetime = true, // 是否验证失效时间
        ValidateIssuerSigningKey = true, // 是否验证 SecurityKey
        ValidAudience = AppSetting.Secret.Audience, // Audience
        ValidIssuer = AppSetting.Secret.Issuer, // Issuer，这两项和前面签发j wt 的设置一致
        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(AppSetting.Secret.JWT))
    };
    options.Events = new JwtBearerEvents()
    {
        OnChallenge = context =>
        {
            context.HandleResponse();
            context.Response.Clear();
            context.Response.ContentType = "application/json";
            context.Response.StatusCode = StatusCodes.Status401Unauthorized;
            context.Response.WriteAsync(ResultModel<string>.Fail(StatusCodes.Status401Unauthorized, "授权未通过").Serialize());
            return Task.CompletedTask;
        }
    };
});

// 注入 JWT
services.AddScoped();

5.5 前端封装通用的 HTTP 请求方法（Vue3 + TS + Axios + Element Plus）

前端 Token 处理：请求发起时拦截判断 localStorage 是否有 Token 然后添加到请求头，请求响应时拦截判断是否 401 授权失败则跳转登录页。

import axios from 'axios'
import type { AxiosInstance, AxiosResponse, AxiosRequestConfig } from 'axios'
import { ElMessage, ElLoading } from 'element-plus'
import router from "@/router/index";

// 创建一个 axios 实例，并设置基本 URL
export const api: AxiosInstance = axios.create({
  baseURL: 'http://localhost:8002/',
  timeout: 10000 * 6, // 设置超时时间为 60 秒
  headers: {
    'Content-Type': 'application/json' // 设置请求头为 JSON 格式
  }
})

// 添加请求拦截器
api.interceptors.request.use(
  (config) => {
    const token = localStorage.getItem('accessToken');
    if (token) {
      config.headers.Authorization = `Bearer ${token}`;
    }
    return config
  },
  (error: any) => {
    // 对请求错误做些什么
    return Promise.reject(error)
  }
)

// 添加响应拦截器
api.interceptors.response.use(
  (response: AxiosResponse<any>) => {
    return response
  },
  (error: any) => {
    // 对响应错误做些什么
    if (error.response && error.response.status === 401) {
      ElMessage.error(error.response.data.message)
      localStorage.removeItem('accessToken');
      router.push('/login'); 
    }
    return Promise.reject(error)
  }
)

export const request = (
  url: string,
  method: 'GET' | 'POST' | 'PUT' | 'DELETE',
  params: any = {},
  loadingOptions: any = {}
): Promise<any> => {
  return new Promise((resolve, reject) => {
    const defaultLoadingOptions = {
      lock: true,
      text: '正在请求接口，请耐心等待',
      background: 'rgba(0, 0, 0, 0.1)'
    }

    let loading: any
    if (loadingOptions) {
      const finalLoadingOptions = { ...defaultLoadingOptions, ...loadingOptions }
      loading = ElLoading.service(finalLoadingOptions)
    }

    const requestConfig: AxiosRequestConfig = {
      url,
      method,
      params: method === 'GET' || method === 'DELETE' ? params : null,
      data: method === 'POST' || method === 'PUT' ? params : null
    }

    api
      .request(requestConfig)
      .then((response) => {
        const result = response.data
        if (result.code === 0) {
          resolve(result)
        } else {
          ElMessage.error(result)
          reject(result)
        }
      })
      .catch((error) => {
        ElMessage.error('接口发生错误：' + error)
        console.error('接口发生错误:', error)
        reject(error)
      })
      .finally(() => {
        setTimeout(() => {
          loading?.close()
        }, 500)
      })
  })
}

export default api

ADO.NET 使用教程

2023-12-22T06:58:38.000Z

1. 引言

1.1 ADO.NET简介

1.1.1 ADO.NET是什么？

ADO.NET（ActiveX Data Objects for .NET）是Microsoft.NET平台上用于数据访问和操作的一组技术。它提供了一种灵活而强大的框架，使开发人员能够连接各种数据源，执行查询、更新和其他数据库操作。

1.1.2 为什么使用ADO.NET？

ADO.NET的设计旨在满足数据访问的多样性和复杂性。通过分离数据访问和数据表示，支持多种数据源，以及提供高性能的数据访问机制，ADO.NET为.NET应用程序提供了强大而可扩展的数据管理工具。

1.2 ADO.NET的核心组件

1.2.1 连接（Connection）

连接是与数据源建立通信的关键组件。ADO.NET提供了连接对象，允许应用程序建立到数据库的连接，以便执行后续的数据操作。

1.2.2 命令（Command）

命令对象允许应用程序定义并执行SQL命令。通过命令对象，可以执行查询、更新、插入和删除等数据库操作。

1.2.3 数据读取器（DataReader）

数据读取器提供了一种只进的、高性能的读取数据的方式。它以流的形式逐行检索数据，适用于大型数据集的快速读取。

1.2.4 数据适配器（DataAdapter）

数据适配器用于填充数据集（DataSet）并更新数据库。它充当数据源和数据集之间的桥梁，支持将数据在内存中进行操作和缓存。

在接下来的章节中，我们将深入探讨每个核心组件的使用方法，以及如何利用它们来实现灵活、高效的数据访问。

2. 连接数据库

2.1 数据库连接字符串

2.1.1 常见连接字符串示例

数据库连接字符串是连接到数据库时的关键配置信息。不同数据库系统有不同的连接字符串格式，以下是一些常见数据库的连接字符串示例：

2.1.1.1 SQL Server连接字符串

1	`Data Source=myServerAddress;Initial Catalog=myDataBase;User Id=myUsername;Password=myPassword;`

2.1.1.2 MySQL连接字符串

1	`Server=myServerAddress;Database=myDataBase;Uid=myUsername;Pwd=myPassword;`

2.1.1.3 Oracle连接字符串

1	`Data Source=myOracleDB;User Id=myUsername;Password=myPassword;`

2.1.2 连接字符串中的重要参数

连接字符串中包含各种参数，以下是一些常见的参数及其作用：

2.1.2.1 Data Source（或 Server）

指定数据库服务器的地址或名称。

2.1.2.2 Initial Catalog（或 Database）

指定要连接的数据库的名称。

2.1.2.3 User Id（或 Uid）和 Password（或 Pwd）

指定连接数据库所使用的用户名和密码。

2.1. 建立数据库连接

2.1.1 使用SqlConnection类

在.NET中，可以使用SqlConnection类来建立与SQL Server数据库的连接。以下是一个简单的连接示例：

string connectionString = "Data Source=myServerAddress;Initial Catalog=myDataBase;User Id=myUsername;Password=myPassword;";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    // 在此执行数据库操作
}

2.1.2 打开和关闭连接

连接成功后，务必在不再需要连接时将其关闭，以释放资源。使用Open方法打开连接，使用Close方法关闭连接：

1
2
3

connection.Open(); // 打开连接
// 执行数据库操作
connection.Close(); // 关闭连接

通过以上介绍，读者现在应该了解到如何构建数据库连接字符串以及如何使用SqlConnection类来建立和关闭数据库连接。在下一章节中，我们将深入研究执行SQL命令的方式，包括使用SqlCommand对象和参数化查询。

3. 执行SQL命令

3.1 创建SqlCommand对象

3.1.1 常见构造方法

SqlCommand是执行与SQL Server数据库交互的关键类。以下是一些创建SqlCommand对象的常见方式：

3.1.1.1 基本构造方法

1	`SqlCommand command = new SqlCommand();`

3.1.1.2 指定SQL语句和连接的构造方法

string queryString = "SELECT * FROM TableName";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlCommand command = new SqlCommand(queryString, connection);
}

3.1.2 参数化查询

参数化查询是一种防止SQL注入攻击的重要方式。通过使用参数，可以安全地将用户输入嵌入到SQL命令中。以下是参数化查询的示例：

string queryString = "SELECT * FROM TableName WHERE ColumnName = @param1";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlCommand command = new SqlCommand(queryString, connection);
    command.Parameters.AddWithValue("@param1", userValue);
}

3.2 执行SQL命令

3.2.1 ExecuteNonQuery方法

ExecuteNonQuery方法用于执行不返回结果集的SQL语句，如INSERT、UPDATE和DELETE。示例：

string queryString = "INSERT INTO TableName (ColumnName) VALUES (@param1)";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlCommand command = new SqlCommand(queryString, connection);
    command.Parameters.AddWithValue("@param1", userValue);
    
    connection.Open();
    int rowsAffected = command.ExecuteNonQuery();
    connection.Close();
}

3.2.2 ExecuteScalar方法

ExecuteScalar方法用于执行查询并返回结果集的第一行第一列。通常用于获取聚合函数的结果或查询单一值。示例：

string queryString = "SELECT COUNT(*) FROM TableName";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlCommand command = new SqlCommand(queryString, connection);

    connection.Open();
    object result = command.ExecuteScalar();
    connection.Close();
}

3.2.3 ExecuteReader方法

ExecuteReader方法用于执行查询并返回SqlDataReader对象，用于逐行读取查询结果。示例：

string queryString = "SELECT * FROM TableName";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlCommand command = new SqlCommand(queryString, connection);

    connection.Open();
    using (SqlDataReader reader = command.ExecuteReader())
    {
        while (reader.Read())
        {
            // 处理每一行数据
        }
    }
    connection.Close();
}

通过以上介绍，读者应该了解如何创建SqlCommand对象，执行不同类型的SQL命令，并且学会了如何使用参数化查询提高应用程序的安全性。在下一章节中，我们将深入研究数据的读取和处理，包括使用DataReader逐行读取数据。

4. 数据读取和处理

4.1 使用DataReader读取数据

4.1.1 逐行读取数据

DataReader提供了一种高效的逐行读取数据的方式，适用于大量数据的快速检索。以下是一个基本的使用示例：

string queryString = "SELECT * FROM TableName";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlCommand command = new SqlCommand(queryString, connection);

    connection.Open();
    using (SqlDataReader reader = command.ExecuteReader())
    {
        while (reader.Read())
        {
            // 读取每一行数据
            int column1Value = reader.GetInt32(0); // 通过列索引获取值
            string column2Value = reader.GetString(1); // 通过列索引获取值
            // 处理数据...
        }
    }
    connection.Close();
}

4.1.2 获取列数据

DataReader提供了多种方法用于获取不同数据类型的列值。以下是一些常见的获取列数据的方法：

GetInt32(int ordinal)：获取整数类型列的值。
GetString(int ordinal)：获取字符串类型列的值。
GetDateTime(int ordinal)：获取日期时间类型列的值。
其他类型的获取方法，如GetBoolean、GetDecimal等。

4.2 数据类型映射

4.2.1 ADO.NET数据类型

ADO.NET支持与数据库中的多种数据类型进行映射。以下是一些常见的ADO.NET数据类型：

Int32：整数类型
String：字符串类型
DateTime：日期时间类型
Boolean：布尔类型
Decimal：十进制类型
…

4.2.2 数据库数据类型

不同的数据库系统支持不同的数据类型，因此在读取数据时，需要确保数据类型的正确映射。例如，SQL Server中的int类型对应于C#中的Int32类型，而MySQL中的INT类型也对应于C#中的Int32类型。

通过DataReader逐行读取数据，并理解数据类型的映射关系，开发人员可以灵活处理不同类型的数据，并确保应用程序对数据的正确解释和使用。

在下一章节中，我们将介绍数据适配器和数据集的概念，以及如何使用它们进行离线数据处理和缓存。

5. 数据适配器和数据集

5.1 数据适配器的作用

数据适配器是ADO.NET中的关键组件之一，用于在数据源（如数据库）和数据集之间建立桥梁。它负责将数据源中的数据填充到数据集中，以及将数据集中的更改提交回数据源。

5.1.1 数据适配器的基本用法

数据适配器通过执行命令（如SELECT、INSERT、UPDATE、DELETE）来与数据库进行交互，将数据填充到数据集中，并通过数据集将修改反馈给数据库。以下是数据适配器的基本用法：

string queryString = "SELECT * FROM TableName";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(queryString, connection);

    DataSet dataSet = new DataSet();
    
    // 使用数据适配器填充数据集
    adapter.Fill(dataSet, "TableName");

    // 对数据集进行操作...

    // 提交更改到数据库
    adapter.Update(dataSet, "TableName");
}

5.2 使用DataSet和DataTable

5.2.1 创建DataSet和DataTable对象

在使用数据集和数据表之前，需要创建相应的对象。以下是创建DataSet和DataTable对象的示例：

DataSet dataSet = new DataSet("MyDataSet");

// 创建DataTable
DataTable dataTable = new DataTable("MyDataTable");

// 将DataTable添加到DataSet中
dataSet.Tables.Add(dataTable);

5.2.2 数据关系和约束

数据集支持数据表之间的关系和约束，以维护数据的完整性。

5.2.2.1 创建数据关系

数据关系定义了不同数据表之间的关联，方便在应用程序中进行更复杂的查询和操作。以下是创建数据关系的示例：

1 2	`DataRelation relation = new DataRelation("MyRelation", parentTable.Columns["ParentColumn"], childTable.Columns["ChildColumn"]); dataSet.Relations.Add(relation);`

5.2.2.2 添加约束

约束用于定义数据表中列的规则，确保数据的正确性和完整性。以下是添加约束的示例：

1 2	`UniqueConstraint uniqueConstraint = new UniqueConstraint(dataTable.Columns["ColumnName"]); dataTable.Constraints.Add(uniqueConstraint);`

通过以上介绍，读者应该了解了数据适配器的作用，以及如何使用DataSet和DataTable进行离线数据处理和数据关系、约束的操作。在下一章节中，我们将深入探讨数据库事务的概念和在ADO.NET中的实际应用。

6. 数据库事务

6.1 事务的基本概念

6.1.1 什么是事务？

事务是数据库管理系统执行的一个操作序列，它要么完全执行，要么完全不执行，不会结束在中间的某个状态。事务可以包含一个或多个数据库操作，如插入、更新、删除等。

6.1.2 事务的特性

事务具有以下四个特性，通常被称为ACID特性：

原子性（Atomicity）：事务中的所有操作要么全部完成，要么全部撤销。如果事务中的任何一个操作失败，整个事务将被回滚，所有的更改都不会生效。
一致性（Consistency）：事务使数据库从一个一致性状态转移到另一个一致性状态。事务执行前后，数据库应保持一致性。
隔离性（Isolation）：事务的执行不受其他事务的干扰。即使有其他事务在同时执行，一个事务的执行不应影响其他事务。
持久性（Durability）：一旦事务完成，其结果就是永久性的。即使系统崩溃，数据库也应该能够在恢复后保持事务的结果。

6.2 ADO.NET中的事务处理

6.2.1 事务的开启和提交

在ADO.NET中，可以使用SqlTransaction类来实现事务处理。以下是事务的开启和提交的基本用法：

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    // 开始事务
    SqlTransaction transaction = connection.BeginTransaction();

    try
    {
        // 在事务中执行数据库操作
        SqlCommand command = new SqlCommand("UPDATE TableName SET ColumnName = Value", connection, transaction);
        command.ExecuteNonQuery();

        // 提交事务
        transaction.Commit();
    }
    catch (Exception ex)
    {
        // 发生异常，回滚事务
        transaction.Rollback();
    }
}

6.2.2 事务的回滚

如果在事务执行过程中发生异常或者事务操作不符合预期，可以通过回滚来撤销事务中的所有更改：

1	`transaction.Rollback();`

通过使用事务，可以确保数据库操作的一致性和完整性。在下一章节中，我们将介绍异常处理和错误处理的最佳实践，以确保应用程序在面临异常情况时能够做出适当的处理。

7 异常处理和错误处理

7.1 ADO.NET中的异常

7.1.1 常见的异常类型

在ADO.NET中，可能发生各种异常，例如数据库连接失败、SQL语法错误等。以下是一些常见的异常类型：

SqlException：与SQL Server相关的异常。
DbException：通用数据库异常类型。
InvalidOperationException：在无效操作时引发的异常。
ArgumentException：参数无效时引发的异常。
其他与数据库操作相关的异常类型。

7.1.2 异常处理的最佳实践

在处理异常时，建议使用适当的异常类型来捕获和处理异常。以下是一些最佳实践：

7.1.2.1 使用多个`catch`块

try
{
    // 数据库操作...
}
catch (SqlException ex)
{
    // 处理数据库相关的异常
    Console.WriteLine($"SQL Exception: {ex.Message}");
}
catch (DbException ex)
{
    // 处理通用数据库异常
    Console.WriteLine($"Database Exception: {ex.Message}");
}
catch (Exception ex)
{
    // 处理其他异常
    Console.WriteLine($"Exception: {ex.Message}");
}
finally
{
    // 在这里执行清理工作，如关闭连接等
}

7.1.2.2 使用`finally`块进行清理

finally块中的代码总是会执行，无论是否发生异常。这里可以放置一些清理资源的代码，如关闭数据库连接。

try
{
    // 数据库操作...
}
catch (SqlException ex)
{
    // 处理数据库相关的异常
    Console.WriteLine($"SQL Exception: {ex.Message}");
}
finally
{
    // 在这里执行清理工作，如关闭连接等
}

7.1.2.3 使用`using`语句自动释放资源

对于需要手动释放的资源，可以使用using语句，确保资源在使用完毕后被正确释放。

using (SqlConnection connection = new SqlConnection(connectionString))
{
    try
    {
        connection.Open();
        // 数据库操作...
    }
    catch (SqlException ex)
    {
        // 处理数据库相关的异常
        Console.WriteLine($"SQL Exception: {ex.Message}");
    }
    // 不需要显式关闭连接，using语句会自动调用connection.Dispose()
}

通过以上最佳实践，可以有效地处理异常，并确保应用程序在发生异常时能够保持稳定。在下一章节中，我们将介绍最佳实践和性能优化，以确保应用程序的高效运行。

8. 最佳实践和性能优化

8.1 参数化查询的重要性

8.1.1 什么是参数化查询？

参数化查询是通过将参数传递给SQL查询，而不是直接将用户输入嵌入到查询字符串中，从而防止SQL注入攻击。参数化查询可以提高查询性能，并提高应用程序的安全性。

8.1.2 参数化查询的示例

string queryString = "SELECT * FROM TableName WHERE ColumnName = @param1";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlCommand command = new SqlCommand(queryString, connection);
    command.Parameters.AddWithValue("@param1", userValue);

    connection.Open();
    using (SqlDataReader reader = command.ExecuteReader())
    {
        // 处理查询结果...
    }
    connection.Close();
}

8.2 数据库连接池

8.2.1 什么是数据库连接池？

数据库连接池是一种维护和管理数据库连接的技术，它允许应用程序在需要时从连接池中获取连接，而不是每次都重新创建连接。连接池可以提高应用程序的性能和资源利用率。

8.2.2 使用数据库连接池的示例

// 使用连接字符串创建连接，连接会自动添加到连接池
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    // 执行数据库操作...
}
// 连接会被自动放回连接池

8.3 数据缓存和性能提升

8.3.1 什么是数据缓存？

数据缓存是将一部分数据存储在内存中，以提高对这些数据的访问速度。在某些情况下，缓存可以减少对数据库的频繁访问，提高应用程序性能。

8.3.2 使用数据缓存的示例

// 使用缓存库（如MemoryCache）存储数据
MemoryCache cache = new MemoryCache(new MemoryCacheOptions());
List data = null;

// 尝试从缓存中获取数据
if (!cache.TryGetValue("CachedData", out data))
{
    // 数据不在缓存中，从数据库中获取数据
    data = GetDataFromDatabase();

    // 将数据存入缓存，设置过期时间等
    cache.Set("CachedData", data, TimeSpan.FromMinutes(10));
}

// 使用数据...

通过以上最佳实践和性能优化方法，可以提高应用程序的性能、安全性，并有效地管理数据库连接。这些方法有助于确保应用程序在处理大量数据时仍能保持高效。

9. 实例演练

9.1 基于ADO.NET的简单CRUD操作示例

9.1.1 连接数据库

string connectionString = "YourConnectionString";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    // 执行CRUD操作...
    
    connection.Close();
}

9.1.2 插入数据

string insertQuery = "INSERT INTO TableName (Column1, Column2) VALUES (@Value1, @Value2)";
using (SqlCommand command = new SqlCommand(insertQuery, connection))
{
    command.Parameters.AddWithValue("@Value1", value1);
    command.Parameters.AddWithValue("@Value2", value2);

    int rowsAffected = command.ExecuteNonQuery();
}

9.1.3 查询数据

string selectQuery = "SELECT * FROM TableName";
using (SqlCommand command = new SqlCommand(selectQuery, connection))
{
    using (SqlDataReader reader = command.ExecuteReader())
    {
        while (reader.Read())
        {
            // 处理查询结果...
        }
    }
}

9.1.4 更新数据

string updateQuery = "UPDATE TableName SET Column1 = @NewValue WHERE Column2 = @OldValue";
using (SqlCommand command = new SqlCommand(updateQuery, connection))
{
    command.Parameters.AddWithValue("@NewValue", newValue);
    command.Parameters.AddWithValue("@OldValue", oldValue);

    int rowsAffected = command.ExecuteNonQuery();
}

9.1.5 删除数据

string deleteQuery = "DELETE FROM TableName WHERE Column = @Value";
using (SqlCommand command = new SqlCommand(deleteQuery, connection))
{
    command.Parameters.AddWithValue("@Value", value);

    int rowsAffected = command.ExecuteNonQuery();
}

10.2 数据库事务的实际应用

10.2.1 开启事务

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    // 开始事务
    SqlTransaction transaction = connection.BeginTransaction();

    try
    {
        // 执行数据库操作...

        // 提交事务
        transaction.Commit();
    }
    catch (Exception ex)
    {
        // 发生异常，回滚事务
        transaction.Rollback();
    }
    finally
    {
        connection.Close();
    }
}

10.2.2 事务中的多个操作

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    // 开始事务
    SqlTransaction transaction = connection.BeginTransaction();

    try
    {
        // 执行数据库操作1
        SqlCommand command1 = new SqlCommand("UPDATE TableName SET Column1 = Value1", connection, transaction);
        command1.ExecuteNonQuery();

        // 执行数据库操作2
        SqlCommand command2 = new SqlCommand("UPDATE TableName SET Column2 = Value2", connection, transaction);
        command2.ExecuteNonQuery();

        // 提交事务
        transaction.Commit();
    }
    catch (Exception ex)
    {
        // 发生异常，回滚事务
        transaction.Rollback();
    }
    finally
    {
        connection.Close();
    }
}

通过以上实例演练，读者应该能够掌握基于ADO.NET进行简单CRUD操作的方法以及数据库事务的实际应用。这些实例有助于将理论知识转化为实际应用。

11 总结

11.1 ADO.NET的优势和局限性

11.1.1 优势

性能： ADO.NET 提供了高性能的数据访问，支持连接池和参数化查询，提高了数据库操作的效率。
灵活性： ADO.NET 提供了多种数据访问组件，如连接对象、命令对象、数据读取器等，使得开发人员可以根据需要灵活选择合适的组件。
与数据库的广泛兼容性： ADO.NET 可以与多种数据库系统进行集成，包括但不限于 Microsoft SQL Server、MySQL、Oracle 等。
事务支持： ADO.NET 提供了对事务的良好支持，开发人员可以通过事务来确保数据库操作的原子性、一致性、隔离性和持久性。

11.1.2 局限性

手动管理连接： ADO.NET 需要开发人员手动管理数据库连接的打开和关闭，如果不谨慎，可能会导致连接未正确关闭而产生资源泄漏。
较低的抽象级别： ADO.NET 的较低抽象级别可能使一些开发任务相对繁琐，相较于一些 ORM 框架，需要更多手动操作。
与数据库紧耦合： 使用 ADO.NET 进行数据库操作时，应用程序与特定数据库的交互较为紧密，切换数据库系统时可能需要进行较大的改动。

11.2 推荐学习资源

11.2.1 官方文档

Microsoft ADO.NET Documentation

通过深入学习和实践，你可以更好地掌握 ADO.NET，并将其应用于实际项目中。希望读者能够在使用ADO.NET中取得良好的效果，不断提升自己的数据访问和处理能力。

SQL Server 存储过程语法教程

2023-10-11T08:57:28.000Z

1. 什么是存储过程？

存储过程（Stored Procedure）是一种在 SQL Server 数据库中定义的可执行的、可重用的数据库对象。它包含了一组 SQL 语句和控制结构，用于执行特定的任务或操作。存储过程通常具有以下特点：

封装性：存储过程将一系列 SQL 语句封装在一个单一的命名单元中。这有助于组织和管理数据库逻辑，同时也提高了数据的安全性，因为用户无法直接访问存储过程中的 SQL 语句。
可重用性：存储过程可以在不同的地方和时间被多次调用。这使得相同的操作可以在多个地方使用，从而提高了代码的重用性。
性能优化：存储过程可以被 SQL Server 编译和优化，以提高执行效率。存储过程的执行计划可以被缓存，减少了重复编译的开销。
安全性：存储过程可以控制对数据库对象的访问权限。只有具有执行权限的用户或应用程序才能执行存储过程。
参数化：存储过程可以接受参数，从外部传递数据给存储过程，使其更加通用和灵活。
减少网络流量：通过将一组操作放在数据库内部执行，可以减少网络传输的数据量，提高应用程序性能。

总之，存储过程是 SQL Server 数据库管理和应用程序开发中的重要工具，能够提高性能、安全性和代码的可维护性。它们在执行常见的数据库操作和数据处理任务时非常有用。

2. 存储过程的创建、删除、更新

创建存储过程是使用 SQL Server 数据库的关键任务之一。存储过程是数据库对象，包含一组 SQL 语句和逻辑，它们可以在需要时被调用。以下是关于创建存储过程的步骤和示例。

创建存储过程的语法

在 SQL Server 中，创建存储过程的一般语法如下：

CREATE PROCEDURE ProcedureName
    @Parameter1 DataType,
    @Parameter2 DataType
AS
BEGIN
    -- 存储过程的主体逻辑
END;

CREATE PROCEDURE 语句用于声明你要创建一个存储过程。
ProcedureName 是存储过程的名称，你可以根据需要自定义名称。
@Parameter1 和 @Parameter2 是存储过程的参数，你可以定义零个或多个参数。
DataType 是参数的数据类型，例如 INT、VARCHAR 等。
AS 关键字用于标识存储过程的主体逻辑的开始。
BEGIN 和 END 用于包裹存储过程的实际操作。

参数的定义与传递

存储过程可以接受参数，这使得它们可以更通用和灵活。参数分为输入参数和输出参数：

输入参数：用于传递数据给存储过程，在存储过程内部使用。
输出参数：用于从存储过程中返回数据给调用方。

以下是一个示例，演示如何创建一个简单的存储过程：

CREATE PROCEDURE GetEmployee
    @EmployeeID INT
AS
BEGIN
    SELECT * FROM Employees WHERE EmployeeID = @EmployeeID;
END;

在这个示例中，我们创建了一个名为 GetEmployee 的存储过程，它接受一个输入参数 @EmployeeID，并根据这个参数返回相应的员工信息。

示例：创建一个简单的存储过程

以下是一个更详细的示例，展示如何创建一个简单的存储过程，它接受两个参数，执行一个查询，并返回结果：

CREATE PROCEDURE GetSalesData
    @StartDate DATE,
    @EndDate DATE
AS
BEGIN
    SELECT SalesDate, TotalSales
    FROM Sales
    WHERE SalesDate BETWEEN @StartDate AND @EndDate;
END;

在这个示例中，存储过程名为 GetSalesData，它接受两个日期参数 @StartDate 和 @EndDate，并返回在指定日期范围内的销售数据。

创建存储过程是 SQL Server 数据库管理和应用程序开发中的基本技能之一。它们可以用于执行各种数据库操作，从简单的查询到复杂的数据处理。存储过程的创建是数据库开发的重要一步，使你能够更好地组织和管理数据库逻辑。

当你创建存储过程后，你可能需要对其进行修改或删除。这两个操作同样在数据库开发中非常重要。让我们看看如何进行存储过程的修改和删除。

修改存储过程

要修改现有的存储过程，你可以使用 ALTER PROCEDURE 语句，并提供新的存储过程定义。以下是一个示例，演示如何修改存储过程的参数：

ALTER PROCEDURE GetSalesData
    @StartDate DATE,
    @EndDate DATE,
    @Category VARCHAR(50)
AS
BEGIN
    SELECT SalesDate, TotalSales
    FROM Sales
    WHERE SalesDate BETWEEN @StartDate AND @EndDate
    AND Category = @Category;
END;

在此示例中，我们添加了一个新的参数 @Category 到存储过程 GetSalesData，以便在查询中使用。这使你可以扩展存储过程的功能，以满足新的需求。

删除存储过程

要删除存储过程，可以使用 DROP PROCEDURE 语句，后跟存储过程的名称。以下是一个示例：

1	`DROP PROCEDURE GetSalesData;`

这将永久删除名为 GetSalesData 的存储过程。请小心使用此命令，因为它无法恢复已删除的存储过程。在删除存储过程之前，确保你不再需要它，或者在删除之前创建备份。

修改和删除存储过程是数据库维护和开发中的常见任务，它们使你能够适应数据库结构和业务需求的变化。通过使用 ALTER PROCEDURE 和 DROP PROCEDURE 语句，你可以轻松管理存储过程，以确保数据库的有效性和一致性。

3. 存储过程的执行

存储过程可以通过多种方式执行，包括直接执行和从应用程序代码中调用。下面将介绍不同的执行方式，包括不指定变量名直接传值的方式。

直接执行存储过程

在 SQL Server 中，你可以使用 EXEC 语句来直接执行存储过程。以下是一些执行方式的示例：

方式1：指定参数名和值

1	`EXEC MyStoredProcedure @Parameter1 = Value1, @Parameter2 = Value2;`

在这种方式下，参数名和值是显式指定的。

方式2：只传递值

如果存储过程的参数在定义时没有指定默认值，你可以只传递参数的值，无需指定参数名。

1	`EXEC MyStoredProcedure Value1, Value2;`

这种方式下，SQL Server 会按照参数在存储过程中的顺序依次匹配值。要小心使用这种方式，确保参数的顺序正确。

方式3：使用参数名传递值

你也可以直接使用参数名传递值，无需显式指定参数名。这种方式在参数顺序变化时尤其有用。

1	`EXEC MyStoredProcedure Value1, @Parameter2 = Value2;`

从应用程序代码中调用存储过程

除了直接执行存储过程，你还可以从应用程序代码中调用存储过程。这通常使用数据库连接库（如 ADO.NET、Entity Framework 等）完成。以下是一个示例：

使用 C# 和 ADO.NET

using System.Data;
using System.Data.SqlClient;

string connectionString = "your_connection_string";
int parameter1 = 42;
string parameter2 = "SomeValue";

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    using (SqlCommand cmd = new SqlCommand("MyStoredProcedure", connection))
    {
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Parameters.AddWithValue("@Parameter1", parameter1);
        cmd.Parameters.AddWithValue("@Parameter2", parameter2);

        cmd.ExecuteNonQuery();
    }
}

在这个示例中，我们使用 C# 和 ADO.NET 从应用程序代码中调用了名为 MyStoredProcedure 的存储过程，并传递了参数的值。这种方式在开发应用程序时非常常见，因为它允许你通过应用程序与数据库交互。

无论你是在 SQL 查询工具中直接执行存储过程，还是从应用程序代码中调用它，存储过程的执行方式取决于具体需求和编程环境。不同的方式提供了不同的灵活性和控制选项，以满足不同的应用场景。

4. 存储过程的参数

存储过程是用于执行数据库操作的重要工具，它可以接受参数以便进行不同的数据处理。存储过程的参数分为输入参数和输出参数，它们使存储过程更加通用和灵活。

输入参数

输入参数用于将数据传递给存储过程，供其内部使用。在存储过程中，输入参数的值可以被引用和操作，但无法被更改。以下是定义输入参数的示例：

CREATE PROCEDURE MyStoredProcedure
    @InputParameter1 DataType,
    @InputParameter2 DataType
AS
BEGIN
    -- 存储过程的主体逻辑
END;

@InputParameter1 和 @InputParameter2 是输入参数的名称。
DataType 是参数的数据类型，可以是整数、字符、日期等。

在存储过程内部，你可以使用这些输入参数执行各种操作，例如查询数据库、更新记录或计算结果。

输出参数

输出参数用于从存储过程中返回数据给调用方。输出参数可以在存储过程执行后包含特定的结果值。以下是定义输出参数的示例：

CREATE PROCEDURE MyStoredProcedure
    @InputParameter DataType,
    @OutputParameter DataType OUTPUT
AS
BEGIN
    -- 存储过程的主体逻辑
    SET @OutputParameter = SomeValue;
END;

@OutputParameter 带有 OUTPUT 关键字，表示它是一个输出参数。
存储过程内部可以使用 SET 语句来设置输出参数的值，以便在存储过程执行后返回给调用方。

使用参数传递数据

存储过程参数的主要目的是传递数据。以下是如何在执行存储过程时传递参数的示例：

在 EXEC 语句中传递参数值

1	`EXEC MyStoredProcedure @InputParameter1 = Value1, @InputParameter2 = Value2;`

在这里，Value1 和 Value2 是要传递给存储过程的具体值。

从应用程序代码中调用存储过程

在应用程序代码中，你可以使用数据库连接库（如 ADO.NET）来为存储过程的参数赋值，然后执行存储过程。以下是一个示例：

using System.Data;
using System.Data.SqlClient;

string connectionString = "your_connection_string";
int inputParameter = 42;

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();

    using (SqlCommand cmd = new SqlCommand("MyStoredProcedure", connection))
    {
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Parameters.AddWithValue("@InputParameter", inputParameter);

        // 执行存储过程
        cmd.ExecuteNonQuery();

        // 获取输出参数的值（如果有输出参数）
        var outputValue = cmd.Parameters["@OutputParameter"].Value;
    }
}

在应用程序代码中，你可以设置输入参数的值，并在存储过程执行后检索输出参数的值（如果有输出参数）。

存储过程参数使数据库操作更加灵活和通用。它们可以用于接受外部数据、执行特定的操作，并将结果返回给调用方，这是在数据库管理和应用程序开发中非常常见的需求。

5. 错误处理与异常

错误处理是存储过程开发中的一个重要方面，因为它确保了在执行期间出现问题时如何处理异常情况。SQL Server 提供了一些机制来处理错误和异常，包括 TRY...CATCH 块和 RAISEERROR 函数。

TRY…CATCH 块

TRY...CATCH 块是一种用于处理异常的结构，允许你捕获并处理执行存储过程期间出现的错误。以下是 TRY...CATCH 块的基本结构：

BEGIN TRY
    -- 可能引发错误的代码
END TRY
BEGIN CATCH
    -- 处理错误的代码
END CATCH

在 TRY 块中，你可以放置可能引发错误的代码。如果在 TRY 块中出现了错误，控制将转移到相应的 CATCH 块，其中可以处理错误，例如记录错误信息或执行特定的操作。

RAISEERROR 函数

RAISEERROR 函数用于引发自定义错误消息，通常与 TRY...CATCH 块一起使用。它的语法如下：

1	`RAISEERROR (MessageString, Severity, State);`

MessageString 是要显示的错误消息。
Severity 是错误的严重性级别，通常在 0 到 25 之间，越高表示错误越严重。
State 是错误状态码，通常用于标识错误的来源。

以下是一个使用 TRY...CATCH 块和 RAISEERROR 函数的示例：

BEGIN TRY
    -- 尝试执行可能引发错误的操作
    SELECT 1 / 0; -- 这会引发除零错误
END TRY
BEGIN CATCH
    -- 处理错误
    DECLARE @ErrorMessage NVARCHAR(4000) = ERROR_MESSAGE();
    DECLARE @ErrorSeverity INT = ERROR_SEVERITY();
    DECLARE @ErrorState INT = ERROR_STATE();

    -- 记录错误信息
    RAISEERROR (@ErrorMessage, @ErrorSeverity, @ErrorState);
END CATCH

在这个示例中，TRY...CATCH 块尝试执行一个除零操作，它会引发一个错误。CATCH 块捕获错误，记录错误信息，然后使用 RAISEERROR 函数引发自定义错误消息。

错误处理和异常处理是确保存储过程能够应对执行期间出现的问题的关键部分。通过使用 TRY...CATCH 块和 RAISEERROR 函数，你可以优雅地处理错误，记录相关信息，同时确保存储过程能够在出现问题时继续执行或提供有关问题的有用信息。

6. 存储过程中的控制流程

存储过程不仅仅是一系列 SQL 语句的集合，还可以包含控制流程逻辑，这意味着你可以在存储过程中使用条件、循环和跳转等结构来实现更复杂的逻辑。以下是存储过程中常用的控制流程结构：

1. IF…ELSE 语句

IF...ELSE 语句用于根据条件执行不同的代码块。它的基本语法如下：

IF Condition
BEGIN
    -- 在条件为真时执行的代码
END
ELSE
BEGIN
    -- 在条件为假时执行的代码
END

以下是一个示例，演示如何在存储过程中使用 IF...ELSE：

IF @IsAdmin = 1
BEGIN
    -- 执行管理员操作
END
ELSE
BEGIN
    -- 执行普通用户操作
END

2. WHILE 循环

WHILE 循环允许你多次执行一组语句，只要给定条件为真。它的语法如下：

WHILE Condition
BEGIN
    -- 循环体，可以包含多个语句
END

以下是一个示例，演示如何在存储过程中使用 WHILE 循环：

DECLARE @Counter INT = 1;
WHILE @Counter <= 10
BEGIN
    -- 执行循环内的操作
    SET @Counter = @Counter + 1;
END

3. GOTO 语句和标签的使用

GOTO 语句和标签的组合允许你在存储过程中跳转到带有标签的代码块，通常用于处理错误、异常或特定条件下的控制流程。冒号 : 用于定义标签，标识代码块的起始点。虽然强大，但也潜在危险，应小心使用。以下是示例和用法：

-- 标签的使用
ErrorHandling:
-- 错误处理逻辑

-- 在某个条件下跳转到标签
IF @SomeCondition = 1
BEGIN
    -- 执行某些操作
END
ELSE
BEGIN
    GOTO ErrorHandling; -- 跳转到错误处理代码块
END

在上述示例中，ErrorHandling 后的冒号 : 标识了一个标签，用于标识错误处理代码块的起始点。当某个条件不满足时，通过 GOTO 语句，控制流程会跳转到标签 ErrorHandling 处执行相应的错误处理逻辑。标签和冒号的使用允许你在存储过程中灵活地管理控制流程，特别是在处理异常情况时非常有用。

4. RETURN 语句

RETURN 语句用于从存储过程中返回结果。它可以用于提前退出存储过程执行，也可以用于返回值。以下是一个示例：

IF @SomeCondition = 1
BEGIN
    -- 执行某些操作
    RETURN 0; -- 返回成功代码
END

5. 使用逻辑运算符

你可以在存储过程中使用逻辑运算符（如 AND 和 OR）以及括号来构建复杂的条件表达式，以便更灵活地控制流程。这使你能够编写更复杂的条件和逻辑，以满足具体需求。以下是一个示例：

IF (@IsAdmin = 1 AND @HasPermission = 1) OR @UserRole = 'SuperAdmin'
BEGIN
    -- 执行某些操作
END
ELSE
BEGIN
    -- 执行其他操作
END

这些控制流程结构使你能够编写更复杂的存储过程，可以根据条件执行不同的操作，循环执行操作，或者跳转到其他部分来处理不同的情况。但请小心使用，确保代码清晰可维护，以避免混乱和错误。

7. 返回数据

在存储过程中，有多种方式可以返回数据给调用方或客户端应用程序，具体取决于存储过程的设计和需求。以下是一些常见的方法：

1. 使用 SELECT 语句

最常见的方式是通过在存储过程中使用 SELECT 语句来返回数据集。这些数据可以被存储过程的调用方或客户端应用程序检索和处理。

CREATE PROCEDURE GetEmployees
AS
BEGIN
    SELECT EmployeeID, FirstName, LastName FROM Employees;
END;

在这个示例中，存储过程 GetEmployees 使用 SELECT 语句返回了员工表中的数据。

2. 使用 OUTPUT 参数

你可以在存储过程中定义输出参数，然后通过这些参数将数据返回给调用方。

CREATE PROCEDURE GetEmployeeName
    @EmployeeID INT,
    @EmployeeName NVARCHAR(50) OUTPUT
AS
BEGIN
    SELECT @EmployeeName = FirstName + ' ' + LastName
    FROM Employees
    WHERE EmployeeID = @EmployeeID;
END;

在这个示例中，存储过程 GetEmployeeName 接受一个输入参数 @EmployeeID，并将查询结果存储在输出参数 @EmployeeName 中。

3. 使用表变量或临时表

你可以在存储过程中创建表变量或临时表，将数据插入到这些表中，然后返回表的内容。这对于返回多个数据行或多个结果集非常有用。

CREATE PROCEDURE GetProductsByCategory
    @CategoryID INT
AS
BEGIN
    DECLARE @Products TABLE (
        ProductID INT,
        ProductName NVARCHAR(100)
    );

    INSERT INTO @Products
    SELECT ProductID, ProductName
    FROM Products
    WHERE CategoryID = @CategoryID;

    SELECT * FROM @Products;
END;

在这个示例中，存储过程 GetProductsByCategory 创建了一个表变量 @Products，将符合条件的产品数据插入到表中，然后通过 SELECT 语句返回表的内容。

4. 使用 XML 或 JSON

如果需要返回复杂的数据结构，你可以将结果转化为 XML 或 JSON 格式，然后将其返回给调用方。SQL Server 提供了内置函数和方法来处理 XML 和 JSON 数据。

CREATE PROCEDURE GetEmployeesAsJSON
AS
BEGIN
    SELECT EmployeeID, FirstName, LastName
    FROM Employees
    FOR JSON AUTO;
END;

在这个示例中，存储过程 GetEmployeesAsJSON 使用 FOR JSON 子句将查询结果以 JSON 格式返回。

使用 RETURN 语句

RETURN 语句通常用于从存储过程中返回一个整数值，表示存储过程的执行状态或结果。这个返回值可以用于指示存储过程的成功或失败，或者返回其他自定义信息。

以下是一个示例，演示如何在存储过程中使用 RETURN 语句：

CREATE PROCEDURE CalculateSum
    @Value1 INT,
    @Value2 INT
AS
BEGIN
    DECLARE @Sum INT;

    SET @Sum = @Value1 + @Value2;

    IF @Sum > 100
    BEGIN
        -- 存储过程执行成功
        RETURN 0;
    END
    ELSE
    BEGIN
        -- 存储过程执行失败
        RETURN -1;
    END
END;

在这个示例中，存储过程 CalculateSum 接受两个整数参数，计算它们的和，并根据计算结果使用 RETURN 语句返回不同的值。如果和大于 100，存储过程返回 0，表示成功；否则，返回 -1，表示失败。

应用程序或客户端应用程序可以检查存储过程的返回值，以确定执行是否成功，然后根据需要采取进一步的操作。 RETURN 语句通常用于返回存储过程的状态或执行结果，但不用于返回数据集或查询结果。如果需要返回数据集，通常使用 SELECT 语句或输出参数。

无论使用哪种方法，存储过程可以根据具体需求返回不同类型的数据，包括单个值、数据集、XML、JSON 或其他自定义数据结构。数据的返回方式应根据应用程序的要求和数据交互的复杂性来选择。

8. 表值函数和标量函数

在 SQL Server 中，表值函数和标量函数是两种特殊类型的用户定义函数，它们允许你封装和重用 SQL 逻辑，以便在查询中使用。这些函数可以在存储过程中或 SQL 查询中发挥关键作用。

表值函数（Table-Valued Functions）

表值函数是一种用户定义函数，它返回一个表作为结果。这允许你将表值函数的结果集嵌套到查询中，类似于从表中检索数据。有两种类型的表值函数：

内联表值函数（Inline Table-Valued Function）：这类函数返回一个结果集，并可以像表一样直接参与查询的 FROM 子句中。内联表值函数的结果集在查询中扮演了一个虚拟表的角色。

CREATE FUNCTION GetEmployeesByDepartment(@DepartmentID INT)
RETURNS TABLE
AS
RETURN (
    SELECT EmployeeID, FirstName, LastName
    FROM Employees
    WHERE DepartmentID = @DepartmentID
);

这个内联表值函数接受一个部门 ID，返回该部门的所有员工。你可以在查询中像使用表一样调用它：

1	`SELECT * FROM GetEmployeesByDepartment(1);`

多语句表值函数（Multi-Statement Table-Valued Function）：这类函数使用 BEGIN...END 块内的多条语句来生成结果集。它们允许更复杂的逻辑，但不能像内联表值函数那样直接嵌套在查询中。

CREATE FUNCTION GetHighSalaryEmployees()
RETURNS @HighSalaryEmployees TABLE
(
    EmployeeID INT,
    FirstName NVARCHAR(50),
    LastName NVARCHAR(50)
)
AS
BEGIN
    INSERT INTO @HighSalaryEmployees
    SELECT EmployeeID, FirstName, LastName
    FROM Employees
    WHERE Salary > 50000;
    RETURN;
END;

标量函数（Scalar Functions）

标量函数是一种用户定义函数，它返回单个标量值作为结果，例如整数、字符串或日期。标量函数通常用于计算、转换或处理数据。以下是一个标量函数的示例：

CREATE FUNCTION CalculateAge(@BirthDate DATE)
RETURNS INT
AS
BEGIN
    DECLARE @Age INT;
    SET @Age = DATEDIFF(YEAR, @BirthDate, GETDATE());
    RETURN @Age;
END;

这个标量函数接受出生日期，返回计算出的年龄。

1	`SELECT dbo.CalculateAge('1990-01-01'); -- 使用标量函数计算年龄`

表值函数和标量函数可以在 SQL 查询中使用，以实现更灵活的数据操作和逻辑封装。它们可以用于简化查询、减少重复性代码，提高可维护性，并提供更强大的数据操作功能。

当谈到表值函数、标量函数以及存储过程时，有一些关键区别需要理解。下面我将为你提供示例，并解释这三者之间的不同之处。

与存储过程的区别

下面是一个表格，描述了函数和存储过程之间的关键区别：

特征	函数	存储过程
返回值	返回一个值或表	通常不返回值，可以执行一系列操作
用途	通常用于封装计算、数据处理或转换逻辑	用于执行数据操作、事务管理、错误处理等
执行方式	可以在查询中直接使用，嵌套在查询中	通常需要使用 `EXEC` 或 `CALL` 显式执行
事务	可以在事务中调用，但通常不引起事务的隐式启动或提交	可以包含事务管理逻辑，例如启动、提交或回滚事务
修改数据库	通常不用于直接修改数据库中的数据	通常用于执行更新、插入、删除等操作，可以修改数据库中的数据
数据操作类型	可能包括 `SELECT` 查询、计算、数据处理等	包括更新、插入、删除、错误处理等数据操作

这个表格强调了函数和存储过程之间的重要区别，尤其是在返回值、用途和执行方式方面。选择使用哪种方式应根据具体需求和任务的性质来决定。

9. 事务管理

在 SQL Server 中，事务管理是数据库管理的关键部分。事务是一组 SQL 操作，要么全部成功执行，要么全部失败并回滚到之前的状态。这确保了数据库的一致性和可靠性。SQL Server 提供了多种方法来管理事务，包括显式事务和隐式事务。

显式事务

显式事务是由开发者显式指定和控制的事务。它们通常用于复杂的数据库操作，确保多个 SQL 语句要么全部执行成功，要么全部失败。显式事务通常使用以下关键字来定义和管理：

BEGIN TRANSACTION：开始一个新事务。
COMMIT：提交当前事务，如果一切正常，事务中的更改将保存到数据库。
ROLLBACK：回滚当前事务，如果出现错误，事务中的更改将被撤销。

以下是一个示例，演示如何使用显式事务管理：

BEGIN TRANSACTION;

UPDATE Accounts SET Balance = Balance - 100 WHERE AccountID = 1;
INSERT INTO Transactions (AccountID, Amount) VALUES (1, -100);

-- 检查其他条件，如果不符合条件则回滚事务
IF @SomeCondition = 0
BEGIN
    ROLLBACK;
    PRINT 'Transaction rolled back.';
END
ELSE
BEGIN
    COMMIT;
    PRINT 'Transaction committed.';
END;

隐式事务

隐式事务是在不明确声明事务的情况下自动启动的事务。通常，每个 SQL 语句都在自己的事务内运行。如果 SQL Server 检测到错误，它将回滚当前事务。如果一切正常，它将自动提交当前事务。

以下是一个示例，演示隐式事务的工作方式：

1
2
3

-- 如果任何语句失败，SQL Server 将自动回滚事务
UPDATE Employees SET Salary = Salary + 500 WHERE Department = 'HR';
INSERT INTO Transactions (EmployeeID, Amount) VALUES (123, 500);

保存点（Savepoints）

SQL Server 允许你在事务中设置保存点，以便在发生错误时回滚到特定的保存点，而不是回滚整个事务。这对于在事务中执行多个步骤并希望能够部分回滚时非常有用。

BEGIN TRANSACTION;

-- 步骤 1
UPDATE Products SET Quantity = Quantity - 10 WHERE ProductID = 1;

-- 设置保存点
SAVE TRANSACTION Step1Complete;

-- 步骤 2
INSERT INTO Orders (ProductID, Quantity) VALUES (1, 10);

-- 检查条件，如果不符合条件则回滚到保存点
IF @SomeCondition = 0
BEGIN
    ROLLBACK TRANSACTION Step1Complete;
    PRINT 'Rolled back to Step 1.';
END
ELSE
BEGIN
    COMMIT;
    PRINT 'Transaction committed.';
END;

在这个示例中，如果某些条件不满足，事务将回滚到保存点 Step1Complete，仅回滚第一步骤的更改。

事务管理是确保数据库操作的一致性和可靠性的重要组成部分。通过使用显式或隐式事务以及保存点，你可以有效地管理事务，以适应不同的业务需求。

10. 游标（Cursor）

游标（Cursor）是一种数据库对象，用于在结果集中逐行浏览数据，通常用于对数据进行逐行处理。以下是游标的生命周期：

阶段	操作	示例
游标声明和定义	声明游标并定义要检索的数据集	DECLARE cursor_name CURSOR FOR SELECT column1, column2 FROM table
游标打开	打开游标以准备开始数据检索	OPEN cursor_name
数据检索	逐行检索数据并存储在变量中	FETCH NEXT FROM cursor_name INTO @var1, @var2
处理操作	处理从游标中检索到的数据	在此执行数据操作和逻辑
游标关闭	关闭游标以释放数据库资源	CLOSE cursor_name
游标释放	释放游标以清除游标定义和声明	DEALLOCATE cursor_name

下面是一个示例存储过程，使用游标遍历表中的数据：

CREATE PROCEDURE ProcessDataWithCursor
AS
BEGIN
    DECLARE @EmployeeID INT;
    DECLARE @FirstName NVARCHAR(50);
    DECLARE @LastName NVARCHAR(50);

    -- 声明和打开游标
    DECLARE EmployeeCursor CURSOR FOR
    SELECT EmployeeID, FirstName, LastName
    FROM Employees;

    OPEN EmployeeCursor;

    -- 获取第一行数据
    FETCH NEXT FROM EmployeeCursor INTO @EmployeeID, @FirstName, @LastName;

    -- 开始循环处理数据
    WHILE @@FETCH_STATUS = 0
    BEGIN
        -- 在这里进行数据处理，可以执行任何操作
        PRINT 'Employee: ' + @FirstName + ' ' + @LastName;

        -- 获取下一行数据
        FETCH NEXT FROM EmployeeCursor INTO @EmployeeID, @FirstName, @LastName;
    END;

    -- 关闭和释放游标
    CLOSE EmployeeCursor;
    DEALLOCATE EmployeeCursor;
END;

这个存储过程使用游标来遍历名为 Employees 的表中的员工数据。在游标内部，它获取每一行的员工数据，并可以对每一行数据执行自定义操作。游标在循环结束后被关闭和释放。

需要注意的是，使用游标可能会导致性能问题，特别是在处理大量数据时。因此，应该仔细考虑是否有更有效的方法来执行数据操作，例如使用集合操作（如 UPDATE 或 INSERT INTO ... SELECT）来替代游标。

11. 系统变量

以下是这些常见系统变量的用法：

@@ERROR：用于检查最近一次 SQL 操作是否引发了错误。通常与 TRY...CATCH 块结合使用，以捕获和处理错误。

BEGIN TRY
    -- 一些 SQL 操作
END TRY
BEGIN CATCH
    -- 处理错误
    IF @@ERROR <> 0
    BEGIN
        -- 执行回滚等操作
        ROLLBACK;
        -- 记录错误信息
        PRINT 'An error occurred: ' + CAST(@@ERROR AS NVARCHAR(10));
    END
END CATCH

@@IDENTITY：用于获取最近插入的标识列的值，通常在 INSERT 操作之后使用。
1
2
INSERT INTO Customers (Name) VALUES ('John Doe'); SELECT @@IDENTITY;

@@ROWCOUNT：用于确定最近的 SQL 语句影响了多少行，通常用于检查操作是否成功或获取受影响的行数。

1
2
3

DELETE FROM Products WHERE Price < 10.00;
IF @@ROWCOUNT > 0
    PRINT 'Deleted ' + CAST(@@ROWCOUNT AS NVARCHAR(10)) + ' rows.';

@@FETCH_STATUS：通常与游标一起使用，以检查 FETCH 操作的状态。

-- 声明和打开游标
DECLARE EmployeeCursor CURSOR FOR
SELECT EmployeeID, FirstName, LastName
FROM Employees;

OPEN EmployeeCursor;

-- 获取第一行数据
FETCH NEXT FROM EmployeeCursor INTO @EmployeeID, @FirstName, @LastName;

-- 检查 FETCH 操作的状态
-- 0：FETCH 操作成功，已经获得了一行或更多行。
-- 1：FETCH 操作失败或没有更多的行可供获取。
-- 2：游标未初始化。
IF @@FETCH_STATUS = 0
BEGIN
    -- 数据获取成功
    PRINT 'Employee: ' + @FirstName + ' ' + @LastName;
END

@@TRANCOUNT：用于跟踪事务的嵌套级别。通常与 BEGIN TRANSACTION 和 COMMIT/ROLLBACK TRANSACTION 一起使用。

BEGIN TRANSACTION; -- 嵌套事务级别 +1
-- 一些操作
IF @@TRANCOUNT > 0
    COMMIT; -- 提交内部事务，嵌套级别 -1

@@LANGUAGE：用于更改当前会话的语言设置，可以影响错误消息和日期格式。
1
2
SET LANGUAGE 'French'; PRINT 'Current Language: ' + @@LANGUAGE;
@@CONNECTIONS：用于获取当前数据库服务器的连接数，可用于监视服务器的负载。
1
SELECT @@CONNECTIONS AS 'Number of Connections';
@@CPU_BUSY：用于获取 SQL Server 实例的 CPU 使用率，有助于监视服务器的性能。
1
SELECT @@CPU_BUSY AS 'CPU Usage';
@@TOTAL_ERRORS：用于获取 SQL Server 实例的总错误数，有助于监视服务器的错误情况。
1
SELECT @@TOTAL_ERRORS AS 'Total Errors';
@@PACK_RECEIVED 和 @@PACK_SENT：用于监视网络数据包的接收和发送情况，有助于分析网络性能。
1
SELECT @@PACK_RECEIVED AS 'Packets Received', @@PACK_SENT AS 'Packets Sent';
@@SERVERNAME：用于获取 SQL Server 实例的名称，有助于标识服务器。
1
SELECT @@SERVERNAME AS 'Server Name';
@@SERVICENAME：用于获取 SQL Server 实例的服务名称，这也可以用于标识服务器。
1
SELECT @@SERVICENAME AS 'Service Name';
@@VERSION：用于获取 SQL Server 的版本信息，可以用于确定正在运行的 SQL Server 版本。
1
SELECT @@VERSION AS 'SQL Server Version';
@@OPTIONS：包含有关当前会话的选项设置，这可以用于查看当前会话的配置。
1
SELECT @@OPTIONS AS 'Session Options';

这些系统变量为性能监视、错误分析、服务器标识以及在数据库对象中控制流程、错误处理和获取与数据库操作相关信息提供了关键工具。

12. 系统存储过程

以下是一些常见系统存储过程：

sp_helpdb：用于查看数据库的信息，包括数据库文件的路径、大小等。
1
EXEC sp_helpdb;
sp_who：用于获取当前连接到 SQL Server 实例的会话信息，包括登录名、数据库、状态等。
1
EXEC sp_who;
sp_who2：用于提供比 sp_who 更详细的会话信息，包括更多列和信息。
1
EXEC sp_who2;
sp_configure：用于查看和更改 SQL Server 的配置选项。
1
EXEC sp_configure;

sp_executesql：用于执行动态 SQL 语句，通常与参数化查询一起使用，以避免 SQL 注入攻击。

1
2
3

DECLARE @sql NVARCHAR(MAX);
SET @sql = 'SELECT * FROM MyTable WHERE ColumnName = @Value';
EXEC sp_executesql @sql, N'@Value INT', @Value = 123;

sp_renamedb：用于更改数据库的名称。

1	`EXEC sp_renamedb 'OldDatabaseName', 'NewDatabaseName';`

sp_spaceused：用于获取数据库中表或索引的空间使用情况。
1
EXEC sp_spaceused 'TableName';
sp_help：用于查看数据库对象（表、视图等）的结构信息。
1
EXEC sp_help 'TableName';
sp_helptext：用于查看存储过程、触发器或视图的定义文本。
1
EXEC sp_helptext 'StoredProcedureName';
sp_depends：用于查看数据库对象之间的依赖关系，包括对象引用和被引用的关系。
1
EXEC sp_depends 'ObjectName';

这些系统存储过程提供了各种功能，用于管理和监视 SQL Server 实例，获取有关数据库和对象的信息，以及执行各种任务，如动态 SQL 执行和配置查看。在实际使用中，根据需求选择适当的系统存储过程。

C# 定时同步数据思路

2023-09-08T07:43:29.000Z

在许多应用程序中，数据同步是一个关键的任务，用于保持应用程序的数据与外部源（如 API 或其他数据库）同步。这篇博客将介绍如何使用 C# 来实现定时数据同步的思路，以确保数据的准确性和一致性。

思路

定时执行同步数据的程序，使用互斥锁或者信号量来控制程序的并发执行，确保定时任务在前一个任务完成之后再触发。
1.1. 发送网络请求，请求接口数据，构造数据对应的实体类。
1.2. 批量插入或批量更新到数据库。
1.3. 把查询放到循环外减少查询次数，去除循环内重复的查询语句，O(n)->O(1) 减小时间复杂度。
减少锁表时间，需要过滤数据，减少数据量，然后进行同步。
2.1. 配置增量或全量同步，把接口数据分批次 IN 查询，然后和数据库的数据进行对比，不存在则更新。
2.2. 配置同步天数，去同步多少天前的数据。

1. 控制并发执行

在定时执行同步数据的程序中，一个重要的考虑因素是如何控制程序的并发执行，以避免可能的冲突和数据不一致。这可以通过以下方式来实现：

1.1 使用互斥锁或信号量

可以使用互斥锁（Mutex）或信号量（Semaphore）来确保定时任务在前一个任务完成之后再触发。这样可以防止多个任务同时执行，避免数据竞争和不一致性问题。

定时同步，代码示例：

using Quartz;
using System;
using System.Threading;
using System.Threading.Tasks;

namespace JobNamespace
{
    public class DataSyncJob : IJob
    {
        private static SemaphoreSlim semaphore = new SemaphoreSlim(1);

        public async Task Execute(IJobExecutionContext context)
        {
            try
            {
                await semaphore.WaitAsync();

                SyncData("示例", () =>
                {
                    // 执行数据同步操作
                });
            }
            catch (Exception ex)
            {
                Console.WriteLine($"定时任务发生异常：{ex.Message}");
            }
            finally
            {
                semaphore.Release();
            }
        }

        private void SyncData(string operationType, Action syncAction)
        {
            Console.WriteLine($"开始同步数据：{operationType}");
            syncAction.Invoke();
            Console.WriteLine($"完成同步数据：{operationType}");
        }
    }
}

using Quartz.Impl;
using Quartz;
using System;
using System.Threading.Tasks;
using JobNamespace.Job;

namespace Demo
{
    internal static class Program
    {
        /// 
        /// 应用程序的主入口点。
        /// 
        [STAThread]
        static void Main()
        {
            // 启动定时任务
            StartScheduler();
        }

        static async void StartScheduler()
        {
            await RunScheduler();
        }

        static async Task RunScheduler()
        {
            // 创建调度器工厂
            ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
            IScheduler scheduler = await schedulerFactory.GetScheduler();

            // 创建一个触发器，使用 Cron 表达式触发定时任务
            ITrigger trigger = TriggerBuilder.Create()
                .WithIdentity("SyncDataTrigger", "Sync")
                .WithCronSchedule("0/30 * * * * ?") // 每30秒触发一次
                .Build();

            // 创建一个任务
            IJobDetail job = JobBuilder.Create()
                .WithIdentity("SyncDataJob", "Sync")
                .Build();

            // 将任务和触发器关联到调度器
            await scheduler.ScheduleJob(job, trigger);

            // 启动调度器
            await scheduler.Start();
        }

    }
}

2. 数据请求和处理

在同步数据的过程中，需要执行以下步骤来获取和处理数据：

2.1 发送网络请求

首先，需要向外部源发送网络请求，以获取需要同步的数据。这通常涉及与外部 API 进行通信，然后将返回的数据转化为 C# 中的实体类。

发送请求，代码示例：

using System;
using System.Net;
using System.Text;
using System.IO;
using Newtonsoft.Json;

public static T ExecutePostRequest<T>(string url, object requestData)
{
    try
    {
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
        request.Method = "POST";
        request.ContentType = "application/json";

        string jsonRequestData = JsonConvert.SerializeObject(requestData);
        byte[] data = Encoding.UTF8.GetBytes(jsonRequestData);

        using (Stream requestStream = request.GetRequestStream())
        {
            requestStream.Write(data, 0, data.Length);
        }

        using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
        {
            if (response.StatusCode != HttpStatusCode.OK)
            {
                throw new Exception($"接口调用失败，状态码：{response.StatusCode}");
            }

            using (Stream responseStream = response.GetResponseStream())
            using (StreamReader reader = new StreamReader(responseStream))
            {
                string jsonResponseData = reader.ReadToEnd();
                return JsonConvert.DeserializeObject(jsonResponseData);
            }
        }
    }
    catch (Exception ex)
    {
        throw new Exception($"接口调用发生异常：{ex.Message}");
    }
}

2.2 数据插入或更新

获取数据后，可以将其批量插入或批量更新到数据库中。这可以通过使用 SqlBulkCopy 来实现，以提高性能和效率。

批量插入，代码示例：

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;

public static void BulkInsertOrders(List orders, string connectionString)
{
    try
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();

            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                bulkCopy.DestinationTableName = "Orders"; // 表名
                bulkCopy.BatchSize = 1000; // 每批次的行数
                bulkCopy.BulkCopyTimeout = 60; // 超时时间（秒）

                // 定义数据映射，将源数据列映射到目标表的列
                bulkCopy.ColumnMappings.Add("ID", "ReferenceID");
                bulkCopy.ColumnMappings.Add("CustomerID", "CustomerID");
                bulkCopy.ColumnMappings.Add("OrderDate", "OrderDate");
                bulkCopy.ColumnMappings.Add("TotalAmount", "Amount");

                DataTable dataTable = new DataTable();
                dataTable.Columns.Add("ID", typeof(int));
                dataTable.Columns.Add("CustomerID", typeof(int));
                dataTable.Columns.Add("OrderDate", typeof(DateTime));
                dataTable.Columns.Add("TotalAmount", typeof(decimal));

                foreach (var order in orders)
                {
                    // 将数据添加到DataTable
                    dataTable.Rows.Add(order.ID, order.CustomerID, order.OrderDate, order.TotalAmount);
                }

                // 执行批量插入
                bulkCopy.WriteToServer(dataTable);
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine("批量插入失败：" + ex.Message);
    }
}

批量更新，代码示例：

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;

public static void BulkUpdateOrders(List updatedOrders, string connectionString)
{
    try
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();

            // 创建一个临时表，用于存储要更新的数据
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                bulkCopy.DestinationTableName = "TempOrders"; // 临时表名
                bulkCopy.BatchSize = 1000; // 每批次的行数
                bulkCopy.BulkCopyTimeout = 60; // 超时时间（秒）

                // 定义数据映射，将源数据列映射到临时表的列
                bulkCopy.ColumnMappings.Add("ID", "ReferenceID");
                bulkCopy.ColumnMappings.Add("CustomerID", "CustomerID");
                bulkCopy.ColumnMappings.Add("OrderDate", "OrderDate");
                bulkCopy.ColumnMappings.Add("TotalAmount", "Amount");

                DataTable dataTable = new DataTable();
                dataTable.Columns.Add("ID", typeof(int));
                dataTable.Columns.Add("CustomerID", typeof(int));
                dataTable.Columns.Add("OrderDate", typeof(DateTime));
                dataTable.Columns.Add("TotalAmount", typeof(decimal));

                foreach (var order in updatedOrders)
                {
                    // 将要更新的数据添加到DataTable
                    dataTable.Rows.Add(order.ID, order.CustomerID, order.OrderDate, order.TotalAmount);
                }

                // 执行将数据插入到临时表的操作
                bulkCopy.WriteToServer(dataTable);
            }

            // 使用SQL语句执行批量更新操作
            using (SqlCommand updateCommand = new SqlCommand("UPDATE [Orders] SET [CustomerID] = [Temp].[CustomerID], [OrderDate] = [Temp].[OrderDate], [TotalAmount] = [Temp].[Amount] FROM [Orders] INNER JOIN [TempOrders] AS [Temp] ON [Orders].[ReferenceID] = [Temp].[ID]", connection))
            {
                updateCommand.ExecuteNonQuery();
            }

            // 清空临时表
            using (SqlCommand truncateCommand = new SqlCommand("TRUNCATE TABLE [TempOrders]", connection))
            {
                truncateCommand.ExecuteNonQuery();
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine("批量更新失败：" + ex.Message);
    }
}

2.3 减少查询次数

为了优化性能，建议将查询操作放到循环外部，以减少查询次数。这可以通过在循环之外查询数据，然后在循环内部对数据进行处理，从而减少数据库查询的次数。这将大大降低时间复杂度，从 O(n) 减小到 O(1)。

3. 减少锁表时间

为了减少锁表时间，可以采取以下措施：

3.1 数据过滤

在同步数据之前，可以对数据进行过滤，减少需要同步的数据量。这可以通过配置增量同步或全量同步来实现。对于增量同步，可以将接口数据分成批次，并将其与数据库数据进行对比，然后仅同步不存在的数据。对于全量同步，可以定期同步所有数据，确保数据的一致性。

增量同步或全量同步，代码示例：

public static List FindOrdersToUpdate(List orders, SqlTransaction transaction)
{
    bool fullSync = ConfigReader.ReadConfigValue<bool>("syncMode");

    if (fullSync)
    {
        // 全量更新
        return orders;
    }

    // 增量更新
    List missingOrders = new List();
    int batchSize = 100;
    List ordersToRemove = new List();

    for (int i = 0; i < orders.Count; i += batchSize)
    {
        List batch = orders.Skip(i).Take(batchSize).ToList();

        string inClause = string.Join(",", batch.Select(order => "'" + order.ID.ToString() + "'"));

        string query = $"SELECT [ReferenceID] FROM [dbo].[Orders] WHERE [ReferenceID] IN ({inClause})";
        using (SqlCommand cmd = new SqlCommand(query, transaction.Connection, transaction))
        {
            using (SqlDataReader reader = cmd.ExecuteReader())
            {
                while (reader.Read())
                {
                    if (!reader.IsDBNull(0))
                    {
                        string referenceID = reader.GetString(0);
                        var matchingOrder = batch.FirstOrDefault(order => order.ID == Convert.ToInt32(referenceID));

                        if (matchingOrder != null)
                        {
                            ordersToRemove.Add(matchingOrder);
                        }
                    }
                }
            }
        }
    }

    // 执行删除操作
    foreach (var orderToRemove in ordersToRemove)
    {
        orders.Remove(orderToRemove);
    }

    return orders;
}

3.2 同步天数配置

可以配置同步天数，以确定要同步多少天前的数据。这有助于控制同步的范围，并避免同步过多的历史数据，从而减少锁表时间。

读取 Json 配置文件，代码示例：

using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace Demo
{
    public static class ConfigReader
    {
        public static T ReadConfigValue<T>(string settingName, string configFilePath = "config.json")
        {
            string configJson = File.ReadAllText(configFilePath);

            JObject config = JObject.Parse(configJson);

            if (config.TryGetValue(settingName, out var value))
            {
                try
                {
                    return (T)Convert.ChangeType(value.ToString(), typeof(T));
                }
                catch
                {
                    // 转换失败，返回默认值
                    return default(T);
                }
            }

            return default(T);
        }
    }
}

// 读取配置文件
bool isFullSync = ConfigReader.ReadConfigValue<bool>("isFullSync");
int syncDay = ConfigReader.ReadConfigValue<int>("SyncDay");
syncDay = Math.Max(syncDay, 0);

通过以上的思路和方法，可以有效地实现定时数据同步任务，并确保数据的准确性、一致性和性能。这将有助于维护应用程序的数据质量和稳定性。希望本篇博客对你理解和实现 C# 数据同步任务有所帮助。

用 C# 编写日志文件

2023-08-15T05:41:27.000Z

在软件开发中，日志记录是一项至关重要的任务，它可以帮助我们跟踪应用程序的状态、故障排除和性能优化。在本篇博客中，我们将深入介绍一个用于日志记录的 C# 类库，展示其如何实现灵活、可靠且易于使用的特性。

背景

在开发过程中，我们常常需要记录应用程序的运行状态、异常情况和重要事件，以便后续分析和调试。传统的日志记录方式可能相对繁琐且难以管理，而这个 C# 类库则提供了一个高效的解决方案，可以帮助开发人员更轻松地实现日志记录功能。

功能概述

这个 C# 类库（命名为 LogWrite）旨在提供一个灵活、可靠且易于使用的日志记录工具。它具有以下主要功能：

日志写入功能：提供了三个不同的方法来写入日志，分别是 WriteLog、WriteLogWithSQL 和 WriteLogWithException。开发人员可以根据需要选择适当的方法，并附加额外的信息，如执行的 SQL 语句或异常信息。
日志文件夹管理：类库会自动创建日志文件夹，以确保日志文件的安全存储。如果日志文件夹不存在，它会在需要时自动创建。
日志文件清理：提供了 DeleteLog 方法，可以删除指定文件夹中过期的日志文件。这有助于保持日志文件夹的整洁，并避免占用过多磁盘空间。
日志编号：每条日志都带有一个唯一的编号，以帮助区分不同的日志条目。该编号会自动递增，确保日志的顺序和唯一性。

代码解析

以下是LogWrite 类的详细代码示例：

using System;
using System.IO;
using System.Text.RegularExpressions;

namespace Demo
{
    public class LogWrite
    {
        private const string DirectoryPathD = @"D:\log\";

        public void WriteLog(string filePath, string content)
        {
            EnsureLogDirectoryExists();

            string logFilePath = GetLogFilePath(filePath);
            WriteLogEntry(logFilePath, content);
        }

        public void WriteLogWithSQL(string filePath, string content, string sql)
        {
            EnsureLogDirectoryExists();

            string logFilePath = GetLogFilePath(filePath);
            WriteLogEntry(logFilePath, content, $"Executed SQL: {sql}");
        }

        public void WriteLogWithException(string filePath, string content, Exception ex)
        {
            EnsureLogDirectoryExists();

            string logFilePath = GetLogFilePath(filePath);
            WriteLogEntry(logFilePath, content, $"Exception Message: {ex.Message}\nStack Trace: {ex.StackTrace}");
        }

        public void DeleteLog(string folderPath)
        {
            try
            {
                DirectoryInfo dir = new DirectoryInfo(folderPath);
                FileSystemInfo[] fileinfo = dir.GetFileSystemInfos();

                foreach (FileSystemInfo info in fileinfo)
                {
                    if (info is DirectoryInfo subdir)
                    {
                        subdir.Delete(true);
                    }
                    else if (info.CreationTime < DateTime.Now.AddDays(-7))
                    {
                        File.Delete(info.FullName);
                    }
                }
            }
            catch { }
        }

        private void EnsureLogDirectoryExists()
        {
            if (!Directory.Exists(DirectoryPathD))
            {
                Directory.CreateDirectory(DirectoryPathD);
            }
        }

        private string GetLogFilePath(string filePath)
        {
            return Path.Combine(DirectoryPathD, $"{DateTime.Now:yyyyMMdd}_{filePath}");
        }

        private void WriteLogEntry(string logFilePath, string content, string additionalInfo = "")
        {
            int logNumber = GetNextLogNumber(logFilePath);

            using (FileStream aFile = new FileStream(logFilePath, FileMode.Append))
            using (StreamWriter sw = new StreamWriter(aFile, System.Text.Encoding.UTF8))
            {
                sw.WriteLine($"[{logNumber}] {DateTime.Now};{content}");
                if (!string.IsNullOrEmpty(additionalInfo))
                {
                    sw.WriteLine(additionalInfo);
                }
                sw.WriteLine();
            }
        }

        private int GetNextLogNumber(string logFilePath)
        {
            int logNumber = 1;

            if (File.Exists(logFilePath))
            {
                string[] lines = File.ReadAllLines(logFilePath);
                foreach (string line in lines)
                {
                    if (!string.IsNullOrWhiteSpace(line) && Regex.IsMatch(line, @"^\[(\d+)\]"))
                    {
                        int logIndex = int.Parse(Regex.Match(line, @"^\[(\d+)\]").Groups[1].Value);
                        logNumber = logIndex + 1;
                    }
                }
            }

            return logNumber;
        }
    }
}

当我们深入了解上述代码中每个方法的实现时，可以更清楚地理解其工作原理和实现方式：

WriteLog：
- 首先，方法调用 EnsureLogDirectoryExists 以确保日志文件夹存在，若不存在则创建。
- 然后，通过调用 GetLogFilePath 构建完整的日志文件路径，包括当前日期作为前缀。
- 最后，调用 WriteLogEntry 方法，将传递的日志内容写入到指定的日志文件中。
WriteLogWithSQL：
- 与 WriteLog 类似，先确保日志文件夹存在并构建日志文件路径。
- 调用 WriteLogEntry 方法，将传递的日志内容和附加信息（执行的 SQL 语句）一同写入到日志文件中。
WriteLogWithException：
- 同样，确保日志文件夹存在并构建日志文件路径。
- 调用 WriteLogEntry 方法，将传递的日志内容和附加信息（异常消息和堆栈跟踪）一同写入到日志文件中。
DeleteLog：
- 方法首先尝试获取指定文件夹中的所有文件和子文件夹。
- 然后，对于每个文件和子文件夹，检查其创建时间。如果是文件夹，则递归删除；如果是文件且创建时间早于7天前，则删除文件。
- 这样，可以确保过期的日志文件被及时清理，避免过多占用磁盘空间。
EnsureLogDirectoryExists：
- 这个方法检查日志文件夹路径是否存在，如果不存在则调用 Directory.CreateDirectory 创建文件夹。
GetLogFilePath：
- 方法将当前日期格式化为字符串，并将其与传递的文件路径结合，形成完整的日志文件路径。
WriteLogEntry：
- 该方法将日志内容写入日志文件。
- 首先，获取下一个可用的日志编号，调用 GetNextLogNumber 。
- 然后，使用文件流 FileStream 和写入器 StreamWriter 打开指定的日志文件，使用 UTF-8 编码。
- 将日志内容和附加信息（如果提供）写入到文件中，确保写入操作的原子性。
GetNextLogNumber：
- 方法读取已有的日志文件内容，分析每行中的日志编号，找到最大的编号。
- 在找到最大编号后，将其加一作为下一个可用的日志编号，确保日志编号的连续性和唯一性。

通过这些方法的具体实现，LogWrite 类提供了一个可靠且易于使用的日志记录工具，帮助开发人员有效地管理和记录应用程序的各种信息，从而更好地进行故障排除和性能优化。

使用示例

下面是一个更详细的使用示例，展示了如何使用LogWrite类来记录日志：

using System;

namespace Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            LogWrite logger = new LogWrite();

            try
            {
                // 模拟执行SQL语句
                string sql = "SELECT * FROM Customers";
                // 模拟异常
                throw new Exception("An error occurred!");

                logger.WriteLogWithSQL("app.log", "Application started", sql);
            }
            catch (Exception ex)
            {
                logger.WriteLogWithException("error.log", "An error occurred", ex);
            }

            logger.DeleteLog(@"D:\log\"); // 清理过期日志

            Console.WriteLine("Log entries recorded.");
        }
    }
}

总结

通过详细介绍这个名为 LogWrite 的类库，我们呈现了一个灵活、可靠且便捷的日志记录工具，它可以协助开发人员轻松地满足各种日志记录需求。不论是对常规信息、SQL 语句或异常情况的记录，这个类库都提供了简便而可靠的方法。此外，它还具备自动创建日志文件夹和清理过期日志的功能，确保了日志记录的高效管理。在开发和维护过程中，这样的日志记录工具将成为宝贵的助手，帮助我们更好地理解和优化应用程序的运行情况。

在 C# 中创建 Excel 文件

2023-07-20T06:01:35.000Z

在本篇博客中，我们将介绍如何使用 EPPlus 库在 C# 中创建 Excel 文件。EPPlus 是一个用于操作 Excel 文件的强大开源库，它支持 .NET Framework 和 .NET Core 平台。

安装 EPPlus

首先，我们需要安装 EPPlus 库。你可以使用 NuGet 包管理器来安装 EPPlus。以下是安装过程：

打开 Visual Studio 项目。
在解决方案资源管理器中，右键单击项目，然后选择“管理 NuGet 程序包”。
在 NuGet 程序包管理器中，搜索“EPPlus”。
选择 EPPlus，并点击“安装”按钮完成安装过程。

导出数据到 Excel

首先，我们需要对 ExcelUtils 类进行扩展，以便它能够接受不同类型的数据源。为实现这个目标，我们将使用泛型方法，使得该方法可以处理各种类型的数据源。

using OfficeOpenXml;
using System;
using System.Collections.Generic;
using System.IO;
using System.Windows.Forms;

namespace DEMO
{
    public class ExcelUtils
    {
        public static string DataGridViewToExcel(DataGridView dataGridView, string filePath, string sheetName)
        {
            // 导出表头
            List<string> headers = new List<string>();
            foreach (DataGridViewColumn column in dataGridView.Columns)
            {
                headers.Add(column.HeaderText);
            }

            // 导出数据
            Listobject>> data = new Listobject>>();
            foreach (DataGridViewRow row in dataGridView.Rows)
            {
                List<object> rowData = new List<object>();
                foreach (DataGridViewCell cell in row.Cells)
                {
                    rowData.Add(cell.Value);
                }
                data.Add(rowData);
            }

            // 调用通用导出方法
            return ExportToExcel(filePath, sheetName, headers, data);
        }

        public static string ExportToExcel<T>(string filePath, string sheetName, List<string> headers, List> data)
        {
            ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
            try
            {
                using (ExcelPackage excelPackage = new ExcelPackage())
                {
                    ExcelWorksheet worksheet = excelPackage.Workbook.Worksheets.Add(sheetName);

                    // 导出表头
                    for (int i = 0; i < headers.Count; i++)
                    {
                        worksheet.Cells[1, i + 1].Value = headers[i];
                    }

                    // 导出数据
                    for (int i = 0; i < data.Count; i++)
                    {
                        for (int j = 0; j < data[i].Count; j++)
                        {
                            worksheet.Cells[i + 2, j + 1].Value = data[i][j];
                        }
                    }

                    // 保存 Excel 文件
                    FileInfo excelFile = new FileInfo(filePath);
                    excelPackage.SaveAs(excelFile);
                }

                return "导出完成！";
            }
            catch (Exception ex)
            {
                return "导出发生错误：" + ex.Message;
            }
        }
    }
}

现在，ExcelUtils 类有两个方法：

DataGridViewToExcel 方法：用于导出 DataGridView 的数据到 Excel 文件。
ExportToExcel 泛型方法：可以处理各种类型的数据源，包括二维列表、DataTable 等。

使用示例：

// 示例1：使用 DataGridView 数据源
string filePath1 = "C:\\Example\\Sample1.xlsx";
string sheetName1 = "Sheet1";
string result1 = ExcelUtils.ExportToExcel(dataGridView1, filePath1, sheetName1);
Console.WriteLine(result1);

// 示例2：使用二维列表数据源
string filePath2 = "C:\\Example\\Sample2.xlsx";
string sheetName2 = "Sheet2";
List<string> headers = new List<string> { "Name", "Age", "City" };
Listobject>> data = new Listobject>>
{
    new List<object> { "John", 30, "New York" },
    new List<object> { "Alice", 25, "Los Angeles" },
    new List<object> { "Bob", 35, "Chicago" }
};
string result2 = ExcelUtils.ExportToExcel(filePath2, sheetName2, headers, data);
Console.WriteLine(result2);

现在你可以根据数据源的类型来选择适当的导出方法，DataGridViewToExcel 用于 DataGridView 数据，而 ExportToExcel 用于其他类型的数据源。这样，你可以方便地将各种数据导出到 Excel 文件中。

希望这篇博客对你有所帮助！

WinForms 中实现自动关闭的 MessageBox

2023-07-13T07:42:03.000Z

在许多软件应用程序中，经常需要显示一段时间后自动关闭的消息框。这种功能可以为用户提供及时的反馈，同时又不会干扰用户的操作。本文将介绍一个使用 C# 编写的自动关闭消息框的代码示例，并详细解释其实现原理。

代码示例

private async void ShowMessageBoxInThread(string message, int time = 1000, string title = "提示")
{
    await Task.Run(() => AutoClosingMessageBox.Show(message, title, time));
}

public class AutoClosingMessageBox
{
    System.Threading.Timer _timeoutTimer;
    string _caption;

    AutoClosingMessageBox(string text, string caption, int timeout)
    {
        _caption = caption;
        _timeoutTimer = new System.Threading.Timer(OnTimerElapsed,
            null, timeout, System.Threading.Timeout.Infinite);
        using (_timeoutTimer)
            MessageBox.Show(text, caption, MessageBoxButtons.OK, MessageBoxIcon.Information);
    }

    public static void Show(string text, string caption, int timeout)
    {
        new AutoClosingMessageBox(text, caption, timeout);
    }

    void OnTimerElapsed(object state)
    {
        IntPtr mbWnd = FindWindow("#32770", _caption); // lpClassName is #32770 for MessageBox
        if (mbWnd != IntPtr.Zero)
            SendMessage(mbWnd, WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
        _timeoutTimer.Dispose();
    }

    const int WM_CLOSE = 0x0010;
    [System.Runtime.InteropServices.DllImport("user32.dll", SetLastError = true)]
    static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
    [System.Runtime.InteropServices.DllImport("user32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto)]
    static extern IntPtr SendMessage(IntPtr hWnd, UInt32 Msg, IntPtr wParam, IntPtr lParam);
}

实现原理

让我们逐步解释上述代码的实现原理。

ShowMessageBoxInThread 方法

首先，我们有一个私有的异步方法ShowMessageBoxInThread，它接受三个参数：message表示要显示的消息内容，time表示消息框显示的时间（默认为1秒），title表示消息框的标题（默认为”提示”）。

private async void ShowMessageBoxInThread(string message, int time = 1000, string title = "提示")
{
    await Task.Run(() => AutoClosingMessageBox.Show(message, title, time));
}

在方法内部，我们使用Task.Run创建一个异步任务，并调用AutoClosingMessageBox.Show方法。通过将消息内容、标题和显示时间传递给Show方法，我们将显示一个自动关闭的消息框。

AutoClosingMessageBox 类

AutoClosingMessageBox类是实现自动关闭消息框的核心部分。

首先，它包含了一个私有字段_timeoutTimer和一个表示消息框标题的字段_caption。

public class AutoClosingMessageBox
{
    System.Threading.Timer _timeoutTimer;
    string _caption;
    // ...
}

构造函数AutoClosingMessageBox接受消息内容、标题和超时时间作为参数。

AutoClosingMessageBox(string text, string caption, int timeout)
{
    _caption = caption;
    _timeoutTimer = new System.Threading.Timer(OnTimerElapsed,
        null, timeout, System.Threading.Timeout.Infinite);
    using (_timeoutTimer)
        MessageBox.Show(text, caption, MessageBoxButtons.OK, MessageBoxIcon.Information);
}

在构造函数内部，首先设置了一个计时器_timeoutTimer，它在指定的超时时间后触发回调函数OnTimerElapsed。计时器的工作是在超时后关闭消息框。

当初始化定时器时，我们使用 new System.Threading.Timer(OnTimerElapsed, null, timeout, System.Threading.Timeout.Infinite) 这段代码。它创建了一个新的 System.Threading.Timer 实例，并设置了相关参数：

OnTimerElapsed 是定时器触发时要执行的回调方法。
null 表示传递给回调方法的状态对象，这里我们不需要传递额外的状态信息。
timeout 表示定时器的超时时间，即经过多少毫秒后触发回调方法。
System.Threading.Timeout.Infinite 表示定时器只触发一次，并不会重复。

using 语句是一种资源管理语句，用于确保在使用完毕后正确释放资源。在这里，我们使用 using 语句来管理 _timeoutTimer 对象的生命周期。当执行到 using 语句的末尾时，会自动调用 _timeoutTimer.Dispose() 方法来释放定时器资源。

接下来，使用MessageBox.Show方法显示消息框，并传递消息内容、标题以及信息图标。

OnTimerElapsed 方法

OnTimerElapsed方法是计时器回调函数，它在超时时被调用。

void OnTimerElapsed(object state)
{
    IntPtr mbWnd = FindWindow("#32770", _caption); // lpClassName is #32770 for MessageBox
    if (mbWnd != IntPtr.Zero)
        SendMessage(mbWnd, WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
    _timeoutTimer.Dispose();
}

在OnTimerElapsed方法中，首先通过FindWindow函数查找具有指定标题的消息框的句柄。如果找到了消息框的句柄，就使用SendMessage函数发送关闭消息给消息框，即通过向消息框发送WM_CLOSE消息来关闭它。最后，我们释放计时器资源。

DllImport 特性

代码中还使用了 DllImport 特性，用于声明FindWindow和SendMessage方法，以便在 C# 代码中使用这些来自 user32.dll 的本机函数。

const int WM_CLOSE = 0x0010;
[System.Runtime.InteropServices.DllImport("user32.dll", SetLastError = true)]
static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
[System.Runtime.InteropServices.DllImport("user32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto)]
static extern IntPtr SendMessage(IntPtr hWnd, UInt32 Msg, IntPtr wParam, IntPtr lParam);

这些特性允许我们直接调用 Windows API 函数，以实现与操作系统交互的功能。

const int WM_CLOSE = 0x0010; 定义了一个常量 WM_CLOSE，它代表了关闭窗口的消息代码。
[System.Runtime.InteropServices.DllImport("user32.dll", SetLastError = true)] 是一个 DllImport 特性，用于指示在 user32.dll 库中查找并导入函数。SetLastError 参数设置为 true，以便在函数调用失败时记录错误状态。
static extern IntPtr FindWindow(string lpClassName, string lpWindowName); 声明了一个名为 FindWindow 的本机函数，它在 user32.dll 中查找具有指定类名和窗口名的顶层窗口。它返回找到的窗口的句柄。
static extern IntPtr SendMessage(IntPtr hWnd, UInt32 Msg, IntPtr wParam, IntPtr lParam); 声明了一个名为 SendMessage 的本机函数，它向指定的窗口发送指定的消息。hWnd 参数是窗口的句柄，Msg 参数是要发送的消息代码，wParam 和 lParam 参数是消息的参数。

这些代码用于在 C# 中与 Windows API 进行交互。通过 FindWindow 函数找到指定标题的窗口句柄，并使用 SendMessage 函数向该窗口发送关闭消息。这样可以实现在定时器回调方法中自动关闭消息框的功能。

使用示例

通过使用以上的代码，我们可以在应用程序中使用ShowMessageBoxInThread方法来显示一个自动关闭的消息框。例如：

1	`ShowMessageBoxInThread("操作已完成！", 2000, "成功");`

以上代码将在一个新的线程中显示一个带有”成功”标题的消息框，显示内容为”操作已完成！”，并在2秒后自动关闭。

参考链接

Close a MessageBox after several seconds

C# 中的 JSON 数据存储、读取和合并操作

2023-07-07T01:43:53.000Z

在博客中，我将介绍一个名为JsonFileManager的类，该类用于管理数据的保存和读取操作，并提供了一些数据合并的方法。下面是该类的代码及其功能的详细说明。

引用和命名空间

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;

上述代码段中的using语句用于引入所需的命名空间，以便在代码中使用相关的类型和方法。

命名空间

namespace Demo
{
    public static class JsonFileManager
    {
        // ...
    }
}

在该命名空间中，定义了一个名为JsonFileManager的静态类，用于提供数据保存和读取的功能。

常量和文件路径

private const string BACKUP_DIRECTORY = @"C:\json_backup\";
public const string INBOUND_FILE_NAME = "Inbound.json";
public const string OUTBOUND_FILE_NAME = "OutBound.json";
public const string CUSTOMER_FILE_NAME = "Customer.json";
public const string MATERIAL_FILE_NAME = "Material.json";
public const string SUPPLIER_FILE_NAME = "Supplier.json";

这些常量定义了备份目录的路径和各个数据文件的文件名。

SaveData 方法

public static void SaveData<T>(List data, string filename)
{
    // 检查备份目录是否存在，如果不存在则创建
    if (!Directory.Exists(BACKUP_DIRECTORY))
        Directory.CreateDirectory(BACKUP_DIRECTORY);

    // 生成文件路径
    string filePath = Path.Combine(BACKUP_DIRECTORY, filename);

    // 读取已保存的数据
    List existingData = ReadData(filename);

    // 合并数据，去除重复项
    List newData = MergeData(existingData, data);

    // 将数据序列化为 JSON 字符串
    string json = JsonConvert.SerializeObject(newData, Formatting.Indented);

    // 保存 JSON 字符串到文件
    File.WriteAllText(filePath, json);
}

该方法用于保存数据到指定的文件。它接收一个泛型参数T表示数据类型，一个List类型的data参数表示要保存的数据列表，以及一个string类型的filename参数表示文件名。方法的实现逻辑如下：

检查备份目录是否存在，如果不存在则创建备份目录。
生成文件路径。
调用ReadData方法读取已保存的数据。
调用MergeData方法合并已保存的数据和新数据，去除重复项。
使用JsonConvert.SerializeObject方法将数据序列化为 JSON 字符串。
调用File.WriteAllText方法将 JSON 字符串写入文件。

ReadData 方法

public static List<T> ReadData<T>(string filename)
{
    // 生成文件路径
    string filePath = Path.Combine(BACKUP_DIRECTORY, filename);

    // 检查文件是否存在
    if (!File.Exists(filePath))
        return new List();

    // 读取文件内容
    string json = File.ReadAllText(filePath);

    // 反序列化 JSON 字符串为数据对象
    List data = JsonConvert.DeserializeObject>(json);

    return data ?? new List();
}

该方法用于读取指定文件中的数据，并以List类型的列表形式返回。它接收一个string类型的filename参数表示要读取的文件名。方法的实现逻辑如下：

生成文件路径。
检查文件是否存在，如果文件不存在则返回空的数据列表。
读取文件内容。
使用JsonConvert.DeserializeObject方法将 JSON 字符串反序列化为数据对象。
返回反序列化后的数据列表。

MergeData 方法

public static List<T> MergeData<T>(List existingData, List newData)
{
    // 获取属性名用于去重判断
    string propertyName = GetPropertyName();

    // 去除重复项
    HashSet<string> existingSet = new HashSet<string>();
    foreach (var item in existingData)
    {
        var propertyValue = GetPropertyValue(item, propertyName);
        if (propertyValue != null)
        {
            existingSet.Add(propertyValue.ToString());
        }
    }

    List mergedData = new List(existingData);
    foreach (var item in newData)
    {
        var propertyValue = GetPropertyValue(item, propertyName);
        if (propertyValue != null && !existingSet.Contains(propertyValue.ToString()))
        {
            mergedData.Add(item);
            existingSet.Add(propertyValue.ToString());
        }
    }

    return mergedData;
}

该方法用于合并已保存的数据和新数据，并去除重复项。它接收两个List类型的参数existingData和newData，表示已保存的数据和新数据。方法的实现逻辑如下：

获取用于去重判断的属性名，调用GetPropertyName方法获取属性名。
创建一个HashSet类型的集合existingSet，用于存储已保存数据中的属性值。
遍历已保存数据列表existingData，获取每个数据项的属性值，并将属性值转换为字符串类型后添加到existingSet集合中。
创建一个新的数据列表mergedData，初始值为已保存的数据列表existingData的副本。
遍历新数据列表newData，获取每个数据项的属性值，并判断属性值是否为空以及existingSet集合是否包含该属性值的字符串形式。
如果属性值不为空且existingSet集合中不包含该属性值的字符串形式，则将数据项添加到mergedData列表中，并将属性值的字符串形式添加到existingSet集合中。
返回合并后的数据列表mergedData。

MergeDataWithLocal 方法

public static List<T> MergeDataWithLocal<T>(List newData, string filename)
{
    // 读取本地的数据 
    List existingData= ReadData(filename);

    // 获取属性名用于查找本地数据
    string propertyName = GetPropertyName();

    // 创建字典映射
    Dictionary<string, T> existingDataMap = new Dictionary<string, T>();

    // 填充字典映射
    foreach (var item in existingData)
    {
        var propertyValue = GetPropertyValue(item, propertyName);
        if (propertyValue != null)
        {
            string key = propertyValue.ToString();
            if (!existingDataMap.ContainsKey(key))
            {
                existingDataMap.Add(key, item);
            }
        }
    }

    // 替换newData中的项
    for (int i = 0; i < newData.Count; i++)
    {
        var itemToReplace = newData[i];
        var propertyValue = GetPropertyValue(itemToReplace, propertyName);
        if (propertyValue != null)
        {
            string key = propertyValue.ToString();
            if (existingDataMap.ContainsKey(key))
            {
                newData[i] = existingDataMap[key];
            }
        }
    }

    return newData;
}

该方法用于将新数据与本地数据进行合并。它接收一个List类型的参数newData，表示新数据列表，以及一个string类型的filename参数，表示本地数据的文件名。方法的实现逻辑如下：

调用ReadData方法读取本地数据，将结果保存在existingData变量中。
获取用于查找本地数据的属性名，调用GetPropertyName方法获取属性名。
创建一个Dictionary类型的字典existingDataMap，用于存储本地数据的映射关系。
遍历本地数据列表existingData，获取每个数据项的属性值，并将属性值转换为字符串类型后作为字典的键，数据项作为字典的值。
创建一个循环，遍历新数据列表newData中的每个数据项。
获取当前要替换的数据项itemToReplace的属性值，并将属性值转换为字符串类型后作为字典的键。
如果字典existingDataMap中包含该键，则从字典中获取对应的本地数据项，并将其替换为新数据列表newData中的对应项。
返回合并后的新数据列表newData。

GetPropertyName 方法

private static string GetPropertyName<T>()
{
    Type type = typeof(T);

    if (type == typeof(Repertory))
    {
        return "RepertoryId";
    }
    else if (type == typeof(Customer))
    {
        return "CustomerId";
    }
    else if (type == typeof(Item))
    {
        return "ItmId";
    }
    else if (type == typeof(Supplier))
    {
        return "SupplierId";
    }

    throw new Exception(type + "类型不匹配");
}

该方法用于根据数据类型T获取属性名。它根据不同的数据类型返回相应的属性名字符串。如果数据类型不匹配，则抛出异常。目前支持的数据类型包括Repertory、Customer、Item和Supplier, 请根据自己需要修改数据类型。

GetPropertyValue 方法

private static object GetPropertyValue<T>(T item, string propertyName)
{
    // 根据属性名获取属性值
    var property = typeof(T).GetProperty(propertyName);
    if (property != null)
    {
        return property.GetValue(item);
    }

    throw new Exception("获取不到" + propertyName + "属性值");
}

该方法用于根据属性名获取数据项中的属性值。它接收一个数据项item和属性名字符串propertyName作为参数。方法的实现逻辑如下：

根据数据项的类型T和属性名字符串propertyName获取属性对象。
如果属性对象不为空，则通过GetValue方法获取属性值，并返回属性值。
如果属性对象为空，则抛出异常，表示无法获取属性值。

以上就是JsonFileManager类的主要方法及其功能的说明。该类提供了数据的保存、读取和合并功能，可以方便地进行数据管理和操作。

在 Java 中使用 Hutool 进行数据加密和解密

2023-02-22T03:05:00.000Z

概述

加密分为三种：1、对称加密，又称为私钥加密、共享密钥加密，使用相同的密钥；2、非对称加密，它需要两个密钥，一个是公开密钥，另一个是私有密钥；公钥用作加密，私钥则用作解密；3、摘要加密，无论用户输入什么长度的原始数据，经过计算后输出的密文都是固定长度的，不可逆。

hutool 针对这三种加密类型分别封装，并提供常用的大部分加密算法。我在此之上使用工厂模式针对这三种算法创建了一个加密和解密的模块，方便业务调用，可以根据需求继续添加其他算法，添加对象时实现共同的接口即可，以下为用到的算法：非对称加密：RSA 、SM2；对称加密：AES、DES、DESede、SM4；摘要算法：MD5、SHA-1、SHA-256、SM3。

依赖

在项目的 pom.xml 的 dependencies 中加入以下内容:

<dependency>
    <groupId>cn.hutoolgroupId>
    <artifactId>hutool-allartifactId>
    <version>5.8.12version>
dependency>

国密算法中的 SM2、SM3、SM4 需要引入 Bouncy Castle 依赖

<dependency>
  <groupId>org.bouncycastlegroupId>
  <artifactId>bcprov-jdk15to18artifactId>
  <version>1.69version>
dependency>

说明 bcprov-jdk15to18 的版本请前往 Maven 中央库搜索，查找对应 JDK 的最新版本。

接口

加密接口

接口 Crypto 提供加密和解密以及生成秘钥的方法。

生成密钥（对）

创建一个名为 Key 的类，用于表示密钥。Key 类有两个构造函数，一个用于对称加密密钥，另一个用于非对称加密的公钥和私钥。密钥可以使用 generateKey() 方法生成。

对称加密密钥的生成使用 SecureUtil.generateKey() 方法，传入参数 AlgorithmConstant.AES 表示使用 AES 算法生成密钥。生成的密钥会被封装成 SecretKey 对象，然后作为参数传递给 Key 类的第一个构造函数，最终生成一个 Key 对象，其中包含了生成的密钥以及它们的 base64 编码形式。

非对称加密的公钥和私钥的生成使用 SecureUtil.generateKeyPair() 方法，传入参数 AlgorithmConstant.RSA 表示使用 RSA 算法生成密钥对。生成的密钥对会被封装成 KeyPair 对象，然后作为参数传递给 Key 类的第二个构造函数，最终生成一个 Key 对象，其中包含了生成的公钥和私钥以及它们的 base64 编码形式。

在 Key 类中，使用 Base64 类将密钥和密钥对的 byte 数组进行 base64 编码，然后存储在对应的字符串变量中，方便后续处理和传输。

1、秘钥：

@Override
public Key generateKey() {
    return new Key(SecureUtil.generateKey(AlgorithmConstant.AES));
}

2、秘钥对：

@Override
public Key generateKey() {
    return new Key(SecureUtil.generateKeyPair(AlgorithmConstant.RSA));
}

3、对于 SecureUtil 不支持使用 SM4 算法生成的秘钥可以这样获取：

@Override
public Key generateKey() {
    return new Key(new SymmetricCrypto(AlgorithmConstant.SM4).getSecretKey());
}

4、自定义 Key 类：

package crypto.model;

import cn.hutool.core.codec.Base64;

import javax.crypto.SecretKey;
import java.security.KeyPair;

/**
 * The type Key.
 *
 * @author loquy
 * @date 2023 /02/07 13:51
 */
public class Key {

    private SecretKey secretKey;
    
    private KeyPair keyPair;
    
    private String base64SecretKey;
    
    private String base64PrivateKey;
    
    private String base64PublicKey;
    
    public Key(SecretKey secretKey) {
        this.secretKey = secretKey;
        setBase64SecretKey(secretKey);
    }

    public Key(KeyPair keyPair) {
        this.keyPair = keyPair;
        setBase64PrivateKey(keyPair);
        setBase64PublicKey(keyPair);
    }

    public SecretKey getSecretKey() {
        return secretKey;
    }

    public void setSecretKey(SecretKey secretKey) {
        this.secretKey = secretKey;
    }

    public KeyPair getKeyPair() {
        return keyPair;
    }

    public void setKeyPair(KeyPair keyPair) {
        this.keyPair = keyPair;
    }

    public String getBase64SecretKey() {
        return base64SecretKey;
    }

    public void setBase64SecretKey(SecretKey secretKey) {
        this.base64SecretKey = Base64.encodeWithoutPadding(secretKey.getEncoded());
    }

    public String getBase64PrivateKey() {
        return base64PrivateKey;
    }

    public void setBase64PrivateKey(KeyPair keyPair) {
        this.base64PrivateKey = Base64.encodeWithoutPadding(keyPair.getPrivate().getEncoded());
    }

    public String getBase64PublicKey() {
        return base64PublicKey;
    }

    public void setBase64PublicKey(KeyPair keyPair) {
        this.base64PublicKey = Base64.encodeWithoutPadding(keyPair.getPublic().getEncoded());
    }
}

对称算法

在 SymmetricCrypto 类的构造方法中，使用 Base64.decode(secretKey) 将 Base64 编码的密钥解码为字节数组，并作为参数传递给构造方法。然后，使用 encryptHex 方法对明文数据进行加密并以十六进制形式返回加密后的密文。

对于解密部分的代码，实现方法和加密部分非常相似。这里使用的是 SymmetricCrypto 类的 decryptStr 方法将十六进制的密文解密为明文，并指定解密后的编码格式为 UTF-8。

需要注意的是，代码中还有一个 isBase64() 方法，用于检查给定的密钥字符串是否是合法的 Base64 编码格式。如果密钥不是合法的 Base64 编码格式，会抛出异常。

default String symmetricEncrypt(String data, String secretKey, String algorithm) throws Exception {
    isBase64(secretKey, "密钥");
    SymmetricCrypto symmetricCrypto = new SymmetricCrypto(algorithm, Base64.decode(secretKey));
    return symmetricCrypto.encryptHex(data);
}

default String symmetricDecrypt(String data, String secretKey, String algorithm) throws Exception {
    isBase64(secretKey, "密钥");
    SymmetricCrypto symmetricCrypto = new SymmetricCrypto(algorithm, Base64.decode(secretKey));
    return symmetricCrypto.decryptStr(data, CharsetUtil.CHARSET_UTF_8);
}

非对称算法

AsymmetricCrypto 类的构造方法中传入指定算法名称和公钥参数，并调用 encryptHex() 方法对待加密的数据进行加密，最终返回加密后的十六进制字符串。

在解密过程中，首先使用 isBase64() 函数对私钥参数进行验证，确保其为 Base64 编码格式。接着，使用 AsymmetricCrypto 类的构造方法中传入指定算法名称和私钥参数，并调用 decryptStr() 方法对待解密的数据进行解密，最终返回解密后的字符串。

需要注意的是，这里的加密和解密使用的是不同的密钥，因此需要分别使用公钥和私钥。这种非对称加密方式相对对称加密更加安全，因为不同的密钥用于加密和解密，不易被攻击者破解。


default String asymmetricEncrypt(String data, String publicKey, String algorithm) throws Exception {
    isBase64(publicKey, "公钥");
    AsymmetricCrypto asymmetricCrypto = new AsymmetricCrypto(algorithm, null, publicKey);
    return asymmetricCrypto.encryptHex(data, KeyType.PublicKey);
}

default String asymmetricDecrypt(String data, String privateKey, String algorithm) throws Exception {
    isBase64(privateKey, "私钥");
    AsymmetricCrypto asymmetricCrypto = new AsymmetricCrypto(algorithm, privateKey, null);
    return asymmetricCrypto.decryptStr(data, KeyType.PrivateKey);
}

摘要接口

接口 Digest 的 digestHex(String data, String algorithm) 方法接收两个参数：一个是数据，另一个是指定算法。它利用 Hutool 库中的 Digester 类来计算消息摘要，并返回摘要的 16 进制字符串表示。

default String digestHex(String data, String algorithm) throws Exception {
    Digester digester = new Digester(algorithm);
    return digester.digestHex(data);
}

工厂

1、使用加密工厂创建加密接口的算法：

package crypto;

import crypto.asymmetric.RSA;
import crypto.asymmetric.SM2;
import crypto.constant.AlgorithmConstant;
import crypto.model.Algorithm;
import crypto.symmetric.AES;
import crypto.symmetric.DES;
import crypto.symmetric.DESede;
import crypto.symmetric.SM4;

/**
 * 加密算法工厂类
 *
 * @author loquy
 * @date 2023/02/07 10:03
 */
public class CryptoFactory {

    public static Crypto getCryptoFactory(Algorithm algorithm) throws Exception {
        switch (algorithm.getPkAlgorithm()) {
            case AlgorithmConstant.DES:
                return new DES(algorithm);
            case AlgorithmConstant.DES3:
                return new DESede(algorithm);
            case AlgorithmConstant.AES:
                return new AES(algorithm);
            case AlgorithmConstant.SM4:
                return new SM4(algorithm);
            case AlgorithmConstant.RSA:
                return new RSA(algorithm);
            case AlgorithmConstant.SM2:
                return new SM2(algorithm);
            default:
                throw new Exception("没有找到此算法：" + algorithm.getPkAlgorithm());
        }
    }
}

2、使用摘要工厂创建摘要接口的算法：

package crypto;

import crypto.constant.AlgorithmConstant;
import crypto.digest.MD5;
import crypto.digest.SHA1;
import crypto.digest.SHA256;
import crypto.digest.SM3;
import crypto.model.Algorithm;

/**
 * @author loquy
 * @date 2023/02/09 9:23
 */
public class DigestFactory {

    public static Digest getDigestFactory(Algorithm algorithm) throws Exception {
        switch (algorithm.getHashAlgorithm()) {
            case AlgorithmConstant.MD5:
                return new MD5(algorithm);
            case AlgorithmConstant.SHA1:
                return new SHA1(algorithm);
            case AlgorithmConstant.SHA256:
                return new SHA256(algorithm);
            case AlgorithmConstant.SM3:
                return new SM3(algorithm);
            default:
                throw new Exception("没有找到此算法：" + algorithm.getHashAlgorithm());
        }
    }
}

3、调用示例：

1
2
3

String encrypt = CryptoFactory.getCryptoFactory(algorithm).encrypt();
String decrypt = CryptoFactory.getCryptoFactory(algorithm).decrypt();
String digest = DigestFactory.getDigestFactory(algorithm).digestHex();

测试

package crypto;

import crypto.constant.AlgorithmConstant;
import crypto.model.Algorithm;
import crypto.model.Key;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @author loquy
 * @date 2023/02/21 15:14
 */
@SpringBootTest
public class CryptoTests {

    @Test
    void asymmetricTest() throws Exception {
        cryptoTest(AlgorithmConstant.RSA, "RSA");
        cryptoTest(AlgorithmConstant.SM2, "SM2");
    }

    @Test
    void symmetricTest() throws Exception {
        cryptoTest(AlgorithmConstant.AES, "AES");
        cryptoTest(AlgorithmConstant.DES, "DES");
        cryptoTest(AlgorithmConstant.DES3, "DESede");
        cryptoTest(AlgorithmConstant.SM4, "SM4");
    }

    @Test
    void digestTest() throws Exception {
        digestTest(AlgorithmConstant.MD5, "MD5");
        digestTest(AlgorithmConstant.SHA1, "SHA1");
        digestTest(AlgorithmConstant.SHA256, "SHA256");
        digestTest(AlgorithmConstant.SM3, "SM3");
    }

    private void cryptoTest(String algorithmName, String data) throws Exception {
        Algorithm algorithm = new Algorithm(algorithmName, null, null, null, null, data);
        Key key = CryptoFactory.getCryptoFactory(algorithm).generateKey();
        algorithm.setKey(key.getBase64SecretKey());
        algorithm.setPrivateKey(key.getBase64PrivateKey());
        algorithm.setPublicKey(key.getBase64PublicKey());
        String encrypt = CryptoFactory.getCryptoFactory(algorithm).encrypt();
        algorithm.setRawData(encrypt);
        String decrypt = CryptoFactory.getCryptoFactory(algorithm).decrypt();
        System.out.println("=====================");
        System.out.println(encrypt);
        System.out.println(decrypt);
    }

    private void digestTest(String algorithmName, String data) throws Exception {
        Algorithm algorithm = new Algorithm(null, null, null, null, algorithmName, data);
        String encrypt = DigestFactory.getDigestFactory(algorithm).digestHex();
        System.out.println("=====================");
        System.out.println(encrypt);
    }
}

输出：

asymmetricTest

=====================
075f2c0e81a54517cd61631668e9b5568e6082e69bf70e93a0996861ce365cad6385b25eaa75f77107595743dd6892e98e78b126369371068f68ff18e0d70cc86a42a74a3726b24d8bd6e53e4635c8faccb4185bdafc4d2ba9c6270db14ddff8633be84d78625775a7c8948719761245bcdc9a8e3a02b42b5e6d0a28352ca2bb
RSA
=====================
0403196b4d211e9af36725da6782f31ff524804057ec7e32b27ae1a79c6065fdb33d2f9a5304a6e039528d53cc7a46dac318497558c00b7865d5f859a6eca28caf0bddf74dcb337d14c58d2392be6fc92ecde35fdb3213a3dfe474ea853ad891260028c5
SM2

digestTest

=====================
7f138a09169b250e9dcb378140907378
=====================
e1744a525099d9a53c0460ef9cb7ab0e4c4fc939
=====================
b3abe5d8c69b38733ad57ea75e83bcae42bbbbac75e3a5445862ed2f8a2cd677
=====================
17a7fa246c4b9b527fb778792b91e3ec1cc51301311801613e1a7783ebcfe2e5

symmetricTest

=====================
6c073cdf45fa0fdf8e5bdb10d3615a0e
AES
=====================
e3512db314d44c2e
DES
=====================
54c3bf117d4c10b5
DESede
=====================
8b3be8b1fb505de0baa48cb5181a7974
SM4

源码

参见此仓库

在线运行 Java 代码的原理及实现

2023-02-20T09:06:00.000Z

简介

在线运行 Java 代码是指用户在浏览器中输入 Java 代码，通过在线编译和加载，最终在服务器上运行代码并返回结果。这种技术被广泛应用于在线编程学习、在线面试和在线评测等场景。

原理

动态编译

Java 的动态编译是指在运行时将 Java 代码编译成字节码的过程。Java 提供了一个标准的 API：JavaCompiler 和 ToolProvider，可以用来进行动态编译。在动态编译时，需要将 Java 代码转换为 JavaFileObject 对象，然后通过 JavaCompiler.getTask() 方法来编译 JavaFileObject 对象。在编译过程中，可以使用 DiagnosticCollector 类来收集编译过程中的错误和警告信息。

动态加载

Java 的动态加载是指在运行时将编译好的字节码加载到内存中，并生成对应的 class 对象的过程。Java 提供了一个标准的 API：ClassLoader，可以用来进行动态加载。通过自定义 ClassLoader 类来加载字节码，然后调用 ClassLoader.loadClass() 方法即可加载类。

线程的限制

在线运行 Java 代码需要考虑线程的限制和安全性控制。为了避免在线运行的代码对服务器产生过多的负载，可以使用线程池来限制并发访问以及设置超时时间停止线程。

安全性控制

为了保证在线运行的代码安全性，需要限制在线运行的代码只能访问一些受控的资源，并且禁止访问其他资源。Java 提供了一个安全管理器（SecurityManager）来控制代码的安全性，可以在代码运行前启用安全管理器，限制代码的访问权限。

实现

编译器

ScriptCompiler 类实现了一个动态编译和执行 Java 代码，主要功能包括：

编译 Java 代码字符串为 Java Class，并加载该 Class。
执行该 Class 中的 Main 方法，并将输出结果返回。

包括以下几个主要步骤：

使用 Java Compiler API 编译 Java 代码字符串为 Java Class。
- 利用 Java Compiler API 获取系统默认的 JavaCompiler，然后创建一个 DiagnosticCollector 用于收集编译过程中的诊断信息。
- 使用 StandardJavaFileManager 创建一个 JavaFileObject 对象，表示一个源代码文件，将 Java 代码字符串作为文件内容。
- 设置编译选项，这里设置了编译输出目录和编译源文件列表。
- 调用 CompilationTask 的 call() 方法编译 Java 代码，如果编译失败，则将诊断信息拼接成字符串并抛出异常。
使用自定义的 ClassLoader 加载编译好的 Java Class。
- ScriptLoader 首先将类名转换成类文件名，然后从指定的路径中加载对应的类文件，返回该类的 class 对象。
执行编译好的 Java Class 的 Main 方法，并将输出结果返回。
- 创建一个 ByteArrayOutputStream 对象用于缓存执行结果。
- 使用 System.setOut() 方法将 System.out 的输出重定向到缓存输出流中。
- 通过反射获取 Main 方法并执行，将传入的参数作为 Main 方法的参数，执行过程中会输出内容到缓存输出流中。
- 将缓存输出流中的内容转换成字符串并返回，同时将 System.out 重定向回原来的输出流。
对执行 Main 方法进行安全控制，防止代码执行恶意操作。
- 在执行 Main 方法之前和之后，调用 ScriptSecurityManager 的相关方法进行安全控制，限制了代码执行的权限和行为，防止代码执行恶意操作。

点击查看代码

Java 代码生成器

2022-12-07T08:51:00.000Z

概述

代码生成器的主要目的是提高开发效率，减少重复劳动，并确保生成的代码符合一定的规范。可以使用它来自动生成那些具有一定规律性的代码，包括但不限于数据库访问层、业务逻辑层和用户界面层。它可以根据给定的数据库和表信息，使用模板生成代码，这个过程包括以下步骤：1、确定需要生成的代码。2、编写代码生成器的逻辑。3、使用模板引擎来帮助你生成代码。4、编写工具来调用你的代码生成器，并将生成的代码写入文件。

实现思路

参考：自定义代码生成器。^[1]

使用 Java 中的 JDBC API 来连接到数据库，并使用 SQL 查询或 DatabaseMetaData 接口来获取数据库表的元数据，例如表名、列名和数据类型。
使用模板引擎（如 Freemarker 或 Velocity）来定义代码生成模板。模板可能包括普通文本和特殊标记，用于在生成代码时插入元数据。
使用 Java 代码从模板引擎加载模板，并将元数据插入模板中。最后，将生成的代码写入文件或输出到控制台。

模板引擎

参考：FreeMarker 快速入门。^[2]

FreeMarker 是一款用 java 语言编写的模版引擎，它通过提供一组指令来处理模板文件，并将数据和模板文件合并成最终的文件。FreeMarker 模板文件可以包含特殊的指令，这些指令可以控制模板的渲染方式，例如条件判断、循环语句等。程序员可以通过在模板文件中插入这些指令来定制模板的渲染方式。

特点：
- 轻量级模版引擎，不需要 Servlet 环境就可以很轻松的嵌入到应用程序中。
- 能生成各种文本，如 html，xml，java 等。
- 入门简单，它是用 java 编写的，很多语法和 java 相似。
工作原理：
使用步骤：
- 加载 FreeMarker 模板引擎的类库。
- 设置模板文件的路径和存储数据的 Map 对象。
- 创建 FreeMarker 模板引擎的 Configuration 对象。
- 创建模板文件的模板对象。
- 程序可以通过调用 FreeMarker 的 process 方法，将模板文件和数据进行合并，并将合并后的结果通过 IO 流输出到指定的文件。

数据库元数据

参考：使用 JDBC 提取数据库元数据。^[3]

Java 数据库元数据（DatabaseMetaData）是一个接口，它提供了有关数据库的元数据（即数据库的数据字典）的信息。

它可以用来获取表详细信息、获取列详细信息、获取主键详细信息等。

要使用数据库元数据，需要先使用 JDBC（Java Database Connectivity，Java 数据库连接）连接数据库，然后通过 Connection 对象的 getMetaData 方法获取 DatabaseMetaData 对象。

获取表信息： getTables(...)。
获取列信息： getColumns(...)。
获取主键信息： getPrimaryKeys(...)。

下面是一个简单的示例，展示了如何使用数据库元数据获取表详细信息、获取列详细信息、获取主键详细信息：

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;

public class MetaDataExample {
    public static void main(String[] args) throws SQLException {
        // 连接 URL
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        // 数据库用户名
        String username = "user";
        // 数据库密码
        String password = "password";

        // 建立与数据库的连接
        Connection conn = DriverManager.getConnection(url, username, password);

        // 获取数据库元数据
        DatabaseMetaData dbMetaData = conn.getMetaData();

        // 获取表的详细信息
        ResultSet tables = dbMetaData.getTables(null, null, null, new String[] {"TABLE"});
        while (tables.next()) {
            String tableName = tables.getString("TABLE_NAME");
            String tableType = tables.getString("TABLE_TYPE");
            String tableRemarks = tables.getString("REMARKS");
            // 输出表信息
            System.out.println("Table Name: " + tableName);
            System.out.println("Table Type: " + tableType);
            System.out.println("Table Remarks: " + tableRemarks);
        }

        // 获取列的详细信息
        ResultSet columns = dbMetaData.getColumns(null, null, "my_table", null);
        while (columns.next()) {
            String columnName = columns.getString("COLUMN_NAME");
            String columnType = columns.getString("TYPE_NAME");
            String columnSize = columns.getString("COLUMN_SIZE");
            String columnRemarks = columns.getString("REMARKS");
            // 输出列信息
            System.out.println("Column Name: " + columnName);
            System.out.println("Column Type: " + columnType);
            System.out.println("Column Size: " + columnSize);
            System.out.println("Column Remarks: " + columnRemarks);
        }

        // 获取主键的详细信息
        ResultSet primaryKeys = dbMetaData.getPrimaryKeys(null, null, "my_table");
        while (primaryKeys.next()) {
            String primaryKeyName = primaryKeys.getString("COLUMN_NAME");
            String primaryKeySeq = primaryKeys.getString("KEY_SEQ");
            String primaryKeyTableName = primaryKeys.getString("TABLE_NAME");
            // 输出主键信息
            System.out.println("Primary Key Name: " + primaryKeyName);
            System.out.println("Primary Key Sequence: " + primaryKeySeq);
            System.out.println("Primary Key Table Name: " + primaryKeyTableName);
        }
    }
}

表结构

创建名为 test 数据库，执行以下 sql 语句创建 user 表。

CREATE TABLE `user` (
  `id` int(11) NOT NULL COMMENT '主键',
  `name` varchar(255) NOT NULL COMMENT '名称',
  `pwd` varchar(255) NOT NULL COMMENT '密码',
  `create_date` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_date` datetime NOT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户表';

项目结构

spring-boot-code-generator│├─src│  ├─main│  │  ├─java│  │  │  └─com│  │  │      └─example│  │  │          └─codegenerator│  │  │              │  SpringBootCodeGeneratorApplication.java│  │  │              ││  │  │              ├─common│  │  │              │      BaseDao.java│  │  │              │      BaseDaoImpl.java│  │  │              │      Page.java│  │  │              │      ResultModel.java│  │  │              ││  │  │              ├─config│  │  │              │      DataSourceConfig.java│  │  │              ││  │  │              ├─constant│  │  │              │      DbConstant.java│  │  │              │      TemplateConstant.java│  │  │              ││  │  │              ├─param│  │  │              │      ColumnParam.java│  │  │              │      TableParam.java│  │  │              │      TemplatePathParam.java│  │  │              ││  │  │              └─utils│  │  │                      CodeGenerateUtils.java│  │  │                      DbUtils.java│  │  │                      FreeMarkerTemplateUtils.java│  │  │                      StrUtils.java│  │  ││  │  └─resources│  │      │  application.properties│  │      ││  │      └─templates│  │              controller.ftl│  │              dao.ftl│  │              entity.ftl│  │              param.ftl│  │              service.ftl│  │              serviceImpl.ftl│  ││  └─test│      └─java│          └─com│              └─example│                  └─codegenerator│                          SpringBootCodeGeneratorApplicationTests.java

依赖配置

在项目的 pom.xml 的 dependencies 中导入需要的依赖包:

<dependency>
    <groupId>org.freemarkergroupId>
    <artifactId>freemarkerartifactId>
    <version>2.3.31version>
dependency>

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>${mysql.version}version>
dependency>

<dependency>
    <groupId>cn.hutoolgroupId>
    <artifactId>hutool-allartifactId>
    <version>5.8.5version>
dependency>

<dependency>
    <groupId>org.apache.commonsgroupId>
    <artifactId>commons-lang3artifactId>
    <version>3.8.1version>
dependency>

<dependency>
    <groupId>org.hibernate.javax.persistencegroupId>
    <artifactId>hibernate-jpa-2.1-apiartifactId>
    <version>1.0.2.Finalversion>
dependency>

<dependency>
    <groupId>org.hibernategroupId>
    <artifactId>hibernate-coreartifactId>
    <version>5.6.9.Finalversion>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-ormartifactId>
    <version>5.3.22version>
dependency>

全局配置

在项目的 application.properties 文件里添加所需配置：

spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=UTC&setUnicode=true&charterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

编码

1、常量类

1.1、数据库常量

该类定义了三个数组常量：COLUMNTYPE_TIME、COLUMNTYPE_NUMBER，分别用于存储数据库时间类型和数字类型。
还定义了四个字符串常量：TYPE_STRING、TYPE_INTEGER、TYPE_LONG 和 TYPE_BIGDECIMAL，用于表示不同类型的数据。
例如，TYPE_STRING 表示字符串类型，TYPE_INTEGER 表示整型，TYPE_LONG 表示长整型，TYPE_BIGDECIMAL 表示高精度计算类型。

点击查看代码

Java 日期和时间

2022-11-18T09:43:00.000Z

概述

Java 提供了两套日期和时间的接口。

旧版：Date、Calendar 等，Date 类主要封装了系统的日期和时间的信息，Calendar 类则会根据系统的日历来解释 Date 对象。
从 Java 8 开始，java.time 包提供了新的日期和时间 API，主要涉及的类有：
- 本地日期和时间：LocalDateTime，LocalDate，LocalTime；
- 带时区的日期和时间：ZonedDateTime；
- 时刻：Instant；
- 时区：ZoneId，ZoneOffset；
- 时间间隔：Duration。
以及一套新的用于取代 SimpleDateFormat 的格式化类 DateTimeFormatter。和旧的 API 相比，新 API 严格区分了时刻、本地日期、本地时间和带时区的日期时间，并且对日期和时间进行运算更加方便。新 API 的类型几乎全部是不变类型（和 String 类似），可以放心使用不必担心被修改。
SimpleDateFormat 是线程不安全的类，一般不要定义为 static 变量，如果定义为 static，必须加锁，或者使用 DateUtils 工具类。正例：注意线程安全，使用 DateUtils。亦推荐如下处理：
1
2
3
4
5
6
private static final ThreadLocal df = new ThreadLocal() { @Override protected DateFormat initialValue() { return new SimpleDateFormat("yyyy-MM-dd"); } };
说明：如果是 JDK8 的应用，可以使用 Instant 代替 Date，LocalDateTime 代替 Calendar，DateTimeFormatter 代替 SimpleDateFormat，官方给出的解释：simple beautiful strong immutable thread-safe。——引用《阿里巴巴Java开发手册》
日期和时间类相关的操作方法用到时查询即可，无需记忆，用着用着就熟悉了。

格式化模式

字母	含义	示例
y	年份	使用 yy 表示的年份，如 11；使用 yyyy 表示的年份，如 2011
M	月份	使用 MM 表示的月份，如 05；使用 MMM 表示月份，在 Locale.CHINA 语言环境下，如“十月”；在 Locale.US 语言环境下，如 Oct
d	月份中的天数	使用 dd 表示的天数，如 10
D	年份中的天数	使用 D 表示的年份中的天数，如 360
E	星期几	使用 E 表示星期几，在 Locale.CHINA 语言环境下，如“星期四”；在 Locale.US 语言环境下，如 Thu
H	一天中的小时数（0~23)	使用 HH 表示的小时数，如 18
h	一天中的小时数（1~12)	使用 hh 表示的小时数，如 10 (注意 10 有可能是 10 点，也可能是 22 点）
m	分钟数	使用 mm 表示的分钟数，如 29
s	秒数	使用 ss 表示的秒数，如 38
S	毫秒数	使用 SSS 表示的毫秒数，如 156

代码示例

日期和字符串相互转换

旧版

public static String dateToStr(Date date) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    return sdf.format(date);
}

public static Date strToDate(String strDate) throws ParseException {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    return sdf.parse(strDate);
}

Java 8

public static String localDateTimeToStr(LocalDateTime localDateTime) {
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    return localDateTime.format(dateTimeFormatter);
}

public static LocalDateTime strToLocalDateTime(String strDate){
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    return LocalDateTime.parse(strDate, dateTimeFormatter);
}

LocalDateTime 和 Date 相互转换

public static LocalDateTime dateToLocalDateTime(Date date){
    return date.toInstant()
        //设置当前系统时区
        .atZone(ZoneId.systemDefault())
        .toLocalDateTime();
}

public static Date localDateTimeToDate(LocalDateTime localDateTime){
    return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
}

获取当天零点

旧版

public static Date getTodayZeroByDate() {
    Calendar calendar = Calendar.getInstance();
    calendar.setTime(new Date());
    calendar.set(Calendar.HOUR_OF_DAY, 0);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);
    return calendar.getTime();
}

Java 8

public static LocalDateTime getTodayZeroByLocalDateTime() {
    LocalDateTime now = LocalDateTime.now();
    // 当天的 00:00
    return LocalDateTime.of(now.toLocalDate(), LocalTime.MIN);
}

获取两个日期之间的所有月份

旧版

public static List getMonthBetweenByCalendar(String minDate, String maxDate) throws ParseException {
    ArrayList result = new ArrayList<>();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
    Calendar min = Calendar.getInstance();
    Calendar max = Calendar.getInstance();
    min.setTime(sdf.parse(minDate));
    max.setTime(sdf.parse(maxDate));
    while (min.before(max) || min.get(Calendar.MONTH) == max.get(Calendar.MONTH)) {
        result.add(sdf.format(min.getTime()));
        min.add(Calendar.MONTH, 1);
    }
    return result;
}

Java 8

public static List getMonthBetweenByLocalDate(String minDate, String maxDate) {
    List localDateList = new ArrayList<>();
    DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM");
    LocalDate min = LocalDate.parse(minDate);
    LocalDate max = LocalDate.parse(maxDate);
    while (min.isBefore(max) || min.getMonth() == max.getMonth()) {
        localDateList.add(min.format(dateTimeFormatter));
        min = min.plusMonths(1);
    }
    return localDateList;
}

Layui 表格多选、合并单元格、父子页传值

2022-11-18T09:43:00.000Z

Layui 表格多选、合并单元格、父子页传值的页面效果如下：

表格多选

使用 templet 自定义列模板，实现表格中添加下拉多选。

方式一：模板中用原生 select 标签进行渲染，以及用 Laytpl 模板引擎处理逻辑进行回显数据。

function initTable() {
    layui.use('table', function () {
        selectHtml = '';

        layui.table.render({
            elem: '#demo',
            page: true, //开启分页
            cols: [
                [ //表头
                    {field: 'id', title: 'ID', align: "center"},
                    {field: 'username', title: '用户名', align: "center"},
                    {field: 'sex', title: '性别', align: "center"},
                    {
                        field: 'sign', title: '爱好', minWidth: 150, align: "center", templet: stringToHTML(selectHtml)
                    },
                    {field: 'classify', title: '职业', align: "center"},
                    { title: '操作', minWidth: 100, align: "center", toolbar: '#barDemo'}
                ]
            ],
            data: init ? initData : tableData,
            done: function (res) {
                //修改一些css样式, 这里虽然能够使用, 但是还是不太友好, 努力中...
                var cells = document.querySelectorAll('div[lay-id="demo"] .layui-table-cell');
                for (var i = 0; i < cells.length; i++) {
                    cells[i].style.overflow = 'unset';
                    cells[i].style.height = 'auto';
                }
                //合并单元格
                merge(res);
            }
        });

    });
}

方式二：模板中用 xmSelect.js 下拉组件进行渲染。

function initTable() {
    layui.use('table', function () {
        layui.table.render({
            elem: '#demo',
            page: true, //开启分页
            cols: cols,
            data: init ? initData : tableData,
            done: function (res) {
                //修改一些css样式, 这里虽然能够使用, 但是还是不太友好, 努力中...
                var cells = document.querySelectorAll('div[lay-id="demo"] .layui-table-cell');
                for (var i = 0; i < cells.length; i++) {
                    cells[i].style.overflow = 'unset';
                    cells[i].style.height = 'auto';
                }
                //渲染多选
                res.data.forEach(item => {
                    var xm = xmSelect.render({
                        el: '#XM-' + item.id,
                        autoRow: true,
                        model: {type: 'fixed'},
                        data: [
                            {name: '张三', value: 1},
                            {name: '李四', value: 2},
                            {name: '王五', value: 3},
                        ]
                    })

                    item.__xm = xm;
                })
            }
        });

    });
}

合并单元格

具体思路就是, 通过循环判断每一行的每一列的返回值与上一行的相同列是否相同,
如果相同就进行行合并 rowspan: mark, 然后把当前行的当前列进行隐藏,
如果不相同就就记下当前行的行号, 并把标记 mark 重置为1。

// 合并单元格
function merge(res) {
    var data = res.data;
    var mergeIndex = 0;//定位需要添加合并属性的行数
    var mark = 1; //这里涉及到简单的运算，mark是计算每次需要合并的格子数
    var columsName = ['sex', 'classify'];// 需要合并的列名称
    var columsIndex = [2, 4];//需要合并的列索引值
    for (var k = 0; k < columsName.length; k++) { //这里循环所有要合并的列
        var trArr = $(".layui-table-body>.layui-table").find("tr");//所有行
        for (var i = 1; i < res.data.length; i++) { //这里循环表格当前的数据
            var tdCurArr = trArr.eq(i).find("td").eq(columsIndex[k]);//获取当前行的当前列
            var tdPreArr = trArr.eq(mergeIndex).find("td").eq(columsIndex[k]);//获取相同列的第一列
            if (data[i][columsName[k]] === data[i - 1][columsName[k]]) { //后一行的值与前一行的值做比较，相同就需要合并
                mark += 1;
                tdPreArr.each(function () {//相同列的第一列增加rowspan属性
                    $(this).attr("rowspan", mark);
                });
                tdCurArr.each(function () {//当前行隐藏
                    $(this).css("display", "none");
                });
            } else {
                mergeIndex = i;
                mark = 1;//一旦前后两行的值不一样了，那么需要合并的格子数mark就需要重新计算
            }
        }
        mergeIndex = 0;
        mark = 1;
    }
}

父子页传值

获取子页面的 window 对象，从而对子页面进行赋值变量和调用方法。

//触发单元格工具事件
layui.table.on('tool(demo)', function (obj) {
    if (obj.event === 'open') {
        layer.open({
            type: 2,
            area: ['80%', '80%'],
            content: 'layui-demo-1.html',
            btn: ['更换子数据', '重置子数据'],
            btnAlign: 'c',
            success: function (layero, index) {
                var w = $(layero).find("iframe")[0].contentWindow;
                w.cols[0].push({fixed: 'right', title: '操作', minWidth: 180, align: "center", toolbar: '#barDemo'});
                w.init = false;
                w.initTable();
            },
            yes: function (index, layero) {
                var w = $(layero).find("iframe")[0].contentWindow;
                w.init = false;
                w.tableData = [
                    {
                        "id": 10000,
                        "username": "user-0",
                        "sex": "女",
                        "sign": "签名-0",
                        "experience": 255,
                        "classify": "作家",
                    }
                ];
                w.initTable();
            }, btn2: function (index, layero) {
                var w = $(layero).find("iframe")[0].contentWindow;
                w.init = true;
                w.initTable();
                return false;
            }
        });
    }
});

在子页面获取 parent 父级对象，从而对父页面进行赋值变量和调用方法。

//触发单元格工具事件
layui.table.on('tool(demo)', function (obj) {
    if (obj.event === 'edit') {
        parent.tableData = [
            {
                "id": 10000,
                "username": "user-0",
                "sex": "女",
                "sign": "签名-0",
                "experience": 255,
                "classify": "作家",
            }
        ];
        parent.init = false;
        parent.initTable();
    } else if (obj.event === 'reset') {
        parent.init = true;
        parent.initTable();
    }
})

完整代码

点击查看父页面代码

Java 调用 Web Service

2022-10-28T02:16:00.000Z

概述

Web 服务

Web 服务是一种服务导向架构的技术，通过标准的 Web 协议提供服务，目的是保证不同平台的应用服务可以互操作。

根据 W3C 的定义，Web 服务（Web service）应当是一个软件系统，用以支持网络间不同机器的互动操作。网络服务通常是许多应用程序接口（API）所组成的，它们透过网络，例如国际互联网（Internet）的远程服务器端，执行客户所提交服务的请求。

尽管 W3C 的定义涵盖诸多相异且无法介分的系统，不过通常我们指有关于主从式架构（Client-Server）之间根据 SOAP 协议进行传递 XML 格式消息。无论定义还是实现，Web 服务过程中会由服务器提供一个机器可读的描述（通常基于 WSDL）以辨识服务器所提供的 WEB 服务。另外，虽然 WSDL 不是 SOAP 服务端点的必要条件，但目前基于 Java 的主流 Web 服务开发框架往往需要 WSDL 实现客户端的源代码生成。一些工业标准化组织，比如 WS-I，就在 Web 服务定义中强制包含 SOAP 和 WSDL。

定义

核心定义
考虑到并没某个独立文档包含一切相关内容，可采用模块化的方式给出对 Web 服务的描述，但不能给出一个“绝对全面和准确”的定义。受外部环境和实现技术影响，各方给出的核心定义可能稍有出入，但通常包括：

SOAP
一个基于 XML 的可扩展消息信封格式，需同时绑定一个网络传输协议。这个协议通常是 HTTP 或 HTTPS，但也可能是 SMTP 或 XMPP。

WSDL
一个 XML 格式文档，用以描述服务端口访问方式和使用协议的细节。通常用来辅助生成服务器和客户端代码及配置信息。

UDDI
一个用来发布和搜索 WEB 服务的协议，应用程序可借由此协议在设计或运行时找到目标WEB服务。
这些标准由这些组织制订：W3C 负责 XML、SOAP 及 WSDL；OASIS 负责 UDDI。

代码示例

先引入 axis 包


<dependency>
    <groupId>org.apache.axisgroupId>
    <artifactId>axisartifactId>
    <version>1.4version>
dependency>

具体代码实现

package com.example.webService;

import org.apache.axis.client.Call;
import org.apache.axis.client.Service;
import org.apache.axis.encoding.XMLType;
import javax.xml.namespace.QName;

/**
 * @author loquy
 */
public class CallWebService {

    private static final String ENDPOINT = "http://localhost:3000/test?wsdl";
    private static final String NAMESPACE = "http://tempuri.org/";
   

    private static String getGuid() throws Exception {
        Service service = new Service();
        Call call = (Call) service.createCall();
        call.setTargetEndpointAddress(ENDPOINT);
        // WSDL 里面描述的接口名称(要调用的方法)
        call.setOperationName(new QName(NAMESPACE, "login"));
        // 接口方法的参数名, 参数类型, 参数模式  IN(输入), OUT(输出) or INOUT(输入输出)
        call.addParameter("userId", XMLType.XSD_STRING, ParameterMode.IN);
        call.addParameter("password", XMLType.XSD_STRING, ParameterMode.IN);
        // 设置被调用方法的返回值类型
        call.setReturnType(XMLType.XSD_STRING);
        // 设置超时
        call.setTimeout(30 * 60 * 1000);
        // 设置方法中参数的值
        Object[] paramValues = new Object[] {"test", "test"};
        // 给方法传递参数，并且调用方法
        String result = (String) call.invoke(paramValues);

        System.out.println(result);

        return result;
    }
}

参考

Windows 下定时重启 Tomcat

2022-10-09T06:02:00.000Z

前言

维护很老的项目时，tomcat 隔几天会死掉一次；其中代码肯定有问题的，但是历史遗留的代码必然有很多坑且非原作者很难去改动；无奈出此下策：写个批处理脚本加入任务计划去定时重启 tomcat；脚本原理是根据端口关闭 tomcat 所在的进程，杀死进程后调用 startup.bat 重新启动 tomcat。

批处理脚本

1、先查看 tomcat 配置目录 conf 下的 server.xml 文件里的两个端口号

"1.0" encoding="UTF-8"?>
<Server port="8005" shutdown="SHUTDOWN">
    
  <Service name="Catalina">
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
     
  Service>
Server>

2、把端口写入到重启 tomcat 的批处理脚本里

@echo off & setlocal EnableDelayedExpansion 
title 定时重启 tomcat

:: Tomcat 路径和端口
set tomcat_root_path=H:
set tomcat_ports=8005,8080
set tomcat_path=H:\environment\apache-tomcat-8.5.72\bin

::循环关闭端口对应的进程
for %%a in (%tomcat_ports%) do (
set pid=0
for /f "tokens=2,5" %%b in ('netstat -ano ^| findstr ":%%a"') do (
set temp=%%b
for /f "usebackq delims=: tokens=1,2" %%i in (`set temp`) do (
if %%j==%%a (
taskkill /f /pid %%c
set pid=%%c
echo 端口号【%%a】相关进程已杀死
) else (
echo 不是本机占用端口【%%a】
)
)
)
if !pid!==0 (
echo 端口号【%%a】没有占用
)
) 
echo tomcat 相关进程已杀死 
::延迟 10 秒
TIMEOUT /T 10

echo 切换到 tomcat 目录，调用 startup.bat 
%tomcat_root_path%
cd %tomcat_path%
call startup.bat 
echo tomcat 已启动!
 
echo 操作完成!
exit

定时重启

1、底部任务栏搜索框输入：任务计划程序，然后打开；

2、创建基本任务，添加任务描述；

3、触发器，选择定时的时间；

4、操作，启动程序，选择重启 tomcat 的批处理脚本；

5、完成。

Java IO 流

2022-09-27T09:26:00.000Z

概述

IO

通过数据流、序列化和文件系统提供系统输入和输出。

流

流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样。

原理

Java 把这些不同来源和目标的数据都统一抽象为数据流。Java 语言的输入输出功能是十分强大而灵活的，美中不足的是看上去输入输出的代码并不是很简洁，因为你往往需要包装许多不同的对象。

在 Java 类库中，IO 部分的内容是很庞大的，因为它涉及的领域很广泛:标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip 文件流。

File 文件类

在 Java 中，File 类是 java.io 包中唯一代表磁盘文件本身的对象，也就是说，如果希望在程序中操作文件和目录，则都可以通过 File 类来完成。File 类定义了一些方法来操作文件，如新建、删除、重命名文件和目录等。

File 类不能访问文件内容本身，如果需要访问文件内容本身，则需要使用输入/输出流。

File 类提供了如下三种形式构造方法。

File(String path)：如果 path 是实际存在的路径，则该 File 对象表示的是目录；如果 path 是文件名，则该 File 对象表示的是文件。
File(String path, String name)：path 是路径名，name 是文件名。
File(File dir, String name)：dir 是路径对象，name 是文件名。

使用任意一个构造方法都可以创建一个 File 对象，然后调用其提供的方法对文件进行操作。在表中列出了 File 类的常用方法及说明。

方法名称	说明
boolean canRead()	测试应用程序是否能从指定的文件中进行读取
boolean canWrite()	测试应用程序是否能写当前文件
boolean delete()	删除当前对象指定的文件
boolean exists()	测试当前 File 是否存在
String getAbsolutePath()	返回由该对象表示的文件的绝对路径名
String getName()	返回表示当前对象的文件名或路径名（如果是路径，则返回最后一级子路径名）
String getParent()	返回当前 File 对象所对应目录（最后一级子目录）的父目录名
boolean isAbsolute()	测试当前 File 对象表示的文件是否为一个绝对路径名。该方法消除了不同平台的差异，可以直接判断 file 对象是否为绝对路径。在 UNIX/Linux/BSD 等系统上，如果路径名开头是一条斜线`/`，则表明该 File 对象对应一个绝对路径；在 Windows 等系统上，如果路径开头是盘符，则说明它是一个绝对路径。
boolean isDirectory()	测试当前 File 对象表示的文件是否为一个路径
boolean isFile()	测试当前 File 对象表示的文件是否为一个“普通”文件
long lastModified()	返回当前 File 对象表示的文件最后修改的时间
long length()	返回当前 File 对象表示的文件长度
String[] list()	返回当前 File 对象指定的路径文件列表
String[] list(FilenameFilter)	返回当前 File 对象指定的目录中满足指定过滤器的文件列表
boolean mkdir()	创建一个目录，它的路径名由当前 File 对象指定
boolean mkdirs()	创建一个目录，它的路径名由当前 File 对象指定
boolean renameTo(File)	将当前 File 对象指定的文件更名为给定参数 File 指定的路径名

IO 流的分类

流向和数据类型

根据数据的流向分为：输入流 和 输出流。

输入流 ：把数据从其他设备上读取到内存中的流。
输出流 ：把数据从内存 中写出到其他设备上的流。

根据数据的类型分为：字节流 和 字符流。

字节流 ：以字节为单位，读写数据的流。
字符流 ：以字符为单位，读写数据的流。

分类之后对应的父类

	输入流	输出流
字节流	字节输入流 InputStream	字节输出流 OutputStream
字符流	字符输入流 Reader	字符输出流 Writer

注：
由这四个类的子类名称基本都是以其父类名作为子类名的后缀。
如：InputStream 的子类 FileInputStream。
如：Reader的子类 FileReader。

具体分类

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件	FileInputStream	FileOutputStream	FileReader	FileWriter
访问数组	ByteArrayInputStream	ByteArrayOutpuStream	CharArrayReader	CharArrayWriter
访问管道	PipedInputStream	PipedOutputStream	PipedReader	PipedWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
转换流			InputStreamReader	OutputStreamWriter
对象流	ObjectInputStream	ObjectOutputStream
过滤流	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter
打印流		PrintStream		PrintWriter
推回输入流	PushbackInputStream		PushbackReader
数据流	DataInputStream	DataOutputStream

注：倾斜代表抽象类，无法创建实例，红色表示节点流，必须直接与指定物理节点关联。

代码示例

File 类

获取文件属性

import java.io.File;
import java.util.Date;

public class FileTest {

    public static void main(String[] args) {
        // 指定文件所在的目录
        String path = "D:/";
        // 建立 File 变量，并设定由 f 变量引用
        File f = new File(path, "test.txt");
        System.out.println("D:\\test.txt文件信息如下：");
        System.out.println("============================================");
        System.out.println("文件长度：" + f.length() + "字节");
        System.out.println("文件或者目录：" + (f.isFile() ? "是文件" : "不是文件"));
        System.out.println("文件或者目录：" + (f.isDirectory() ? "是目录" : "不是目录"));
        System.out.println("是否可读：" + (f.canRead() ? "可读取" : "不可读取"));
        System.out.println("是否可写：" + (f.canWrite() ? "可写入" : "不可写入"));
        System.out.println("是否隐藏：" + (f.isHidden() ? "是隐藏文件" : "不是隐藏文件"));
        System.out.println("最后修改日期：" + new Date(f.lastModified()));
        System.out.println("文件名称：" + f.getName());
        System.out.println("文件路径：" + f.getPath());
        System.out.println("绝对路径：" + f.getAbsolutePath());
    }
}

输出：

D:\test.txt文件信息如下：============================================文件长度：0字节文件或者目录：是文件文件或者目录：不是目录是否可读：可读取是否可写：可写入是否隐藏：不是隐藏文件最后修改日期：Tue Sep 27 16:06:10 GMT+08:00 2022文件名称：test.txt文件路径：D:\test.txt绝对路径：D:\test.txt

创建和删除文件

import java.io.File;
import java.io.IOException;

public class FileTest01 {

    public static void main(String[] args) throws IOException {
        // 创建指向文件的 File 对象
        File f = new File("D:\\test.txt");
        // 判断文件是否存在
        if (f.exists()) {
            // 存在则先删除
            boolean delete = f.delete();
            System.out.println(delete);
        }
        // 再创建
        boolean newFile = f.createNewFile();
        System.out.println(newFile);
    }
}

输出：

truetrue

import java.io.File;

public class FileTest02 {

    public static void main(String[] args) {
        // 指定目录位置
        String path = "D:/config/";
        // 创建 File 对象
        File f = new File(path);
        if (f.exists()) {
            boolean delete = f.delete();
            System.out.println(delete);
        }
        // 创建目录
        boolean mkdir = f.mkdir();
        System.out.println(mkdir);
    }
}

输出：

truetrue

import java.io.File;

public class FileTest03 {

    public static void main(String[] args) {
        // 建立 File 变量,并设定由 f 变量变数引用
        File f = new File("D:/");
        System.out.println("文件名称\t\t文件类型\t\t文件大小");
        System.out.println("===================================================");
        // 调用不带参数的 list() 方法
        String[] fileList = f.list();
        assert fileList != null;
        // 遍历返回的字符数组
        for (String s : fileList) {
            System.out.print(s + "\t\t");
            System.out.print((new File("D:/", s)).isFile() ? "文件" + "\t\t" : "文件夹" + "\t\t");
            System.out.println((new File("D:/", s)).length() + "字节");
        }
    }
}

输出：

文件名称文件类型文件大小===================================================$RECYCLE.BIN文件夹0字节config文件夹0字节data文件夹0字节home文件夹0字节JamWorkspaceAndroid文件夹0字节note文件夹4096字节oracle文件夹4096字节pagefile.sys文件8053063680字节picture文件夹12288字节Program Files文件夹4096字节Program Files (x86)文件夹4096字节project文件夹0字节study文件夹4096字节System Volume Information文件夹0字节test.txt文件192字节test1.txt文件0字节Users文件夹0字节virtual文件夹0字节软件文件夹4096字节

字节流

文件的复制（字节流）

import java.io.*;

public class InputOutputTest {

    public static void main(String[] args)throws IOException {
        // 源文件和目标文件
        File source = new File("D:\\test.txt") ;
        File target = new File("D:\\test1.txt") ;
        // 字节输入流和输出流
        InputStream inStream = new FileInputStream(source) ;
        OutputStream outStream = new FileOutputStream(target) ;
        // 字节读入和写出
        byte[] byteArr = new byte[1024];
        int readSign ;
        while ((readSign = inStream.read(byteArr)) != -1){
            outStream.write(readSign);
        }
        // 关闭流
        outStream.close();
        inStream.close();
    }
}

字符流

文件的复制（字符流），其速度效率要快于字节流读取，对于非文本文件（视频文件、音频文件、图片），只能使用字节流！

import java.io.*;

public class ReaderWriterTest {

    public static void main(String[] args) throws Exception {
        // 读文本和写文本
        File readerFile = new File("D:\\test.txt") ;
        File writerFile = new File("D:\\test1.txt") ;
        // 字符输入和输出流
        Reader reader = new FileReader(readerFile) ;
        Writer writer = new FileWriter(writerFile);
        // 字符读入和写出
        int readSign;
        while ((readSign = reader.read()) != -1) {
            writer.write(readSign);
        }
        writer.flush();
        // 关闭流
        writer.close();
        reader.close();
    }
}

字节缓冲流

文件的复制（字节缓冲流，加速字节读取）

import java.io.*;

public class BufferedInputOutputTest {

    public static void main(String[] args) throws Exception {
        // 源文件 目标文件
        File source = new File("D:\\test.txt");
        File target = new File("D:\\test1.txt");
        // 缓冲：字节输入流字符输出流
        InputStream bufInStream = new BufferedInputStream(new FileInputStream(source));
        OutputStream bufOutStream = new BufferedOutputStream(new FileOutputStream(target));
        // 字节读入和写出
        int readSign;
        while ((readSign = bufInStream.read()) != -1) {
            bufOutStream.write(readSign);
        }
        // 关闭流
        bufOutStream.close();
        bufInStream.close();
    }
}

字符缓冲流

文件的复制（字符缓冲流，加速字符读取）

import java.io.*;

public class BufferedReaderWriterTest {

    public static void main(String[] args) throws Exception {
        // 读文本和写文本
        File readerFile = new File("D:\\test.txt") ;
        File writerFile = new File("D:\\test1.txt") ;
        // 缓冲：字符输入和输出流
        BufferedReader bufReader = new BufferedReader(new FileReader(readerFile)) ;
        BufferedWriter bufWriter = new BufferedWriter(new FileWriter(writerFile)) ;
        // 字符读入和写出
        String line;
        while ((line = bufReader.readLine()) != null){
            bufWriter.write(line);
            bufWriter.newLine();
        }
        bufWriter.flush();
        // 关闭流
        bufWriter.close();
        bufReader.close();
    }
}

转换流

转换流可以将字节流读取到的字节，按指定字符集解码成字符。

import java.io.*;
import java.nio.charset.StandardCharsets;

public class InputOutputStreamReaderTest {

    public static void main(String[] args) {
        try {
            // 解码，把字节数组变成字符流
            InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\test.txt"));
            BufferedReader br = new BufferedReader(isr);

            // 编码，把字符流变成字节数组
            FileOutputStream fos = new FileOutputStream("D:\\test.txt");
            // 指定字符集
            OutputStreamWriter osr = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
            BufferedWriter bw = new BufferedWriter(osr);

            int len;
            char[] c = new char[8 * 1024];
            while ((len = br.read(c)) != -1) {
                bw.write(c, 0, len);
                bw.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

数据流

数据流：用来处理基本数据类型、String、字节数组的数据。

import java.io.*;

public class DataInputOutputStream {

    public static void main(String[] args) throws Exception  {
        DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream("D:\\test.txt"));
        dataOutputStream.writeUTF("我爱你，而你不知道");
        dataOutputStream.writeBoolean(true);
        dataOutputStream.writeInt(12);
        dataOutputStream.close();

        DataInputStream dataInputStream = new DataInputStream(new FileInputStream("D:\\test.txt"));
        System.out.println(dataInputStream.readUTF());
        System.out.println(dataInputStream.readBoolean());
        System.out.println(dataInputStream.readInt());
        dataInputStream.close();
    }
}

输出：

我爱你，而你不知道true12

对象流

序列化：对象转换为流的过程，反序列化：流转换为对象的过程。

import java.io.*;

public class ObjectInputOutputStreamTest {

    public static void main(String[] args) throws Exception {
        // 序列化对象
        OutputStream outStream = new FileOutputStream("D:\\test.txt");
        ObjectOutputStream objOutStream = new ObjectOutputStream(outStream);
        objOutStream.writeObject(new User(1,"test"));
        objOutStream.close();

        // 反序列化对象
        InputStream inStream = new FileInputStream("D:\\test.txt");
        ObjectInputStream objInStream = new ObjectInputStream(inStream) ;
        User user = (User) objInStream.readObject();
        System.out.println(user);
        System.out.println(user.id);
        System.out.println(user.name);
        inStream.close();
    }

    static class User implements Serializable {
        private final Integer id ;
        private final String name ;

        public User(int id, String name) {
            this.id = id;
            this.name = name;
        }
    }
}

输出：

ObjectInputOutputStreamTest$User@47f64731test

参考

Java 自定义注解

2022-09-13T03:54:00.000Z

注解知识点

思维导图

自定义注解

编写规则

Annotation 型定义为 @interface，所有的 Annotation 会自动继承 java.lang.Annotation 这一接口，并且不能再去继承别的类或是接口。
参数成员只能用 public 或默认(default) 这两个访问权修饰。
参数成员只能用基本类型 byte、short、char、int、long、float、double、boolean 八种基本数据类型和 String、Enum、Class、annotations 等数据类型，以及这一些类型的数组。
要获取类方法和字段的注解信息，必须通过 Java 的反射技术来获取 Annotation 对象，因为你除此之外没有别的获取注解对象的方法。

代码示例

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author loquy
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface FieldInfo {
    String description();
    int length();
}

import java.lang.reflect.Field;

/**
 * @author loquy
 */
public class FieldInfoTest {

    @FieldInfo(description = "用户名", length = 10)
    private String username;

    public static void main(String[] args) {
        // 获取类模板
        Class c = FieldInfoTest.class;

        // 获取所有字段
        for(Field f : c.getDeclaredFields()){
            // 判断这个字段是否有 FieldInfo 注解
            if(f.isAnnotationPresent(FieldInfo.class)){
                FieldInfo annotation = f.getAnnotation(FieldInfo.class);
                System.out.println(
                        "字段:[" + f.getName() + "]," +
                        "描述:[" + annotation.description() + "]," +
                        "长度:[" + annotation.length() +"]"
                );
            }
        }
    }

}

输出：

字段：[username]，描述：[用户名]，长度：[10]

MySQL 行转列

2022-09-01T06:49:46.000Z

列表数据

mysql> select * from score;
+----+--------+---------+-------+
| id | name   | subject | score |
+----+--------+---------+-------+
|  1 | 张三   | 语文    |    10 |
|  2 | 张三   | 数学    |    30 |
|  3 | 张三   | 英语    |    40 |
|  4 | 张三   | 化学    |    50 |
|  5 | 李四   | 语文    |    60 |
|  6 | 李四   | 数学    |    70 |
|  7 | 李四   | 英语    |    80 |
|  8 | 王五   | 英语    |    90 |
|  9 | 王五   | 语文    |   100 |
| 10 | 王五   | 数学    |   110 |
| 11 | 王五   | 数学    |   120 |
+----+--------+---------+-------+

行转列写法

CASE 函数定义和用法

CASE
    WHEN 条件1 THEN 结果1
    WHEN 条件2 THEN 结果2
    WHEN 条件N THEN 结果N
    ELSE 结果
END;

查询语句：
按 name 字段进行 group by 分组，分组后使用 case 函数达成行转列，如果符合条件的 subject 字段对应有多行数据，取其中最大的 score 字段的值，如果不符合条件则设为 0。
要注意在 case 函数中使用的字段不可用来 group by 分组，选取其他具有相同值的字段进行分组。

SELECT `name`,
max( CASE `subject` WHEN '语文' THEN score ELSE 0 END ) AS '语文',
max( CASE `subject` WHEN '数学' THEN score ELSE 0 END ) AS '数学',
max( CASE `subject` WHEN '英语' THEN score ELSE 0 END ) AS '英语',
max( CASE `subject` WHEN '化学' THEN score ELSE 0 END ) AS '化学' 
FROM
score 
GROUP BY
`name`

查询结果：

+--------+--------+--------+--------+--------+
| name   | 语文   | 数学   | 英语   | 化学   |
+--------+--------+--------+--------+--------+
| 张三   |     10 |     30 |     40 |     50 |
| 李四   |     60 |     70 |     80 |      0 |
| 王五   |    100 |    120 |     90 |      0 |
+--------+--------+--------+--------+--------+

创建表和导入数据

表结构：

CREATE TABLE `score` (
  `id` int(11) NOT NULL,
  `name` varchar(255) NOT NULL,
  `subject` varchar(255) NOT NULL,
  `score` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

测试数据：

INSERT INTO `score` (`id`, `name`, `subject`, `score`) VALUES (1, '张三', '语文', 10);
INSERT INTO `score` (`id`, `name`, `subject`, `score`) VALUES (2, '张三', '数学', 30);
INSERT INTO `score` (`id`, `name`, `subject`, `score`) VALUES (3, '张三', '英语', 40);
INSERT INTO `score` (`id`, `name`, `subject`, `score`) VALUES (4, '张三', '化学', 50);
INSERT INTO `score` (`id`, `name`, `subject`, `score`) VALUES (5, '李四', '语文', 60);
INSERT INTO `score` (`id`, `name`, `subject`, `score`) VALUES (6, '李四', '数学', 70);
INSERT INTO `score` (`id`, `name`, `subject`, `score`) VALUES (7, '李四', '英语', 80);
INSERT INTO `score` (`id`, `name`, `subject`, `score`) VALUES (8, '王五', '英语', 90);
INSERT INTO `score` (`id`, `name`, `subject`, `score`) VALUES (9, '王五', '语文', 100);
INSERT INTO `score` (`id`, `name`, `subject`, `score`) VALUES (10, '王五', '数学', 110);
INSERT INTO `score` (`id`, `name`, `subject`, `score`) VALUES (11, '王五', '数学', 120);

SpringBoot 中使用 Hutool 跨数据库增删改查

2022-08-26T03:36:47.000Z

概述

Hutool 是一个小而全的Java工具类库，通过静态方法封装，降低相关 API 的学习成本，提高工作效率，使 Java 拥有函数式语言般的优雅，让 Java 语言也可以“甜甜的”。Hutool 中的工具方法来自每个用户的精雕细琢，它涵盖了 Java 开发底层代码中的方方面面，它既是大型项目开发中解决小问题的利器，也是小型项目中的效率担当；Hutool 是项目中“util”包友好的替代，它节省了开发人员对项目中公用类和公用工具方法的封装时间，使开发专注于业务，同时可以最大限度的避免封装不完善带来的 bug。

表结构

我们以 MySQL 为例，分别在两个数据库创建名为 test 和 test_1 的数据库，执行以下 sql 语句创建 user 表。

CREATE TABLE `user` (
  `id` int(11) NOT NULL,
  `name` varchar(255) NOT NULL,
  `pwd` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

项目结构

spring-boot-demo│  .gitignore│  pom.xml│  README.md│  spring-boot-demo.iml│├─spring-boot-crossdatabase│  │  .gitignore│  │  pom.xml│  │  spring-boot-crossdatabase.iml│  ││  ├─src│  │  ├─main│  │  │  ├─java│  │  │  │  └─com│  │  │  │      └─example│  │  │  │          └─crossdatabase│  │  │  │              │  SpringBootCrossdatabaseApplication.java│  │  │  │              ││  │  │  │              └─utils│  │  │  │                      CrossDatabaseUtils.java│  │  │  ││  │  │  └─resources│  │  │      │  application.properties│  │  │      ││  │  │      └─config│  │  │              db.setting│  │  ││  │  └─test│  │      └─java│  │          └─com│  │              └─example│  │                  └─crossdatabase│  │                          SpringBootCrossdatabaseApplicationTests.java│├─spring-boot-hibernate│└─spring-boot-mongodb

引入依赖

在项目的 pom.xml 的 dependencies 中加入以下内容:

导入 hutool-all 包

<dependency>
    <groupId>cn.hutoolgroupId>
    <artifactId>hutool-allartifactId>
    <version>5.8.5version>
dependency>

引入 MySQL JDBC 驱动 jar

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>${mysql.version}version>
dependency>

数据库配置

在 src/main/resources/config 目录下添加 db.setting 文件：

[test]
url = jdbc:mysql://localhost:3306/test?serverTimezone=UTC&setUnicode=true&charterEncoding=utf-8
username = root
password = root
driver = com.mysql.jdbc.Driver

[test_1]
url = jdbc:mysql://192.168.8.117:3306/test_1?serverTimezone=UTC&setUnicode=true&charterEncoding=utf-8
username = root
password = root
driver = com.mysql.jdbc.Driver

编写工具类

package com.example.crossdatabase.utils;

import cn.hutool.db.Db;
import cn.hutool.db.ds.DSFactory;

import javax.sql.DataSource;
import java.util.HashMap;


/**
 * @author loquy
 */
public class CrossDatabaseUtils {

    private static final HashMap DBS = new HashMap<>();

    /**
     * 初始化数据源
     *
     */
    public static Db initDb(String dataBase) {
        Db db;
        if (DBS.containsKey(dataBase)) {
            db = DBS.get(dataBase);
        } else {
            DataSource ds = DSFactory.get(dataBase);
            db = Db.use(ds);
            DBS.put(dataBase,db);
        }
        return db;
    }
}

测试

package com.example.crossdatabase;

import cn.hutool.db.Db;
import cn.hutool.db.Entity;
import com.example.crossdatabase.utils.CrossDatabaseUtils;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.sql.SQLException;
import java.util.List;

@SpringBootTest
class SpringBootCrossdatabaseApplicationTests {

    @Test
    void contextLoads() {
        try {
            Db testDb = CrossDatabaseUtils.initDb("test");
            Db testDb1 = CrossDatabaseUtils.initDb("test_1");
            System.out.println("============test=============");
            crud(testDb);
            System.out.println("============test_1=============");
            crud(testDb1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void crud(Db db) throws SQLException {
        // 删除所有
        int deleteAll = db.execute("delete from user");
        // 新增
        int insert = db.execute("insert into user values (?, ?, ?)", 1, "张三", 123123);
        int insert1 = db.execute("insert into user values (?, ?, ?)", 2, "李四", 123123);
        // 更新
        int update = db.execute("update user set pwd = ? where name = ?", 123456, "张三");
        // 删除
        int delete = db.execute("delete from user where name = ?", "张三");
        // 查询
        List query = db.query("select * from user");
        System.out.println(deleteAll);
        System.out.println(insert);
        System.out.println(insert1);
        System.out.println(update);
        System.out.println(delete);
        System.out.println(query);
    }
}

输出

源码

参见此仓库

SpringBoot 中使用 Hibernate

2022-08-11T01:20:09.000Z

概述

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。

表结构

创建名为 hibernate 数据库，执行以下 sql 语句创建 user 表。

CREATE TABLE `user` (
  `id` int(11) NOT NULL,
  `name` varchar(255) NOT NULL,
  `pwd` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

Maven 项目结构

spring-boot-demo│  .gitignore│  pom.xml│  README.md│├─spring-boot-hibernate│  │  .gitignore│  │  pom.xml│  ││  ├─src│  │  ├─main│  │  │  ├─java│  │  │  │  └─com│  │  │  │      └─example│  │  │  │          └─hibernate│  │  │  │              │  SpringBootHibernateApplication.java│  │  │  │              ││  │  │  │              ├─config│  │  │  │              │      DataSourceConfig.java│  │  │  │              ││  │  │  │              ├─dao│  │  │  │              │  │  UserDao.java│  │  │  │              │  ││  │  │  │              │  └─common│  │  │  │              │          BaseDao.java│  │  │  │              │          BaseDaoImpl.java│  │  │  │              │          Page.java│  │  │  │              ││  │  │  │              └─entity│  │  │  │                      User.java│  │  │  ││  │  │  └─resources│  │  │          application.properties│  │  ││  │  └─test│  │      └─java│  │          └─com│  │              └─example│  │                  └─hibernate│  │                          SpringBootHibernateApplicationTests.java│└─spring-boot-mongodb

Pom.xml 依赖配置

spring-boot-demo

"1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.7.2version>
        <relativePath/> 
    parent>
    <packaging>pompackaging>

    <modules>
        <module>spring-boot-mongodbmodule>
    modules>

    <groupId>com.examplegroupId>
    <artifactId>spring-boot-demoartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>spring-boot-demoname>
    <description>spring-boot-demodescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starterartifactId>
        dependency>

        <dependency>
            <groupId>cn.hutoolgroupId>
            <artifactId>hutool-allartifactId>
            <version>5.8.5version>
        dependency>

        
        <dependency>
            <groupId>org.apache.commonsgroupId>
            <artifactId>commons-lang3artifactId>
            <version>3.8.1version>
        dependency>

    dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombokgroupId>
                            <artifactId>lombokartifactId>
                        exclude>
                    excludes>
                configuration>
            plugin>
        plugins>
    build>

project>

spring-boot-hibernate
- 导入 hibernate 核心的对象关系映射（简称ORM）功能的包
- 导入使用 hibernate 实现 java 持久化接口（简称JPA）的包

"1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>com.examplegroupId>
        <artifactId>spring-boot-demoartifactId>
        <version>0.0.1-SNAPSHOTversion>
    parent>
    <artifactId>spring-boot-hibernateartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>spring-boot-hibernatename>
    <description>spring-boot-hibernatedescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        
        <dependency>
            <groupId>org.hibernate.javax.persistencegroupId>
            <artifactId>hibernate-jpa-2.1-apiartifactId>
            <version>1.0.2.Finalversion>
        dependency>
        
        <dependency>
            <groupId>org.hibernategroupId>
            <artifactId>hibernate-coreartifactId>
            <version>5.6.9.Finalversion>
        dependency>

        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <scope>runtimescope>
        dependency>

        
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-ormartifactId>
            <version>5.3.22version>
        dependency>
    dependencies>
project>

Application.properties 配置

spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3306/hibernate?serverTimezone=UTC&setUnicode=true&charterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

Entity 对象

package com.example.hibernate.entity;

import javax.persistence.*;

/**
 * @author loquy
 */
@Entity
@Table(name = "user")
public class User {

    @Id
    private int id;

    private String name;

    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

DataSource 数据源配置

package com.example.hibernate.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

import java.util.Properties;

/**
 * @author loquy
 */
@Configuration
public class DataSourceConfig {

    @Value("${spring.datasource.url}")
    private String dbUrl;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;

    @Bean(name = "datasource")
    public DriverManagerDataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(dbUrl);
        dataSource.setUsername(username);
        dataSource.setPassword(password);

        Properties propertiesJpa = new Properties();
        dataSource.setConnectionProperties(propertiesJpa);
        return dataSource;
    }
}

Dao 层封装 CRUD

JPA 实体管理器（EntityManager）

实体管理器（EntityManager）用于管理系统中的实体，它是实体与数据库之间的桥梁，通过调用实体管理器的相关方法可以把实体持久化到数据库中，同时也可以把数据库中的记录打包成实体对象。

配置好数据源后可以通过 @PersistenceContext 注解注入 EntityManager 到上下文里管理实体，也可以执行原始的sql查询语句。
详情查看此教程 JPA 实体管理器

通用 BaseDao

BaseDao

package com.example.hibernate.dao.common;


import java.util.List;

/**
 * The interface Base dao.
 *
 * @author loquy
 */
public interface BaseDao {

    /**
     * Insert.
     *
     * @param model the model
     */
    void insert(Object model);

    /**
     * Update t.
     *
     * @param entity the entity
     * @return the t
     */
    T update(T entity);

    /**
     * Delete.
     *
     * @param model the model
     */
    void delete(Object model);

    /**
     * Find one t.
     *

     * @param primaryKey  the primary key
     * @return the t
     */
    T findOne(Object primaryKey);

    /**
     * Find all list.
     *

     * @return the list
     */
    List findAll();

    /**
     * 获取查询列表
     *
     * @param queryStr    the query str

     * @return 返回的是list 对象
     */
    List getNativeQueryList(final String queryStr);

    /**
     * 获取查询分页列表
     *
     * @param queryStr    the query str
     * @param page        the page

     * @return 返回的是Page> 对象
     */
    Page getNativeQueryListByPage(String queryStr, Page page);

}

BaseDaoImpl

package com.example.hibernate.dao.common;

import cn.hutool.core.bean.BeanUtil;
import org.hibernate.query.internal.NativeQueryImpl;
import org.hibernate.transform.Transformers;
import org.springframework.util.Assert;

import javax.persistence.EntityManager;
import javax.persistence.NoResultException;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * @author loquy
 */
public class BaseDaoImpl implements BaseDao {

    @PersistenceContext
    private EntityManager entityManager;

    private final Class entityClass;

    public BaseDaoImpl(Class entityClass) {
        this.entityClass = entityClass;
    }

    @Override
    public void insert(Object model) {
        this.entityManager.persist(model);
    }

    @Override
    public T update(T entity) {
        return entityManager.merge(entity);
    }

    @Override
    public void delete(Object model) {
        this.entityManager.remove(model);
    }

    @Override
    public T findOne(Object primaryKey) {
        return entityManager.find(entityClass, primaryKey);
    }

    @Override
    @SuppressWarnings("unchecked")
    public  List findAll() {
        return this.entityManager.createQuery("select obj from " + entityClass.getName() + " obj").getResultList();
    }

    /**
     * 获取查询列表
     *
     * @return 返回的是list对象
     */
    @Override
    @SuppressWarnings("unchecked")
    public  List getNativeQueryList(final String queryStr) {
        Query query = createNativeQuery(queryStr);
        query.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
        List tmpResult = query.getResultList();
        List result = new ArrayList<>();
        for (Object object : tmpResult) {
            result.add(BeanUtil.toBean(object, entityClass));
        }
        return result;
    }

    /**
     * 获取查询分页列表
     *
     * @return 返回的是Page> 对象
     */
    @Override
    @SuppressWarnings("unchecked")
    public  Page getNativeQueryListByPage(String queryStr, Page page) {
        queryStr += page.getOrderString();

        Query query = createNativeQuery(queryStr);
        query.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);

        int totalCount = countSqlResult(queryStr).intValue();
        page.setTotalCount(totalCount);
        if (totalCount == 0) {
            return page;
        }
        setPageParameter(query, page);
        List tmpResult = query.getResultList();
        List result = new ArrayList<>();
        for (Object object : tmpResult) {
            result.add(BeanUtil.toBean(object, entityClass));
        }
        page.setResult(result);
        return page;
    }

    /**
     * 统计条数
     *
     */
    protected Long countSqlResult(final String sql) {
        String countHql = "select count(*) from (" + sql + ") count";
        try {
            String valueStr = createNativeQuery(countHql).getSingleResult().toString();
            return new BigDecimal(valueStr.trim()).longValue();
        } catch (NoResultException e) {
            return 0L;
        } catch (Exception e) {
            throw new RuntimeException("sql can't be auto count, sql is:" + countHql, e);
        }
    }


    private Query createNativeQuery(final String queryString, Object... params) {
        Assert.hasText(queryString, "queryString can not empty");
        Query query;
        query = entityManager.createNativeQuery(queryString);
        if (params != null) {
            for (int i = 0; i < params.length; i++) {
                query.setParameter(i + 1, params[i]);
            }
        }
        return query;
    }

    /**
     * 设置分页参数
     *
     */
    protected  void setPageParameter(final Query q, final Page page) {
        q.setFirstResult(page.getOffset());
        q.setMaxResults(page.getLimit());
    }
}

Page

package com.example.hibernate.dao.common;

import org.apache.commons.lang3.StringUtils;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

/**
 * @author loquy
 */
public class Page implements Serializable {

    private static final long serialVersionUID = 1L;

    private final int limit;

    private int offset;

    private final int currentPage;

    private List result = new ArrayList<>();

    private int totalCount = 0;

    private String sortField;

    private int totalPage = 0;

    public Page(Integer page, Integer limit) {
        this.currentPage = page - 1;
        this.limit = limit;
    }

    public int getOffset() {
        if (offset == 0) {
            this.offset = currentPage * limit;
        }
        return offset;
    }

    public int getLimit() {
        return limit;
    }

    public List getResult() {
        return result;
    }

    public void setResult(final List result) {
        this.result = result;
    }

    public int getTotalCount() {
        return totalCount;
    }

    public void setTotalCount(final int totalCount) {
        this.totalCount = totalCount;
        this.totalPage = this.totalCount / this.limit;
        if (totalCount % limit > 0) {
            this.totalPage++;
        }
    }

    public int getTotalPage() {
        return totalPage;
    }

    public void setSortField(String sortField) {
        this.sortField = sortField;
    }

    public String getOrderString() {
        String orderString = "";
        if (StringUtils.isNotBlank(sortField)) {
            orderString = " order by " + sortField;
        }
        return orderString;
    }
}

业务 UserDao

package com.example.hibernate.dao;

import com.example.hibernate.dao.common.BaseDaoImpl;
import com.example.hibernate.entity.User;
import org.springframework.stereotype.Repository;

/**
 * @author loquy
 */
@Repository
public class UserDao extends BaseDaoImpl {
    public UserDao() {
        super(User.class);
    }
}

测试

package com.example.hibernate;

import com.example.hibernate.dao.UserDao;
import com.example.hibernate.dao.common.Page;
import com.example.hibernate.entity.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import javax.transaction.Transactional;
import java.util.List;

@SpringBootTest
@Transactional
class SpringBootHibernateApplicationTests {

    @Autowired
    public UserDao userDao;

    @Test
    void contextLoads() {
        User one = userDao.findOne(1);

        System.out.println("========");
        System.out.println(one);
        if (one != null) {
            userDao.delete(one);
        }

        User user = new User(1, "insert", "insert");
        userDao.insert(user);
        List all = userDao.findAll();

        System.out.println("========");
        for (User user1 : all) {
            System.out.println(user1.toString());
        }

        user.setName("update");
        user.setPwd("update");
        User update = userDao.update(user);

        System.out.println("========");
        System.out.println(update);

        List nativeQueryList = userDao.getNativeQueryList("select * from user");
        System.out.println("========");
        System.out.println(nativeQueryList);

        Page page = new Page<>(1, 10);
        page.setSortField("id");
        Page nativeQueryListByPage = userDao.getNativeQueryListByPage("select * from user", page);
        System.out.println("========");
        System.out.println(nativeQueryListByPage.getResult());
        System.out.println(nativeQueryListByPage.getTotalCount());
        System.out.println(nativeQueryListByPage.getTotalPage());
        System.out.println(nativeQueryListByPage.getOrderString());
    }

}

输出

源码

参见此仓库

SpringBoot 中使用 MongoDb 上传文件

2022-07-28T01:37:38.000Z

概述

什么是 MongoDb

MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。

在高负载的情况下，添加更多的节点，可以保证服务器性能。

MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。

MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。

MongoDB GridFS

GridFS 用于存储和恢复那些超过16M（BSON文件限制）的文件(如：图片、音频、视频等)。

GridFS 也是文件存储的一种方式，但是它是存储在MonoDB的集合中。

GridFS 可以更好的存储大于16M的文件。

GridFS 会将大文件对象分割成多个小的chunk(文件片段),一般为256k/个,每个chunk将作为MongoDB的一个文档(document)被存储在chunks集合中。

GridFS 用两个集合来存储一个文件：fs.files与fs.chunks。

每个文件的实际内容被存在chunks(二进制数据)中,和文件有关的meta数据(filename,content_type,还有用户自定义的属性)将会被存在files集合中。

以下是简单的 fs.files 集合文档：

{
   "filename": "test.txt",
   "chunkSize": NumberInt(261120),
   "uploadDate": ISODate("2014-04-13T11:32:33.557Z"),
   "md5": "7b762939321e146569b07f72c62cca4f",
   "length": NumberInt(646)
}

以下是简单的 fs.chunks 集合文档：

{
   "files_id": ObjectId("534a75d19f54bfec8a2fe44b"),
   "n": NumberInt(0),
   "data": "Mongo Binary Data"
}

MongoDB 下载

Maven 项目结构

spring-boot-demo│  .gitignore│  pom.xml│  spring-boot-demo.iml│└─spring-boot-mongodb│  .gitignore│  pom.xml│  spring-boot-mongodb.iml│├─src│  ├─main│  │  ├─java│  │  │  └─com│  │  │      └─example│  │  │          └─mongodb│  │  │              │  SpringBootMongodbApplication.java│  │  │              ││  │  │              ├─controller│  │  │              │      MongoFileController.java│  │  │              ││  │  │              └─utils│  │  │                      MongoFileUtils.java│  │  ││  │  └─resources│  │          application.properties│  ││  └─test│      └─java│          └─com│              └─example│                  └─mongodb│                          SpringBootMongodbApplicationTests.java

Pom.xml 依赖配置

spring-boot-demo 项目配置

"1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.7.2version>
        <relativePath/> 
    parent>
    <packaging>pompackaging>

    <modules>
        <module>spring-boot-mongodbmodule>
    modules>

    <groupId>com.examplegroupId>
    <artifactId>spring-boot-demoartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>spring-boot-demoname>
    <description>spring-boot-demodescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starterartifactId>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombokgroupId>
                            <artifactId>lombokartifactId>
                        exclude>
                    excludes>
                configuration>
            plugin>
        plugins>
    build>

project>

spring-boot-mongodb 子模块配置

"1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>com.examplegroupId>
        <artifactId>spring-boot-demoartifactId>
        <version>0.0.1-SNAPSHOTversion>
    parent>
    <artifactId>spring-boot-mongodbartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>spring-boot-mongodbname>
    <description>spring-boot-mongodbdescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-mongodbartifactId>
            <version>2.7.2version>
        dependency>
    dependencies>

project>

Application.properties 配置

server.port = 8088
spring.profiles.active=default

spring.data.mongodb.uri=mongodb://localhost:27017/GridFS
spring.data.mongodb.database=GridFS
spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.username=
spring.data.mongodb.password=

控制器

package com.example.mongodb.controller;

import com.example.mongodb.utils.MongoFileUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;

/**
 * The type Mongo file controller.
 *
 * @author loquy
 */
@RestController
@RequestMapping(value = "/mongoFile")
public class MongoFileController {

    /**
     * 上传文件
     *
     * @param multipartFile the multipart file
     * @return the string
     */
    @PostMapping("/upload")
    public String uploadFile(@RequestParam("file") MultipartFile multipartFile) {
        String originFilename = multipartFile.getOriginalFilename();
        String fileId;
        try {
            fileId = MongoFileUtils.uploadFileToGridFs(StringUtils.getFilename(originFilename), multipartFile.getInputStream());
        } catch (Exception e) {
            e.printStackTrace();
            return "上传失败，" + e.getMessage();
        }
        return "上传成功，文件ID：" + fileId;
    }

    /**
     * 删除文件
     *
     * @param fileId the file id
     * @return the string
     */
    @PostMapping("/remove")
    public String removeFile(@RequestParam("fileId") String fileId) {
        try {
            MongoFileUtils.deleteByObjectId(fileId);
        } catch (Exception e) {
            e.printStackTrace();
            return "删除失败，" + e.getMessage();
        }

        return "删除成功";
    }

    /**
     * 显示图片
     *
     * @param fileId   the file id
     * @param response the response
     */
    @GetMapping(value = "/showImage/{fileId}")
    public Object showImage(@PathVariable(name = "fileId") String fileId, HttpServletResponse response)  {
        try {
            MongoFileUtils.showImage(fileId, response);
        } catch (Exception e) {
            e.printStackTrace();
            return "显示失败，" + e.getMessage();
        }

        return "";
    }

    /**
     * 下载附件
     *
     * @param fileId   the file id
     * @param response the response
     */
    @GetMapping(value = "/download/{fileId}")
    public Object download(@PathVariable(name = "fileId") String fileId, HttpServletResponse response) {
        try {
            MongoFileUtils.downloadFile(fileId, response);
        } catch (Exception e) {
            e.printStackTrace();
            return "下载失败，" + e.getMessage();
        }
        return "";
    }
}

工具类

package com.example.mongodb.utils;

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.gridfs.GridFSBucket;
import com.mongodb.client.gridfs.GridFSBuckets;
import com.mongodb.client.gridfs.GridFSDownloadStream;
import com.mongodb.client.gridfs.model.GridFSFile;
import org.bson.types.ObjectId;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.io.OutputStream;


/**
 * The type Mongo file utils.
 *
 * @author loquy
 */
@Component
public class MongoFileUtils {

    private static String database;

    /**
     * Sets database.
     *
     * @param database the database
     */
    @Value("${spring.data.mongodb.database}")
    public void setDatabase(String database) {
        MongoFileUtils.database = database;
    }

    /**
     * Gets database.
     *
     * @return the database
     */
    public static MongoDatabase getMongoDatabase() {
        MongoClient mongoClient = MongoClients.create();
        return mongoClient.getDatabase(database);
    }

    /**
     * Upload file to grid fs string.
     *
     * @param filename the filename
     * @param in       the in
     * @return the string
     * @throws Exception the exception
     */
    public static String uploadFileToGridFs(String filename, InputStream in) throws Exception {
        GridFSBucket bucket = GridFSBuckets.create(getMongoDatabase());
        ObjectId fileId = bucket.uploadFromStream(filename, in);
        in.close();
        return fileId.toHexString();
    }

    /**
     * Download to stream.
     *
     * @param objectId the object id
     * @param out      the out
     */
    public static void downloadToStream(String objectId, OutputStream out) {
        GridFSBucket bucket = GridFSBuckets.create(getMongoDatabase());
        bucket.downloadToStream(new ObjectId(objectId), out);
    }

    /**
     * Download file.
     *
     * @param objectId the object id
     * @param response the response
     * @throws Exception the exception
     */
    public static void downloadFile(String objectId, HttpServletResponse response) throws Exception {
        OutputStream os;
        String outFileName = findFileNameById(objectId);
        response.setHeader("content-disposition", "attachment;filename=" + java.net.URLEncoder.encode(outFileName, "UTF-8"));
        os = response.getOutputStream();
        downloadToStream(objectId, os);
        os.close();
    }

    /**
     * Show image.
     *
     * @param objectId the object id
     * @param response the response
     * @throws Exception the exception
     */
    public static void showImage(String objectId, HttpServletResponse response) throws Exception {
        response.setContentType("image/jpeg");
        OutputStream out = response.getOutputStream();
        downloadToStream(objectId, out);
        out.flush();
        out.close();
    }

    /**
     * Delete by object id.
     *
     * @param objectId the object id
     */
    public static void deleteByObjectId(String objectId) {
        GridFSBucket bucket = GridFSBuckets.create(getMongoDatabase());
        bucket.delete(new ObjectId(objectId));
    }

    /**
     * Find file name by id string.
     *
     * @param objectId the object id
     * @return the string
     */
    public static String findFileNameById(String objectId) {
        GridFSBucket bucket = GridFSBuckets.create(getMongoDatabase());
        GridFSDownloadStream stream;
        stream = bucket.openDownloadStream(new ObjectId(objectId));
        GridFSFile file = stream.getGridFSFile();
        return file.getFilename();
    }
}

测试

上传文件

下载文件

显示图片

删除文件

源码

参见此仓库

前后端耦合下实现多文件上传和下拉树选择

2022-07-23T02:08:59.000Z

环境

后端框架：SpringBoot
模板引擎：FreeMarker
前端框架：JQuery
前端 UI 组件：Layui、xm-select

前端代码

表单部分

使用 Layui 表单样式。
编写一个下拉树的分隔区块。
编写一个上传按钮和上传成功后显示文件名和操作的表格。

<form class="layui-form" lay-filter="add" style="height:100%; padding-top:16px;">
    <div class="layui-form-item">
        <label class="layui-form-label">下拉树：<span style="color:red">*span>label>
        <div class="layui-input-block" id="selectTree">div>
    div>
    <div class="layui-form-item">
        <label class="layui-form-label">附件：label>
        <input type="hidden" name="attachment" id="attachment" value="${demo.attachment!}"/>
        <div class="layui-input-block layui-upload">
            <button type="button" class="layui-btn layui-btn-normal" id="testList">上传文件button>
            <div class="layui-upload-list">
                <table class="layui-table">
                    <thead>
                        <tr>
                            <th>文件名th>
                            <th>操作th>
                        tr>
                    thead>
                    <tbody id="demoList">tbody>
                table>
            div>
        div>
    div>
    <div class="layui-form-item">
        <button type="button" class="btn layer-cancel">取消button>
        <button lay-submit class="btn btn-primary" lay-filter="add" id="submitAddForm">完成button>
        <button type="reset" class="btn btn-warm" id="resetAddForm">重置button>
    div>
form>

JS 部分

使用 layui.upload 上传组件，上传成功后 js 动态拼接表格元素显示文件名和监听删除操作。
使用 xm-select 多选组件，初始化使用 ajax 请求接口返回树形数据，然后动态赋值给下拉框。

'">'
,''
,''
,''].join(''));

tr.find('.demo-delete').on('click', function(){
// Ajax 模拟 Form 表单提交
var formData = newFormData();
formData.append("uuid", tr.attr('id'));
$.ajax({
type: "post",
async: false,
url: '${request.contextPath}/file/remove',
dataType: "json",
data: formData,
contentType: false,//这里
processData: false,//这两个一定设置为false
success: function (res) {
Array.prototype.removeByValue = function (val) {
for (var i = 0; i < this.length; i++) {
if (this[i] === val) {
this.splice(i, 1);
i--;
}
}
returnthis;
}
var attachment = $("#attachment").val();
var attachmentArray = attachment ? attachment.split(",") : [];
attachmentArray.removeByValue(tr.attr('id'));
$("#attachment").val(attachmentArray.join(","))
},
error: function (err) {
console.log(err)
}
});
tr.remove();
});

$('#demoList').append(tr);
}

var selectTreeXmSelect = layui.xmSelect.render({
el: '#selectTree',
autoRow: true,
name: "selectTree",
//单选模式
radio: true,
height: 'auto',
data: []
})

$.ajax({
type: "get",
async: false,
url: Ams.ctxPath + "/demo/demo/selectTree",
dataType: "json",
data: {},
contentType: "application/json;charset=UTF-8",
success: function(res) {
selectTreeXmSelect.update({
data: res,
tree: {
show: true,
//非严格模式
strict: false,
//展开所有节点
expandedKeys: true,
},
})
selectTreeXmSelect.setValue(['${demo.selectTree!}'])
},
error: function(err) {
console.log(err)
}
})
});

$(function () {
    var uploadListIns = layui.upload.render({
        elem: '#testList'
        ,elemList: $('#demoList')
        ,url: '${request.contextPath}/file/upload'
        ,accept: 'file'
        ,multiple: true
        ,number: 10
        ,auto: true
        ,done: function(res, index, upload){ //成功的回调
            var attachment = $("#attachment").val();
            var attachmentArray = attachment ? attachment.split(",") : [];
            attachmentArray.push(res.uuid)
            $("#attachment").val(attachmentArray.join(","))
            appendTr(res.uuid, res.fileName, res.fileId);
            return;
        }
        ,error: function(){
        }
    });

    <#list files as file>
        appendTr('${file.uuid}', '${file.fileName}', '${file.fileId}')
    

    function appendTr(uuid, fileName, fileId) {
        let downloadUrl = '${request.contextPath}/file/download?fileId=' + fileId
        var tr = $(['

'+ ''" style="color:blue; text-decoration:underline;">' + fileName + '' +' '
,''
,'

后端代码

控制器

页面跳转和获取下拉树数据的接口。

/**
 * 跳转页面
 *
 */
@RequestMapping(value = "/editDemo", method = RequestMethod.GET)
public ModelAndView editDemo(ModelAndView modelAndView, String id) {
    Demo demo = new Demo();
    if (StringUtils.isNotEmpty(id)) {
        demo = demoService.getById(id);
    }
    List files = demoService.getFiles(demo);
    modelAndView.addObject("files", files);
    modelAndView.addObject("demo", demo);
    modelAndView.setViewName("/demo/demoEdit");
    return modelAndView;
}

/**
 * 下拉树
 *
 */
@RequestMapping(value = "/selectTree", method = RequestMethod.GET)
public List selectTree() {
    return demoService.selectTree();
}

Service

构造树形数据以及查询文件信息。
文件上传、删除、下载相关操作的接口，单独抽出一个模块来实现，实现方式有很多种，例如可存储到本地，也可以存储到 MongoDB 等，具体实现以后单独写篇文章。

@Override
public List selectTree() {
    List selectTree = selectTreeService.list();
    return menuList(selectTree);
}

/**
 * Menu list list.
 *
 * @param menu the menu
 * @return the list
 */
public List menuList(List menu) {
    List list = new ArrayList<>();
    for (SelectTree selectTree : menu) {
        Map map = new LinkedHashMap<>();
        if (selectTree.getParentId() == null) {
            menuItem(menu, list, selectTree, map);
        }
    }
    return list;
}

/**
 * Menu child list.
 *
 * @param menu the menu
 * @param id   the id
 * @return the list
 */
public List menuChild(List menu, String id) {
    List list = new ArrayList<>();
    for (SelectTree selectTree : menu) {
        Map map = new LinkedHashMap<>();
        if (selectTree.getParentId() != null && selectTree.getParentId().equals(id)) {
            menuItem(menu, list, selectTree, map);
        }
    }
    return list;
}

private void menuItem(
        List menu,
        List list,
        SelectTree selectTree,
        Map map
) {
    map.put("value", selectTree.getUuid());
    map.put("name", selectTree.getPointName());
    map.put("pid", selectTree.getParentId());
    List children = menuChild(menu, selectTree.getUuid());
    map.put("children", children);
    list.add(map);
}

@Override
public List getFiles(Demo demo) {
    String attachment = demo.getAttachment();
    if (StringUtils.isEmpty(attachment)) {
        return new ArrayList<>();
    }
    String[] attachmentArray = attachment.split(",");
    StringBuilder in = new StringBuilder();
    for (String s : attachmentArray) {
        if (in.length() == 0) {
            in.append("'").append(s).append("'");
        }
        in.append(",'").append(s).append("'");
    }
    return demoDao.getNativeQueryList(filesSql(in.toString()));
}

public String filesSql(String in) {
    return "SELECT\n" +
            "\tuuid,\n" +
            "\tfile_name,\n" +
            "\tfile_id \n" +
            "FROM\n" +
            "\tFILE \n" +
            "WHERE\n" +
            "\tuuid IN (" + in + ")";
}

Oracle 常用查询语句总结

2022-07-06T08:27:48.000Z

ROWNUM 字段

rownum 是 Oracle 系统顺序分配为从查询返回的行的编号，返回的第一行分配的是 1，返回的第二行分配的是 2，这个伪字段可以用于限制返回查询的总行数，且 rownum 不可以以任何表的名称作为前缀。

rownum 对于等于某值的查询条件：如果想找到第一条查询数据，可以使用 rownum = 1 作为查询条件，但是想找到第二条查询数据，使用 rownum = 2 则查不到数据，原因是：rownum 都是从 1开始，但是 1 以上的自然数与 rownum 做等于时，都认为是 false 条件，所以无法查询到 rownum = n（ n > 1 的自然数）；
rownum 对于大于某值的查询条件：要是想查询出第二行以后的记录，直接使用 rownum > 2 是查不出数据的，原因是 rownum 是一个总是以 1 开始的伪列，rownum > n（ n > 1 的自然数）依然不成立。可以使用子查询来解决，注意子查询中的 rownum 必须要有别名，否则还是不会查出记录来，这是因为 rownum 不是某个表的列，如果不起别名的话，无法知道 rownum 是子查询的列还是主查询的列。

DUAL 表

Oracle 提供的最小的工作表，只有一行一列，具有某些特殊功用。

表结构

Name	Type
DUMMY	Varchar(1)

特性

Oracle 提供的最小的表，不论进行何种操作（不要删除记录），它都只有一条记录——‘X’。例如：执行 select * from dual，里面只有一条记录；执行 insert into dual values(‘Y’)后，再次查询 dual表，仍然显示一条记录。
是 sys 用户下的一张内部表，所有用户都可以使用 DUAL 名称访问，无论什么时候这个表总是存在。例如：执行一个查看当前日期的语句 select sysdate from dual，这条语句在放在放在任何一个 oracle 数据库当中都不会报错，所以一般做一些特定查询的时候用这个表是最稳妥的。

用途

select 计算常量表达式、伪列等值 oracle 内部处理使它只返回一行数据，而使用其它表时可能返回多个数据行。
查看当前用户 select user from dual;select count(*) from dual;
用做计算器 select 7910-10 from dual；
调用系统函数
- 获得当前系统时间 select to_char(sysdate,’yyyy-mm-dd hh24:mi:ss’) from dual;
- 获得主机名 select sys_context(‘userenv’,’terminal’) from dual;
- 获得当前 locale select sys_context(‘userenv’,’language’) from dual;
- 获得一个随机数 select DBMS_RANDOM.random from dual;
查看序列值
- 创建序列 aaa 以1开始，每次加1 create sequence aaa increment by 1 start with 1;
- 获得序列 aaa 的下一个序列值 select aaa.nextval from dual;
- 获得序列 aaa 的当前序列值 select aaa.currval from dual;

UNION 与 UNION ALL 的区别

UNION：对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序。
UNION ALL：对两个结果集进行并集操作，包括重复行，不进行排序。

查询最新的一条数据

SELECT
* 
FROM
( SELECT * FROM BOOK ORDER BY CREATE_DATE DESC ) 
WHERE
ROWNUM = 1

保留 N 位小数

-- round(m,n)，四舍五入，0.87。
SELECT
ROUND( 0.866, 2 ) 
FROM
DUAL;
-- trunc(m,n)，不四舍五入，0.86。
SELECT
TRUNC( 0.866, 2 ) 
FROM
DUAL;

查询当天时间

-- 使用 trunc 函数截断时间
-- 2022-07-06 00:00:00，今天的日期
SELECT
TRUNC( SYSDATE ) 
FROM
DUAL;
-- 2022-07-01 00:00:00，返回当月第一天.
SELECT
TRUNC( SYSDATE, 'mm' ) 
FROM
DUAL;
-- 2022-01-01 00:00:00，返回当年第一天
SELECT
TRUNC( SYSDATE, 'yy' ) 
FROM
DUAL;
-- 2022-07-06 00:00:00，返回当前年月日
SELECT
TRUNC( SYSDATE, 'dd' ) 
FROM
DUAL;
-- 2022-01-01 00:00:00，返回当年第一天
SELECT
TRUNC( SYSDATE, 'yyyy' ) 
FROM
DUAL;
-- 2022-07-03 00:00:00，返回当前星期的第一天
SELECT
TRUNC( SYSDATE, 'd' ) 
FROM
DUAL;
-- 2022-07-06 10:00:00，当前时间
SELECT
TRUNC( SYSDATE, 'hh' ) 
FROM
DUAL;
-- 2022-07-06 10:51:00，RUNC()函数没有秒的精
SELECT
TRUNC( SYSDATE, 'mi' ) 
FROM
DUAL;

补空行

SELECT
* 
FROM
( SELECT id, name FROM BOOK UNION ALL SELECT NULL id, 'book' name FROM DUAL CONNECT BY ROWNUM < 11 ) 
WHERE
ROWNUM < 11

分页查询

-- where 条件：rn > (page - 1) * pageSize and rn <= (page) * pageSize
SELECT
* 
FROM
( SELECT t.*, ROWNUM rn FROM BOOK t ) 
WHERE
rn > ( 1 - 1 ) * 10 
AND rn <= ( 1 ) * 10

TO_CHAR 和 TO_DATE 日期转换

语法

TO_DATE(‘字符串’, ‘格式’)
TO_CHAR(‘日期’, ‘格式’)

含义

TO_DATE：将字符串转化为日期型。
TO_CHAR：将日期或数字转换为 char 数据类型。

示例

SELECT SYSDATE, TO_DATE('2022-7-06','yyyy-mm-dd') FROM DUAL; -- 2022-07-06 00:00:00
SELECT SYSDATE, TO_DATE('2022-7-06','yyyy.mm.dd') FROM DUAL; -- 2022-07-06 00:00:00
SELECT SYSDATE, TO_DATE('2022-7-06','yyyy/mm/dd') FROM DUAL; -- 2022-07-06 00:00:00
SELECT SYSDATE, TO_DATE('2022-7-06','yyyy-mm-dd hh24:mi:ss') FROM DUAL; -- 2022-07-06 00:00:00
SELECT SYSDATE, TO_DATE('2022.7.06','yyyy-mm-dd') FROM DUAL; -- 2022-07-06 00:00:00
SELECT SYSDATE, TO_DATE('2022/7/06','yyyy-mm-dd') FROM DUAL; -- 2022-07-06 00:00:00
SELECT SYSDATE, TO_DATE('20220706','yyyy-mm-dd') FROM DUAL; -- 2022-07-06 00:00:00

SELECT SYSDATE, TO_CHAR(SYSDATE,'yyyy-mm-dd') FROM DUAL; -- 2022-07-06
SELECT SYSDATE, TO_CHAR(SYSDATE,'yyyy/mm/dd') FROM DUAL; -- 2022/07/06
SELECT SYSDATE, TO_CHAR(SYSDATE,'yyyymmdd') FROM DUAL; -- 20220706
SELECT SYSDATE, TO_CHAR(SYSDATE,'yyyy-mm-dd hh24:mi:ss') FROM DUAL; -- 2022-07-06 16:14:34

SELECT SYSDATE, TO_CHAR(SYSDATE,'yyyy') FROM DUAL; -- 2022
SELECT SYSDATE, TO_CHAR(SYSDATE,'mm') FROM DUAL; -- 07
SELECT SYSDATE, TO_CHAR(SYSDATE,'hh24') FROM DUAL; -- 16
SELECT SYSDATE, TO_CHAR(SYSDATE,'mi') FROM DUAL; -- 14

DECODE 条件取值

语法

decode(条件, 值1, 翻译值1, 值2, 翻译值2, …, 值n, 翻译值n, 缺省值)

含义

IF 条件=值1 THEN
RETURN(翻译值1)
ELSIF 条件=值2 THEN
RETURN(翻译值2)
......
ELSIF 条件=值n THEN
RETURN(翻译值n)　　
ELSE
RETURN(缺省值)
END IF

NVL 和 NVL2 为空值赋值

NVL

语法

NVL (expr1, expr2)

含义

若 expr1 为NULL，返回 expr2；expr1不为 NULL，返回 expr1。
注意两者的类型要一致。

NVL2

语法

NVL2 (expr1, expr2, expr3)

含义

expr1 不为 NULL，返回 expr2；expr2 为 NULL，返回 expr3。
expr2 和 expr3 类型不同的话，expr3 会转换为 expr2 的类型。

CONNECT BY LEVEL 递归查询

构造连续的数字

1
2
3

SELECT LEVEL 
FROM
DUAL CONNECT BY LEVEL <= 5;

构造连续的日期

SELECT SYSDATE
+ LEVEL 
FROM
DUAL CONNECT BY LEVEL <= 5;

按逗号分隔字符串

SELECT
REGEXP_SUBSTR( 'a,b,c', '[^,]+', 1, LEVEL ) 
FROM
DUAL CONNECT BY REGEXP_SUBSTR( 'a,b,c', '[^,]+', 1, LEVEL ) IS NOT NULL

原理说明：

dual 只有 1 条记录，所以构造树时，每层都只有 1 个记录，可能形成了包含本记录的 n 次不同 level 的重复。
connect by 条件：按层级截取表达不能为空，因为只有 3 个元素，所以只到 3 级。
正则表达式的含义：
pattern ='[^,]+'，[]表示待选集合，但以 ^ 开头，表示非逗号的所有元素。
是从左开始截取、直到遇到不符合 pattern 的元素。

前后端耦合下实现多级联动选择下拉框

2022-06-29T05:48:42.000Z

环境

后端框架：SpringBoot
模板引擎：FreeMarker
前端框架：JQuery
前端 UI 组件：Layui

前端代码

容器中设定 class=”layui-form” 来标识一个 Layui 表单元素块。
放多个下拉框，第一个下拉框需要通过模板引擎循环渲染变量。
lay-filter：过滤器，主要用于事件匹配。

<form class="layui-form custom-form">
    <div class="layui-form-item">
        <label class="layui-form-label">所属区域：label>
        <div class="layui-input-inline">
            <select name="province" id="province" lay-filter="province">
                <option disabled selected value="">请选择省option>
                <#list province! as item>
                <option value="${item.uuid}" >${item.name}option>
                
            select>
        div>
        <div class="layui-input-inline">
            <select name="city" id="city" lay-filter="city">
                <option disabled selected value="">请选择市option>
            select>
        div>
        <div class="layui-input-inline">
            <select name="county" id="county" lay-filter="county">
                <option disabled selected value="">请选择县option>
            select>
        div>
        <div class="layui-input-inline">
            <select name="town" id="town" lay-filter="town">
                <option disabled selected value="">请选择镇option>
            select>
        div>
        <div class="layui-input-inline">
            <select name="village" id="village" lay-filter="village">
                <option selected="selected" disabled="disabled" value="" >请选择村option>
            select>
        div>
    div>
form>

使用 layui.form.on 监听事件，下拉选择框选中时触发事件，通过 ajax 请求下级的数据。

$(function () {
    layui.use(['jquery', 'form'], function () {
        let form = layui.form;
        form.on('select(province)', function (data) {
            selectRegion("#province", [
                {element: "#city", text: "请选择市"},
                {element: "#county", text: "请选择县"},
                {element: "#town", text: "请选择镇"},
                {element: "#village", text: "请选择村"},
            ], data, form);
        });
        form.on('select(city)', function (data) {
            selectRegion("#city", [
                {element: "#county", text: "请选择县"},
                {element: "#town", text: "请选择镇"},
                {element: "#village", text: "请选择村"},
            ], data, form);
        });
        form.on('select(county)', function (data) {
            selectRegion("#county", [
                {element: "#town", text: "请选择镇"},
                {element: "#village", text: "请选择村"},
            ], data, form);
        });
        form.on('select(town)', function (data) {
            selectRegion("#town", [
                {element: "#village", text: "请选择村"},
            ], data, form)
        });
    });
});

function selectRegion(element, childElements, data, form) {
    let regionId = data.value;
    $.ajax({
        url: "${request.contextPath}/select",
        type: "get",
        dataType: "json",
        data: {
            "regionId": regionId
        },
        success: function (data) {
            for (let i = 0; i < childElements.length; i++) {
                
                $(childElements[i].element).empty();
                
                $(childElements[i].element).append(' + childElements[i].text + "");
            }
            
            if (regionId !== "") {
                for (let i = 0; i < data.length; i++) {
                    $(childElements[0].element).append("");
                }
            }
            form.render();
        }
    });
}

后端代码

获取子级数据接口。

/**
 * 跳转下拉页面
 *
 */
public ModelAndView index(ModelAndView modelAndView) {
    modelAndView.addObject("province", regionService.getRegionByParentId(""));
    modelAndView.setViewName("/selectPage");
    return modelAndView;
}
/**
 * 查询地区信息
 */
@GetMapping("/select")
public List getRegionByParentId(String regionId) {
    return regionService.getRegionByParentId(regionId);
}

查询当前 ID 下的子级数据。

SELECT
    uuid,
    pid,
    name
FROM
    region
WHERE
    pid = 'xx'

二叉树的三种遍历方式

2022-06-22T02:53:35.000Z

概述

二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个节点最多只能有两棵子树，且有左右之分。二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个节点。

例子

前序遍历

思路

遍历顺序：根结点 -> 左子树 -> 右子树

代码示例

用递归的方式实现遍历。

package com.leetcode.editor.tree;

import com.leetcode.utils.TreeNode;

import java.util.ArrayList;
import java.util.List;

/**
 * 二叉树的前序遍历
 *
 * @author loquy
 * @date 2021 /12/10 16:32
 */
public class BinaryTreePreorderTraversal {

    /**
     * The entry point of application.
     *
     * @param args the input arguments
     */
    public static void main(String[] args) {
        TreeNode left2 = new TreeNode(4);
        TreeNode right2 = new TreeNode(5);
        TreeNode left = new TreeNode(2, left2, right2);
        TreeNode right3 = new TreeNode(6);
        TreeNode right = new TreeNode(3, null, right3);
        TreeNode treeNode = new TreeNode(1, left, right);
        List integers = preorderTraversal(treeNode);
        for (Integer integer : integers) {
            System.out.println(integer);
        }
        TreeNode.show(treeNode);
    }

    /**
     * Preorder traversal list.
     *
     * @param root the root
     * @return the list
     */
    public static List preorderTraversal(TreeNode root) {
        List res = new ArrayList();
        preorder(root, res);
        return res;
    }

    /**
     * Preorder.
     *
     * @param root the root
     * @param res  the res
     */
    public static void preorder(TreeNode root, List res) {
        if (root == null) {
            return;
        }
        // 前序遍历，根->左->右的顺序
        // 把当前节点的值添加到集合
        res.add(root.val);
        // 递归遍历左子树，直到没有左子树
        preorder(root.left, res);
        // 递归遍历右子树，直到没有右子树
        preorder(root.right, res);
    }
}

输出

1
2
4
5
3
6
      1      
    /   \    
  2       3  
 / \       \ 
4   5       6

中序遍历

思路

遍历顺序：左子树 -> 根结点 -> 右子树

代码示例

用递归的方式实现遍历。

package com.leetcode.editor.tree;

import com.leetcode.utils.TreeNode;

import java.util.ArrayList;
import java.util.List;

/**
 * 二叉树的中序遍历
 *
 * @author loquy
 * @date 2021 /12/06 10:25
 */
public class BinaryTreeInorderTraversal {

    /**
     * The entry point of application.
     *
     * @param args the input arguments
     */
    public static void main(String[] args) {
        TreeNode left2 = new TreeNode(4);
        TreeNode right2 = new TreeNode(5);
        TreeNode left = new TreeNode(2, left2, right2);
        TreeNode right3 = new TreeNode(6);
        TreeNode right = new TreeNode(3, null, right3);
        TreeNode treeNode = new TreeNode(1, left, right);
        List integers = inorderTraversal(treeNode);
        for (Integer integer : integers) {
            System.out.println(integer);
        }
        TreeNode.show(treeNode);
    }

    /**
     * Inorder traversal list.
     *
     * @param root the root
     * @return the list
     */
    public static List inorderTraversal(TreeNode root) {
        List res = new ArrayList();
        inorder(root, res);
        return res;
    }

    /**
     * Inorder.
     *
     * @param root the root
     * @param res  the res
     */
    public static void inorder(TreeNode root, List res) {
        if (root == null) {
            // 递归结束条件，空则返回
            return;
        }
        // 中序遍历，左->根->右的顺序
        // 递归遍历左子树，直到没有左子树
        inorder(root.left, res);
        // 把当前节点的值添加到集合
        res.add(root.val);
        // 递归遍历右子树，直到没有右子树
        inorder(root.right, res);
    }
}

输出

4
2
5
1
3
6
      1      
    /   \    
  2       3  
 / \       \ 
4   5       6

后序遍历

思路

遍历顺序：左子树 -> 右子树 -> 根结点

代码示例

用递归的方式实现遍历。

package com.leetcode.editor.tree;

import com.leetcode.utils.TreeNode;

import java.util.ArrayList;
import java.util.List;

/**
 * 二叉树的后序遍历
 * @author loquy
 * @date 2021/12/10 16:40
 */
public class BinaryTreePostorderTraversal {

    /**
     * The entry point of application.
     *
     * @param args the input arguments
     */
    public static void main(String[] args) {
        TreeNode left2 = new TreeNode(4);
        TreeNode right2 = new TreeNode(5);
        TreeNode left = new TreeNode(2, left2, right2);
        TreeNode right3 = new TreeNode(6);
        TreeNode right = new TreeNode(3, null, right3);
        TreeNode treeNode = new TreeNode(1, left, right);
        List integers = postorderTraversal(treeNode);
        for (Integer integer : integers) {
            System.out.println(integer);
        }
        TreeNode.show(treeNode);
    }

    /**
     * postorder traversal list.
     *
     * @param root the root
     * @return the list
     */
    public static List postorderTraversal(TreeNode root) {
        List res = new ArrayList();
        postorder(root, res);
        return res;
    }

    /**
     * postorder.
     *
     * @param root the root
     * @param res  the res
     */
    public static void postorder(TreeNode root, List res) {
        if (root == null) {
            return;
        }
        // 后序遍历，左->右->根的顺序
        // 递归遍历左子树，直到没有左子树
        postorder(root.left, res);
        // 递归遍历右子树，直到没有右子树
        postorder(root.right, res);
        // 把当前节点的值添加到集合
        res.add(root.val);
    }
}

输出

4
5
2
6
3
1
      1      
    /   \    
  2       3  
 / \       \ 
4   5       6

源码

查看此仓库

《玲音》剧情记录

2022-06-20T08:48:34.000Z

文章出处为我的B站专栏，写于2018年6月4日上午。

玲音

Present Day Present Time

第一话

四方田千砂自杀。

乘坐电车的玲音觉得周围很吵说能不能安静，大家就真的不说话停下来看向她。

学校不少人收到已经死去的四方田千砂发的电子邮件引发了骚动。

回到家的玲音也收到了邮件，信中四方田千砂发说自己只是舍弃了肉体这封邮件就是证明，并且说这里存在神。玲音向妈妈说了这件事，玲音妈妈无动于衷。

玲音向爸爸要新的NAVI(个人电脑、移动终端等设备的统称)。

爸爸说无论是现实世界还是连线世界（Wired），大家彼此连系社会才得以运转。

爸爸问玲音为什么突然提起这件事，玲音说有想见的朋友。

画面切换到玲音在电车上，电车因为遭遇事故紧急停车，玲音看出窗外，电线上流下了血。

接着画面频繁切换到玲音站在路中央、地铁楼梯出口、学校广场电线杆上的电线，最后切换到玲音看着四方田千砂走到轨道上迎着电车相撞的场景。

画面切回玲音在教室在考试，玲音出现幻觉看到黑板上写着快点来到连线世界。

路上玲音看到四方田千砂说了声千砂，随即消失，等等，玲音说。

第二话

这集比较奇怪，一开始夜总会里一个男人买了Accela〔Accela是一种大脑补充剂，通过纳米机械在体内产生固有频率的振动，以促进某种激素分泌，该激素会影响人的意识中对时间的感知，据服用者称:就像意识加速了一般。不仅如此，他还能有效刺激脑部运作，令服用者的计算能力提高二至十二倍不等，这种纳米机械本身虽然在24小时内几乎会被完全消化，但它会造成断续的闪回症状（幻觉重现）…〕。

玲音被同学认为像夜总会里的一个性格不同外貌很像的女生。

玲音收到一台全新的NAVI。

晚上玲音被同学邀去夜总会，在夜总会里吃药的男人好像发病了开枪打死人引发骚乱，玲音看上去出神了站着不动盯着男人，男人看到玲音说了一些奇怪的话：你有什么权利让我这么做，与我无关你这个傲慢的神，连线世界绝对不可以干扰现实世界，你到底是谁！玲音走过去说:无论在哪儿，人和人都彼此相连。男人就自杀了。

第三话

玲音电车上幻听到一个男人对他说话：玲音是我…..玲音明白吗?玲音回答：谁?男子说：不是一个人。

课堂上玲音幻听到千砂说：我已经没有理由继续留在现实世界中了，对于现实世界而言，我是个可有可无的存在，当我明白这点的时候，我对舍弃自己的肉体已经没有丝毫的畏惧。然后一个机器合成的声音反复说：玲音是谁?

更衣室里爱丽丝说:说来奇怪呢，昨天我们亲眼目睹了人的死亡，尽管如此，却感觉只像看了场电影。同学A:虽然昨晚我们确实在那儿，但总觉得没什么真实感呢同学B:我也这么觉得，爱丽丝这件事还是别想得太深比较好。爱丽丝：不是这样，我觉得反而我们没想得太深才比较奇怪，你说呢玲音?接着玲音收到了一个奇怪物件。

路上玲音看着物件说:Psyche。

家中玲音问爸爸这是什么爸爸说不知道。还收到了一封电子邮件。

夜总会一个男子问玲音最近怎么没有见到你，咦你怎么变清纯了。下次开锐舞派对，组织安排就交给你咯。

玲音看到上次来时见到的三个小孩，拿出物件问知道这是什么吗？小鬼A:这个不是Psyche吗。小鬼B:真的假的。小鬼C:不会吧，我还是头一回亲眼。小鬼B:在哪儿买的？玲音：你知道这是什么吗？小鬼A:你在说啥啊，装上它(外形类似枪的机器)就算是这玩意也能毫无节制地访问连线世界呢。玲音:这个要怎么用呢?小鬼C:真逊连这个也不知道吗。小鬼B:把它卖给我吧卖给我吧。小鬼A:笨蛋你买的起吗。小鬼B:把它接入NAVI主处理器的背面，它会截取原有的信息并自动运行，其实就像拼装模型一样简单，只是要小心静电。小鬼C想要收钱并且对玲音说在网上见过她表现的很极端，前不久有个白痴在这家店惹事你也在吧，你有什么阴谋。玲音：你要我做什么。小鬼A要求和状态判若两人，疯狂人格的玲音约会一次。。

玲音的姐姐回家时被两个站在家门口带着奇怪眼镜的黑衣男子吓到，询问是谁后黑衣男说:你从没遇见过我们，要说为什么因为我们此刻并不在这里。

玲音姐姐看到玲音把Psyche装在NAVI上很惊讶。

最后，发出虚拟声音的玲音说了声：你回来啦姐姐。

第四话

这集不断有人因为玩了一个叫PHANTOMa【基于其他游戏的网游，估计被改造过，问题在于两种程序合成的部分，协议里似乎存在漏洞，猜想会不会是Knights（不是实体，而是存在于网络上的一种思想，如同在连线世界中不断蔓延的宗教信仰一般）搞的鬼】的游戏而自杀，通过它可以在连线世界对战，玩家过的玩家，已经不玩的玩家，没有进入游戏也会在现实中乱入游戏世界，因为看到幻象感到害怕从而会发生逃跑哀嚎等行为最终有些玩家会崩溃自杀(其实是被迫自杀)。其中的一个男孩子在这乱入的过程幸运没有死，奇怪的是空中出现了一个投影虚拟的玲音在看着他。

玲音在改造NAVI过不了多久就能全范围、全动态的进入连新世界，爸爸提醒连线世界终究只是收发信息交流的空间，玲音说不是这样的，两者的界限没有划分的那么明确。

黑衣男子站在玲音家周围监视，玲音发现后说：给我滚开！然后黑衣男子马上滚蛋了，NAVI也发出提示说:已经入侵者已拦截。

第五话

旁白：人类难道还会进化吗?有学说称：作为一种癌症发病率和其他动物相比极低的幼太持续（Neoteny）型生物，人类已无法再进化了。若真如此，人类真是进化成了一种多么愚蠢的生物啊，对推动自己的力量丝毫未觉，只为满足欲望而维持着肉体，不觉得无趣吗？人类终究只是这种东西。没必要继续过这种凄惨的人生了，因为人类已经创造出了用以逃生的出口。

玲音：那是什么？

旁白：网络，也就是连线世界，铃音。

玲音：你是谁？

旁白：我是神。

画面切回玲音的房间，玲音对着一个娃娃人偶说话，问它一些玲音不知道的事，娃娃说：你不知道的事不存在，我没法说不存在的事，事情的发生其实是先有预言的，有了预言这些事才会成真。玲音问：谁？谁会预言？

玲音走在马路上有人在发纸巾，玲音姐姐也收到了还被一个熊孩子搭讪不小心被泼到饮料，拿出纸巾擦衣服时发现纸巾上面写着：冥府已人满为患死者将无处可去。

又切回房间，一个黑色人头雕像对着玲音说：预言正在实现。

玲音：若是这样的话就不是预言了。

雕像：不是预言，所谓的历史不只是线性时间轴上的点，它们都是通过线连接在一起，不，应该说这些点都被人用线连接在一起比较好。

玲音：谁？是谁将它们连接起来的？

这回是漂浮在房间内好似虚拟的玲音妈妈说：把连线世界看成是现实世界的上层目录比较恰当，也就是说肉体等现实中的物体只不过是连线世界中的信息投射而成的全息影像。肉体、人脑的活动原本就是通过突触传递电信号引发的，说到底不过是单纯的物理现象而已，肉体存在的理由只是为了确认自身的存在。

这一段玲音姐姐被各种奇怪的现象吓死了，最后被关在厕所一整扇门写满了红色的去实现预言。。

这回是漂浮在房间内好似虚拟的玲音爸爸说：连线世界中传递的也许不只是电信号，如果将电话等电子通讯设备的发展视作连线世界形成的起源，不觉得在那一刻一个新的世界就已经诞生了吗？在这个现实世界中神的存在终究只是个概念，但在连线世界中或许能让宙斯般的化身得以显现，不知称其为神是否恰当，但他至少应该拥有像神话中的宙斯那样的支配力，连线世界中的宙斯所具的支配力也许已经影响现实世界了，没错以预言这种形式。

姐姐跑回家被吓出阴影来又碰到一个一模一样的自己，结果在玲音眼中变成透明的数据体，好似被侵入替换了。。

最后铃玲音回到房间对着那个被他改造的很科幻的NAVI说：今天是谁？

第六话

开头玲音爸爸被玲音改造的NAVI吓到了，玲音看着屏幕一脸陶醉的表情。

一个朦胧色彩变幻的空间玲音对着周围说：寄存器早已通过验证，下一代协议能尽快定下来就好了，这样我就能…我说你们为什么对我这么好？不是这个意思只是好奇，因为我没几个朋友，谢谢你们 Knights的各位。

一个傻孩子举着手望着天空。。

教室里玲音和同学聊起网络的朋友不告诉她们是谁说是个秘密。

傻孩子举着手望着天空*2

人群举着手望着天空*3

哇呜，天空中出现巨大的玲音幻影。

家里姐姐做在沙发看电视一脸被玩坏的表情好似丢了魂（感觉身体被掏空233）

玲音进入连线世界，黑暗中和一张巨大的嘴交谈想知道最近孩子流行的游戏，巨嘴说这个人或许能回答你的疑问。

杀害儿童的科学家，现实世界只是个在单人病房等死的老头。

去打听下KIDS吧巨嘴说。

霍奇森教授轮到你了你会告诉我吧，玲音说。

镜头切换到夕阳里。

玲音不断询问KIDS是谁，教授却答非所问在享受此刻233，玲音问给我看15年前的实验数据，教授说没打算让孩子们置于险境，玲音说不是十五年前的事，如今孩子们流行的游戏不是教授当初那个实验的再现吗?教授：大概是被谁从垃圾站捡了回来吧，我原本打算将所有的数据销毁。玲音：告诉我有关于15年前肯辛通实验的事。教授：大部分儿童都拥有极其微弱的PSI超心理能力，和那种不着边际的超能力不同，比如一点点的第六感还有像弯曲硬币这种程度的作用力。玲音：他们头上装的是什么？教授：我们称之为外部受体由下面这个系统来接收，这就是KIDS（看起来像黑盒子）虽然他们各自的力量及其微弱，但如果将这些力量汇聚起来…玲音：你在期盼什么？教授：那是无法预见的事小姐我想看的就是这个。玲音：你做了什么？教授：个人觉得科学应该不单只是去验证假设。玲音：不是说这个，那么孩子们会怎样你根本就没想过吧。教授：是的如之前所言外部受体将接受到的微弱脑电波进行转换，使大脑某部分的某种机制能得以增强，这就是KIDS系统的真面目。玲音：孩子们的PSI在合并时究竟产生了多么巨大的能量…我看不下去了够了。教授:我把KIDS系统彻底破坏了，但那套机器的设计图好像流传到了连线世界的某处，从此沉入了时间的沉渣中。玲音：然后有谁发现了它…教授：而且还更新了系统，使其无需借助外部受体便可引发现象，通过模拟硬件环境便使影响范围如此之广，真可谓优秀。铃音眼中含着泪光说：你只有这种想法吗？孩子们会怎样都无所谓吗。教授：我的想法改变不了孩子们已无法回归现实世界的事实，更何况现在受害的这些孩子。玲音：真是自以为是，那么现在使用的是那个系统吗？教授：小姐我说的太多现在累了，很高心见到你，虽然不知道你在连线世界里做什么也不清楚你的真实身份，但我感觉到你很强大，强到逆天233，如果这个连线世界有神存在的话，你一定是个被神祝福的孩子。玲音：我…我并不是…教授：模拟KIDS系统的那帮无赖，他们那种强大的力量究竟又是从哪儿来的呢。玲音：那帮无赖…教授：那么请容我先行告辞有点疲倦了，我的肉体已将消亡愿望也实现了。

切回房间，玲音坐着对着屏幕抱怨：烦死了，你们究竟在搞什么，为什么告诉我这么多？我也是你们手中的玩物吧？这一切都是场游戏吗？你们利用孩子们想做什么?只是觉得好玩？只要觉得好玩你们什么事都干？那样的话和一群猴子有什么区别（嘲笑），怎么不吭声了？没人回答吗？

此时那两个带着红外线眼镜的黑衣男又来到玲音家下面。玲音跑下楼质问他们是不是Knights,黑衣男说不是，刚下来房间的冷却系统就爆炸了，黑衣男说被植入寄生炸弹，最后说是Knight干的就潇洒开着车走了。。

第七话

科幻的房间里玲音对着屏幕说着：不不是那样，我只是看着而已因为连线世界中的我…嗯已不再是我，嗯不是很清楚，咦你说谁？门口：姐姐嘴上说着但没发出声。。

一个男子带着类似VR的机器走在大街上说着：连线世界和现实世界连接在一条线上，无论哪个世界我都可以生存，不管肉体位于何处，意识都能去往任何地方。

办公室一位女士对着经理说：E发动（据说一种永动机）机集团的午宴就要开始了。

经理对着屏幕奸笑：这次要玩什么呢？

教室里玲音在偷玩着外形类似手机的机器。

一个肥宅对着屏幕说：没错我和你们这群笨蛋有着天壤之别。

切回楼顶：爱丽丝和玲音说最近变得不一样了，我们带着你到处玩是为了不让你孤单，希望你变得开朗些，真心为你着想，但是玲音你不高兴的话我想你道歉。玲音：我没觉得…没觉得不高兴（紧张的发抖）。爱丽丝说太好了，铃音感谢爱丽丝为她担心，爱丽丝说谁让我们是朋友呢,回头见。

新闻：情报中心防火墙被人攻破，目前连线世界一片混论。

连线世界再讨论Knights。 Knights据称是个在连线世界中拥有强大势力的算法骑士团，组成人员不明，他们不单对情报进行操控，而且还从事非法信息设备的开发和流通。

快递男想勾引家庭主妇被识破，家庭主妇也说了奇怪的话，连线世界也和现实世界一样。

路上黑衣男邀请玲音跟他走，玲音问你们是谁，黑衣男摘掉面具说跟我走就告诉你。

VR男走在路上在求着加入Knight，突然镜头闪过玲音的虚拟人像，男子问道是谁？

玲音被带到橘综合研究所，被一男子请求修好电脑，打开电脑虚拟铃音对着VR男说八嘎。

关掉电脑男子对玲音说：Knights是个不同寻常的组织，Knights对连线世界中的你特别感兴趣，他们利用你达到某种目的，要不惜动用任何手段组织他们。玲音问你们是谁。

切回VR男追寻着Knights想加入他们，影像里闪现出之前的经理、肥宅、主妇。

男子问道你和连线世界的玲音是同一个人吗？你究竟是谁？你的父母是你的亲生父母吗？你的姐姐是你的亲姐姐吗？玲音回答你在说什么？这不是理说当然的吗。男子：你父亲的生日是哪天？你母亲的生日是哪天？一连串问题玲音回答不上来。快要崩溃了，突然强硬的虚拟玲音仿佛上了现实世界玲音的身，怼回男子真啰嗦啊无聊至极尽说些没用的….男子：喔是连线世界的玲音吗？玲音：是又如何？男子：你应该也知道把即使不借助任何设备，也能将连线世界与现实世界之间的界限逐步瓦解。玲音：那又怎样？男子：我认为这种行为非常危险。玲音：那不是很有趣么，哼。走的时候被黑衣男拉住说：有危险的是你自己。男子训斥卡尔，正如他说的那样有趣的事要发生了，静观其变。

主妇扔掉寄来已经烧坏的硬件，VR男死在草地上。

第八话

旁白：你也想伤害自己吗？渴望拥有一段心如刀割的回忆吗?那就千万别移开视线…

线上世界玲音和一道声音交谈：六代协议下的数据吞吐量已经见顶，第七代协议正在建立，一旦掌控了协议实际就掌控了连线世界的经济，因此各方在争斗，收拾这一局面的是橘综研。

回到房间姐姐依旧被玩坏一样。。父母因为玲音谈到有人说在橘综研的事很诡异盯着玲音。

学校爱丽丝和几个同学问玲音连线世界的某件事是不是他做的。最后爱丽丝看到玲音紧张的样子马上说没事不是玲音做的（如果这都不算爱）。

又来意识流，黑暗的空间里一群人讨论着各种八卦，玲音说很烦。接着一个男性的声音出现了问道你不觉得有趣吗？你在找我吧。玲音：传说中的神登场了？

神的定义是什么呢？世界的造物主？那么我不是。掌控世界的全能统治者？那就高估我了。

玲音：你在哪儿？

如果所谓的神是这个世界普遍存在的事物，那么没错你可以这么称呼我，我只是在对世界的走向稍加干涉。

玲音：你究竟是谁？

我就是你，你应该也发觉了吧？很久以前这个连线世界中就一直存在着另一个你。你不过是她投射出的全息影像，你只是一具肉体。

玲音：这种事谁会信啊，不可能有这种事。

可是现实世界的你与现在的你两者人格截然不同，你自己也这么觉得吧？

玲音：但我还是我…

切回到教室，所有人和父母一样诡异的盯着玲音。。跑出去也是同样的情况。玲音不断的在问爱丽丝在那里。抱膝哭着自责另一个在连线世界的我到底做了什么?

卧槽切回到房间爱丽丝在想着老师自慰，一旁坏人格的玲音在幸灾乐祸。

爱丽丝问果然是散布的吗，你一直在暗中偷窥我吗？

切回玲音房间身体插着线躺着眼中哭着好似很难受。

意识流，坏玲音笑了和玲音互怼。你不是我，我不会做这种事，为什么要模仿我所厌恶的那个自己？（坏玲音奸笑）玲音掐着坏玲音。坏玲音说我在自杀吗？（嘲讽）玲音说为什么你有体温？为什么要让我感觉到你的体温。坏玲音：因为…我不就是你吗。玲音：不是的！

切回另一个意识所谓的神又出现了告诉玲音到处都是你你不断着偷窥别人的隐私，连线世界就应该共享。

玲音：你说的这些全都是骗人的。

为什么？

玲音：爱丽丝她们看到了连线世界的我，而我当时并不在这里，只要我能分辨自己，我的自我就与我同在。如果是像你说的一样的话，大家被玲音偷窥的这段记忆，应该都可以被消除。

说的对，用你与生俱来的能力试试看吧。

嘀嘀嘀，正在删除…

结果大家都忘了玲音，生活中被坏玲音替代了。。

屏幕前玲音说：我还是我对吧？除了我之外的我根本不存在对吧？(含着眼泪)

第九话

旁白：若想摆脱痛苦就去信奉神吧，不管你是否相信神始终都在你的身旁。

切换到三次元影像，1947.7.4飞船坠落在美国墨西哥州的沙漠，真实面目至今未被证实，而当时的猜测却被当作真相流传下来成为了历史。

卧槽玲音房间门口出现外星人一下又消失了。

三次元：1984年电视剧制片人詹姆·山德拉家中收到一个匿名邮包，牛皮纸封套里装着尚未冲洗的胶卷，照片上拍摄的是所谓的MJ-12文件。据该文件所述罗斯威尔事件发生后，以当时的中情局局长罗斯科·希伦科特为首的12人成立了一个直接受命于总统的组织并于外星生物签订了秘密条约，经验证这份文件上杜鲁门总统的署名是从其他文件上复制过来的，当时被指明为MJ-12成员之一的正是麻省理工学院工程学院院长范内瓦·布什。

玲音进入连线世界问着一群影子一样的人：究竟要怎样才能让已经发生的事变成从未发生过？

A：是玲音啊原来如此。

玲音：我对你一无所知，而你却对我一清二楚。

A:情报未必总会流向双方，自从你在连线世界上诞生的那一刻起，你就一直存在于此，在这里你是自由的。

玲音：都说了那不是我！

A：那么我们是从何时开始存在于此的？至少不会是在这个世界诞生之初吧。

B：与此无关，只要存在本身被记忆过，就应该会有记录。

三次元：范内瓦·布什在1945年发表了一个记录扩展设想（MEMEX），该系统能将微缩胶卷上存储的信息呈现在半透明的屏幕上，他所构思的是这一种信息压缩和快速读取的技术，当时正在指挥核爆试验曼哈顿计划的布什，在计算机诞生之前就为现在的多媒体技术打下了基础。

夜店男和玲音说有个你忘记的东西，一块装在信封的硬件。

三次元：约翰·李利为了探索人的无意识曾利用印度的麻药和隔离箱做过感觉剥夺实验，实验过程中他认为自己借助通信网络和宇宙的某种存在取得了连接，李利将引导他的那个存在称之为E.C.C.O——地球暗号管制局。之后李利把研究转向了海豚间的交流，海豚可通过自身发出的超声波在水中建立起范围极广的交流网络。

夜店和三个熊孩子交谈，之前做过约定所以玲音说一起约会。这个熊孩子竟然说要约的不是现在的你。。玲音说：都一样，我就是我，只有一个我。

带着熊孩子参观玲音的间，熊孩子看着科幻的房间很兴奋。

玲音问熊孩子夜店男给送的硬件是什么，你是Knights的一员吧。

熊孩子被怀疑是夜店铃音出现时的犯人了，操控别人的记忆。

家里爸爸妈妈姐姐的行为都很奇怪。

玲音播放了一首令人产生幻觉的音乐，熊孩子说不是他干的。

逼问下原来这个硬件是一块非易失性内存，可以改写已有的记忆。

熊孩子说Knights不只是黑客，是为了实现唯一真理而奋斗的执行者，你很奇怪才会被盯上。

玲音说不大明白唯一的真理是什么？真理代表着强大象征着正义熊孩子说。

卧槽熊孩子强吻了玲音！！！还是舌吻把口香糖传到玲音嘴里。。。

三次元：泰德·纳尔逊继承了范内瓦·布什和约翰·李利这两位异端先行者的理念，发表了名为Xanadu的数据库设想——将一个巨大电子图书馆以静止卫星形式发射到运行轨道上，地球上的各种终端在任何角落都能通过电波和电话线来使用它。Xanadu是传说中蒙古的理想乡在哪里所有的文字文化永远不会消逝，而在现实世界中令其实现的正式超文本这一概念，它的设计者泰德·纳尔逊定会名留史册吧。

玲音检查NAVI内存知道了自己不是亲生的。很困惑。

三次元：地球又其特定的而电磁波，在电离层和地表之间，一直存在着频率为8Hz的极低频电磁波，它被称为舒曼共振。这种地球常年发出的电磁波可看作是地球的脑波，它会对人类产生怎样的影响，至今仍未判明，地球人口数已达到了人脑神经元的数量，道格拉斯·洛希科夫主张通过网络将地球上的人类互相连接，以唤醒地球自身的意识，如今网络已进化成为神经系统，就像人脑中突触连接神经元那样，整个地球正在转变为一个神经网络。曾担任橘宗研研究主任的英利政美，进一步发展了这一覆盖地球的神经网络假说，据他所称地球上所有人甚至不需要借助任何设备，就可以在无意识下连接网络，不仅如此他还擅自将加密后的舒曼共振因子写入了第七代网络协议中。

橘宗研知道此事后解雇了英利政美，一周后山手线上发现了英利政美被碾压后的尸体。

伴随着嗡嗡的电流声结尾出现了——

穿着白色长袍腰上绑着绷带脸上涂着红色印记的一个妖异的长发男子。

第十话

开头玲音与这个妖异男子谈了一段话知道他就是死去的英利政美。

对话如下：

玲音：你就是神？

英利政美：没错我就是神。

我搞不懂你为什么你会是神？你不是已经死了吗？一个死人怎么可能会成为神。

玲音：我明白了肉体只是累赘，所谓的死只是舍弃肉体而已。

英利政美：那是千砂…

玲音：是的没错，我进化了网络协议统治了连线世界。

英利政美：对你确实这么做了，但协议只是个约定。

玲音：对不过我将加密后的作用代码写入了更高级的协议层。

英利政美：那又如何？

玲音：这个协议中混入了压缩后的信息。

英利政美：什么信息？

玲音：人的记忆我英利政美本人的思想、经历、记录、情绪…

英利政美：这又意味着什么呢？

玲音：以匿名用户的身份在连线世中永生，利用信息统治连线世界。

英利政美：你觉得该如何形容这种存在？

玲音：神。

英利政美：神根本不存在。

玲音：没错即使普遍存在于这个世界能对这个世界施加影响，但没有信徒就不足以为神。

英利政美：不过你拥有信徒，不，应该说制造了信徒。

玲音：Knights…

英利政美：对你而言肉体只是累赘玲音…

玲音：一派胡言！

切回教室玲音的座位没了，别人也没发现她，看起来很失落。

一直在陈述自己是存在的，慢慢怀疑自己是错的不可以拥有肉体。而爱丽丝说世界不需要你，很受打击。

切回家也空荡荡很久没人住了一样。玲音爸爸突然出现跟他道别，说工作就到此为止。

玲音说别留下我一个人，他回答说到连线世界所有人都会欢迎你，你就是这样一种存在。

连线世界玲音问虚拟的我是不是Knights制造出来的，有声音回答早在连线世界诞生之前，他们就一直在利用人与人之间存在的无形网络——集体无意识。

Knights的成员名单突然出现在网络新闻里。之前的经理男被黑衣男杀死了，肥宅也是，主妇也是，各处都有成员死去。

玲音房间里黑衣男说连线世界中英利政美的残留思念程序终将被清除，我们的雇主正在对第七代协议的代码进行全面改写，我们不需要神，虽然我们至今无法理解你这个存在。不过我喜欢你。

刮风的马路上——

玲音：该怎么办？

英利政美：那么如何是好呢。

玲音：你的信徒消失了。

英利政美：那样我就不再是神了，不过还没有全部消失，只要还有一个信徒我就让仍是神。

玲音：那个人是谁？

英利政美：讨厌说的就是你啊玲音，你能成为你都是我的功劳，你原本诞生于连线世界中，你只是连线世界的传说，只是连线世界的童话中的主人公。

玲音：骗人…

英利政美：现实世界中的岩仓玲音只是她的全息投影，是用人造核糖体制成的人造人，你原本并没有实体。

玲音：骗人…

英利政美：虚假的家庭虚假的朋友，没错所有的一切都是骗人的。

玲音：骗人… 你在骗人…（含泪）

英利政美：可怜的玲音孤单一人。但还有我，还有爱着你的我，我把你送到了这个世界，你应该会爱我才对，我是你的创造者。爱我吧。好吗玲音。

玲音：另一个…

英利政美：嗯？

玲音：另一个我…

英利政美：不是另一个，那是真正的你。

玲音：随你怎么说！

第十一话

记忆并不是模糊不清。

然后回忆了此前的种种事件走马观花。

意识流一幕幕画面。

切回房间英利政美对玲音说：你是个拥有肉体的可执行程序。

路上四方田千砂出现了，死去的酒吧暴走男出现了，一个低落一个兴奋。

男子逼着铃音舍弃肉体，千砂低落的说死没那么简单。

玲音跑到爱丽丝房间和她说要删除之前所有发生的事。

学校里爱丽丝和老师的事被删了没人记得了。

第十二话

玲音发邮件发给爱丽丝说那些不愉快的事改写掉就是了。

英利政美一波理论要把人类从身体挣脱出来共享感知等等，鼓动玲音。

车里两个黑衣男交谈：雇主和英利政美是串通的是一件阴谋。

地下室质问雇主连线世界与现实世界无需任何设备就能连接有什么目的？雇主只说了会发生美妙的事拭目以待。结果两个人好像中病毒般被杀死了。

爱丽丝访问玲音的家，问玲音为什么唯独让我保留原来的记忆？玲音：只有你是我真正的朋友。我本身就是一个用于破坏连线世界与现实世界的间隔的程序。

爱丽丝：不是这样的。

英利政美反驳怼了一波爱丽丝。

玲音又怼了一波英利政美。反杀！

玲音：你只是接触了各种设备与连线世界的关联，没有电话、电视和网络你就什么也做不到。

英利政美：没错这些不都是人类进化过程中的产物吗，人类位于进化的顶点有权拥有比它们更高级的机能。

玲音：谁给的权力？你在第七代网络协议中编入了于地球的固有振动相同的代码，因此才得以创造出能让集体无意识转化为意识的程序，这真的是你自己想出来的吗？

英利政美：你究竟想说什么？难道…难道你想说这个世界真有所谓的神吗？

玲音：不管怎样失去肉体的你是不会明白的。

英利政美：骗人！我…是无所不能的！我让你在现实世界中拥有了肉体！我让普遍存在于连线世界中的你拥有了自我！可你…

玲音：假设我是这样那么你呢？

英利政美：我不一样！我…

暴走一波

玲音：连线世界不是现实世界的上级目录。

英利政美：什么意思？

玲音：你确实是连线世界的神那么在连线世界诞生之前呢？你只是一直在等待连线世界发展到今天，你只是神的代理人。

英利政美：你说什么…胡说！

暴走第二波

玲音：你不是不需要肉体吗？

英利政美被这句将死崩溃消失了。

第十三话

开头虚拟玲音在问自己是谁。

玲音向爱丽丝道歉之前做的是错的。

镜头出现重置一切的字体。

伴随着BGM

世界又回归正常。死的人也都复活了。英利政美竟然也复活了。

但是玲音不见了谁也不记得她。(虐)

一波意识流，两个玲音在谈论重置世界对与错，利与弊。

纠结于自身的存在。

连线世界其实只是连接而已，那么连接另一端通往哪里？

人类有必要了解这个吗。

就算对此一无所知人类不是依旧走到了今天。

玲音讨厌这种说法。

玲音是任何事物是观察者。

（你是什么你从哪里来要到那里去）

最后类似神的存在幻化成玲音爸爸和伤心的玲音交谈…

切回马路天桥上玲音与长大后的爱丽丝相遇了，爱丽丝还是不记得玲音。

玲音望着爱丽丝背影说着没错无论何时我们都能相见。

结尾虚拟玲音说我在这里所以我们永远都在一起。

完

《文学回忆录》读书笔记

2022-06-17T05:46:05.000Z

一、前言

关于《文学回忆录》（木心口述，陈丹青笔录）的一些读后笔记，主要记录些文学史上重要的作者和书籍，汇集成书目，以书找书，方便日后查看，写于2020年初。

二、史诗

《伊利亚特》、《奥德赛》（荷马，古希腊）。

三、宗教

《圣经》新旧约。

四、各大学家（作家、哲学家、文学家、史学家）

中国：老子、庄子、墨子、孔子、苏东坡、司马迁、曹雪芹。
外国：尼采、莎士比亚、福楼拜、雨果、叔本华、易卜生、爱伦坡、托尔斯泰、巴尔扎克、陀思妥耶夫斯基、莫泊桑、卡夫卡、加缪、普希金、伍尔芙夫人、高尔基、契科夫、纪德、歌德、席勒。

五、诗人

中国：李白、杜甫、陶渊明、屈原。
外国：拜伦、雪莱、海涅。

六、书

中国：《红楼梦》、《诗经》、《道德经》、《金瓶梅》、《水浒》、《浮生六记》、《易经》。
外国：《地粮》(纪德，盛澄华译本)。

七、观点

某个方向的书，要由浅到深看。
文学是人学。
时时要有死的恳切，活着就知道该如何了。

在 LeetCode 上学习的算法和数据结构

2022-06-15T03:08:06.000Z

LeetCode

在 LeetCode 上学习算法和数据结构。

数组

序号	题目	题解	标签	难度
1	两数之和	Java	`数组` `哈希表`	简单
26	删除有序数组中的重复项	Java	`数组` `双指针`	简单
27	移除元素	Java	`数组` `双指针`	简单
35	搜索插入位置	Java	`数组` `二分查找`	简单
53	最大子数组和	Java	`数组` `分治` `动态规划`	简单
66	加一	Java	`数组` `数学`	简单
88	合并两个有序数组	Java	`数组` `双指针` `排序`	简单
108	将有序数组转换为二叉搜索树	Java	`数组` `二叉搜索树` `分治`	简单
118	杨辉三角	Java	`数组` `动态规划`	简单
136	只出现一次的数字	Java	`位运算` `数组`	简单
169	多数元素	Java	`数组` `哈希表` `分治` `计数` `排序`	简单
228	汇总区间	Java	`数组`	简单
268	丢失的数字	Java	`位运算` `数组` `哈希表` `数学` `排序`	简单
283	移动零	Java	`位运算` `数组` `哈希表` `数学` `排序`	简单
303	区域和检索 - 数组不可变	Java	`设计` `数组` `前缀和`	简单
349	两个数组的交集	Java	`数组` `哈希表` `双指针` `二分查找` `排序`	简单
448	找到所有数组中消失的数字	Java	`数组` `哈希表`	简单

链表

序号	题目	题解	标签	难度
2	两数相加	Java	`递归` `链表` `数学`	中等
21	合并两个有序链表	Java	`递归` `链表`	简单
83	删除排序链表中的重复元素	Java	`链表`	简单
141	环形链表	Java	`哈希表` `链表` `双指针`	简单
160	相交链表	Java	`哈希表` `链表` `双指针`	简单
203	移除链表元素	Java	`递归` `链表`	简单
206	反转链表	Java	`递归` `链表`	简单
234	回文链表	Java	`栈` `递归` `链表` `双指针`	简单
237	删除链表中的节点	Java	`链表`	简单

数学

序号	题目	题解	标签	难度
7	整数反转	Java	`数学`	中等
9	回文数	Java	`数学`	简单
29	两数相除	Java	`位运算` `数学`	中等
69	x 的平方根	Java	`数学` `二分查找`	简单
70	爬楼梯	Java	`记忆化搜索` `数学` `动态规划`	简单
202	快乐数	Java	`哈希表` `数学` `双指针`	简单
231	2 的幂	Java	`位运算` `递归` `数学`	简单
258	各位相加	Java	`数学` `数论` `模拟`	简单
263	丑数	Java	`数学`	简单
326	3 的幂	Java	`递归` `数学`	简单
338	比特位计数	Java	`位运算` `动态规划`	简单
342	4 的幂	Java	`位运算` `递归` `数学`	简单
367	有效的完全平方数	Java	`数学` `二分查找`
405	数字转换为十六进制数	Java	`位运算` `数学`	简单
441	排列硬币	Java	`数学` `二分查找`	简单

队列

序号	题目	题解	标签	难度
225	用队列实现栈	Java	`栈` `设计` `队列`	简单

栈

序号	题目	题解	标签	难度
155	最小栈	Java	`栈` `设计`	简单
232	用栈实现队列	Java	`栈` `设计` `队列`	简单

字符串

序号	题目	题解	标签	难度
13	罗马数字转整数	Java	`哈希表` `数学` `字符串`	简单
20	有效的括号	Java	`栈` `字符串`	简单
28	实现 strStr()	Java	`双指针` `字符串` `字符串匹配`	简单
58	最后一个单词的长度	Java	`字符串`	简单
67	二进制求和	Java	`位运算` `数学` `字符串` `模拟`	简单
125	验证回文串	Java	`双指针` `字符串`	简单
168	Excel 表列名称	Java	`数学` `字符串`	简单
171	Excel 表列序号	Java	`数学` `字符串`	简单
205	同构字符串	Java	`哈希表` `字符串`	简单
242	有效的字母异位词	Java	`哈希表` `字符串` `排序`	简单
257	二叉树的所有路径	Java	`树` `深度优先搜索` `字符串` `二叉树`	简单
290	单词规律	Java	`哈希表` `字符串`	简单
344	反转字符串	Java	`递归` `双指针` `字符串`	简单
387	字符串中的第一个唯一字符	Java	`队列` `哈希表` `字符串` `计数`	简单
389	找不同	Java	`位运算` `哈希表` `字符串` `排序`	简单
392	判断子序列	Java	`双指针` `字符串` `动态规划`	简单
409	最长回文串	Java	`贪心` `哈希表` `字符串`	简单
434	字符串中的单词数	Java	`字符串`	简单
459	重复的子字符串	Java	`字符串` `字符串匹配`	简单

树

序号	题目	题解	标签	难度
94	二叉树的中序遍历	Java	`栈` `树` `深度优先搜索` `二叉树`	简单
100	相同的树	Java	`树` `深度优先搜索` `广度优先搜索` `二叉树`	简单
101	对称二叉树	Java	`树` `深度优先搜索` `广度优先搜索` `二叉树`	简单
104	二叉树的最大深度	Java	`树` `深度优先搜索` `广度优先搜索` `二叉树`	简单
110	平衡二叉树	Java	`树` `深度优先搜索` `二叉树`	简单
111	二叉树的最小深度	Java	`树` `深度优先搜索` `广度优先搜索` `二叉树`	简单
112	路径总和	Java	`树` `深度优先搜索` `二叉树`	简单
144	二叉树的前序遍历	Java	`栈` `树` `深度优先搜索` `二叉树`	简单
145	二叉树的后序遍历	Java	`栈` `树` `深度优先搜索` `二叉树`	简单
226	翻转二叉树	Java	`树` `深度优先搜索` `广度优先搜索` `二叉树`	简单
235	二叉搜索树的最近公共祖先	Java	`树` `深度优先搜索` `二叉搜索树` `二叉树`	简单
404	左叶子之和	Java	`树` `深度优先搜索` `广度优先搜索` `二叉树`	简单

数据库

序号	题目	题解	标签	难度
175	组合两个表	MySQL	`数据库`	简单
176	第二高的薪水	MySQL	`数据库`	中等
177	第N高的薪水	MySQL	`数据库`	中等
181	超过经理收入的员工	MySQL	`数据库`	简单
182	查找重复的电子邮箱	MySQL	`数据库`	简单
183	从不订购的客户	MySQL	`数据库`	简单
184	部门工资最高的员工	MySQL	`数据库`	中等

SpringBoot 中使用 Mybatis

2022-06-14T02:42:48.000Z

概述

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

详细使用教程参见官方文档。

表结构

创建名为 mybatis 数据库，执行以下 sql 语句创建 user 表。

CREATE TABLE `user` (
  `id` int(11) NOT NULL,
  `name` varchar(255) NOT NULL,
  `pwd` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

Maven 项目结构

springboot-05-mybatis├─src│  ├─main│  │  ├─java│  │  │  └─com│  │  │      └─example│  │  │          │  Springboot05MybatisApplication.java│  │  │          ││  │  │          ├─controller│  │  │          │      UserController.java│  │  │          ││  │  │          ├─mapper│  │  │          │      UserMapper.java│  │  │          ││  │  │          └─pojo│  │  │                  User.java│  │  ││  │  └─resources│  │      │  application.properties│  │      ││  │      └─mybatis│  │          └─mapper│  │                  UserMapper.xml│  ││  └─test│      └─java│          └─com│              └─example│                      Springboot05MybatisApplicationTests.java

Pom.xml 依赖配置

"1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.5.5version>
        <relativePath/> 
    parent>
    <groupId>com.examplegroupId>
    <artifactId>springboot-05-mybatisartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>springboot-05-mybatisname>
    <description>Demo project for Spring Bootdescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
            <version>2.1.3version>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jdbcartifactId>
        dependency>

        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <scope>runtimescope>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>

project>

Application.properties 配置

mybatis.type-aliases-package： 类型别名可为 Java 类型设置一个缩写名字。它仅用于 XML 配置，意在降低冗余的全限定类名书写。
mybatis.mapper-locations： xml 映射器的位置，*.xml 代表目录下所有的 xml 文件

spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&setUnicode=true&charterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

#整合mybatis
mybatis.type-aliases-package=com.example.pojo
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml

POJO 对象

package com.example.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

    private int id;
    private String name;
    private String pwd;

}

XML 映射器

在对应的标签中添加 sql 语句。
mapper 标签的 namespace 属性值为映射的接口类路径。
select、insert、update、delete 标签的 id 属性值为接口类下的方法，resultType 属性值为返回的对象类型。
标签详细的属性含义参见此处。

"1.0" encoding="UTF-8" ?>
mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
    <select id="queryUserList" resultType="User">
        select * from user
    select>

    <select id="queryUserById" resultType="User">
        select * from user where id = #{id}
    select>

    <insert id="addUser" parameterType="User">
        insert into user(id, name, pwd) values (#{id}, #{name}, #{pwd})
    insert>

    <update id="updateUser" parameterType="User">
        update user set name=#{name},pwd=#{pwd} where id = #{id}
    update>

    <delete id="deleteUser" parameterType="int">
        delete from user where id = #{id}
    delete>


mapper>

接口类

package com.example.mapper;

import com.example.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Mapper
@Repository
public interface UserMapper {
    List queryUserList();

    User queryUserById(int id);

    int addUser(User user);

    int updateUser(User user);

    int deleteUser(int id);
}

测试

新建控制器，添加 REST 请求接口。

package com.example.controller;

import com.example.mapper.UserMapper;
import com.example.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class UserController {

    @Autowired
    private UserMapper userMapper;

    @GetMapping("/queryUserList")
    public List queryUserList(){
        List userList = userMapper.queryUserList();
        for (User user : userList) {
            System.out.println(user);
        }
        return userList;
    }

    @GetMapping("/addUser")
    public String addUser(){
        userMapper.addUser(new User(5, "啊啊", "123123"));
        return "ok";
    }

    @GetMapping("/updateUser")
    public String updateUser(){
        userMapper.updateUser(new User(5, "AA", "123123"));
        return "ok";
    }

    @GetMapping("/deleteUser")
    public String deleteUser(){
        userMapper.deleteUser(5);
        return "ok";
    }

}

请求结果。

[
  {
    "id": 5,
    "name": "AA",
    "pwd": "123123"
  }
]

源码

参见此仓库

SpringBoot 中使用 Redis

2022-06-13T08:06:27.000Z

概述

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

最新版本的 Redis 文件可在 GitHub Releases 上获得。
首先要启动 redis-server，教程参见此处。

Maven 项目结构

springboot-10-redis├─src│  ├─main│  │  ├─java│  │  │  └─com│  │  │      └─example│  │  │          │  Springboot10RedisApplication.java│  │  │          ││  │  │          ├─config│  │  │          │      RedisConfig.java│  │  │          ││  │  │          ├─pojo│  │  │          │      User.java│  │  │          ││  │  │          └─utils│  │  │                  RedisUtil.java│  │  ││  │  └─resources│  │          application.properties│  ││  └─test│      └─java│          └─com│              └─example│                      Springboot10RedisApplicationTests.java

Pom.xml 依赖配置

"1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.5.6version>
        <relativePath/> 
    parent>
    <groupId>com.examplegroupId>
    <artifactId>springboot-10-redisartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>springboot-10-redisname>
    <description>Demo project for Spring Bootdescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-configuration-processorartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombokgroupId>
                            <artifactId>lombokartifactId>
                        exclude>
                    excludes>
                configuration>
            plugin>
        plugins>
    build>

project>

Redis 配置

package com.example.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    @ConditionalOnMissingBean(
            name = {"redisTemplate"}
    )
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        // json 序列化配置
        Jackson2JsonRedisSerializer Jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        Jackson2JsonRedisSerializer.setObjectMapper(om);

        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setValueSerializer(Jackson2JsonRedisSerializer);
        template.setHashValueSerializer(Jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

Application.properties 配置

#=====================redis ========
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379

Redis 工具类

package com.example.utils;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import lombok.extern.slf4j.Slf4j;


@Component
@Slf4j
public class RedisUtil {
    @Autowired
    private RedisTemplate redisTemplate;

    // =============================common============================

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete((Collection) CollectionUtils.arrayToList(key));
            }
        }
    }

    // ============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 递增 适用场景： https://blog.csdn.net/y_y_y_k_k_k_k/article/details/79218254 高并发生成订单号，秒杀类的业务逻辑等。。
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ================================Map=================================

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return
     */
    public Set sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            log.error(key, e);
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    // ============================zset=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return
     */
    public Set zSGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            log.error(key, e);
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean zSHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    public Boolean zSSet(String key, Object value, double score) {
        try {
            return redisTemplate.opsForZSet().add(key, value, 2);
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long zSSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long zSGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long zSetRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }
    // ===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始 0 是第一个元素
     * @param end   结束 -1代表所有值
     * @return
     * @取出来的元素 总数 end-start+1
     */
    public List lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            log.error(key, e);
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            log.error(key, e);
            return null;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            log.error(key, e);
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            log.error(key, e);
            return 0;
        }
    }

}

POJO 对象

package com.example.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;

@Component
@AllArgsConstructor
@NoArgsConstructor
@Data
public class User {

    private String name;
    private int age;
}

Junit 测试

package com.example;

import com.example.pojo.User;
import com.example.utils.RedisUtil;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class Springboot10RedisApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private RedisUtil redisUtil;

    @Test
    public void test1(){
        redisUtil.set("name", "test3");
        System.out.println(redisUtil.get("name"));
    }

    @Test
    void contextLoads() {

        redisTemplate.opsForValue().set("k1", "v1");

        System.out.println(redisTemplate.opsForValue().get("k1"));
    }

    @Test
    public void test() throws JsonProcessingException {

        User user = new User("user", 11);

        String joinUser = new ObjectMapper().writeValueAsString(user);

        redisTemplate.opsForValue().set("user", joinUser);

        System.out.println(redisTemplate.opsForValue().get("user"));
    }

}

项目源码

参见此仓库

JavaScript 常用业务代码总结

2022-06-10T03:13:52.000Z

事件和选择器

// 元素选择器
$("p")
// #id 选择器
$("#test")
// .class 选择器
$(".test")

// 点击事件
$("p").click(function(){
    // 动作触发后执行的代码!!
});
// 添加一个或多个事件处理程序
$("p").on("click",function(){
    alert("段落被点击了。");
});

$(selector).on(event,childSelector,data,function)

参数	描述
event	必需。规定要从被选元素添加的一个或多个事件或命名空间。由空格分隔多个事件值，也可以是数组。必须是有效的事件。
childSelector	可选。规定只能添加到指定的子元素上的事件处理程序（且不是选择器本身，比如已废弃的 delegate() 方法）。
data	可选。规定传递到函数的额外数据。
function	可选。规定当事件发生时运行的函数。

Ajax 执行异步的 HTTP 请求方法

$.ajax({
    type: "get",
    async: true,
    url: '',
    dataType: "json",
    data: {},
    contentType: "application/json;charset=UTF-8",
    success: function(res) {
    },
    error: function(err) {
        console.log(err)
    },
    complete: function(res) {
        reload();
    }
})

下面的表格中列出了可能的名称/值：

名称	值/描述
async	布尔值，表示请求是否异步处理。默认是 true。
beforeSend(xhr)	发送请求前运行的函数。
cache	布尔值，表示浏览器是否缓存被请求页面。默认是 true。
complete(xhr,status)	请求完成时运行的函数（在请求成功或失败之后均调用，即在 success 和 error 函数之后）。
contentType	发送数据到服务器时所使用的内容类型。默认是：”application/x-www-form-urlencoded”。
context	为所有 AJAX 相关的回调函数规定 “this” 值。
data	规定要发送到服务器的数据。
dataFilter(data,type)	用于处理 XMLHttpRequest 原始响应数据的函数。
dataType	预期的服务器响应的数据类型。
error(xhr,status,error)	如果请求失败要运行的函数。
global	布尔值，规定是否为请求触发全局 AJAX 事件处理程序。默认是 true。
ifModified	布尔值，规定是否仅在最后一次请求以来响应发生改变时才请求成功。默认是 false。
jsonp	在一个 jsonp 中重写回调函数的字符串。
jsonpCallback	在一个 jsonp 中规定回调函数的名称。
password	规定在 HTTP 访问认证请求中使用的密码。
processData	布尔值，规定通过请求发送的数据是否转换为查询字符串。默认是 true。
scriptCharset	规定请求的字符集。
success(result,status,xhr)	当请求成功时运行的函数。
timeout	设置本地的请求超时时间（以毫秒计）。
traditional	布尔值，规定是否使用参数序列化的传统样式。
type	规定请求的类型（GET 或 POST）。
url	规定发送请求的 URL。默认是当前页面。
username	规定在 HTTP 访问认证请求中使用的用户名。
xhr	用于创建 XMLHttpRequest 对象的函数。

Layer 弹出层组件

特别说明：
事件需自己绑定，以下只展现调用代码。
 
//初体验

layer.alert('内容')
 
//询问框

layer.confirm('您是如何看待前端开发？', {
  btn: ['重要','奇葩'] //按钮
}, function(){
  layer.msg('的确很重要', {icon: 1});
}, function(){
  layer.msg('也可以这样', {
    time: 20000, //20s后自动关闭
    btn: ['明白了', '知道了']
  });
});
 
//提示层

layer.msg('一段提示信息');
 
//墨绿深蓝风

layer.alert('墨绿风格，点击确认看深蓝', {
  skin: 'layui-layer-molv' //样式类名
  ,closeBtn: 0
}, function(){
  layer.alert('偶吧深蓝style', {
    skin: 'layui-layer-lan'
    ,closeBtn: 0
    ,anim: 4 //动画类型
  });
});
//捕获页

layer.open({
  type: 1,
  shade: false,
  title: false, //不显示标题
  content: $('.layer_notice'), //捕获的元素，注意：最好该指定的元素要存放在body最外层，否则可能被其它的相对元素所影响
  cancel: function(){
    layer.msg('捕获就是从页面已经存在的元素上，包裹layer的结构', {time: 5000, icon:6});
  }
});
//页面层

layer.open({
  type: 1,
  skin: 'layui-layer-rim', //加上边框
  area: ['420px', '240px'], //宽高
  content: 'html内容'
});
//自定页

layer.open({
  type: 1,
  skin: 'layui-layer-demo', //样式类名
  closeBtn: 0, //不显示关闭按钮
  anim: 2,
  shadeClose: true, //开启遮罩关闭
  content: '内容'
});
//tips层

layer.tips('Hi，我是tips', '吸附元素选择器，如#id');
//iframe 层

layer.open({
  type: 2,
  title: 'layer mobile页',
  shadeClose: true,
  shade: 0.8,
  area: ['380px', '90%'],
  content: 'mobile/' //iframe的url
}); 
//iframe 层

layer.open({
  type: 2,
  title: '很多时候，我们想最大化看，比如像这个页面。',
  shadeClose: true,
  shade: false,
  maxmin: true, //开启最大化最小化按钮
  area: ['893px', '600px'],
  content: 'https://layui.jianwoo.cn'
});
//加载层

var index = layer.load(0, {shade: false}); //0代表加载的风格，支持0-2
//loading层

var index = layer.load(1, {
  shade: [0.1,'#fff'] //0.1透明度的白色背景
});
//小tips

layer.tips('我是另外一个tips，只不过我长得跟之前那位稍有些不一样。', '吸附元素选择器', {
  tips: [1, '#3595CC'],
  time: 4000
});
//prompt层

layer.prompt({title: '输入任何口令，并确认', formType: 1}, function(pass, index){
  layer.close(index);
  layer.prompt({title: '随便写点啥，并确认', formType: 2}, function(text, index){
    layer.close(index);
    layer.msg('演示完毕！您的口令：'+ pass +'
您最后写下了：'+text);
  });
});
//tab层

layer.tab({
  area: ['600px', '300px'],
  tab: [{
    title: 'TAB1', 
    content: '内容1'
  }, {
    title: 'TAB2', 
    content: '内容2'
  }, {
    title: 'TAB3', 
    content: '内容3'
  }]
});
//相册层

$.getJSON('test/photos.json?v='+new Date, function(json){
  layer.photos({
    photos: json //格式见API文档手册页
    ,anim: 5 //0-6的选择，指定弹出图片动画类型，默认随机
  });
});
//显示自动关闭倒计秒数

layer.alert('在标题栏显示自动关闭倒计秒数', {
  time: 5*1000
  ,success: function(layero, index){
    var timeNum = this.time/1000, setText = function(start){
      layer.title((start ? timeNum : --timeNum) + ' 秒后关闭', index);
    };
    setText(!0);
    this.timer = setInterval(setText, 1000);
    if(timeNum <= 0) clearInterval(this.timer);
  }
  ,end: function(){
    clearInterval(this.timer);
  }
});

Layui 表格

html>
<html>
<head>
  <meta charset="utf-8">
  <title>table模块快速使用title>
  <link rel="stylesheet" href="/layui/css/layui.css" media="all">
head>
<body>
 
<table id="demo" lay-filter="test">table>
 
<script src="/layui/layui.js">script>
<script>
layui.use('table', function(){
  var table = layui.table;
  
  //第一个实例
  table.render({
    elem: '#demo'
    ,height: 312
    ,url: '../../demo/table/user/-page=1&limit=30.js' //数据接口
    ,page: true //开启分页
    ,cols: [[ //表头
      {field: 'id', title: 'ID', width:80, sort: true, fixed: 'left'}
      ,{field: 'username', title: '用户名', width:80}
      ,{field: 'sex', title: '性别', width:80, sort: true}
      ,{field: 'city', title: '城市', width:80} 
      ,{field: 'sign', title: '签名', width: 177}
      ,{field: 'experience', title: '积分', width: 80, sort: true}
      ,{field: 'score', title: '评分', width: 80, sort: true}
      ,{field: 'classify', title: '职业', width: 80}
      ,{field: 'wealth', title: '财富', width: 135, sort: true}
    ]]
  });
  
});
script>
body>
html>

下面是目前 table 模块所支持的全部参数一览表，我们对重点参数进行了的详细说明，你可以点击下述表格最右侧的“示例”去查看

参数

类型

说明

示例值

elem

String/DOM

指定原始 table 容器的选择器或 DOM，方法渲染方式必填

“#demo”

cols

Array

设置表头。值是一个二维数组。方法渲染方式必填

详见表头参数

url（等）

异步数据接口相关参数。其中 url 参数为必填项

详见异步参数

toolbar

String/DOM/Boolean

开启表格头部工具栏区域，该参数支持四种类型值：toolbar: ‘#toolbarDemo’ //指向自定义工具栏模板选择器toolbar: ‘

xxx

‘ //直接传入工具栏模板字符toolbar: true //仅开启工具栏，不显示左侧模板toolbar: ‘default’ //让工具栏左侧显示默认的内置模板注意： 1. 该参数为 layui 2.4.0 开始新增。 2. 若需要“列显示隐藏”、“导出”、“打印”等功能，则必须开启该参数

false

defaultToolbar

Array

该参数可自由配置头部工具栏右侧的图标按钮

详见头工具栏图标

width

Number

设定容器宽度。table容器的默认宽度是跟随它的父元素铺满，你也可以设定一个固定值，当容器中的内容超出了该宽度时，会自动出现横向滚动条。

1000

height

Number/String

设定容器高度

详见height

cellMinWidth

Number

（layui 2.2.1 新增）全局定义所有常规单元格的最小宽度（默认：60），一般用于列宽自动分配的情况。其优先级低于表头参数中的 minWidth

100

done

Function

数据渲染完的回调。你可以借此做一些其它的操作

详见 done 回调

error

Function

数据请求失败的回调，返回两个参数：错误对象、内容 layui 2.6.0 新增

data

Array

直接赋值数据。既适用于只展示一页数据，也非常适用于对一段已知数据进行多页展示。

[{}, {}, {}, {}, …]

escape

Boolean

是否开启 xss 字符过滤（默认 false）layui 2.6.8 新增

true

totalRow

Boolean/String

是否开启合计行区域

false

page

Boolean/Object

开启分页（默认：false）。支持传入一个对象，里面可包含 laypage 组件所有支持的参数（jump、elem除外）

{theme: ‘#c00’}

limit

Number

每页显示的条数（默认 10）。值需对应 limits 参数的选项。注意：优先级低于 page 参数中的 limit 参数

limits

Array

每页条数的选择项，默认：[10,20,30,40,50,60,70,80,90]。注意：优先级低于 page 参数中的 limits 参数

[30,60,90]

Boolean

是否显示加载条（默认 true）。若为 false，则在切换分页时，不会出现加载条。该参数只适用于 url 参数开启的方式

false

title

String

定义 table 的大标题（在文件导出等地方会用到）

“用户表”

text

Object

自定义文本，如空数据时的异常提示等。

详见自定义文本

autoSort

Boolean

默认 true，即直接由 table 组件在前端自动处理排序。若为 false，则需自主排序，即由服务端返回排序好的数据

详见事件排序

initSort

Object

初始排序状态。用于在数据表格渲染完毕时，默认按某个字段排序。

详见初始排序

String

设定容器唯一 id。id 是对表格的数据操作方法上是必要的传递条件，它是表格容器的索引，你在下文诸多地方都将会见识它的存在。另外，若该参数未设置，则默认从
中的 id 属性值中获取。

test

skin（等）

设定表格各种外观、尺寸等

详见表格风格

cols - 表头参数一览表

相信我，在你还尚无法驾驭 layui table 的时候，你的所有焦点都应放在这里，它带引领你完成许多可见和不可见甚至你无法想象的工作。如果你采用的是方法渲染，cols 是一个二维数组，表头参数设定在数组内；如果你采用的自动渲染，表头参数的设定应放在标签上

参数	类型	说明	示例值
field	String	设定字段名。非常重要，且是表格数据列的唯一标识	username
title	String	设定标题名称	用户名
width	Number/String	设定列宽，若不填写，则自动分配；若填写，则支持值为：数字、百分比。请结合实际情况，对不同列做不同设定。	200 30%
minWidth	Number	局部定义当前常规单元格的最小宽度（默认：60），一般用于列宽自动分配的情况。其优先级高于基础参数中的 cellMinWidth	100
type	String	设定列类型。可选值有：normal（常规列，无需设定）checkbox（复选框列）radio（单选框列，layui 2.4.0 新增）numbers（序号列）space（空列）	任意一个可选值
LAY_CHECKED	Boolean	是否全选状态（默认：false）。必须复选框列开启后才有效，如果设置 true，则表示复选框默认全部选中。	true
fixed	String	固定列。可选值有：left（固定在左）、right（固定在右）。一旦设定，对应的列将会被固定在左或右，不随滚动条而滚动。注意：如果是固定在左，该列必须放在表头最前面；如果是固定在右，该列必须放在表头最后面。	left（同 true） right
hide	Boolean	是否初始隐藏列，默认：false。layui 2.4.0 新增	true

totalRow	Boolean/String	是否开启该列的自动合计功能，默认：false。当开启时，则默认由前端自动合计当前行数据。从 layui 2.5.6 开始：若接口直接返回了合计行数据，则优先读取接口合计行数据，格式如下：`code{ "code": 0, "totalRow": { "score": "666" ,"experience": "999" }, "data": [{}, {}], "msg": "", "count": 1000}` 如上，在 totalRow 中返回所需统计的列字段名和值即可。另外，totalRow 字段同样可以通过 parseData 回调来解析成为 table 组件所规定的数据格式。从 layui 2.6.3 开始，如果 totalRow 为一个 string 类型，则可解析为合计行的动态模板，如：`codetotalRow: '{{ d.TOTAL_NUMS }} 单位'//还比如只取整：'{{ parseInt(d.TOTAL_NUMS) }}'`	true
totalRowText	String	用于显示自定义的合计文本。layui 2.4.0 新增	“合计：”

sort	Boolean	是否允许排序（默认：false）。如果设置 true，则在对应的表头显示排序icon，从而对列开启排序功能。注意：不推荐对值同时存在“数字和普通字符”的列开启排序，因为会进入字典序比对。比如：’贤心’ > ‘2’ > ‘100’，这可能并不是你想要的结果，但字典序排列算法（ASCII码比对）就是如此。	true
unresize	Boolean	是否禁用拖拽列宽（默认：false）。默认情况下会根据列类型（type）来决定是否禁用，如复选框列，会自动禁用。而其它普通列，默认允许拖拽列宽，当然你也可以设置 true 来禁用该功能。	false
edit	String	单元格编辑类型（默认不开启）目前只支持：text（输入框）	text
event	String	自定义单元格点击事件名，以便在 tool 事件中完成对该单元格的业务处理	任意字符
style	String	自定义单元格样式。即传入 CSS 样式	background-color: #5FB878; color: #fff;
align	String	单元格排列方式。可选值有：left（默认）、center（居中）、right（居右）	center
colspan	Number	单元格所占列数（默认：1）。一般用于多级表头	3
rowspan	Number	单元格所占行数（默认：1）。一般用于多级表头	2
templet	String	自定义列模板，模板遵循 laytpl 语法。这是一个非常实用的功能，你可借助它实现逻辑处理，以及将原始数据转化成其它格式，如时间戳转化为日期字符等	详见自定义模板
toolbar	String	绑定工具条模板。可在每行对应的列中出现一些自定义的操作性按钮	详见行工具事件

Layui 表单

在一个容器中设定 class=”layui-form” 来标识一个表单元素块，通过规范好的HTML结构及CSS类，来组装成各式各样的表单元素，并通过内置的 form模块 来完成各种交互。

依赖加载模块：form （请注意：如果不加载form模块，select、checkbox、radio等将无法显示，并且无法使用form相关功能）

UI的最终呈现得益于 Form模块的全自动渲染，她将原本普通的诸如select、checkbox、radio等元素重置为你所看到的模样。

渲染

尽管 form 会对表单进行自动渲染，但当元素动态插入时，需通过核心方法 form.render(type, filter) 来进行渲染。
其中参数 type为表单的元素类型，可选。默认对全部类型的表单进行一次渲染。也可指向 type 进行渲染：

type	描述
select	渲染 select 选择框
checkbox	渲染 checkbox 复选框（含开关）
radio	渲染 radio 单选框框

// 示例
var form = layui.form;
 
// 一般当表单存在动态生成时，进行渲染
form.render(); // 渲染全部
form.render('select'); //渲染 select 选择框

第二个参数 filter 为 class=”layui-form” 所在元素的 lay-filter=”” 的值。你可以借助该参数，对表单完成区域渲染。

<div class="layui-form" lay-filter="test1">
  …
div>
      
<script>
layui.use('form', function(){
  var form = layui.form;
 
  // 一般当表单存在动态生成时，进行渲染
  form.render(null, 'test1'); // 渲染所在容器内的全部表单
  form.render('select', 'test1'); // 渲染所在容器内的 select 元素
});
script>

定向渲染 - 注：v2.7.0 新增

<div class="layui-form">
  <select id="select-id">
    <option value="a">Aoption>
  select>
div>
 
<script> 
layui.use('form', function(){
  var $ = layui.$;
  var form = layui.form;
  
  // 定向渲染（一般当表单存在动态生成时，进行渲染）
  form.render($('#select-id')); // 传入需要渲染的相应表单元素的 jQuery 对象 
});
script>

属性

事实上在使用表单时，你的一半精力可能会在元素本身上。所以我们把一些基础属性的配置恰恰安放在了标签本身上。如：

1
2
3

<input type="text" lay-verify="email">
<input type="checkbox" checked lay-skin="switch" lay-filter="encrypt" title="是否加密">
<button lay-submit>提交button>

上述 lay- 前缀的属性即是表单所能识别的元素属性，他们可以使得一些交互操作交由 form 模块内部处理，或者借助 form 提供的 api 精确操作。目前我们可支持的属性如下表所示：

属性名	属性值	说明
title	任意字符	设定元素名称，一般用于 checkbox、radio 框
lay-filter	任意字符	过滤器，主要用于事件匹配
lay-search	default （等同空字符） cs （区分字母大小写）	用于给 select 开启搜索功能。默认不区分字母大小写（注：v2.7.0 新增）
lay-skin	switch（开关风格） primary（原始风格）	定义元素的风格，目前只对 checkbox 元素有效，可将其转变为开关样式
lay-ignore	任意字符或不设值	是否忽略元素美化处理。设置后，将不会对该元素进行初始化渲染，即保留系统风格
lay-verify	required（必填项） phone（手机号） email（邮箱） url（网址） number（数字） date（日期） identity（身份证）自定义值	同时支持多条规则的验证，格式：`lay-verify=”验证A
lay-verType	tips（吸附层） alert（对话框） msg（默认）	用于定义异常提示层模式。
lay-reqText	任意字符	用于自定义必填项（即设定了 lay-verify=”required” 的表单）的提示文本
lay-submit	无需填写值	绑定触发提交的元素，如button

API

var form = layui.form; // 获得 form 模块对象
 
form.render(type, filter); // 渲染 - 核心方法
form.validate(elem); // 执行验证，elem 为需要验证的区域选择器或 DOM 对象  注：v2.7.0 新增
form.verify(obj); // 定义表单验证的规则（详见下文）
form.on('event(filter)', callback); // 事件
form.val(filter, object); // 表单赋值或取值。 如果 object 参数存在，则为赋值，否则为取值。
form.submit(filter, callback); // 用于执行指定表单的提交 注：v2.7.0 新增
form.config; // 获取 form 模块的配置信息
form.set(options); // 设置 form 的配置信息

事件

语法：form.on('event(filter)', callback);

event	描述
select	触发select下拉选择事件
checkbox	触发checkbox复选框勾选事件
switch	触发checkbox复选框开关事件
radio	触发radio单选框事件
submit	触发表单提交事件

默认情况下，事件所触发的是全部的 form 模块元素，但如果你只想触发某一个元素，使用事件过滤器即可。
如：

1
2
3

form.on('select(test)', function(data){
  console.log(data);
});

select 事件

下拉选择框被选中时触发，回调函数返回一个object参数，携带两个成员：

form.on('select(filter)', function(data){
  console.log(data.elem); //得到select原始DOM对象
  console.log(data.value); //得到被选中的值
  console.log(data.othis); //得到美化后的DOM对象
});

请注意：如果你想触发所有的select，去掉过滤器*(filter)*即可。下面将不再对此进行备注。

checkbox 事件

复选框点击勾选时触发，回调函数返回一个object参数，携带两个成员：

form.on('checkbox(filter)', function(data){
  console.log(data.elem); //得到checkbox原始DOM对象
  console.log(data.elem.checked); //是否被选中，true或者false
  console.log(data.value); //复选框value值，也可以通过data.elem.value得到
  console.log(data.othis); //得到美化后的DOM对象
});

switch 事件

开关被点击时触发，回调函数返回一个object参数，携带两个成员：

form.on('switch(filter)', function(data){
  console.log(data.elem); //得到checkbox原始DOM对象
  console.log(data.elem.checked); //开关是否开启，true或者false
  console.log(data.value); //开关value值，也可以通过data.elem.value得到
  console.log(data.othis); //得到美化后的DOM对象
});

radio 事件

radio单选框被点击时触发，回调函数返回一个object参数，携带两个成员：

form.on('radio(filter)', function(data){
  console.log(data.elem); //得到radio原始DOM对象
  console.log(data.value); //被点击的radio的value值
});

submit 事件

按钮点击或者表单被执行提交时触发，其中回调函数只有在验证全部通过后才会进入，回调返回三个成员：

form.on('submit(*)', function(data){
  console.log(data.elem) //被执行事件的元素DOM对象，一般为button对象
  console.log(data.form) //被执行提交的form对象，一般在存在form标签时才会返回
  console.log(data.field) //当前容器的全部表单字段，名值对形式：{name: value}
  return false; //阻止表单跳转。如果需要表单跳转，去掉这段即可。
});

再次温馨提示：上述的*submit(*)*中的 *** 号为事件过滤器的值，是在你绑定执行提交的元素时设定的，如：

1	`<button lay-submit lay-filter="*">提交button>`

你可以把号换成任意的值，如：lay-filter=”go”*，但触发事件时也要改成 form.on(‘submit(go)’, callback);

执行提交方法：

有时我们未必要通过点击表单内的按钮来进行提交，这时需要用到提交方法：form.submit(filter, callback);

class="layui-form" lay-filter="test1">
  

 
<button id="testSubmitBtn">任意位置按钮button>
 
<script>
layui.use('form', function(){ 
  var form = layui.form;
  
  //方法提交
  $('#testSubmitBtn').on('click', function(data){
    form.submit('test1', function(data){ // 注：v2.7.0 新增
      // 回调函数返回结果跟上述 submit 事件完全一致
      var field = data.field;
      // do something
    });
    return false;
  });
});
script>

表单赋值 / 取值

语法：form.val(‘filter’, object);

用于给指定表单集合的元素赋值和取值。如果 object 参数存在，则为赋值；如果 object 参数不存在，则为取值。
注：其中「取值」功能为 layui 2.5.5 开始新增

//给表单赋值
form.val("formTest", { //formTest 即 class="layui-form" 所在元素属性 lay-filter="" 对应的值
  "username": "贤心" // "name": "value"
  ,"sex": "女"
  ,"auth": 3
  ,"check[write]": true
  ,"open": false
  ,"desc": "我爱layui"
});
 
//获取表单区域所有值
var data1 = form.val("formTest");

第二个参数中的键值是表单元素对应的 name 和 value。

表单验证

我们对表单的验证进行了非常巧妙的支持，大多数时候你只需要在表单元素上加上 lay-verify=”” 属性值即可。如：

<input type="text" lay-verify="email"> 
 
还同时支持多条规则的验证，如下：
<input type="text" lay-verify="required|phone|number">

上述对输入框定义了一个邮箱规则的校验，它会在 form 模块内部完成。目前我们内置的校验支持见上文的：预设元素属性

定义验证规则

除了内置的校验规则外，你还可以自定义验证规则，通常对于比较复杂的校验，这是非常有必要的。

form.verify({
  username: function(value, item){ //value：表单的值、item：表单的DOM对象
    if(!new RegExp("^[a-zA-Z0-9_\u4e00-\u9fa5\\s·]+$").test(value)){
      return '用户名不能有特殊字符';
    }
    if(/(^\_)|(\__)|(\_+$)/.test(value)){
      return '用户名首尾不能出现下划线\'_\'';
    }
    if(/^\d+\d+\d$/.test(value)){
      return '用户名不能全为数字';
    }
    
    //如果不想自动弹出默认提示框，可以直接返回 true，这时你可以通过其他任意方式提示（v2.5.7 新增）
    if(value === 'xxx'){
      alert('用户名不能为敏感词');
      return true;
    }
  }
  
  //我们既支持上述函数式的方式，也支持下述数组的形式
  //数组的两个值分别代表：[正则匹配、匹配不符时的提示文字]
  ,pass: [
    /^[\S]{6,12}$/
    ,'密码必须6到12位，且不能出现空格'
  ] 
});

当你自定义了类似上面的验证规则后，你只需要把 key 赋值给输入框的 lay-verify 属性即可：

1
2
3

code<input type="text" name="username" lay-verify="username"><input type="password" name="pass" lay-verify="pass"><input type="chtext" name="username" lay-verify="username">
<input type="password" name="pass" lay-verify="pass">
<input type="checkbox" name="agreement" lay-verify="required" title="同意">eckbox" name="agreement" lay-verify="required" title="同意">

当表单提交时，自动触发验证

var layer = layui.layer;
var form = layui.form;
 
// 提交事件
form.on('submit(*)', function(data){
  var field = data.field;
  
  // 若需验证 checkbox 是否勾选，则需判断其值是否存在，如：
  if(!field.agreement){
    layer.msg('请同意');
    return false;
  }
  
  // 验证均通过后的操作（如 Ajax 提交）
  // …
  
  return false;
});

主动触发验证

方法：form.validate(elem); 若验证通过返回 true，否则 false

<div class="layui-form">  
  <div class="layui-form-item">
    <label class="layui-form-label">手机label>
    <div class="layui-input-block">
      <input type="tel" name="phone" lay-verify="required|phone" class="layui-input demo-phone">
    div>
  div>
  <div class="layui-form-item">
    <label class="layui-form-label">验证码label>
    <div class="layui-input-inline">
      <input type="text" name="vercode" lay-verify="required" class="layui-input">
    div>
    <div class="layui-inline"> 
      <button type="button" class="layui-btn layui-btn-primary" lay-on="get-vercode">获取验证码button>
    div>
  div>
div>
 
<script>
layui.use(['form', 'util'], function(){
  var form = layui.form;
  var layer = layui.layer;
  var util = layui.util;
  
  // 自定义普通事件
  util.on('lay-on', {
    "get-vercode": function(othis){
      var isValid = form.validate('.demo-phone');  // 注：v2.7.0 新增
  
      // 验证通过
      if(isValid){
        layer.msg('手机号验证通过，执行发送验证码的操作');
      }
    }
  });
});
script>

Layui 日期与时间选择

Layui 上传文件

更多支持的参数详见下表，合理的配置它们，应对各式各样的业务需求。

参数选项	说明	类型	默认值
elem	指向容器选择器，如：elem: ‘#id’。也可以是DOM对象	string/object	-
url	服务端上传接口，返回的数据规范请详见下文	string	-
data	请求上传接口的额外参数。如：data: {id: ‘xxx’} 从 layui 2.2.6 开始，支持动态值，如:`codedata: { id: function(){ return $('#id').val(); }}`	object	-
headers	接口的请求头。如：headers: {token: ‘sasasas’}。注：该参数为 layui 2.2.6 开始新增
accept	指定允许上传时校验的文件类型，可选值有：images（图片）、file（所有文件）、video（视频）、audio（音频）	string	images
acceptMime	规定打开文件选择框时，筛选出的文件类型，值为用逗号隔开的 MIME 类型列表。如： acceptMime: ‘image/‘（只显示图片文件） acceptMime: ‘image/jpg, image/png’*（只显示 jpg 和 png 文件）注：layui 2.2.6 新增	string	images
exts	允许上传的文件后缀。一般结合 accept 参数类设定。假设 accept 为 file 类型时，那么你设置 exts: ‘zip\|rar\|7z’ 即代表只允许上传压缩格式的文件。如果 accept 未设定，那么限制的就是图片的文件格式	string	jpg\|png\|gif\|bmp\|jpeg
auto	是否选完文件后自动上传。如果设定 false，那么需要设置 bindAction 参数来指向一个其它按钮提交上传	boolean	true
bindAction	指向一个按钮触发上传，一般配合 auto: false 来使用。值为选择器或DOM对象，如：bindAction: ‘#btn’	string/object	-
force	规定强制返回的数据格式，默认不强制。若值为 ‘json’，则强制为 JSON 数据格式注：layui 2.6.9 新增	string	null
field	设定文件域的字段名	string	file
size	设置文件最大可允许上传的大小，单位 KB。不支持ie8/9	number	0（即不限制）
multiple	是否允许多文件上传。设置 true即可开启。不支持ie8/9	boolean	false
number	设置同时可上传的文件数量，一般配合 multiple 参数出现。注意：该参数为 layui 2.2.3 开始新增	number	0（即不限制）
drag	是否接受拖拽的文件上传，设置 false 可禁用。不支持ie8/9	boolean	true
回调
choose	选择文件后的回调函数。返回一个object参数，详见下文	function	-
before	文件提交上传前的回调。返回一个object参数（同上），详见下文	function	-
done	执行上传请求后的回调。返回三个参数，分别为：res（服务端响应信息）、index（当前文件的索引）、upload（重新上传的方法，一般在文件上传失败后使用）。详见下文	function	-
error	执行上传请求出现异常的回调（一般为网络异常、URL 404等）。返回两个参数，分别为：index（当前文件的索引）、upload（重新上传的方法）。详见下文	function	-

如何判断 JavaScript 对象是否为空

Object.keys()

1
2
3

function isEmpty(obj) {
    return Object.keys(obj).length === 0;
}

for…in…

for (var i in obj) { // 如果不为空，则会执行到这一步，返回true
    return true
}
return false // 如果为空,返回false

JSON.stringify()

if (JSON.stringify(data) === '{}') {
    return false // 如果为空,返回false
}
return true // 如果不为空，则会执行到这一步，返回true

Json 数据解析

JSON.parse()

JSON 通常用于与服务端交换数据。

在接收服务器数据时一般是字符串。

我们可以使用 JSON.parse() 方法将数据转换为 JavaScript 对象。

语法

1	`JSON.parse(text[, reviver])`

参数说明：

text: 必需，一个有效的 JSON 字符串。
reviver: 可选，一个转换结果的函数，将为对象的每个成员调用此函数。

JSON 解析实例

例如我们从服务器接收了以下数据：

1	`{ "name":"runoob", "alexa":10000, "site":"www.runoob.com" }`

我们使用 JSON.parse() 方法处理以上数据，将其转换为 JavaScript 对象：

1	`var obj = JSON.parse('{ "name":"runoob", "alexa":10000, "site":"www.runoob.com" }');`

JSON.stringify()

JSON 通常用于与服务端交换数据。

在向服务器发送数据时一般是字符串。

我们可以使用 JSON.stringify() 方法将 JavaScript 对象转换为字符串。

语法

1	`JSON.stringify(value[, replacer[, space]])`

参数说明：

value:
必需，要转换的 JavaScript 值（通常为对象或数组）。
replacer:
可选。用于转换结果的函数或数组。
如果 replacer 为函数，则 JSON.stringify 将调用该函数，并传入每个成员的键和值。使用返回值而不是原始值。如果此函数返回 undefined，则排除成员。根对象的键是一个空字符串：””。
如果 replacer 是一个数组，则仅转换该数组中具有键值的成员。成员的转换顺序与键在数组中的顺序一样。当 value 参数也为数组时，将忽略 replacer 数组。
space:
可选，文本添加缩进、空格和换行符，如果 space 是一个数字，则返回值文本在每个级别缩进指定数目的空格，如果 space 大于 10，则文本缩进 10 个空格。space 也可以使用非数字，如：\t。

JavaScript 对象转换

例如我们向服务器发送以下数据：

1	`var obj = { "name":"runoob", "alexa":10000, "site":"www.runoob.com"};`

我们使用 JSON.stringify() 方法处理以上数据，将其转换为字符串：

1	`var myJSON = JSON.stringify(obj);`

JavaScript 删除数组元素

splice() 方法

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1); // 第二个参数为删除的次数，设置只删除一次
}

// array = [2, 9]
console.log(array);

delete 关键字

var colors = ["red", "blue", "grey", "green"];

delete colors[0];

console.log(colors); // [undefined, "blue", "grey", "green"]

Java 常用业务代码总结

2022-06-10T03:13:27.000Z

遍历文件夹下的所有文件

public static ArrayList readFiles(File file){
    ArrayList list = new ArrayList<>();
    File[] fs = file.listFiles();
    assert fs != null;
    for (File f : fs) {
        // 若是目录，则递归读取
        if (f.isDirectory()) {
            readFiles(f);
        }
        // 若是文件，添加到集合
        if (f.isFile()) {
            list.add(f);
        }
    }
    return list;
}

导出Excel

public void exportData(List> data, Map headerMap, String title, HttpServletResponse response) {
    // 通过工具类创建writer，默认创建xls格式
    ExcelWriter writer = ExcelUtil.getWriter();
    writer.merge(headerMap.size() - 1, title);
    for (Map stringObjectMap : data) {
        List removeKeys = new LinkedList<>();
        for (String stringObjectKey : stringObjectMap.keySet()) {
            if (!headerMap.containsKey(stringObjectKey)) {
                removeKeys.add(stringObjectKey);
            }
        }
        for (String removeKey : removeKeys) {
            stringObjectMap.remove(removeKey);
        }
    }
    writer.setHeaderAlias(headerMap);
    // 一次性写出内容，使用默认样式，强制输出标题
    writer.write(data, true);
    int i = 0;
    while (i < data.size()) {
        //自动宽度
        writer.autoSizeColumn(i);
        i++;
    }
    //out为OutputStream，需要写出到的目标流
    //response为HttpServletResponse对象
    response.setContentType("application/vnd.ms-excel;charset=utf-8");
    //devices.xls是弹出下载对话框的文件名，不能为中文，中文请自行编码
    try {
        response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(title + ".xls", "utf-8"));
    } catch (Exception e) {
        e.printStackTrace();
    }
    ServletOutputStream out = null;
    try {
        out = response.getOutputStream();
    } catch (IOException e) {
        e.printStackTrace();
    }
    writer.flush(out);
    // 关闭writer，释放内存
    writer.close();
    //此处记得关闭输出Servlet流
    IoUtil.close(out);
}

接口接收 Json 数组对象

1
2
3

@PostMapping("example")
public void example(@RequestBody List exampleDtoList) {
}

接口通用返回泛型数据的格式

@ApiModel(value = "通用返回格式")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ResultModel implements Serializable {

    private static final long serialVersionUID = 1L;

    @ApiModelProperty(value = "返回状态码（0成功，-1失败）")
    public int code;

    @ApiModelProperty(value = "返回消息")
    public String message;

    @ApiModelProperty(value = "返回数据")
    public T data;

    public static ResultModel success() {
        return new ResultModel<>(ResultEnums.SUCCESS.getCode(), ResultEnums.SUCCESS.getMessage(), null);
    }

 
    public static ResultModel success(T data) {
        return new ResultModel<>(ResultEnums.SUCCESS.getCode(), ResultEnums.SUCCESS.getMessage(), data);
    }


    public static ResultModel success(T data, String message) {
        return new ResultModel<>(ResultEnums.SUCCESS.getCode(), message, data);
    }


    public static ResultModel fail(String message) {
        return new ResultModel<>(ResultEnums.FAIL.getCode(), message, null);
    }


    public static ResultModel fail(int code, String message) {
        return new ResultModel<>(code, message, null);
    }


    public static ResultModel fail(int code, String message, T data) {
        return new ResultModel<>(code, message, data);
    }
}

开启定时任务

package com.example.cron;

import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
@EnableScheduling
public class exampleCron {

    /**
     * 每天凌晨执行一次
     */
    @Scheduled(cron = "1 * * * * ?")
    public void example() {
    }
}

开启事务

1	`@Transactional(rollbackFor = Exception.class)`

判断多个线程结束

public static void threadIsOver(ArrayList threads, long start){
    int size = threads.size();
    HashSet died = new HashSet<>();
    do {
        for (SearchByTime thread : threads) {
            if (!thread.isAlive()) {
                died.add(thread.getId());
            }
        }
    } while (size != died.size());
    long end = System.currentTimeMillis();
    System.out.println("\033[42m所有线程执行完毕" +
                       "，线程数："+ size +
                       "，用时: " + (end - start) / 1000 + "s" + "\033[0m"
                      );
}

package com.example.thread;

public class SearchByTime extends Thread {
    
    @Override
    public void run() {
    }
}

请求接口

public static JSONArray get(String apiFrom, String startTime, String endTime, String timeType) {
    String baseUrl = "";
    String url = baseUrl + apiFrom
        + "?start_time=" + startTime + "&"
        + "end_time=" + endTime + "&"
        + "time_type=" + timeType;
    url = url.replaceAll(" ", "%20");
    HttpResponse response = HttpRequest.get(url)
        .header("charset", "UTF-8")
        .timeout(60000 * 5)
        .execute();
    JSONObject jsonObject = JSONObject.parseObject(response.body());
    Object code = jsonObject.get("code");
    String msg = (String) jsonObject.get("msg");
    JSONArray data = jsonObject.getJSONArray("result");
    Integer successCode = 2000;
    if (!successCode.equals(code)) {
        logger.info(msg + "\n获取接口数据失败，接口地址：" + url);
        return new JSONArray();
    }
    return data;
}

private JSONArray post(String token) {
    JSONObject params = new JSONObject();
    params.put("pageSize", 1000);
    params.put("currentPage", currentPage);
    HttpResponse response = HttpRequest.post(baseUrl + "xx")
        .header("Content-Type", "application/json")
        .header("charset", "UTF-8")
        .header("Authorization", token)
        .body(params.toJSONString())
        .execute();

    JSONObject JsonObject = JSONObject.parseObject(response.body());
    Object code = JsonObject.get("code");
    JSONArray data = JsonObject.getJSONArray("data");
    if (!successCode.equals(code)) {
        logger.info("获取接口数据失败");
    }
    return data;
}

文件上传下载

package com.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.commons.CommonsMultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.net.URLEncoder;

@Controller
public class FileController {

    //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
    //批量上传CommonsMultipartFile则为数组即可
    @RequestMapping("/upload")
    public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {

        //获取文件名 : file.getOriginalFilename();
        String uploadFileName = file.getOriginalFilename();

        //如果文件名为空，直接回到首页！
        if ("".equals(uploadFileName)){
            return "redirect:/index.jsp";
        }
        System.out.println("上传文件名 : "+uploadFileName);

        //上传路径保存设置
        String path = request.getServletContext().getRealPath("/upload");
        //如果路径不存在，创建一个
        File realPath = new File(path);
        if (!realPath.exists()){
            realPath.mkdir();
        }
        System.out.println("上传文件保存地址："+realPath);

        InputStream is = file.getInputStream(); //文件输入流
        OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流

        //读取写出
        int len=0;
        byte[] buffer = new byte[1024];
        while ((len=is.read(buffer))!=-1){
            os.write(buffer,0,len);
            os.flush();
        }
        os.close();
        is.close();
        return "redirect:/index.jsp";
    }

    /*
     * 采用file.Transto 来保存上传的文件
     */
    @RequestMapping("/upload2")
    public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {

        //上传路径保存设置
        String path = request.getServletContext().getRealPath("/upload");
        File realPath = new File(path);
        if (!realPath.exists()){
            realPath.mkdir();
        }
        //上传文件地址
        System.out.println("上传文件保存地址："+realPath);

        //通过CommonsMultipartFile的方法直接写文件（注意这个时候）
        file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));

        return "redirect:/index.jsp";
    }

    @RequestMapping(value="/download")
    public String downloads(HttpServletResponse response , HttpServletRequest request) throws Exception{
        //要下载的图片地址
        String  path = request.getServletContext().getRealPath("/static");
        String  fileName = "1.jpg";
        System.out.println(path);
        //1、设置response 响应头
        response.reset(); //设置页面不缓存,清空buffer
        response.setCharacterEncoding("UTF-8"); //字符编码
        response.setContentType("multipart/form-data"); //二进制传输数据
        //设置响应头
        response.setHeader("Content-Disposition",
                "attachment;fileName="+ URLEncoder.encode(fileName, "UTF-8"));

        File file = new File(path,fileName);
        //2、 读取文件--输入流
        InputStream input=new FileInputStream(file);
        //3、 写出文件--输出流
        OutputStream out = response.getOutputStream();

        byte[] buff =new byte[1024];
        int index=0;
        //4、执行 写出操作
        while((index= input.read(buff))!= -1){
            out.write(buff, 0, index);
            out.flush();
        }
        out.close();
        input.close();
        return null;
    }
}

自动生成接口文档

/**
 * Swagger2的接口配置
 * 
 * @author loquy
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig
{
    /**
     * 创建API
     */
    @Bean
    public Docket createRestApi()
    {
        return new Docket(DocumentationType.SWAGGER_2)
                // 详细定制
                .apiInfo(apiInfo())
                .select()
                // 指定当前包路径
                .apis(RequestHandlerSelectors.basePackage("com.example.app.api"))
                // 扫描所有 .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build();
    }

    /**
     * 添加摘要信息
     */
    private ApiInfo apiInfo()
    {
        // 用ApiInfoBuilder进行定制
        return new ApiInfoBuilder()
                .title("标题")
                .description("描述")
                .version("版本号:1.01")
                .build();
    }
}

Bean 和 Map 的转换

package com.fjzxdz.ams.module.wryzl.utils;

import org.springframework.cglib.beans.BeanMap;

import java.util.HashMap;
import java.util.Map;

public class HashMapUtils {

    public static int calculateInitialCapacity(int expectedSize) {
        return (int) ((expectedSize / 0.75) + 1);
    }

    public static  Map beanToMap(T bean) {
        Map map = new HashMap<>(16);
        if (bean != null) {
            BeanMap beanMap = BeanMap.create(bean);
            for (Object key : beanMap.keySet()) {
                map.put(key + "", beanMap.get(key));
            }
        }
        return map;
    }

    public static  T mapToBean(Map map, Class clazz) throws Exception {
        T bean = clazz.newInstance();
        BeanMap beanMap = BeanMap.create(bean);
        beanMap.putAll(map);
        return bean;
    }
}

Oracle中分页查询语句

public HashMap getPageList(String listSql, String page, String pageSize) {
    List> list = simpleDao.getNativeQueryList("SELECT\n" +
            "\t* \n" +
            "FROM\n" +
            "\t(\n" +
            "SELECT\n" +
            "\ta.*,\n" +
            "\tROWNUM rn \n" +
            "FROM\n" +
            "\t(\n" + listSql +
            "\t) a \n" +
            "\t) \n" +
            "WHERE\n" +
            "\trn > ( " + page + " - 1 ) * " + pageSize + " \n" +
            "\tAND rn <= ( " + page + " ) * " + pageSize + "");

    List> countList = simpleDao.getNativeQueryList("SELECT\n" +
            "\tcount( * ) total\n" +
            "FROM\n" +
            "\t(\n" + listSql +
            "\t)");

    HashMap map = new HashMap<>(HashMapUtils.calculateInitialCapacity(4));
    map.put("list", list);
    map.put("total", countList.size() > 0 ? countList.get(0).get("total") : 0);
    map.put("page", Integer.valueOf(page));
    map.put("pageSize", Integer.valueOf(pageSize));

    return map;
}

构造树形结构

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class TreeEntity {
    private String uuid;
    private String pid;
    private List children;
    private Object value;
    private String name;

    public TreeEntity(String pid, Object value, String name) {
        this.uuid = UUID.randomUUID().toString();
        this.pid = pid;
        this.children = new ArrayList<>();
        this.value = value;
        this.name = name;
    }

    public String getUuid() {
        return uuid;
    }

    public void setUuid(String uuid) {
        this.uuid = uuid;
    }

    public String getPid() {
        return pid;
    }

    public void setPid(String pid) {
        this.pid = pid;
    }

    public List getChildren() {
        return children;
    }

    public void setChildren(List children) {
        this.children = children;
    }

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void addChild(TreeEntity child) {
        children.add(child);
    }

    public void removeChild(TreeEntity child) {
        children.remove(child);
    }
}


public static List buildTree(List nodes, boolean isSearch) {
    if (isSearch) {
        // 遍历节点，将uuid添加到nodeIds中
        Set nodeIds = new HashSet<>();
        for (TreeEntity node : nodes) {
            String nodeId = node.getUuid();
            nodeIds.add(nodeId);
        }

        // 找到所有没有父节点的节点，并将它们的pid设置为null
        for (TreeEntity node : nodes) {
            String pid = node.getPid();
            if (pid != null && !nodeIds.contains(pid)) {
                node.setPid(null);
            }
        }
    }

    // 按照pid进行分组，然后递归构造树
    Map> map = new HashMap<>();
    for (TreeEntity node : nodes) {
        String pid = node.getPid();
        List group = map.computeIfAbsent(pid, k -> new ArrayList<>());
        group.add(node);
    }

    List roots = map.get(null);
    if (roots != null) {
        for (TreeEntity root : roots) {
            buildSubTree(root, map);
        }
    }

    return roots;
}


private static void buildSubTree(TreeEntity node, Map> map) {
    String nodeId = node.getUuid();
    node.setValue(node.getUuid());
    List children = map.get(nodeId);
    node.setChildren(children);

    if (children != null) {
        for (TreeEntity child : children) {
            buildSubTree(child, map);
        }
    }
}

读取目录的所有文件后逐行写入新的文件

import java.io.*;
import java.nio.charset.StandardCharsets;

/**
 * @author loquy
 */
public class ReadFiles {

    public static void main(String[] args) {

        File fileE = new File("H:\\test.txt");

        if (fileE.exists()) {
            boolean delete = fileE.delete();
            System.out.println(delete);
        }

        File file = new File("H:\\");

        File writerFile = new File("H:\\test.txt");
        try {
            boolean newFile = writerFile.createNewFile();
            System.out.println(newFile);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        readFiles(file, writerFile);
    }

    public static void readFiles(File file, File writerFile) {
        File[] fs = file.listFiles();
        assert fs != null;
        for (File f : fs) {
            // 若是目录，则递归读取
            if (f.isDirectory()) {
                readFiles(f, writerFile);
            }
            // 不是 java 后缀跳过
            String suffix = f.getName().substring(f.getName().lastIndexOf(".") + 1);
            if (!"java".equals(suffix)) {
                continue;
            }
            if (f.isFile()) {
                try {
                    readAndWriterFile(f, writerFile);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void readAndWriterFile(File f, File writerFile) throws IOException {
        BufferedReader br;
        br = new BufferedReader(new FileReader(f.getPath()));
        String con;
        FileOutputStream fop = new FileOutputStream(writerFile, true);
        OutputStreamWriter writer = new OutputStreamWriter(fop, StandardCharsets.UTF_8);
        // 逐行读取
        while ((con = br.readLine()) != null) {
            // 跳过空行
            if (!"".equals(con)) {
                boolean is = false;
                // 跳过tab
                if (con.length() == 1) {
                    for (int i = 0; i < con.length(); i++) {
                        char c = con.charAt(i);
                        if ('\t' == c) {
                            is = true;
                            break;
                        }
                    }
                }
                if (!is) {
                    System.out.println(con);
                    writer.append(con);
                    writer.append("\n");
                }
            }
        }
        writer.close();
        fop.close();
        br.close();
    }
}

常用字符串操作

package com.example.demo.utils;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;

import java.text.ParseException;
import java.util.Date;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * The type Common String utils.
 *
 * @author loquy
 */
public class CommonStringUtils {

    private static final String[] IS_DATE_PATTERNS = {
            "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy/MM/dd",
            "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm"
    };

    /**
     * The constant IS_NUM_PATTERN.
     */
    public static final Pattern IS_NUM_PATTERN = Pattern.compile("-?[0-9]+(\\.[0-9]+)?");

    /**
     * The constant MESSY_CODE_PATTERN.
     */
    public static final Pattern MESSY_CODE_PATTERN = Pattern.compile("\\s*|\t*|\r*|\n*");

    /**
     * 解析字符串是否是日期
     *
     * @param string the string
     * @return the date
     */
    public static Date parseDate(String string) {
        if (string == null) {
            return null;
        }
        try {
            return DateUtils.parseDate(string, IS_DATE_PATTERNS);
        } catch (ParseException e) {
            return null;
        }
    }

    /**
     * 解析字符串是否是数字
     *
     * @param str the str
     * @return the boolean
     */
    public static boolean isNumeric(String str) {
        return IS_NUM_PATTERN.matcher(str).matches();
    }

    /**
     * 获取指定长度随机数
     *
     * @param len the len
     * @return the random
     */
    public static String getRandom(int len) {
        Random r = new Random();
        StringBuilder rs = new StringBuilder();
        for (int i = 0; i < len; i++) {
            rs.append(r.nextInt(10));
        }
        return rs.toString();
    }

    /**
     * 获取指定长度字符
     *
     * @param len       the len
     * @param character the character
     * @return the characters
     */
    public static String getCharacters(int len, String character) {
        StringBuilder rs = new StringBuilder();
        for (int i = 0; i < len; i++) {
            rs.append(character);
        }
        return rs.toString();
    }

    /**
     * 返回左移n位字符串方法
     *
     * @param str      the str
     * @param position the position
     * @return the string
     */
    public static String moveToLeft(String str, int position) {
        String str1 = str.substring(position);
        String str2 = str.substring(0, position);
        return str1 + str2;
    }

    /**
     * 返回右移n位字符串方法
     *
     * @param str      the str
     * @param position the position
     * @return the string
     */
    public static String moveToRight(String str, int position) {
        String str1 = str.substring(str.length() - position);
        String str2 = str.substring(0, str.length() - position);
        return str1 + str2;
    }

    /**
     * 检查字符串是否乱码
     *
     * @param strName the str name
     * @return the boolean
     */
    public static boolean isMessyCode(String strName) {
        try {
            Matcher m = MESSY_CODE_PATTERN.matcher(strName);
            String after = m.replaceAll("");
            String temp = after.replaceAll("\\p{P}", "");
            char[] ch = temp.trim().toCharArray();

            for (char c : ch) {
                if (!Character.isLetterOrDigit(c)) {
                    String str = "" + c;
                    if (!str.matches("[\u4e00-\u9fa5]+")) {
                        return true;
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        return false;
    }

    /**
     * 原始数据里匹配关键字替换成别的字符串
     */
    public static  String keywordReplacement(String rawData, String keyword, String replacementString) throws Exception {
        StringBuilder stringBuilder = new StringBuilder(rawData);

        Matcher m = Pattern.compile(keyword).matcher(stringBuilder);
        StringBuffer appendReplacement = new StringBuffer();
        while (m.find()) {
            m.appendReplacement(appendReplacement, replacementString);
        }
        if (StringUtils.isEmpty(appendReplacement)) {
            throw new Exception("原始数据里没有匹配到关键字");
        }
        m.appendTail(appendReplacement);

        return appendReplacement.toString();
    }
}

使用 WinSW 将任何程序设为 Windows 服务

2022-06-08T02:13:03.000Z

下载

最新版本和预发布的 WinSW 二进制文件可在 GitHub Releases 上获得。

使用

将 WinSW 用作捆绑工具

从发行版中获取 WinSW.exe 或 WinSW.zip，然后根据您的喜好重命名.exe（例如 myapp.exe）。
编写 myapp.xml 。
将这两个文件并排放置，因为这就是 WinSW 发现其相关配置的方式。
运行 myapp.exe install 以安装服务。
运行 myapp.exe start 以启动服务。

配置

您编写定义服务的配置文件。
下面的示例是 Jenkins 项目中使用的原始示例：

<service>
    <id>jenkinsid>
    <name>Jenkinsname>
    <description>This service runs Jenkins continuous integration system.description>
    <env name="JENKINS_HOME" value="%BASE%"/>
    <executable>javaexecutable>
    <arguments>-Xrs -Xmx256m -jar "%BASE%\jenkins.war" --httpPort=8080arguments>
    <log mode="roll">log>
service>

配置文件的完整规范可在此处获得。
您可以在此处找到更多示例。

命令

WinSW 由 XML 配置文件管理。

您重命名的 WinSW.exe 二进制文件还接受以下命令：

命令	说明
install	安装服务。
uninstall	卸载服务。
start	启动服务。
stop	停止服务。
restart	停止然后启动服务。
status	检查服务的状态。
refresh	无需重新安装即可刷新服务属性。
customize	自定义包装器可执行文件。

实验命令：

命令	说明
dev-ps	绘制与服务关联的进程树。
dev-kill	如果服务停止响应，则终止服务。
dev-list	列出由当前可执行文件管理的服务。

大多数命令需要管理员权限才能执行。WinSW 将在非提升会话中提示输入 UAC。

例子

Nacos

下载

最新版本的 Nacos 文件可在 GitHub Releases 上获得。

配置

编写 nacos-service.xml 配置执行 startup.cmd。

<service>
    <id>nacos serviceid>
    <name>Nacos Servicename>
    <description>Nacos-servicedescription>
    <logpath>H:\environment\nacos\bin\logs\logpath>
    <logmode>rolllogmode>
    <executable>H:\environment\nacos\bin\startup.cmdexecutable>
    <stopexecutable>H:\environment\nacos\bin\shutdown.cmdstopexecutable>
service>

安装

将 WinSW.exe 重命名为 nacos-service.exe 和 nacos-service.xml 放到同一个目录。
在 CMD 中运行 nacos-service.exe install。

Redis

下载

最新版本的 Redis 文件可在 GitHub Releases 上获得。

配置

编写 Redis.xml 配置执行 redis-server.exe。

<service>
 
 <id>Redisid>
 
 <name>Redisname>
 
 <description>Redisdescription>
 
 <executable>
     H:\environment\Redis-x64-5.0.14\redis-server.exe
 executable>
 
 <logpath>H:\environment\Redis-x64-5.0.14\loglogpath>
 
 <logmode>resetlogmode>
service>

安装

将 WinSW.exe 重命名为 Redis.exe 和 Redis.xml 放到同一个目录。
在 CMD 中运行 Redis.exe install。

VirtualBox

下载

最新版本的 VirtualBox 文件可在官网上获得。

配置

编写 startup.bat 执行脚本, 命令为启动两个虚拟机。

@ECHO OFF
cd C:\Program Files\Oracle\VirtualBox\
start VBoxManage.exe startvm  CentOS-Stream-9 --type headless
cd C:\Program Files\Oracle\VirtualBox\
start VBoxManage.exe startvm startvm cs --type headless
EXIT

编写 VirtualBox.xml 配置执行 startup.bat 文件。

<service>
 
 <id>VirtualBoxid>
 
 <name>VirtualBoxname>
 
 <description>VirtualBoxdescription>
 
 <executable>
     H:\environment\VirtualBox\startup.bat
 executable>
 
 <logpath>H:\environment\VirtualBox\loglogpath>
 
 <logmode>resetlogmode>
service>

安装

将 WinSW.exe 重命名为 VirtualBox.exe 和 VirtualBox.xml 放到同一个目录。
在 CMD 中运行 VirtualBox.exe install。

Sentinel

下载

最新版本的 Sentinel 文件可在 GitHub Releases 上获得。

配置

编写 startup.bat 执行脚本, 命令为启动 jar 包。

1
2
3

@ECHO OFF
java -Dserver.port=8718 -Dcsp.sentinel.dashboard.server=localhost:8718 -Dproject.name=sentinel-dashboard -jar "H:\environment\sentinel\sentinel-dashboard.jar"
EXIT

编写 sentinel-dashboard.xml 配置执行 startup.bat 文件。

<service>
 
 <id>sentinel-dashboardid>
 
 <name>sentinel-dashboardname>
 
 <description>sentinel-dashboarddescription>
 
 <executable>
     H:\environment\sentinel\startup.bat
 executable>
 
 <logpath>H:\environment\sentinel\loglogpath>
 
 <logmode>resetlogmode>
service>

安装

将 WinSW.exe 重命名为 sentinel-dashboard.exe 和 sentinel-dashboard.xml 放到同一个目录。
在 CMD 中运行 sentinel-dashboard.exe install。

参考

WinSW

GitLab 安装和使用

2021-07-01T01:27:14.000Z

环境

GitLab 官方安装要求

系统：可自由选择，我虚拟机上的是 CentOS Stream release 8CPU：4 核是建议的最低核数，最多支持 500 个用户内存：4GB RAM 是所需的最小内存大小，最多支持 500 个用户硬盘：必要的硬盘空间在很大程度上取决于您要存储在 GitLab 中的存储库的大小，但根据经验，您应该拥有至少与所有存储库组合占用的空间一样多的可用空间

安装

安装和配置必要的依赖项

sudo dnf install -y curl policycoreutils openssh-server perl
sudo systemctl enable sshd
sudo systemctl start sshd

# Check if opening the firewall is needed with: sudo systemctl status firewalld
sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https
sudo systemctl reload firewalld

下载 gitlab-ce 社区版的 rpm 包

1	`rpm -ivh gitlab-ce-12.10.0-ce.0.el8.x86_64.rpm`

修改 gitlab 默认配置
编辑 /etc/gitlab/gitlab.rb 搜索 external_url
把后面的地址修改为你自己的域名或者 IP，是单引号，而且前面的 http 不要改
默认填写 http:// 加上本机 IP 即可，如需自定义域名需加入到 /etc/hosts 中

1	`vim /etc/gitlab/gitlab.rb`

重新加载配置后重启 gitlab

1 2	`gitlab-ctl reconfigure gitlab-ctl restart`

使用

初始化账户与创建仓库

打开浏览器输入配置的 external_url进行初始化账户设定密码，这个密码为 root 管理员账户的密码设置完密码之后会自动跳转到登录页面可以使用 root 登录，也可以在登录界面创建一个账户登录，登录后创建仓库

安装 Git 后配置 SSH-Key

安装 Git 安装后设置你的用户名和邮件地址

1 2	`git config --global user.name "John Doe" git config --global user.email johndoe@example.com`

在 Git Bash 上生成 SSH-Key

1	`ssh-keygen -t rsa -C 'email' -f ~/.ssh/local_gitlab_rsa`

在 ~/.ssh 目录下新建一个 config 文件

1
2
3

#gitlab
HostName gitlab 的主机 IP
IdentityFile  ~/.ssh/local_gitlab_rsa

添加秘钥
点击右上角头像，Settings -> SSH
把刚刚生成的 ~/.ssh/local_gitlab_rsa.pua 文件的内容粘贴上
添加一个 Title，然后 Add Key
Git 工作流

git clone
git add
git commit
git push
git pull
...

参考

在 PHP 中使用单元测试

2021-05-30T00:17:04.000Z

PHPUnit 的安装和配置

目前支持的版本是PHPUnit 9

安装

PHP 档案包（PHAR）

➜ wget -O phpunit https://phar.phpunit.de/phpunit-9.phar➜ chmod +x phpunit➜ ./phpunit --versionPHPUnit 9.0.0 by Sebastian Bergmann and contributors.

Composer

➜ composer require --dev phpunit/phpunit ^9➜ ./vendor/bin/phpunit --versionPHPUnit 9.0.0 by Sebastian Bergmann and contributors.

配置

XML 配置文件

用于编排测试套件，示例如下：

<phpunit bootstrap="./bootstrap.php"
         colors="true"
         verbose="true"
>

    <php>
        <ini name="error_reporting" value="-1"/>
    php>

    <testsuites>
        <testsuite name="test">
            <directory>./Tests/directory>
        testsuite>
    testsuites>

phpunit>

Bootstrap 启动文件

在启动 PHPUnit 时会加载的文件，用于自动加载依赖等，示例如下：



$classNameMap = [
    'single' => __DIR__ . DIRECTORY_SEPARATOR . 'single',
];

spl_autoload_register(function($className) use ($classNameMap) {
    $position = strpos($className, '\\');
    if ($position) {
        $namespace = substr($className, 0, $position);
        $directory = $classNameMap[$namespace] ?? '';
        if ($directory) {
            $classFile = $directory . substr($className, $position) . '.php';
            is_file($classFile) && require $classFile;
        }
    }
});

在 PhpStorm 里配置使用

文件 -> 设置 -> PHP，设置 cli 解释器。
文件 -> 设置 -> PHP -> 测试框架，设置 phpunit.phar 路径或 composer 下的 phpunit 路径，设置 xml 配置文件。
使用 IDE 自动帮我们执行 PHPUnit 的命令，便不用手动操作了，测试时只需点击文件里的执行按钮即可。

编写 PHPUnit 测试

步骤

针对类 Class 的测试写在类 ClassTest 中。
ClassTest（通常）继承自 PHPUnit\Framework\TestCase。
测试都是命名为 test* 的公用方法。
也可以在方法的文档注释块（docblock）中使用 @test 标注将其标记为测试方法。在测试方法内，类似于 assertSame()（参见断言）这样的断言方法用来对实际值与预期值的匹配做出断言。

示例

类



namespace single;

class test
{
    public $attr;

    public function hello(): string
    {
        return 'hello';
    }
}

测试类



use PHPUnit\Framework\TestCase;
use single\test;

final class Assert extends TestCase
{
    public function testIsTheContrastEqual()
    {
        $this->assertEquals('hello', (new test)->hello());
    }

    public function testIsThereAnyAttribute()
    {
        $this->assertClassHasAttribute('attr', test::class);
    }
}

执行结果

在 PHP 中使用多进程

2021-04-04T15:38:28.000Z

多道程序设计以及顺序和并发执行

所谓多道程序设计，就是允许多个程序同时进入内存并运行。多道程序设计是操作系统所采用的最基本、最重要的技术，其根本目的是提高整个系统的效率。
程序是一个在时间上按严格次序前后相继的操作序列，具有独立功能的程序独占处理器直到得到最终结果的过程称为程序的顺序执行。所谓程序的并发执行，是指两个或两个以上程序在计算机系统中，同时处于开始执行且尚未结束的状态。

进程和线程

进程是具有一定独立功能的程序在某个数据集合上的一次运行活动，是系统进行资源分配和调度的一个基本单位。
线程是进程中的一个实体，是处理器调度和分派的基本单位。线程自己基本上不拥有系统资源，只拥有少量在运行中必不可少的资源（如程序计数器、一组寄存器和栈等），但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程；同一个进程中的多个线程之间可以并发执行。由于线程之间的制约，至使线程在运行中也呈现出间断性。相应的，线程也同样拥有就绪、等待和运行三种基本状态。有的系统中线程还有终止状态等。

代码示例

开启多个进程，检查代理节点 ip:port 是否可以连接

deadoralive.php



$json = file_get_contents('./node.json');
$array = json_decode($json, true);
$array = array_chunk($array, $argv[1]);
$connection = [];
$success = 0;
$unit = $argv[2];
foreach ($array[$unit] as $value) {
    $ip = $value['server'];
    $port = $value['server_port'];
    $deadoralive = @fsockopen($ip, $port, $errno, $errstr, 1);

    if (!$deadoralive) {
        echo getmypid() . " | The IP address, $ip, is dead" . "\n";
    } else {
        $success++;
        $connection[] = $value;
        echo getmypid() . " | The IP address, $ip, is alive". "\n";
    }
}
$total = count($array[$unit]);
echo "\033[31m unit: $unit |total: $total |success: $success \033[0m \n";
$connection = print_r($connection, true);
file_put_contents('./alivenode_' . $argv[3] . '.log', $connection, FILE_APPEND);

process.php



$time = time();
$begin = round(microtime(true), 4);
$json = file_get_contents('./node.json');
$array = json_decode($json, true);
$size = 5;
$chunk = count($array) / $size;
$chunk = ceil($chunk);
// 此处使用 popen 开启多进程，同理可以使用 proc_open、exec 等函数实现
for ($i=0; $i < $chunk; $i++) {
    $pipe[$i] = popen('php ./deadoralive.php ' . $size . ' '. $i . ' ' . $time, 'w');
}
for ($i=0; $i < $chunk; $i++) {
    $r = pclose($pipe[$i]);
}
$end = round(microtime(true), 4);
echo $end - $begin . "\n";

cli 模式下执行命令 php process.php ，效率还行 181 个节点 12 秒就跑完了

Vim 常用命令和配置

2020-10-12T15:00:00.000Z

模式

在其他模式下使用 Esc 切换回普通模式，命令行模式下使用 :命令 + Enter 执行命令。

命令	模式	描述
`默认`	普通模式	控制光标移动，可对文本进行复制、粘贴等操作
`i`	插入模式	写入和编辑文本
`:`	命令行模式	保存或退出文本等，设置 Vim 的配置项
`v`	可视模式	配合方向键选取某一块文本区域，像使用鼠标一样

命令

注意 n 为数字，+ 表示组合使用，其他的字符对应键盘上的按键。

普通模式：

常用的光标移动命令。

命令	描述
`n + h` 或 `n + ←`	光标左移 n 个位置
`n + l` 或 `n + →`	光标右移 n 个位置
`n + j` 或 `n + ↓`	光标下移 n 个位置
`n + k` 或 `n + ↑`	光标上移 n 个位置
`ctrl + f`	向下滚动一屏
`ctrl + b`	向上滚动一屏
`ctrl + d`	向下滚动半屏
`ctrl + u`	向上滚动半屏
`0`	跳到首行，可以理解为无穷大的h
`^`	跳到行首开始的第一个非空白字符
`$`	跳到行尾，可以理解为无穷大的l
`gg` 或 `1 + G`	跳到首行，可以理解为无穷大的k
`G`	跳到末行，可以理解为无穷大的j
`w`	跳到下一个词首
`b`	跳到上一个词首
`e`	跳到下一个词尾
`ge`	跳到上一个词尾
`H`	移动到屏幕的最上方那一行的第一个字符
`M`	移动到屏幕的最中央那一行的第一个字符
`L`	移动到屏幕的最下方那一行的第一个字符
`n + Enter`	光标向下移动 n 行
`c`	删除当前光标后面的部分. 进入插入模式
`cc`	将当前行替换为空行，进入插入模式
`cw`	删除当前单词的光标右侧部分，进入插入模式
`s`	删除当前字母，进入插入模式
`r`	替换当前字母，输入一个字母后自动返回普通模式
`a`	在光标右侧插入文本
`A`	在行末插入文本
`i`	在光标左侧插入文本
`I`	在行首插入文本
`o`	在光标下插入新行
`O`	在光标上插入新行
`n`	跳转下一个搜索词
`N`	跳转上一个搜索词

常用的复制、黏贴、删除、撤销、查找等操作。

命令	描述
`n + x`	剪切（删除）光标右边n个字符
`n + X`	剪切（删除）光标左边n个字符
`y`	复制在可视模式下选中的文本
`y + n`	复制在可视模式下选中的文本
`yy`	复制光标所在整行
`n + yy`	复制光标所在的向下 n 行
`y + n + w`	复制1(n)个词
`y + n + l`	复制光标右边1(n)个字符
`y + n + h`	复制光标左边1(n)个字符
`y + $`	从光标当前位置复制到行尾
`y + 0`	从光标当前位置复制到行首
`y + 0`	从光标当前位置复制到行首。
`y + 1 + G` 或 `y + gg`	复制光标以上的所有行
`d`	剪切（删除）在可视模式下选中的文本
`dd`	剪切（删除）光标所在整行
`n + dd`	剪切（删除）光标所在的向下 n 行
`d + n + w`	剪切（删除）1(n)个词
`d + n + l`	剪切（删除）光标右边1(n)个字符
`d + n + h`	剪切（删除）光标左边1(n)个字符
`d + $`	从光标当前位置剪切（删除）到行尾
`d + 0`	从光标当前位置剪切（删除）到行首
`d + 1 + G` 或 `d + gg`	剪切（删除）光标以上的所有行
`d + G`	剪切光标以下的所有行
`p`	粘贴光标上一行
`P`	粘贴到光标下一行
`u`	撤销
`ctrl + r`	恢复上一步撤销

命令行模式：

命令	描述
`:w`	保存
`:q`	退出
`:wq` 或 `ZZ`	保存退出
`:q!` 或 `ZQ`	强制退出（放弃对文档的修改内容）
`:wq!`	强制保存退出
`:set nu`	显示行号
`:set nonu`	不显示行号
`:整数`	跳转到该行
`?字符串`	在文本中从下至上搜索该字符串
`/字符串`	在文本中从上至下搜索该字符串
`:s/one/two`	将当前光标所在行的第一个one替换成two
`:s/one/two/g`	将当前光标所在行的所有one替换成two
`:%s/one/two/g`	将全文中的所有one替换成two
`:m,ny`	复制m行到n行的内容
`:m,nd`	剪切（删除）m行到n行的内容
`:help 命令`	查看命令帮助信息

配置

Vim 的全局配置一般在/etc/vim/vimrc或者/etc/vimrc，对所有用户生效。用户个人的配置在~/.vimrc。
配置项一般都有”打开”和”关闭”两个设置。”关闭”就是在”打开”前面加上前缀”no”，双引号开始的行表示注释。

加上 : 可在命令行模式运行，一些常用配置：

" 显示行号
set number

" 不显示行号
set nonumber

" 不与 Vi 兼容（采用 Vim 自己的操作命令）
set nocompatible

" 打开语法高亮。自动识别代码，使用多种颜色显示。
syntax on

" 在底部显示，当前处于普通模式还是插入模式。
set showmode

" 普通模式下，在底部显示，当前键入的指令。
set showcmd

" 支持使用鼠标。
set mouse=a

" 使用 utf-8 编码。
set mouse=a

" 启用256色。
set t_Co=256

" 启文件类型检查，并且载入与该类型对应的缩进规则。
filetype indent on

" 按下回车键后，下一行的缩进会自动跟上一行的缩进保持一致。
set autoindent

" Tab 转为多少个空格。
set softtabstop=2

" 设置行宽，即一行显示多少个字符。
set textwidth=80

" 光标所在的当前行高亮。
set cursorline

" 自动折行，即太长的行分成几行显示。
set wrap

" 输入搜索模式时，每输入一个字符，就自动跳到第一个匹配的结果。
set incsearch

" 搜索时，高亮显示匹配结果。
set hlsearch

" 搜索时忽略大小写。
set ignorecase

" 递归的按键映射，按 a 和 c 等于按 b。
:map a b
:map c a
    
" 非递归的按键映射，表示按 d 等于按 a。
:noremap d a

插件

Unix 安装 vim-plus（一个极简的Vim插件管理器）：

 curl -fLo ~/.vim/autoload/plug.vim --create-dirs \ https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

配置：

在~/.vimrc中添加要下载的vim插件，然后重启。

" 开始标签

call plug#begin('~/.vim/plugged')

" 单引号内些上你需要安装的插件

    Plug 'xxx'

" 结束标签

call plug#end()

使用和卸载：

在命令行模式输入命令使用插件。

命令	描述
`:PlugInstall [name ...] [#threads]`	安装插件
`:PlugUpdate [name ...] [#threads]`	安装或更新插件
`:PlugClean[!]`	删除未列出的插件
`:PlugUpgrade`	升级vim-plug
`:PlugStatus`	检查插件状态
`:PlugDiff`	检查来自先前更新的更改以及未决的更改
`:PlugSnapshot[!] [output path]`	生成脚本以还原插件的当前快照

更多插件参见 vim Awesome。

参考

Yii 中活动记录（Active Record）类的使用

2020-08-21T03:33:12.000Z

Yii中活动记录（Active Record）类的使用

查询数据

/** 
定义 Active Record 类后，你可以从相应的数据库表中查询数据。 查询过程大致如下三个步骤：
1.通过 yii\db\ActiveRecord::find() 方法创建一个新的查询生成器对象；
2.使用查询生成器的构建方法来构建你的查询；
3.调用查询生成器的查询方法来取出数据到 Active Record 实例中。
正如你看到的，是不是跟查询生成器的步骤差不多。 唯一有区别的地方在于你用 yii\db\ActiveRecord::find() 去获得一个新的查询生成器对象，这个对象是 yii\db\ActiveQuery， 而不是使用 new 操作符创建一个查询生成器对象。 
下面是一些例子，介绍如何使用 Active Query 查询数据：
**/

// SELECT * FROM `customer` WHERE `id` = 123 
$customer = Customer::find()->where(['id' => 123])->one();
$customer = Customer::findOne(123);
$customer = Customer::findOne(['id' => 123]);

// 取回所有活跃客户并以他们的 ID 排序：
$customers = Customer::find()
    ->where(['status' => Customer::STATUS_ACTIVE])
    ->orderBy('id')
    ->all();

// 返回 id 是 100, 101, 123, 124 的客户
// SELECT * FROM `customer` WHERE `id` IN (100, 101, 123, 124)
$customers = Customer::findAll([100, 101, 123, 124]);

// 返回 id 是 123 的活跃客户
// SELECT * FROM `customer` WHERE `id` = 123 AND `status` = 1
$customer = Customer::findOne([
    'id' => 123,
    'status' => Customer::STATUS_ACTIVE,
]);

// 返回所有不活跃的客户
// SELECT * FROM `customer` WHERE `status` = 0
$customers = Customer::findAll([
    'status' => Customer::STATUS_INACTIVE,
]);

// 取回活跃客户的数量：
// SELECT COUNT(*) FROM `customer` WHERE `status` = 1
$count = Customer::find()
    ->where(['status' => Customer::STATUS_ACTIVE])
    ->count();

// 以客户 ID 索引结果集：
// SELECT * FROM `customer`
$customers = Customer::find()
    ->indexBy('id')
    ->all();

// 警告： 如果你需要将用户输入传递给这些方法，请确保输入值是标量或者是 数组条件，确保数组结构不能被外部所改变：

// yii\web\Controller 确保了 $id 是标量
public function actionView($id)
{
    $model = Post::findOne($id);
    // ...
}

// 明确了指定要搜索的列，在此处传递标量或数组将始终只是查找出单个记录而已
$model = Post::findOne(['id' => Yii::$app->request->get('id')]);

// 不要使用下面的代码！可以注入一个数组条件来匹配任意列的值！
$model = Post::findOne(Yii::$app->request->get('id'));

数据转换

class Customer extends ActiveRecord
{
    // ...

    public function getBirthdayText()
    {
        return date('Y/m/d', $this->birthday);
    }
    
    public function setBirthdayText($value)
    {
        $this->birthday = strtotime($value);
    }
}

// 访问$customer->birthdayText

以数组形式获取数据

// 返回所有客户
// 每个客户返回一个关联数组
$customers = Customer::find()
    ->asArray()
    ->all();

// 提示： 虽然这种方法可以节省内存并提高性能，但它更靠近较低的 DB 抽象层 你将失去大部分的 Active Record 提供的功能。 一个非常重要的区别在于列值的数据类型。 当您在 Active Record 实例中返回数据时，列值将根据实际列类型，自动类型转换； 然而，当您以数组返回数据时，列值将为 字符串（因为它们是没有处理过的 PDO 的结果），不管它们的实际列是什么类型。

批量获取数据

// 每次获取 10 条客户数据
foreach (Customer::find()->batch(10) as $customers) {
    // $customers 是个最多拥有 10 条数据的数组
}

// 每次获取 10 条客户数据，然后一条一条迭代它们
foreach (Customer::find()->each(10) as $customer) {
    // $customer 是个 `Customer` 对象
}

// 贪婪加载模式的批处理查询
foreach (Customer::find()->with('orders')->each() as $customer) {
    // $customer 是个 `Customer` 对象，并附带关联的 `'orders'`
}

保存数据

// 插入新记录
$customer = new Customer();
$customer->name = 'James';
$customer->email = 'james@example.com';
$customer->save();

// 更新已存在的记录
$customer = Customer::findOne(123);
$customer->email = 'james@newexample.com';
$customer->save();

// save() 方法可能插入或者更新表的记录，这取决于 Active Record 实例的状态。 如果实例通过 new 操作符实例化，调用 save() 方法将插入新记录； 如果实例是一个查询方法的结果，调用 save() 方法 将更新这个实例对应的表记录行。

数据验证

因为 yii\db\ActiveRecord 继承于 yii\base\Model，它共享相同的 输入验证 功能。 你可以通过重写 rules() 方法声明验证规则并执行， 通过调用 validate() 方法进行数据验证。当你调用 save() 时，默认情况下会自动调用 validate()。 只有当验证通过时，它才会  真正地保存数据; 否则将简单地返回 false， 您可以检查 errors 属性来获取验证过程的错误消息。提示： 如果你确定你的数据不需要验证（比如说数据来自可信的场景）， 你可以调用 save(false) 来跳过验证过程。

快赋值

  // 和普通的 模型 一样，你亦可以享受 Active Record 实例的 块赋值 特性。 使用此功能，您可以在单个 PHP 语句中，给 Active Record 实例的多个属性批量赋值， 如下所示。 记住，只有 安全属性 才可以批量赋值。

$values = [
    'name' => 'James',
    'email' => 'james@example.com',
];

$customer = new Customer();

$customer->attributes = $values;
$customer->save();

更新计数

// 在数据库表中增加或减少一个字段的值是个常见的任务。我们将这些列称为“计数列”。 您可以使用 updateCounters() 更新一个或多个计数列。 例如，
    
$post = Post::findOne(100);

// UPDATE `post` SET `view_count` = `view_count` + 1 WHERE `id` = 100
$post->updateCounters(['view_count' => 1]);

// 同样，你可以调用 updateAllCounters() 同时更新多条记录的计数列
// UPDATE `customer` SET `age` = `age` + 1
Customer::updateAllCounters(['age' => 1]);

更新多个数据行

1 2	// UPDATE `customer` SET `status` = 1 WHERE `email` LIKE `%@example.com%` Customer::updateAll(['status' => Customer::STATUS_ACTIVE], ['like', 'email', '@example.com']);

删除数据

// 要删除单行数据，首先获取与该行对应的 Active Record 实例，然后调用 yii\db\ActiveRecord::delete() 方法。

$customer = Customer::findOne(123);
$customer->delete();

// 你可以调用 yii\db\ActiveRecord::deleteAll() 方法删除多行甚至全部的数据。例如,

Customer::deleteAll(['status' => Customer::STATUS_INACTIVE]);

事务操作

$customer = Customer::findOne(123);

Customer::getDb()->transaction(function($db) use ($customer) {
    $customer->id = 200;
    $customer->save();
    // ...其他 DB 操作...
});
    
// 或者

$transaction = Customer::getDb()->beginTransaction();
try {
    $customer->id = 200;
    $customer->save();
    // ...other DB operations...
    $transaction->commit();
} catch(\Exception $e) {
    $transaction->rollBack();
    throw $e;
} catch(\Throwable $e) {
    $transaction->rollBack();
    throw $e;
}
    
    // 提示： 在上面的代码中，我们有两个catch块用于兼容 PHP 5.x 和 PHP 7.x。 \Exception 继承于 \Throwable interface 由于 PHP 7.0 的改动，如果您的应用程序仅使用 PHP 7.0 及更高版本，您可以跳过 \Exception 部分。

乐观锁

乐观锁是一种防止此冲突的方法：一行数据 同时被多个用户更新。例如，同一时间内，用户 A 和用户 B 都在编辑 相同的 wiki 文章。用户 A 保存他的编辑后，用户 B 也点击“保存”按钮来 保存他的编辑。实际上，用户 B 正在处理的是过时版本的文章， 因此最好是，想办法阻止他保存文章并向他提示一些信息。乐观锁通过使用一个字段来记录每行的版本号来解决上述问题。 当使用过时的版本号保存一行数据时，yii\db\StaleObjectException 异常 将被抛出，这阻止了该行的保存。乐观锁只支持更新 yii\db\ActiveRecord::update() 或者删除 yii\db\ActiveRecord::delete() 已经存在的单条数据行。使用乐观锁的步骤，1.在与 Active Record 类相关联的 DB 表中创建一个列，以存储每行的版本号。 这个列应当是长整型（在 MySQL 中是 BIGINT DEFAULT 0）。2.重写 yii\db\ActiveRecord::optimisticLock() 方法返回这个列的命名。3.在你的 Model 类里实现 OptimisticLockBehavior 行为（注：这个行为类在 2.0.16 版本加入），以便从请求参数里自动解析这个列的值。 然后从验证规则中删除 version 属性，因为 OptimisticLockBehavior 已经处理它了.4.在用于用户填写的 Web 表单中，添加一个隐藏字段（hidden field）来存储正在更新的行的当前版本号。5.在使用 Active Record 更新数据的控制器动作中，要捕获（try/catch） yii\db\StaleObjectException 异常。 实现一些业务逻辑来解决冲突（例如合并更改，提示陈旧的数据等等）。例如，假定版本列被命名为 version。您可以使用下面的代码来实现乐观锁。

// ------ 视图层代码 -------

use yii\helpers\Html;

// ...其他输入栏
echo Html::activeHiddenInput($model, 'version');


// ------ 控制器代码 -------

use yii\db\StaleObjectException;

public function actionUpdate($id)
{
    $model = $this->findModel($id);

    try {
        if ($model->load(Yii::$app->request->post()) && $model->save()) {
            return $this->redirect(['view', 'id' => $model->id]);
        } else {
            return $this->render('update', [
                'model' => $model,
            ]);
        }
    } catch (StaleObjectException $e) {
        // 解决冲突的代码
    }
}

// ------ Model 代码 -------

use yii\behaviors\OptimisticLockBehavior;

public function behaviors()
{
    return [
        OptimisticLockBehavior::className(),
    ];
}

使用关联数据

// 声明关联关系
class Customer extends ActiveRecord
{
    // ...

    public function getOrders()
    {
        return $this->hasMany(Order::className(), ['customer_id' => 'id']);
    }
}

class Order extends ActiveRecord
{
    // ...

    public function getCustomer()
    {
        return $this->hasOne(Customer::className(), ['id' => 'customer_id']);
    }
}

/** 上述的代码中，我们为 Customer 类声明了一个 orders 关联， 和为 Order 声明了一个 customer 关联。

 每个关联方法必须这样命名：getXyz。然后我们通过 xyz（首字母小写）调用这个关联名。 请注意关联名是大小写敏感的。

当声明一个关联关系的时候，必须指定好以下的信息：

关联的对应关系：通过调用 hasMany() 或者 hasOne() 指定。在上面的例子中，您可以很容易看出这样的关联声明： 一个客户可以有很多订单，而每个订单只有一个客户。
相关联 Active Record 类名：用来指定为 hasMany() 或者 hasOne() 方法的第一个参数。 推荐的做法是调用 Xyz::className() 来获取类名称的字符串，以便您 可以使用 IDE 的自动补全，以及让编译阶段的错误检测生效。
两组数据的关联列：用以指定两组数据相关的列（hasOne()/hasMany() 的第二个参数）。 数组的值填的是主数据的列（当前要声明关联的 Active Record 类为主数据）， 而数组的键要填的是相关数据的列。

一个简单的口诀，先附表的主键，后主表的主键。 正如上面的例子，customer_id 是 Order 的属性，而 id是 Customer 的属性。 （译者注：hasMany() 的第二个参数，这个数组键值顺序不要弄反了）**/
    
// 访问关联数据
    
// SELECT * FROM `customer` WHERE `id` = 123
$customer = Customer::findOne(123);

// SELECT * FROM `order` WHERE `customer_id` = 123
// $orders 是由 Order 类组成的数组
$orders = $customer->orders;

//  当你通过 getter 方法 getXyz() 声明了一个叫 xyz 的关联属性，你就可以像 属性 那样访问 xyz。注意这个命名是区分大小写的。

// 提示： 虽然这个概念跟 这个 属性 特性很像， 但是还是有一个很重要的区别。普通对象属性的属性值与其定义的 getter 方法的类型是相同的。 而关联方法返回的是一个 yii\db\ActiveQuery 活动查询生成器的实例。只有当访问关联属性的的时候， 才会返回 yii\db\ActiveRecord Active Record 实例，或者 Active Record 实例组成的数组。

$customer->orders; // 获得 `Order` 对象的数组
$customer->getOrders(); // 返回 ActiveQuery 类的实例

动态关联查询

$customer = Customer::findOne(123);

// SELECT * FROM `order` WHERE `customer_id` = 123 AND `subtotal` > 200 ORDER BY `id`
$orders = $customer->getOrders()
    ->where(['>', 'subtotal', 200])
    ->orderBy('id')
    ->all();

class Customer extends ActiveRecord
{
    public function getBigOrders($threshold = 100) // 老司机的提醒机的提醒threshold 参数一定一定要给个默认值一定要给个默认值{
        return $this->hasMany(Order::className(), ['customer_id' => 'id'])
            ->where('subtotal > :threshold', [':threshold' => $threshold])
            ->orderBy('id');
    }
}

// 然后你就可以执行以下关联查询：

// SELECT * FROM `order` WHERE `customer_id` = 123 AND `subtotal` > 200 ORDER BY `id`
$orders = $customer->getBigOrders(200)->all();

// SELECT * FROM `order` WHERE `customer_id` = 123 AND `subtotal` > 100 ORDER BY `id`
$orders = $customer->bigOrders;

中间表关联

// 在数据库建模中，当两个关联表之间的对应关系是多对多时， 通常会引入一个连接表。例如，order 表 和 item 表可以通过名为 order_item 的连接表相关联。一个 order 将关联多个 order items， 而一个 order item 也会关联到多个 orders。

// 当声明这种表关联后，您可以调用 via() 或 viaTable() 指明连接表。via() 和 viaTable() 之间的区别是 前者是根据现有的关联名称来指定连接表，而后者直接使用 连接表。例如，

class Order extends ActiveRecord
{
    public function getItems()
    {
        return $this->hasMany(Item::className(), ['id' => 'item_id'])
            ->viaTable('order_item', ['order_id' => 'id']);
    }
}

// 或者,

class Order extends ActiveRecord
{
    public function getOrderItems()
    {
        return $this->hasMany(OrderItem::className(), ['order_id' => 'id']);
    }

    public function getItems()
    {
        return $this->hasMany(Item::className(), ['id' => 'item_id'])
            ->via('orderItems');
    }
}

// 使用连接表声明的关联和正常声明的关联是等同的，例如，

// SELECT * FROM `order` WHERE `id` = 100
$order = Order::findOne(100);

// SELECT * FROM `order_item` WHERE `order_id` = 100
// SELECT * FROM `item` WHERE `item_id` IN (...)
// 返回 Item 类组成的数组
$items = $order->items;

通过多个表来连接关联声明

// 通过使用 via() 方法，它还可以通过多个表来定义关联声明。 再考虑考虑上面的例子，我们有 Customer，Order 和 Item 类。 我们可以添加一个关联关系到 Customer 类，这个关联可以列出了 Customer（客户） 的订单下放置的所有 Item（商品）， 这个关联命名为 getPurchasedItems()，关联声明如下代码示例所示：

class Customer extends ActiveRecord
{
    // ...

    public function getPurchasedItems()
    {
        // 客户的商品，将 Item 中的 'id' 列与 OrderItem 中的 'item_id' 相匹配
        return $this->hasMany(Item::className(), ['id' => 'item_id'])
                    ->via('orderItems');
    }

    public function getOrderItems()
    {
        // 客户订单中的商品，将 `Order` 的 'id' 列和 OrderItem 的 'order_id' 列相匹配
        return $this->hasMany(OrderItem::className(), ['order_id' => 'id'])
                    ->via('orders');
    }

    public function getOrders()
    {
        // 见上述列子
        return $this->hasMany(Order::className(), ['customer_id' => 'id']);
    }
}

延迟加载和即时加载

// 在 访问关联数据 中，我们解释说可以像问正常的对象属性那样 访问 Active Record 实例的关联属性。SQL 语句仅在 你第一次访问关联属性时执行。我们称这种关联数据访问方法为 延迟加载。 例如，

// SELECT * FROM `customer` WHERE `id` = 123
$customer = Customer::findOne(123);

// SELECT * FROM `order` WHERE `customer_id` = 123
$orders = $customer->orders;

// 没有 SQL 语句被执行
$orders2 = $customer->orders;
// 延迟加载使用非常方便。但是，当你需要访问相同的具有多个 Active Record 实例的关联属性时， 可能会遇到性能问题。请思考一下以下代码示例。 有多少 SQL 语句会被执行？

// SELECT * FROM `customer` LIMIT 100
$customers = Customer::find()->limit(100)->all();

foreach ($customers as $customer) {
    // SELECT * FROM `order` WHERE `customer_id` = ...
    $orders = $customer->orders;
}
// 你瞅瞅，上面的代码会产生 101 次 SQL 查询！ 这是因为每次你访问 for 循环中不同的 Customer 对象的 orders 关联属性时，SQL 语句 都会被执行一次。

// 为了解决上述的性能问题，你可以使用所谓的 即时加载，如下所示，

// SELECT * FROM `customer` LIMIT 100;
// SELECT * FROM `orders` WHERE `customer_id` IN (...)
$customers = Customer::find()
    ->with('orders')
    ->limit(100)
    ->all();

foreach ($customers as $customer) {
    // 没有任何的 SQL 执行
    $orders = $customer->orders;
}
// 通过调用 yii\db\ActiveQuery::with() 方法，你使 Active Record 在一条 SQL 语句里就返回了这 100 位客户的订单。 结果就是，你把要执行的 SQL 语句从 101 减少到 2 条！

// 你可以即时加载一个或多个关联。 你甚至可以即时加载 嵌套关联 。嵌套关联是一种 在相关的 Active Record 类中声明的关联。例如，Customer 通过 orders 关联属性 与 Order 相关联， Order 与 Item 通过 items 关联属性相关联。 当查询 Customer 时，您可以即时加载 通过嵌套关联符 orders.items 关联的 items。

// 以下代码展示了 with() 的各种用法。我们假设 Customer 类 有两个关联 orders 和 country，而 Order 类有一个关联 items。

//  即时加载 "orders" and "country"
$customers = Customer::find()->with('orders', 'country')->all();
// 等同于使用数组语法 如下
$customers = Customer::find()->with(['orders', 'country'])->all();
// 没有任何的 SQL 执行
$orders= $customers[0]->orders;
// 没有任何的 SQL 执行
$country = $customers[0]->country;

// 即时加载“订单”和嵌套关系“orders.items”
$customers = Customer::find()->with('orders.items')->all();
// 访问第一个客户的第一个订单中的商品
// 没有 SQL 查询执行
$items = $customers[0]->orders[0]->items;
// 你也可以即时加载更深的嵌套关联，比如 a.b.c.d。所有的父关联都会被即时加载。 那就是, 当你调用 with() 来 with a.b.c.d, 你将即时加载 a, a.b, a.b.c and a.b.c.d。

// 提示： 一般来说，当即时加载 N 个关联，另有 M 个关联 通过 连接表 声明，则会有 N+M+1 条 SQL 语句被执行。 请注意这样的的嵌套关联 a.b.c.d 算四个关联。

// 当即时加载一个关联，你可以通过匿名函数自定义相应的关联查询。 例如，

// 查找所有客户，并带上他们国家和活跃订单
// SELECT * FROM `customer`
// SELECT * FROM `country` WHERE `id` IN (...)
// SELECT * FROM `order` WHERE `customer_id` IN (...) AND `status` = 1
$customers = Customer::find()->with([
    'country',
    'orders' => function ($query) {
        $query->andWhere(['status' => Order::STATUS_ACTIVE]);
    },
])->all();
// 自定义关联查询时，应该将关联名称指定为数组的键 并使用匿名函数作为相应的数组的值。匿名函数将接受一个 $query 参数 它用于表示这个自定义的关联执行关联查询的 yii\db\ActiveQuery 对象。 在上面的代码示例中，我们通过附加一个关于订单状态的附加条件来修改关联查询。

// 提示： 如果你在即时加载的关联中调用 select() 方法，你要确保 在关联声明中引用的列必须被 select。否则，相应的模型（Models）可能 无法加载。例如，

$orders = Order::find()->select(['id', 'amount'])->with('customer')->all();
// $orders[0]->customer 会一直是 `null`。你应该这样写，以解决这个问题：
$orders = Order::find()->select(['id', 'amount', 'customer_id'])->with('cus

关联关系的 JOIN 查询

// 提示： 这小节的内容仅仅适用于关系数据库， 比如 MySQL，PostgreSQL 等等。

// 到目前为止，我们所介绍的关联查询，仅仅是使用主表列 去查询主表数据。实际应用中，我们经常需要在关联表中使用这些列。例如， 我们可能要取出至少有一个活跃订单的客户。为了解决这个问题，我们可以 构建一个 join 查询，如下所示：

// SELECT `customer`.* FROM `customer`
// LEFT JOIN `order` ON `order`.`customer_id` = `customer`.`id`
// WHERE `order`.`status` = 1
// 
// SELECT * FROM `order` WHERE `customer_id` IN (...)
$customers = Customer::find()
    ->select('customer.*')
    ->leftJoin('order', '`order`.`customer_id` = `customer`.`id`')
    ->where(['order.status' => Order::STATUS_ACTIVE])
    ->with('orders')
    ->all();
// 提示： 在构建涉及 JOIN SQL 语句的连接查询时，清除列名的歧义很重要。 通常的做法是将表名称作为前缀加到对应的列名称前。

// 但是，更好的方法是通过调用 yii\db\ActiveQuery::joinWith() 来利用已存在的关联声明：

$customers = Customer::find()
    ->joinWith('orders')
    ->where(['order.status' => Order::STATUS_ACTIVE])
    ->all();
// 两种方法都执行相同的 SQL 语句集。然而，后一种方法更干净、简洁。

// 默认的，joinWith() 会使用 LEFT JOIN 去连接主表和关联表。 你可以通过 $joinType 参数指定不同的连接类型（比如 RIGHT JOIN）。 如果你想要的连接类型是 INNER JOIN，你可以直接用 innerJoinWith() 方法代替。

// 调用 joinWith() 方法会默认 即时加载 相应的关联数据。 如果你不需要那些关联数据，你可以指定它的第二个参数 $eagerLoading 为 false。

// 注意： 即使在启用即时加载的情况下使用 joinWith() 或 innerJoinWith()， 相应的关联数据也不会从这个 JOIN 查询的结果中填充。 因此，每个连接关系还有一个额外的查询，正如即时加载部分所述。

// 和 with() 一样，你可以 join 多个关联表；你可以动态的自定义 你的关联查询；你可以使用嵌套关联进行 join。你也可以将 with() 和 joinWith() 组合起来使用。例如：

$customers = Customer::find()->joinWith([
    'orders' => function ($query) {
        $query->andWhere(['>', 'subtotal', 100]);
    },
])->with('country')
    ->all();
// 有时，当连接两个表时，你可能需要在 JOIN 查询的 ON 部分中指定一些额外的条件。 这可以通过调用 yii\db\ActiveQuery::onCondition() 方法来完成，如下所示：

// SELECT `customer`.* FROM `customer`
// LEFT JOIN `order` ON `order`.`customer_id` = `customer`.`id` AND `order`.`status` = 1 
// 
// SELECT * FROM `order` WHERE `customer_id` IN (...)
$customers = Customer::find()->joinWith([
    'orders' => function ($query) {
        $query->onCondition(['order.status' => Order::STATUS_ACTIVE]);
    },
])->all();
// 以上查询取出 所有 客户，并为每个客户取回所有活跃订单。 请注意，这与我们之前的例子不同，后者仅取出至少有一个活跃订单的客户。

// 提示： 当通过 onCondition() 修改 yii\db\ActiveQuery 时， 如果查询涉及到 JOIN 查询，那么条件将被放在 ON 部分。如果查询不涉及 JOIN ，条件将自动附加到查询的 WHERE 部分。 因此，它可以只包含 包含了关联表的列 的条件。（译者注：意思是 onCondition() 中可以只写关联表的列，主表的列写不写都行）

反向关联

// 两个 Active Record 类之间的关联声明往往是相互关联的。例如，Customer 是 通过 orders 关联到 Order ，而Order 通过 customer 又关联回到了 Customer。

class Customer extends ActiveRecord
{
    public function getOrders()
    {
        return $this->hasMany(Order::className(), ['customer_id' => 'id']);
    }
}

class Order extends ActiveRecord
{
    public function getCustomer()
    {
        return $this->hasOne(Customer::className(), ['id' => 'customer_id']);
    }
}
// 现在考虑下面的一段代码：

// SELECT * FROM `customer` WHERE `id` = 123
$customer = Customer::findOne(123);

// SELECT * FROM `order` WHERE `customer_id` = 123
$order = $customer->orders[0];

// SELECT * FROM `customer` WHERE `id` = 123
$customer2 = $order->customer;

// 显示 "not the same"
echo $customer2 === $customer ? 'same' : 'not the same';
// 我们原本认为 $customer 和 $customer2 是一样的，但不是！其实他们确实包含相同的 客户数据，但它们是不同的对象。 访问 $order->customer 时，需要执行额外的 SQL 语句， 以填充出一个新对象 $customer2。

// 为了避免上述例子中最后一个 SQL 语句被冗余执行，我们应该告诉 Yii customer 是 orders 的 反向关联，可以通过调用 inverseOf() 方法声明， 如下所示：

class Customer extends ActiveRecord
{
    public function getOrders()
    {
        return $this->hasMany(Order::className(), ['customer_id' => 'id'])->inverseOf('customer');
    }
}
// 这样修改关联声明后：

// SELECT * FROM `customer` WHERE `id` = 123
$customer = Customer::findOne(123);

// SELECT * FROM `order` WHERE `customer_id` = 123
$order = $customer->orders[0];

// No SQL will be executed
$customer2 = $order->customer;

// 输出 "same"
echo $customer2 === $customer ? 'same' : 'not the same';

// 注意： 反向关联不能用在有 连接表 关联声明中。 也就是说，如果一个关联关系通过 via() 或 viaTable() 声明， 你就不能再调用 inverseOf() 了。

保存关联数据

// 在使用关联数据时，您经常需要建立不同数据之间的关联或销毁 现有关联。这需要为定义的关联的列设置正确的值。通过使用 Active Record， 你就可以编写如下代码：

$customer = Customer::findOne(123);
$order = new Order();
$order->subtotal = 100;
// ...

// 为 Order 设置属性以定义与 "customer" 的关联关系
$order->customer_id = $customer->id;
$order->save();
Active Record 提供了 link() 方法，可以更好地完成此任务：

$customer = Customer::findOne(123);
$order = new Order();
$order->subtotal = 100;
// ...

$order->link('customer', $customer);
// link()方法需要指定关联名 和要建立关联的目标 Active Record 实例。该方法将修改属性的值 以连接两个 Active Record 实例，并将其保存到数据库。在上面的例子中，它将设置 Order 实例的 customer_id 属性 为 Customer 实例的 id 属性的值，然后保存 到数据库。

// 注意： 你不能关联两个新的 Active Record 实例。
// 使用 link() 的好处在通过 junction table 定义关系时更加明显。 例如，你可以使用以下代码关联 Order 实例 和 Item 实例：

$order->link('items', $item);
// 上述代码会自动在 order_item 关联表中插入一行，以关联 order 和 item 这两个数据记录。

// 信息： link() 方法在保存相应的 Active Record 实例时， 将不会执行任何数据验证。在调用此方法之前， 您应当验证所有的输入数据。

//link() 方法的反向操作是 unlink() 方法， 这将可以断掉两个 Active Record 实例间的已经存在了的关联关系。例如，

$customer = Customer::find()->with('orders')->where(['id' => 123])->one();
$customer->unlink('orders', $customer->orders[0]);
// 默认情况下，unlink() 方法将设置指定的外键值， 以把现有的关联指定为 null。此外，你可以选择通过将 $delete 参数设置为true 传递给方法， 删除包含此外键值的表记录行。

// 当关联关系中有连接表时，调用 unlink() 时， 如果 $delete 参数是 true 的话，将导致 连接表中的外键或相应的行被删除。

跨数据库关联

// Active Record 允许您在不同数据库驱动的 Active Record 类之间声明关联关系。 这些数据库可以是不同的类型（例如 MySQL 和 PostgreSQL ，或是 MS SQL 和 MongoDB），它们也可以运行在 不同的服务器上。你可以使用相同的语法来执行关联查询。例如，

// Customer 对应的表是关系数据库中（比如 MySQL）的 "customer" 表
class Customer extends \yii\db\ActiveRecord
{
    public static function tableName()
    {
        return 'customer';
    }

    public function getComments()
    {
        // 一个 customer 有很多条评论（comments）
        return $this->hasMany(Comment::className(), ['customer_id' => 'id']);
    }
}

// Comment 对应的是 MongoDB 数据库中的  "comment" 集合（译者注：MongoDB 中的集合相当于 MySQL 中的表）
class Comment extends \yii\mongodb\ActiveRecord
{
    public static function collectionName()
    {
        return 'comment';
    }

    public function getCustomer()
    {
        // 一条评论对应一位 customer
        return $this->hasOne(Customer::className(), ['id' => 'customer_id']);
    }
}

$customers = Customer::find()->with('comments')->all();
// 本节中描述的大多数关联查询功能，你都可以抄一抄。

// 注意： joinWith() 这个功能限制于某些数据库是否支持跨数据库 JOIN 查询。  因此，你再上述的代码里就不能用此方法了，因为 MongoDB 不支持 JOIN 查询。

自定义查询类

// 默认情况下，yii\db\ActiveQuery 支持所有 Active Record 查询。要在 Active Record 类中使用自定义的查询类， 您应该重写 yii\db\ActiveRecord::find() 方法并返回一个你自定义查询类的实例。 例如，

// file Comment.php
namespace app\models;

use yii\db\ActiveRecord;

class Comment extends ActiveRecord
{
    public static function find()
    {
        return new CommentQuery(get_called_class());
    }
}
// 现在，对于 Comment 类，不管你执行查询（比如 find()、findOne()），还是定义一个关联（比如 hasOne()）， 你都将调用到 CommentQuery 实例，而不再是 ActiveQuery 实例。

// 现在你可以定义 CommentQuery 类了，发挥你的奇技淫巧，以改善查询构建体验。例如，

// file CommentQuery.php
namespace app\models;

use yii\db\ActiveQuery;

class CommentQuery extends ActiveQuery
{
    // 默认加上一些条件（可以跳过）
    public function init()
    {
        $this->andOnCondition(['deleted' => false]);
        parent::init();
    }

    // ... 在这里加上自定义的查询方法 ...

    public function active($state = true)
    {
        return $this->andOnCondition(['active' => $state]);
    }
}
// 注意： 作为 onCondition() 方法的替代方案，你应当调用 andOnCondition() 或 orOnCondition() 方法来附加新增的条件， 不然在一个新定义的查询方法，已存在的条件可能会被覆盖。

// 然后你就可以先下面这样构建你的查询了：

$comments = Comment::find()->active()->all();
$inactiveComments = Comment::find()->active(false)->all();
// 提示： 在大型项目中，建议您使用自定义查询类来容纳大多数与查询相关的代码， 以使 Active Record 类保持简洁。

// 您还可以在 Comment 关联关系的定义中或在执行关联查询时，使用刚刚新建查询构建方法：

class Customer extends \yii\db\ActiveRecord
{
    public function getActiveComments()
    {
        return $this->hasMany(Comment::className(), ['customer_id' => 'id'])->active();
    }
}

$customers = Customer::find()->joinWith('activeComments')->all();

// 或者这样
class Customer extends \yii\db\ActiveRecord
{
    public function getComments()
    {
        return $this->hasMany(Comment::className(), ['customer_id' => 'id']);
    }
}

$customers = Customer::find()->joinWith([
    'comments' => function($q) {
        $q->active();
    }
])->all();
// 提示： 在 Yii 1.1 中，有个概念叫做 命名范围。命名范围在 Yii 2.0 中不再支持， 你依然可以使用自定义查询类、查询方法来达到一样的效果。

选择额外的字段

// 当 Active Record 实例从查询结果中填充时，从数据结果集中， 其属性的值将被相应的列填充。

// 你可以从查询中获取其他列或值，并将其存储在 Active Record 活动记录中。 例如，假设我们有一个名为 room 的表，其中包含有关酒店可用房间的信息。 每个房间使用字段 length，width，height 存储有关其空间大小的信息。 想象一下，我们需要检索出所有可用房间的列表，并按照体积大小倒序排列。 你不可能使用 PHP 来计算体积，但是，由于我们需要按照它的值对这些记录进行排序，你依然需要 volume （体积） 来显示在这个列表中。 为了达到这个目标，你需要在你的 Room 活动记录类中声明一个额外的字段，它将存储 volume 的值：

class Room extends \yii\db\ActiveRecord
{
    public $volume;

    // ...
}
// 然后，你需要撰写一个查询，它可以计算房间的大小并执行排序：

$rooms = Room::find()
    ->select([
        '{{room}}.*', // select all columns
        '([[length]] * [[width]] * [[height]]) AS volume', // 计算体积
    ])
    ->orderBy('volume DESC') // 使用排序
    ->all();

foreach ($rooms as $room) {
    echo $room->volume; // 包含了由 SQL 计算出的值
}
// 额外字段的特性对于聚合查询非常有用。 假设您需要显示一系列客户的订单数量。 首先，您需要使用 orders 关系声明一个 Customer 类，并指定额外字段来存储 count 结果：

class Customer extends \yii\db\ActiveRecord
{
    public $ordersCount;

    // ...

    public function getOrders()
    {
        return $this->hasMany(Order::className(), ['customer_id' => 'id']);
    }
}
// 然后你可以编写一个查询来 JOIN 订单表，并计算订单的总数：

$customers = Customer::find()
    ->select([
        '{{customer}}.*', // select customer 表所有的字段
        'COUNT({{order}}.id) AS ordersCount' // 计算订单总数
    ])
    ->joinWith('orders') // 连接表
    ->groupBy('{{customer}}.id') // 分组查询，以确保聚合函数生效
    ->all();
// 使用此方法的一个缺点是，如果数据不是从 SQL 查询上加载的，它必须再单独计算一遍。 因此，如果你通过常规查询获取个别的数据记录时，它没有额外的 select 语句，那么它 将无法返回额外字段的实际值。新保存的记录一样会发生这种情。

$room = new Room();
$room->length = 100;
$room->width = 50;
$room->height = 2;

$room->volume; // 为 `null`, 因为它没有被声明（赋值）
// 通过 __get() 和 __set() 魔术方法 我们可以将属性赋予行为特性：

class Room extends \yii\db\ActiveRecord
{
    private $_volume;
    
    public function setVolume($volume)
    {
        $this->_volume = (float) $volume;
    }
    
    public function getVolume()
    {
        if (empty($this->length) || empty($this->width) || empty($this->height)) {
            return null;
        }
        
        if ($this->_volume === null) {
            $this->setVolume(
                $this->length * $this->width * $this->height
            );
        }
        
        return $this->_volume;
    }

    // ...
}
// 当 select 查询不提供 volume 体积时，这模型将能够自动计算体积的值出来， 当访问模型的属性的时候。

// 当定义关联关系的时候，你也可以计算聚合字段：

class Customer extends \yii\db\ActiveRecord
{
    private $_ordersCount;

    public function setOrdersCount($count)
    {
        $this->_ordersCount = (int) $count;
    }

    public function getOrdersCount()
    {
        if ($this->isNewRecord) {
            return null; // 这样可以避免调用空主键进行查询
        }

        if ($this->_ordersCount === null) {
            $this->setOrdersCount($this->getOrders()->count()); // 根据关联关系按需计算聚合字段
        }

        return $this->_ordersCount;
    }

    // ...

    public function getOrders()
    {
        return $this->hasMany(Order::className(), ['customer_id' => 'id']);
    }
}
// 使用此代码，如果 'select' 语句中存在 'ordersCount' - 它会从查询结果集获取数据填充 Customer::ordersCount 属性， 否则它会在被访问的时候，使用 Customer::orders 关联按需计算。

// 这种方法也适用于创建一些关联数据的快捷访问方式，特别是对于聚合。 例如：

class Customer extends \yii\db\ActiveRecord
{
    /**
     * 为聚合数据定义一个只读的虚拟属性
     */
    public function getOrdersCount()
    {
        if ($this->isNewRecord) {
            return null; //  这样可以避免调用空主键进行查询
        }
        
        return empty($this->ordersAggregation) ? 0 : $this->ordersAggregation[0]['counted'];
    }

    /**
     * 声明一个常规的 'orders' 关联
     */
    public function getOrders()
    {
        return $this->hasMany(Order::className(), ['customer_id' => 'id']);
    }

    /**
     * 基于 'orders' 关联，声明一个用于查询聚合的新关联
     */
    public function getOrdersAggregation()
    {
        return $this->getOrders()
            ->select(['customer_id', 'counted' => 'count(*)'])
            ->groupBy('customer_id')
            ->asArray(true);
    }

    // ...
}

foreach (Customer::find()->with('ordersAggregation')->all() as $customer) {
    echo $customer->ordersCount; // 输出关联的聚合数据，而不需要额外的查询，因为我们用了即时加载
}

$customer = Customer::findOne($pk);
$customer->ordersCount; // 从延迟加载的关联中，输出聚合数据

————————————————
文章来源于Yii官方文档：活动记录（Active Record）

PHP 7 新特性

2020-07-13T14:51:37.000Z

标量类型声明

标量类型声明有两种模式: 强制 (默认) 和严格模式。现在可以使用下列类型参数（无论用强制模式还是严格模式）：字符串 (string), 整数 (int), 浮点数 (float), 以及布尔值 (bool)。它们扩充了PHP5中引入的其他类型：类名，接口，数组和回调类型。

// 强制模式
function sumOfInts(int ...$ints)
{
    return array_sum($ints);
}

var_dump(sumOfInts(2, '3', 4.1));

以上例程会输出：

int(9)

要使用严格模式，一个 declare 声明指令必须放在文件的顶部。这意味着严格声明标量是基于文件可配的。这个指令不仅影响参数的类型声明，也影响到函数的返回值声明]

// 严格模式
declare(strict_types=1);
function sumOfInts(int ...$ints)
{
    return array_sum($ints);
}

var_dump(sumOfInts(2, '3', 4.1));

以上程序由于采用了严格模式，所以如果参数中出现不适整数的类型会报错，执行输出结果为：

PHP Fatal error:  Uncaught TypeError: Argument 2 passed to sumOfInts() must be of the type integer, string given...

返回值类型声明

PHP 7 增加了对返回类型声明的支持。类似于参数类型声明，返回类型声明指明了函数返回值的类型。可用的类型与参数声明中可用的类型相同。

function arraysSum(array ...$arrays): array
{
    return array_map(function(array $array): int {
        return array_sum($array);
    }, $arrays);
}

print_r(arraysSum([1,2,3], [4,5,6], [7,8,9]));

以上例程会输出：

Array(    [0] => 6    [1] => 15    [2] => 24)

null合并运算符

由于日常使用中存在大量同时使用三元表达式和 isset()的情况，我们添加了 null 合并运算符 (??) 这个语法糖。如果变量存在且值不为 NULL，它就会返回自身的值，否则返回它的第二个操作数。

// 如果$_GET['user']存在且不为空则返回它自己，否则返回合并运算符后面的值
$username = $_GET['user'] ?? 'nobody';
// 相当于:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// 多个合并运算符可以一起使用
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';

太空船操作符（组合比较符）

太空船操作符用于比较两个表达式。当 $a 小于、等于或大于 $b 时它分别返回 -1 0 或 1。比较的原则是沿用 PHP 的常规比较规则进行的。

// 整数
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

// 浮点数
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
 
// 字符串
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1

通过 define() 定义常量数组

Array 类型的常量现在可以通过 define() 来定义。在 PHP5.6 中仅能通过 const 定义。

define('ANIMALS', [
    'dog',
    'cat',
    'bird'
]);

echo ANIMALS[1]; // 输出 "cat"

匿名类

现在支持通过 new class 来实例化一个匿名类，这可以用来替代一些“用后即焚”的完整类定义。

interface Logger {
    public function log(string $msg);
}

class Application {
    private $logger;

    public function getLogger(): Logger {
         return $this->logger;
    }

    public function setLogger(Logger $logger) {
         $this->logger = $logger;
    }
}

$app = new Application;
$app->setLogger(new class implements Logger {
    public function log(string $msg) {
        echo $msg;
    }
});

var_dump($app->getLogger());

以上例程会输出：

object(class@anonymous)#2 (0) {}

Unicode codepoint 转译语法

这接受一个以16进制形式的 Unicode codepoint，并打印出一个双引号或 heredoc 包围的 UTF-8 编码格式的字符串。可以接受任何有效的 codepoint，并且开头的 0 是可以省略的。

echo “\u{aa}”;
echo “\u{0000aa}”;
echo “\u{9999}”;
以上例程会输出：

ªª (same as before but with optional leading 0's)香

Closure::call()

Closure::call() 现在有着更好的性能，简短干练的暂时绑定一个方法到对象上闭包并调用它。

class A {private $x = 1;}

// PHP 7 之前版本的代码
$getXCB = function() {return $this->x;};
$getX = $getXCB->bindTo(new A, 'A'); // 中间层闭包
echo $getX();

// PHP 7+ 及更高版本的代码
$getX = function() {return $this->x;};
echo $getX->call(new A);

以上例程会输出：

为unserialize()提供过滤

这个特性旨在提供更安全的方式解包不可靠的数据。它通过白名单的方式来防止潜在的代码注入。


// 将所有的对象都转换为 __PHP_Incomplete_Class 对象
$data = unserialize($foo, ["allowed_classes" => false]);

// 将除 MyClass 和 MyClass2 之外的所有对象都转换为 __PHP_Incomplete_Class 对象
$data = unserialize($foo, ["allowed_classes" => ["MyClass", "MyClass2"]);

// 默认情况下所有的类都是可接受的，等同于省略第二个参数
$data = unserialize($foo, ["allowed_classes" => true]);

IntlChar

新增加的 IntlChar 类旨在暴露出更多的 ICU 功能。这个类自身定义了许多静态方法用于操作多字符集的 unicode 字符。

1
2
3

printf('%x', IntlChar::CODEPOINT_MAX);
echo IntlChar::charName('@');
var_dump(IntlChar::ispunct('!'));

以上例程会输出：

10ffffCOMMERCIAL ATbool(true)

若要使用此类，请先安装Intl扩展

预期

预期是向后兼用并增强之前的 assert() 的方法。它使得在生产环境中启用断言为零成本，并且提供当断言失败时抛出特定异常的能力。

老版本的API出于兼容目的将继续被维护，assert()现在是一个语言结构，它允许第一个参数是一个表达式，而不仅仅是一个待计算的 string或一个待测试的boolean。

ini_set('assert.exception', 1);

class CustomError extends AssertionError {}

assert(false, new CustomError('Some error message'));

以上例程会输出：

Fatal error: Uncaught CustomError: Some error message

Group use declarations

从同一 namespace 导入的类、函数和常量现在可以通过单个 use 语句一次性导入了。


// PHP 7 之前的代码
use some\namespace\ClassA;
use some\namespace\ClassB;
use some\namespace\ClassC as C;

use function some\namespace\fn_a;
use function some\namespace\fn_b;
use function some\namespace\fn_c;

use const some\namespace\ConstA;
use const some\namespace\ConstB;
use const some\namespace\ConstC;

// PHP 7+ 及更高版本的代码
use some\namespace\{ClassA, ClassB, ClassC as C};
use function some\namespace\{fn_a, fn_b, fn_c};
use const some\namespace\{ConstA, ConstB, ConstC};

生成器可以返回表达式

此特性基于 PHP 5.5 版本中引入的生成器特性构建的。它允许在生成器函数中通过使用 return 语法来返回一个表达式（但是不允许返回引用值），可以通过调用 Generator::getReturn() 方法来获取生成器的返回值，但是这个方法只能在生成器完成产生工作以后调用一次。


$gen = (function() {
    yield 1;
    yield 2;

    return 3;
})();

foreach ($gen as $val) {
    echo $val, PHP_EOL;
}

echo $gen->getReturn(), PHP_EOL;

以上例程会输出：

在生成器中能够返回最终的值是一个非常便利的特性，因为它使得调用生成器的客户端代码可以直接得到生成器（或者其他协同计算）的返回值，相对于之前版本中客户端代码必须先检查生成器是否产生了最终的值然后再进行响应处理来得方便多了。

Generator delegation

现在，只需在最外层生成其中使用 yield from，就可以把一个生成器自动委派给其他的生成器， Traversable 对象或者 array。


function gen()
{
    yield 1;
    yield 2;

    yield from gen2();
}

function gen2()
{
    yield 3;
    yield 4;
}

foreach (gen() as $val)
{
    echo $val, PHP_EOL;
}

以上例程会输出：

整数除法函数 intdiv()

新加的函数 intdiv() 用来进行整数的除法运算。

1 2	`var_dump(intdiv(10, 3));`

以上例程会输出：

int(3)

会话选项

session_start() 可以接受一个 array 作为参数，用来覆盖 php.ini 文件中设置的会话配置选项。

在调用 session_start() 的时候，传入的选项参数中也支持 session.lazy_write 行为，默认情况下这个配置项是打开的。它的作用是控制 PHP 只有在会话中的数据发生变化的时候才写入会话存储文件，如果会话中的数据没有发生改变，那么 PHP 会在读取完会话数据之后，立即关闭会话存储文件，不做任何修改，可以通过设置 read_and_close 来实现。

例如，下列代码设置 session.cache_limiter 为 private，并且在读取完毕会话数据之后马上关闭会话存储文件。

session_start([
    'cache_limiter' => 'private',
    'read_and_close' => true,
]);

preg_replace_callback_array()

在 PHP 7 之前，当使用 preg_replace_callback() 函数的时候，由于针对每个正则表达式都要执行回调函数，可能导致过多的分支代码。而使用新加的 preg_replace_callback_array() 函数，可以使得代码更加简洁。

现在，可以使用一个关联数组来对每个正则表达式注册回调函数，正则表达式本身作为关联数组的键，而对应的回调函数就是关联数组的值。

CSPRNG Functions

新加入两个跨平台的函数： random_bytes() 和 random_int() 用来产生高安全级别的随机字符串和随机整数。

可以使用 list() 函数来展开实现了 ArrayAccess 接口的对象

在之前版本中，list() 函数不能保证正确的展开实现了 ArrayAccess 接口的对象，现在这个问题已经被修复。

其他特性

允许在克隆表达式上访问对象成员，例如： (clone $foo)->bar()。

————————————————
文章来源于PHP官方文档：PHP 5.6.x 移植到 PHP 7.0.x

安装 LNMP 环境

2020-07-05T03:37:09.000Z

安装

虚拟机中安装 centos 8（自行搜索,安装后只有命令行，图形界面需要另外安装）
切换 root 账号
```
  su root
```
使用 dhclient 命令为 centos 8 分配一个 ip 地址

使用vim编辑网卡配置，将上面分配所得的ip地址写入配置文件
```
  vim /etc/sysconfig/network-scripts/ifcfg-enp0s3
```
注意红框的修改的配置按 i 键插入编辑

按 Esc 键然后 :wq 保存退出
重启网卡使用 nmcli c reload 命令，ping 下百度发现网络可以用了

使用 dnf 取代了 yum 来进行包管理，安装 nginx、php、mysql
```
  dnf install nginx php mariadb-server php-mysqlnd
```

把 nginx、php-fpm、mariadb 加入到开机启动

  systemctl enable nginx  systemctl enable php-fpm  systemctl enable mariadb

启动 nginx、php-fpm、mariadb

  systemctl start nginx  systemctl start php-fpm  systemctl start mariadb

设置防火墙开放 tcp 80 和 tcp 3306 端口

  firewall-cmd --zone=public --add-port=80/tcp --permanent  firewall-cmd --zone=public --add-port=3306/tcp --permanent  firewall-cmd --reload

使用

nginx

浏览器访问服务器 ip

mysql

设置 mysql 数据库 root 账号密码

  mysqladmin -uroot  password  'your password'

root 账号登陆 mysql
```
  mysql -uroot -p
```
创建一个新用户 web，密码为 123456，授权远程计算机使用账号 web 登陆数据库，并立刻刷新权限
```
  MariaDB[(none)]>grant all on *.* to 'web'@'%'  identified by '123456';  MariaDB[(none)]>flush privileges;
```
退出 mysql 数据库
```
  MariaDB[(none)]> quit;
```

php

创建文件 index.php

  touch /usr/share/nginx/html/index.php  echo  "" > /usr/share/nginx/html/index.php

重启 nginx 服务，使用浏览器访问服务器 ip
```
  systemctl restart  nginx
```

PHP 面试问题整理

2020-06-25T02:05:23.000Z

PHP 的生命周期是什么？

PHP 生命周期有5个阶段：

模块初始化阶段 （module init）
- Zend 引擎的初始化操作。SAPI、FPM（master 进程）启动，加载扩展、模块初始化
请求初始化阶段 （request init）
- FPM 里 worker 进程接收一个请求并读取请求数据，PHP初始化本次请求所需的环境变量
PHP脚本执行阶段
- Zend 引擎接将 PHP 代码编译成 opcodes 并顺次执行
请求关闭阶段 （request shutdown）
- 按顺序调用各个模块的 RSHUTDOWN 方法，对每个变量调用 unset 函数
模块关闭阶段 （module shutdown）
- SAPI 关闭，进行资源的清理，关闭各个模块，关闭 FPM

数据库事务的理解？

数据库事务(transaction)是访问并可能操作各种数据项的一个数据库操作序列，这些操作要么全部执行,要么全部不执行，是一个不可分割的工作单位。事务由事务开始与事务结束之间执行的全部数据库操作组成。

原子性（Atomic）
- 事务要么全部完成，要么全部取消。如果事务崩溃，状态回到事务之前（事务回滚）。
一致性（Consitency）
- 只有合法的数据（依照关系约束和函数约束）才能写入数据库。
隔离性（Isolation）
- 如果2个事务 T1 和 T2 同时运行，事务 T1 和 T2 最终的结果是相同的，不管 T1和T2谁先结束。
持久性（Durability）
- 一旦事务提交，不管发生什么（崩溃或者出错），数据要保存在数据库中。

数据库设计范式是什么？

第一范式（1NF）
- 表中的列只能含有原子性(不可再分)的值。
第二范式（2NF）
- 满足第一范式，没有部分依赖
第三范式（3NF）
- 满足第二范式，没有传递依赖

PHP Swoole是什么？

PHP 协程框架

Swoole 使 PHP 开发人员可以编写高性能高并发的 TCP、UDP、Unix Socket、HTTP、 WebSocket 等服务，让 PHP 不再局限于 Web 领域。Swoole4 协程的成熟将 PHP 带入了前所未有的时期， 为性能的提升提供了独一无二的可能性。Swoole 可以广泛应用于互联网、移动通信、云计算、 网络游戏、物联网（IOT）、车联网、智能家居等领域。使用 PHP + Swoole 可以使企业 IT 研发团队的效率大大提升，更加专注于开发创新产品

PHP 和 Nginx 怎么交互的？

Nginx + PHP 的工程模式下，两位主角分工明确，Nginx 负责承载 HTTP 请求的响应与返回，以及超时控制记录日志等 HTTP 相关的功能，而PHP则负责处理具体请求要做的业务逻辑，它们俩的这种合作模式也是常见的分层架构设计中的一种，在它们各有专注面的同时，FastCGI 又很好的将两块衔接，保障上下游通信交互

发送 HTTP 请求 Nginx 接收
Nginx 解析到对应 PHP 文件
加载 Nginx 的 FastCGI 模块启动对应端口
PHP-FPM 监听对应端口，接收请求，启用 worker 进程处理
PHP-FPM 处理完请求，返回给 Nginx

MySQL 存储引擎有什么？

存储引擎其实就是对于数据库文件的一种存取机制，如何实现存储数据，如何为存储的数据建立索引以及如何更新，查询数据等技术实现的方法。

InnoDB
- 优点支持事务处理、崩溃修复能力和并发控制。缺点是读写效率较差，占用空间大。
MyISAM
- 优点占用空间小，处理速度快。缺点是不支持事务的完整性和并发性。
MEMORY
- 所有的数据存储在内存中，关闭机器数据消失。
ARCHIVE
- 提供了压缩功能，拥有高效的插入速度，不支持索引，所查询性能较差

PHP 网页跳转的方式？

header()函数;

1	`header('location:http://www.baidu.com');`

meta标签
1
echo '';

script标签;

echo'';

Redis 有几种类型?

String（字符串）
- 一个 key 对应一个 value。
- 一个 key 最大能存储 512MB
- 常用命令：set、get、decr、incr、mget
Hash（哈希）
- 键值(key => value)对集合，是一个 string 类型的 field 和 value 的映射表，特别适合用于存储对象
- 每个 hash 可以存储 2³² - 1 键值对（40多亿）
- 常用命令：hget、hset、hgetall
List（列表）
- 字符串列表，按照插入顺序排序。可以添加一个元素到列表的头部（左边）或者尾部（右边）
- 列表最多可以包含 2³² - 1 个元素 (40多亿)
- list 类型经常会被用于消息队列的服务，以完成多程序之间的消息交换
- 常用命令：lpush、rpush、lpop、rpop、lrange
Set（集合）
- Set 是 String 类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据
- 集合中最大的成员数为 2³² - 1 (40多亿)
- 常用命令：sadd、spop、smembers、sunion
Sorted Set（有序集合)
- 有序集合和集合一样也是 string 类型元素的集合,且不允许重复的成员
- 不同的是每个元素都会关联一个 double 类型的分数。redis 正是通过分数来为集合中的成员进行从小到大的排序
- 有序集合的成员是唯一的,但分数(score)却可以重复
- 集合中最大的成员数为 2³² - 1 (40多亿)
- 常用命令：zadd、zrange、zrem、zcard

PHP 数组在底层怎么实现的？

HashTable 是 zend 的核心数据结构，在PHP里面几乎并用来实现所有常见功能，我们知道的 PHP 数组即是其典型应用，此外，在 zend 内部，如函数符号表、全局变量等也都是基于 hash table 来实现

散列表（hashTable）具有如下特点
- 支持典型的 key => value 查询
- 可以当做数组使用
- 添加、删除节点是 O(1)复杂度
- key 支持混合类型：同时存在关联数组合索引数组
- Value 支持混合类型：array(“string”,2332)
- 支持线性遍历：如 foreach

微信授权登录的流程？

调用 wx.login() 获取 临时登录凭证code ，并回传到开发者服务器。
调用 auth.code2Session 接口，换取 用户唯一标识 OpenID 和 会话密钥 session_key。
具体思路如下
- 在 main.js 中封装公共函数，用于判断用户是否登录
- 在 main.js 中分定义全局变量，用于存储接口地址
- 如果没有登录、则跳转至登录页面
- 进入登录页面
- 通过 wx.login 获取用户的 code
- 通过 code 获取用户的 SessionKey、OpenId 等信息
- 通过 openId 调用后台 Api 获取用户的信息
- 获取成功，则说明已经授权过了,直接登录成功
- 获取失败，则说明没有授权过，需要授权之后才能进行登录
- 用户点击页面微信登录按钮 open-type=”getUserInfo”
- 获取用户数据，然后调用后台接口写入数据库

什么是消息队列 (Message Queue) ？

从本质上说消息对列就是一个队列结构的中间件，也就是说消息放入这个中间件之后就可以直接返回，并不需要系统立即处理，而另外会有一个程序读取这些数据，并按顺序进行逐次处理。
它有三个好处
- 异步
  - 用户注册后，需要发注册邮件和注册短信。传统的做法有两种 1.串行的方式；2.并行方式
  - 串行方式：将注册信息写入数据库成功后，发送注册邮件，再发送注册短信。以上三个任务全部完成后，返回给客户端
  - 并行方式：将注册信息写入数据库成功后，发送注册邮件的同时，发送注册短信。以上三个任务完成后，返回给客户端。
  - 消息队列：将注册信息写入数据库成功后，写入消息队列，异步读取需要发送的邮件和短信
- 解耦
  - 订单系统：用户下单后，订单系统完成持久化处理，将消息写入消息队列，返回用户订单下单成功
  - 库存系统：订阅下单的消息，采用拉/推的方式，获取下单信息，库存系统根据下单信息，进行库存操作
  - 假如：在下单时库存系统不能正常使用。也不影响正常下单，因为下单后，订单系统写入消息队列就不再关心其他的后续操作了。实现订单系统与库存系统的应用解耦
- 削峰/限流
  - 秒杀活动，一般会因为流量过大，导致流量暴增，应用挂掉。为解决这个问题，一般需要在应用前端加入消息队列
  - 可以控制活动的人数，缓解短时间内高流量压垮应用
  - 用户的请求，服务器接收后，首先写入消息队列。假如消息队列长度超过最大数量，则直接抛弃用户请求或跳转到错误页面
  - 秒杀业务根据消息队列中的请求信息，再做后续处理
使用PHP的数组函数 array_push、array_shift 实现一个队列



class QueueArray
{
    public $arr = array();
    
    public function tailEnqueue($val)
    {
        return array_push($this->arr, $val); // 队尾入队
    }
    
    public function tailDequeue()
    {
        return array_pop($this->arr); // 队尾出队
    }
    
    public function headEnqueue($val)
    {
        return array_unshift($this->arr, $val); // 队首入队
    }
    
    public function headDequeue()
    {
        return array_shift($this->arr); //队首出队
    }
    
    public function length()
    {
        return count($this->arr); // 队列长度
    }
    
    public function head()
    {
        return reset($this->arr); // 获取队首元素
    }
    
    public function tail()
    {
        return end($this->arr); // 获取队尾元素
    }
    
    public function clear()
    {
        unset($this->arr); // 清空队列
        return true;
    }
}

PHP 设计模式之单例模式（Singleton）

2020-06-22T08:08:19.000Z

单例模式被公认为是反面模式，为了获得更好的可测试性和可维护性，请使用『依赖注入模式』

1.8.1. 目的

在应用程序调用的时候，只能获得一个对象实例。

1.8.2. 例子

数据库连接
日志 (多种不同用途的日志也可能会成为多例模式)
在应用中锁定文件 (系统中只存在一个 …)

1.8.4. 代码部分

Singleton.php



namespace DesignPatterns\Creational\Singleton;

final class Singleton
{
    /**
    * @var Singleton
    */
    private static $instance;

    /**
    * 通过懒加载获得实例（在第一次使用的时候创建）
    */
    public static function getInstance(): Singleton
    {
        if (null === static::$instance) {
            static::$instance = new static();
        }

        return static::$instance;
    }

    /**
    * 不允许从外部调用以防止创建多个实例
    * 要使用单例，必须通过 Singleton::getInstance() 方法获取实例
    */
    private function __construct()
    {
    }

    /**
    * 防止实例被克隆（这会创建实例的副本）
    */
    private function __clone()
    {
    }

    /**
    * 防止反序列化（这将创建它的副本）
    */
    private function __wakeup()
    {
    }
}

1.8.5. 测试

Tests/SingletonTest.php



namespace DesignPatterns\Creational\Singleton\Tests;

use DesignPatterns\Creational\Singleton\Singleton;
use PHPUnit\Framework\TestCase;

class SingletonTest extends TestCase
{
    public function testUniqueness()
    {
        $firstCall = Singleton::getInstance();
        $secondCall = Singleton::getInstance();

        $this->assertInstanceOf(Singleton::class, $firstCall);
        $this->assertSame($firstCall, $secondCall);
    }
}

————————————————
原文作者：PHP 技术论坛文档：《PHP 设计模式全集（2018）》
转自链接：https://learnku.com/docs/php-design-patterns/2018/Singleton/1494
版权声明：翻译文档著作权归译者和 LearnKu 社区所有

在 PHP 中使用 cURL

2020-06-10T09:15:08.000Z

什么是cURL

先来看下维基百科的解释：

  cURL 是一个开源项目，主要的产品是 curl（命令行工具）和 libcurl（C语言的API库），两者功能均是：基于网络协议，对指定 URL 进行网络传输。  cURL 涉及是任何网络协议传输，不涉及对具体数据的具体处理。（如：html 的渲染等）

简单讲就是我们不用浏览器，在curl命令行工具就可以访问任意网址
PHP中集成了cURL库，那么我们就可以在代码上使用它的功能

在PHP中使用cURL

使用 cURL 函数的基本思想是先使用 curl_init() 初始化 cURL 会话，接着可以通过 curl_setopt() 设置需要的全部选项，然后使用 curl_exec() 来执行会话，当执行完会话后使用 curl_close() 关闭会话

其中最需要我们配置的是 curl_setopt() 这步,我们来看下这个函数的说明

/**
*  为 cURL 会话句柄设置选项。
*  @param resource $ch 返回的 cURL 句柄
*  @param int $option 需要设置的CURLOPT_XXX选项。
*  @param mixed $value 将设置在option选项上的值，可以接收多种类型的参数。
*  @return bool 成功时返回 TRUE， 或者在失败时返回 FALSE 
*/
curl_setopt( resource $ch, int $option, mixed $value) : bool

/*
 * 为 cURL 传输会话批量设置选项
 * @param resource $ch 返回的 cURL 句柄
 * @param array $options 一个 array 用来确定将被设置的选项及其值。数组的键值必须是一个有效的curl_setopt()常量或者是它们对等的整数值。 
 */
curl_setopt_array( resource $ch, array $options) : bool

option参数选项和值具体看官方文档，用的时候在查询
我们看下官方文档中使用 cURL 发送 POST 和 GET 封装后的函数

/** 
* Send a POST requst using cURL                              
* @param string $url to request 
* @param array $post values to send 
* @param array $options for cURL 
* @return string 
*/ 
function curl_post($url, array $post = array(), array $options = array()) 
{ 
    $defaults = array( 
        CURLOPT_POST => 1, // 发送 POST 请求
        CURLOPT_HEADER => 0, // 启用时会将头文件的信息作为数据流输出，这边不启用。 
        CURLOPT_URL => $url, // 需要获取的 URL 地址，也可以在curl_init() 初始化会话的时候
        CURLOPT_FRESH_CONNECT => 1, // 强制获取一个新的连接，而不是缓存中的连接
        CURLOPT_RETURNTRANSFER => 1, // 将curl_exec()获取的信息以字符串返回，而不是直接输出。
        CURLOPT_FORBID_REUSE => 1, // 在完成交互以后强制明确的断开连接，不能在连接池中重用
        // CURLOPT_TIMEOUT => 10, // 允许 cURL 函数执行的最长秒数，这边先不限制
        CURLOPT_POSTFIELDS => http_build_query($post), // 全部数据使用HTTP协议中的 "POST" 操作来发送，http_build_query返回一个 URL 编码后的字符串
        // 以下两个设置是为了防止访问没有SSL证书的网站报错
        CURLOPT_SSL_VERIFYPEER => 0, // 禁止 cURL 验证对等证书（peer'scertificate）。要验证的交换证书可以在 CURLOPT_CAINFO 选项中设置，或在 CURLOPT_CAPATH中设置证书目录。
        CURLOPT_SSL_VERIFYHOST => 0 // 设置为 1 是检查服务器SSL证书中是否存在一个公用名, 0 为不检查名称
    ); 

    $ch = curl_init(); 
    curl_setopt_array($ch, ($options + $defaults));
    if( ! $result = curl_exec($ch)) 
    { 
        trigger_error(curl_error($ch)); 
    } 
    curl_close($ch); 
    return $result; 
} 

/** 
* Send a GET requst using cURL 
* @param string $url to request 
* @param array $get values to send 
* @param array $options for cURL 
* @return string 
*/ 
function curl_get($url, array $get = array(), array $options = array()) 
{    
    $defaults = array( 
        CURLOPT_URL => $url. (strpos($url, '?') === FALSE ? '?' : ''). http_build_query($get), // 需要获取的 URL 地址，也可以在curl_init() 初始化会话的时候。 
        CURLOPT_HEADER => 0, // 启用时会将头文件的信息作为数据流输出。 
        CURLOPT_RETURNTRANSFER => TRUE, 
        // CURLOPT_TIMEOUT => 10,
        CURLOPT_SSL_VERIFYPEER => 0, 
        CURLOPT_SSL_VERIFYHOST => 0            
    ); 
    
    $ch = curl_init(); 
    curl_setopt_array($ch, ($options + $defaults)); 
    if( ! $result = curl_exec($ch)) 
    { 
        trigger_error(curl_error($ch)); 
    } 
    curl_close($ch); 
    return $result; 
}

发送GET/POST请求到接口交互数据

首先我们得有个运行PHP的环境，我这边使用 PHPStudy
其次在站点域名那里配置我们测试的 demo 的域名

以下为测试 demo
新建两个 php 文件：一个是提供数据的接口，创建一个数组然后转成 json 格式输出到浏览器；另个是使用 curl 获取数据的接口，使用上面封装好的 curl_get 和 curl_post 函数获取数据。


/**
 * 提供数据的类，
 */
class Data
{
    public function creatData()
    {
        $data = ['car'=>'Benz','book'=>'Little Prince','house'=>'The Ocean Villas'];
        echo json_encode($data);
    }
}

$data = new Data;
$data->creatData();


/**
* 获取数据的类
*/
class GetData
{
    public $url = 'http://127.0.0.1:1000/data.php';

    public function test_curl_get()
    {
        $result = $this->curl_get($this->url);
        var_dump(json_decode($result,true));
    }

    public function test_curl_post()
    {
        $result = $this->curl_post($this->url);
        var_dump(json_decode($result,true));
    }
    
    /**
    * Send a POST requst using cURL
    * @param string $url to request
    * @param array $post values to send
    * @param array $options for cURL
    * @return string
    */
    public function curl_post($url, array $post = array(), array $options = array())
    {
        $defaults = array(
            CURLOPT_POST => 1, // 发送 POST 请求
            CURLOPT_HEADER => 0, // 启用时会将头文件的信息作为数据流输出，这边不启用。
            CURLOPT_URL => $url, // 需要获取的 URL 地址，也可以在curl_init() 初始化会话的时候
            CURLOPT_FRESH_CONNECT => 1, // 强制获取一个新的连接，而不是缓存中的连接
            CURLOPT_RETURNTRANSFER => 1, // 将curl_exec()获取的信息以字符串返回，而不是直接输出。
            CURLOPT_FORBID_REUSE => 1, // 在完成交互以后强制明确的断开连接，不能在连接池中重用
            // CURLOPT_TIMEOUT => 10, // 允许 cURL 函数执行的最长秒数，这边先不限制
            CURLOPT_POSTFIELDS => http_build_query($post), // 全部数据使用HTTP协议中的 "POST" 操作来发送，http_build_query返回一个 URL 编码后的字符串
            // 以下两个设置是为了防止访问没有SSL证书的网站报错
            CURLOPT_SSL_VERIFYPEER => 0, // 禁止 cURL 验证对等证书（peer'scertificate）。要验证的交换证书可以在 CURLOPT_CAINFO 选项中设置，或在 CURLOPT_CAPATH中设置证书目录。
            CURLOPT_SSL_VERIFYHOST => 0 // 设置为 1 是检查服务器SSL证书中是否存在一个公用名, 0 为不检查名称
        );

        $ch = curl_init();
        curl_setopt_array($ch, ($options + $defaults));
        if (! $result = curl_exec($ch)) {
            trigger_error(curl_error($ch));
        }
        curl_close($ch);
        return $result;
    }

    /**
    * Send a GET requst using cURL
    * @param string $url to request
    * @param array $get values to send
    * @param array $options for cURL
    * @return string
    */
    public function curl_get($url, array $get = array(), array $options = array())
    {
        $defaults = array(
            CURLOPT_URL => $url. (strpos($url, '?') === false ? '?' : ''). http_build_query($get), // 需要获取的 URL 地址，也可以在curl_init() 初始化会话的时候。
            CURLOPT_HEADER => 0, // 启用时会将头文件的信息作为数据流输出。
            CURLOPT_RETURNTRANSFER => true,
            // CURLOPT_TIMEOUT => 10,
            CURLOPT_SSL_VERIFYPEER => 0,
            CURLOPT_SSL_VERIFYHOST => 0
        );
        
        $ch = curl_init();
        curl_setopt_array($ch, ($options + $defaults));
        if (! $result = curl_exec($ch)) {
            trigger_error(curl_error($ch));
        }
        curl_close($ch);
        return $result;
    }
}

$GetData = new GetData;
$GetData->test_curl_get();
$GetData->test_curl_post();

在浏览器访问写好的 demo

到此便使用curl成功获取到数据

使用 Github Pages 和 Hexo 搭建博客

2020-05-26T07:59:13.000Z

项目简介

当前项目是使用 Github Pages 和 Hexo 搭建的静态博客

Github Pages 是 GitHub 提供的一个网页寄存服务，于 2008 年推出。可以用于存放静态网页，包括博客、项目文档甚至整本书。Jekyll 软件可以用于将文档转换成静态网页，该软件提供了将网页上传到 Github Pages 的功能。一般 Github Pages 的网站使用 github.io 的子域名，但是用户也可以使用第三方域名。Hexo 是一个快速、简洁且高效的博客框架。Hexo 使用 Markdown（或其他渲染引擎）解析文章，在几秒内，即可利用靓丽的主题生成静态网页。

首先搭建 Github Pages
然后使用 Hexo 部署到 Github 远程仓库

Github Pages 的搭建方式

如果之前未使用过 Git，可以学习，Git 小白教程

创建名为 username.github.io 的仓库，username 是你的 github 的用户名，不是昵称
克隆到本地
git clone https://github.com/username/username.github.io
进入文件夹创建 index.html 文件
推送到 github 远程仓库
git add –all
git commit -m “Initial commit”
git push -u origin master
搭建完成，在浏览器打开 https://username.github.io 即可访问

Hexo 安装

安装前提

安装 hexo 相当简单，只需要先安装下列应用程序即可：

安装 Hexo

所有必备的应用程序安装完成后，即可使用 npm 安装 hexo。

$ npm install -g hexo-cli

对于熟悉 npm 的进阶用户，可以仅局部安装 Hexo 包。

$ npm install hexo

新建一个网站和启动服务器运行

$ hexo init  如果没有设置 folder hexo 默认在目前的文件夹建立网站$ hexo server 简写 $ hexo s 默认情况下，访问网址为： http://localhost:4000/

部署到 Github Pages

编辑 _config.yml 配置文件

  deploy:      type: git      repo: https://github.com/username/username.github.io.git      branch: master

hexo generate 生成静态文件。
hexo deploy
以上两步可以简写为 hexo g -d 或 hexo d -g

Hexo 目录结构

.├── _config.yml ├── package.json├── scaffolds├── source|   ├── _drafts|   └── _posts└── themes└── node_modules└── public└── .deploy_git

_config.yml

Hexo配置文件

package.json

应用程序的信息

scaffolds

模版件夹。当您新建文章时，Hexo 会根据 scaffold 来建立文件。Hexo 的模板是指在新建的文章文件中默认填充的内容。

source

资源文件夹是存放用户资源的地方。除 _posts 文件夹之外，开头命名为 _ (下划线)的文件 / 文件夹和隐藏的文件将会被忽略。Markdown 和 HTML 文件会被解析并放到 public 文件夹，而其他文件会被拷贝过去。

themes

主题文件夹。Hexo 会根据主题来生成静态页面。

特殊目录

node_modules， npm install hexo 生成的包和依赖
public ，hexo g 部署之前预先生成的静态文件
.deploy_git， hexo d 部署提交到 git 主干的目录

Hexo 发布文章

创建文章 hexo new “article title”
本地预览 hexo server
部署网站 hexo g -d 或 hexo d -g

多台电脑同步 Hexo 版本

问题：远程仓库存的是静态文件，换电脑就无法使用 hexo
解决思路：创建分支管理 hexo 源代码

克隆 username.github.io 仓库到本地

  git clone https://github.com/username/username.github.io.git

除 git 外的文件都删掉
整个 hexo 文件复制过来
切换并创建一个叫 hexo 的分支
```
  git checkout -b Hexo
```

提交到 hexo 分支

  git add .  git commit -m "新建分支"  git remote add origin https://github.com/username/username.github.io.git  git push -u origin hexo

Vue 基础知识总结

2020-05-23T02:33:22.000Z

一、常用指令

v-on 绑定一个事件缩写 @ 在 methods 类方法里面操作绑定的方法
v-bind 绑定一个属性缩写 : 在 data 数据对象里面操作绑定的数据
v-model 双向绑定通常用于获取 input 框输入的内容，无论那边更改都会同步值
v-for 基于数组或对象来循环渲染一个列表，语法：
1.循环数组，index 是数组的索引
1
v-for="(item,index) in items" :key="index"
2.循环对象，name 是对象的键值
1
v-for="(value, name, index) in object" :key="index"
3.为什么使用 v-for 时必须添加唯一的 key?
使用 v-for 更新已渲染的元素列表时，默认用就地复用策略;
列表数据修改的时候，他会根据 key 值去判断某个值是否修改，如果修改，则重新渲染这一项，否则复用之前的元素
v-if v-else v-else-if 动态添加或删除元素
v-show 添加元素的 display 样式控制显示或隐藏
v-html 输出 html 代码

二、常用属性

属性写法	名称	作用
data: {}	数据属性	用来存放需要绑定的数据
methods: {}	事件操作属性	用来放定义的事件方法
components: {}	组件属性	自定义组件声明
props: {}	获取父组件数据	单向绑定
computed: {}	计算属性	提供相对简单的数据计算
watch: {}	侦听器	观察某一特定question的值
directives: {}	自定义指令属性	注册内部自定义指令
filters: {}	过滤器	自定义过滤器
…

三、文件结构



<script>
import otherComponent from './OtherComponent.vue'
export default {
    // 常用属性
    components: {
      // 组件注册
      otherComponent
    },
    data () { 
      return {
        // 自定义数据
        msg: 'Hello world!'
      }
    },    
    create () {
      // 初始化
    },
    mounted () {
      // 挂载
      this.getData()
    },
    methods: {
      // 自定义方法
      getData(){
          console.log('success')
      }
    }
}
script>

<style>
  .example {
    color: red;
  }
style>

四、生命周期

Hello Hexo

2020-05-23T02:33:21.000Z

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1	`$ hexo new "My New Post"`

More info: Writing

Run server

1	`$ hexo server`

More info: Server

Generate static files

1	`$ hexo generate`

More info: Generating

Deploy to remote sites

1	`$ hexo deploy`

More info: Deployment

loquy

ASP.NET Core 使用教程

一、应用启动

1. 主机（Host）

2. 应用程序启动

3. 主机构建器（Host Builder）

4. Web 主机配置

5. 启动配置类（Startup Class）

6. 启动过程总结

二、依赖注入

1. 依赖注入的核心概念

2. 服务的生命周期

3. 自定义扩展方法注册 Services

4. 在 Startup.cs 中注册服务

三、中间件

1. 自定义中间件

1.1. 编写基于约定的中间件

1.2. 使用工厂模式的中间件

2. 分析中间件代码

3. 使用 WebApplication 创建中间件管道

4. 对请求管道进行短路

1. 为什么需要短路

2. 示例：静态文件中间件

3. 确保短路后正确处理

4. 示例：条件短路

51. 警告：避免在响应启动后调用 next.Invoke

6. 检查响应是否已启动

7. 示例：检查 HasStarted

5. 使用 Run 委托

6. 灵活的中间件调用

7. 确保中间件顺序正确

示例：中间件顺序的重要性

中间件执行顺序的示例

8. 对中间件管道进行分支

9. 使用 MapWhen 进行条件分支

10. 使用 UseWhen 进行条件分支

11. 内置中间件

四、配置

1. 配置源

2. 配置文件

3. 配置加载顺序

4. 读取配置

5. 强类型配置

5.1 定义配置类

5.2 绑定配置

5.3 使用配置

6. 环境特定的配置

6.1 设置环境变量

7. 用户机密

7.1 启用用户机密

7.2 添加用户机密

7.3 读取用户机密

8. 自定义配置源

8.1 实现自定义配置提供程序

8.2 实现自定义配置源

8.3 注册自定义配置源

五、日志

1. 内置日志记录提供程序

1.1 创建日志

1.2 配置日志记录

1.3 日志级别

1.4 日志消息模板

1.5 记录异常

1.6 默认日志级别

2. 第三方日志记录提供程序之 NLog

2.1. 安装

2.2. 创建 nlog.config 文件：

2.3. 更新 program.cs

2.4. Microsoft 日志记录过滤器

2.5. 使用

2.6. 示例输出

六、模型绑定

1. 路由参数

接收单个参数

2. URL 参数

接收单个参数

接收数组参数

接收对象参数

3. 请求体参数

接收单个参数

51. 警告：避免在响应启动后调用 `next.Invoke`

7. 示例：检查 `HasStarted`

9. 使用 `MapWhen` 进行条件分支

10. 使用 `UseWhen` 进行条件分支

2.2. 创建 `nlog.config` 文件：

2.3. 更新 `program.cs`

`dotnet ef dbcontext scaffold`

2. 配置 JWTBearer 身份验证：在 `Startup.cs` 文件的 `ConfigureServices` 方法中配置 JWTBearer 身份验证，并读取 `appsettings.json` 提供的配置。

3. 保护你的 API 端点：在需要保护的 API 控制器或方法上使用 `[Authorize]` 特性。

4. 生成和验证 JWT 令牌：当需要生成 JWT 令牌时，你可以使用 `System.IdentityModel.Tokens.Jwt` 或其他相关库。你可以使用提供的配置中的过期时间来设置令牌的有效期。