分类后端技术下的文章

2024-09-02

所有,数据库

要在PostgreSQL中实现定时自动备份，你可以使用cron（Linux）或者任务计划器（Windows）来定时执行备份命令。以下是一个使用pg_dump命令进行数据库备份的例子，并将备份文件保存在一个指定的目录中。

Linux系统（使用cron）:

编辑crontab文件:
```
crontab -e
```
添加一个新行来设定定时任务，例如每天凌晨1点执行备份:
```
0 1 * * * /usr/bin/pg_dump -U your_username -W -F t -f /path/to/backup/dbname.tar.gz dbname
```
解释:
- 0 1 * * * 是cron时间设置，意味着每天1点执行任务。
- /usr/bin/pg_dump 是pg_dump程序的路径，可能需要根据实际安装位置调整。
- -U your_username 是PostgreSQL的用户名。
- -W 强制pg_dump在执行时提示输入密码。
- -F t 指定输出格式为tar文件。
- -f /path/to/backup/dbname.tar.gz 是备份文件的存储路径和文件名。
- dbname 是你要备份的数据库名。
保存并退出crontab编辑器。

Windows系统（使用任务计划器）:

打开任务计划程序。
创建基本任务。
设定触发器，比如每天凌晨1点。
作为操作选择"启动程序"。
在"程序/脚本"框中，输入pg_dump的完整路径，例如C:\Program Files\PostgreSQL\13\bin\pg_dump.exe（路径根据实际安装位置确定）。
在"添加参数"框中，输入命令行参数，如 -U your_username -W -F t -f \path\to\backup\dbname.tar.gz dbname。
完成任务创建。

确保你的备份路径是有效的，并且PostgreSQL的可执行文件对任务计划程序是可访问的。如果你的系统环境变量中没有包含pg_dump的路径，你可能需要在程序路径中提供完整的文件目录。

这些步骤会创建一个定时任务，在指定时间执行数据库备份。记得替换示例中的用户名、路径和数据库名为你自己的信息，并确保你的备份路径是可写的。

Golang 标签与 goto

2024-09-02

所有,golang

在 Go 语言中，goto 语句允许无条件地转移到过程中的某个标签行。然而，goto 语句通常被认为是有害的，因为它可能导致代码难以理解和维护。在实际编程中，应尽量避免使用 goto 语句，而改用循环和条件判断。

以下是一个使用 goto 语句和标签的示例代码：




package main
 
import "fmt"
 
func main() {
Label:
    for i := 0; i < 10; i++ {
        for j := 0; j < 10; j++ {
            if i*j > 5 {
                goto Label
            }
            fmt.Printf("i: %d, j: %d\n", i, j)
        }
    }
}

在这个例子中，我们有一个双层循环，内层循环用于打印 i 和 j 的值。当 i 和 j 的乘积大于 5 时，goto 语句将控制转移到 Label 标签，这会导致内层循环结束，i 递增，进入下一个内层循环。这个过程会一直重复，直到 i*j 不再大于 5 为止。

这个例子展示了 goto 语句的基本用法，但是在实际编程中，应该尽量避免使用 goto 语句，因为它会使代码的流程变得不清晰，容易造成代码错误和难以维护。

【SpringBoot】00 Maven配置及创建项目

2024-09-02

在IDEA中创建SpringBoot项目，首先需要配置Maven环境。

打开IDEA，点击Create New Project。
在左侧选择Spring Initializr，然后在右侧的SDK中选择你的JDK版本，比如我这里选择的是1.8版本。
点击Next，在弹出的窗口中填写GroupId和ArtifactId，GroupId一般是组织或公司的域名反写，ArtifactId是项目的唯一身份标识。
点击Next，选择需要的Spring Boot版本，以及需要的依赖。
点击Next，填写项目名和项目位置，然后点击Finish。

以上步骤完成后，IDEA会自动帮你生成SpringBoot项目，并配置好Maven。

以下是pom.xml文件的内容：




<?xml version="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.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

以上就是创建SpringBoot项目的全过程以及pom.xml的配置。

SpringBoot——Swagger2 接口规范

2024-09-02

在Spring Boot项目中使用Swagger2可以帮助我们生成API文档，并提供在线的接口测试功能。以下是一个简单的例子，展示如何在Spring Boot项目中集成Swagger2。

添加依赖到pom.xml：




<dependencies>
    <!-- Swagger2 -->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>2.9.2</version>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>2.9.2</version>
    </dependency>
</dependencies>

创建Swagger2配置类：




import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
 
@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any())
                .build();
    }
}

在Controller中使用Swagger注解标注接口规范：




import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
@Api(value = "用户管理接口", tags = "UserController", description = "提供用户的增删改查操作")
public class UserController {
 
    @GetMapping("/user")
    @ApiOperation(value = "获取用户信息", notes = "根据用户ID获取用户信息")
    public String getUser(@RequestParam(value = "id") String id) {
        return "获取用户信息，用户ID：" + id;
    }
}

启动Spring Boot应用，并访问http://localhost:8080/swagger-ui.html查看生成的API文档。

以上代码提供了一个简单的Swagger2集成示例，包括配置类和一个使用Swagger注解的Controller。通过这个示例，开发者可以学习如何在Spring Boot项目中集成Swagger2，并使用Swagger2来规范化和文档化API接口。

2024-09-02

所有,redis




@RestController
public class LoginController {
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody UserLoginIn userLoginIn){
        // 假设验证用户是通过的
        boolean isVerify = UserVerify.verify(userLoginIn.getUsername(), userLoginIn.getPassword());
        if (!isVerify){
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("登录失败");
        }
        // 生成Token
        String token = JwtUtils.generateToken(userLoginIn.getUsername());
        // 存储Token到Redis，假设有效期为1天
        redisTemplate.opsForValue().set(token, token, 1, TimeUnit.DAYS);
        return ResponseEntity.ok(token);
    }
 
    @GetMapping("/validate")
    public ResponseEntity<?> validateToken(@RequestHeader("Authorization") String token){
        // 从Redis获取Token进行比对
        String redisToken = redisTemplate.opsForValue().get(token);
        if (redisToken == null || !redisToken.equals(token)){
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Token失效或未认证");
        }
        return ResponseEntity.ok("Token有效");
    }
}
 
// 假设的UserLoginIn类
class UserLoginIn {
    private String username;
    private String password;
    // getter和setter略
}
 
// 假设的UserVerify类
class UserVerify {
    static boolean verify(String username, String password){
        // 假设验证逻辑，返回验证结果
        return "user".equals(username) && "pass".equals(password);
    }
}
 
// 假设的JwtUtils工具类
class JwtUtils {
    static String generateToken(String username){
        // 假设的JWT生成逻辑，返回生成的Token
        return "Bearer ey123...";
    }
}

这个代码示例展示了如何在Spring Boot项目中使用JWT和Redis来完成登录流程和Token验证。在login接口中，用户提交用户名和密码进行登录，成功后生成JWT Token并将其存储到Redis中。在validateToken接口中，通过从Redis获取Token与请求中的Token进行比对，来验证Token的有效性。这个示例假设了一些工具类和方法的实现，实际应用中需要根据项目具体情况进行调整。

MariaDB权限详解

2024-09-02

所有,数据库

MariaDB的权限系统基于用户对数据库的操作权限。以下是MariaDB权限的详细解释和示例：

权限类型：
- SELECT：允许查询数据。
- INSERT：允许插入数据。
- UPDATE：允许更新数据。
- DELETE：允许删除数据。
- CREATE：允许创建数据库和表。
- DROP：允许删除数据库和表。
- RELOAD：允许执行刷新操作，如刷新日志等。
- SHUTDOWN：允许关闭数据库。
- PROCESS：允许查看进程信息。
- FILE：允许导入和导出数据。
- REFERENCES：保留，未使用。
- INDEX：允许创建和删除索引。
- ALTER：允许修改表结构。
- SHOW DATABASES：允许查看所有数据库的列表。
- SUPER：允许执行更高级的操作，如杀死其他用户的线程。
- TRIGGER：允许创建和删除触发器。
- CREATE TEMPORARY TABLES：允许创建临时表。
- CREATE VIEW：允许创建视图。
- SHOW VIEW：允许查看视图。
- CREATE ROUTINE：保留，未使用。
- ALTER ROUTINE：保留，未使用。
- EXECUTE：保留，未使用。
- REPLICATION CLIENT：允许查看主/从二进制日志。
- REPLICATION SLAVE：允许复制主服务器的二进制日志。
- USAGE：无权限，用于登录。
权限级别：
- 全局权限：适用于整个数据库实例。
- 数据库权限：适用于特定数据库。
- 表权限：适用于特定数据库中的表。
- 列权限：适用于特定表的列。
权限管理命令：
- GRANT：授予用户权限。
- REVOKE：回收用户权限。
示例代码：




-- 创建用户
CREATE USER 'username'@'hostname' IDENTIFIED BY 'password';
 
-- 授予权限
GRANT SELECT, INSERT ON database.table TO 'username'@'hostname';
 
-- 设置权限生效
FLUSH PRIVILEGES;
 
-- 回收权限
REVOKE INSERT ON database.table FROM 'username'@'hostname';

在这个例子中，我们首先创建了一个新用户。然后，我们授予了用户对特定数据库和表的SELECT和INSERT权限。使用FLUSH PRIVILEGES命令使权限更改立即生效。最后，我们回收了用户的INSERT权限。

确保替换'username'、'hostname'和'password'为实际的用户名、主机名和密码。'database.table'是指定数据库和表的名字。

2024-09-02

报错解释：

这个错误通常发生在Spring Boot应用程序中配置数据库连接时。错误信息表明没有指定数据库的URL，同时也没有配置嵌入式数据源。

解决方法：

检查你的Spring Boot配置文件（如application.properties或application.yml），确保你已经正确配置了数据库的URL。例如，对于application.properties，你应该有类似这样的配置：




spring.datasource.url=jdbc:mysql://localhost:3306/your_database
spring.datasource.username=your_username
spring.datasource.password=your_password

对于YAML格式的配置文件，它看起来像这样：




spring:
  datasource:
    url: jdbc:mysql://localhost:3306/your_database
    username: your_username
    password: your_password

如果你正在使用内存数据库（如H2, HSQLDB, Derby），确保你的配置没有问题，并且依赖项已经包含在你的项目中。
如果你不需要配置数据库（例如，你的应用不使用数据库），确保你的配置文件中没有包含与数据库相关的属性，或者在配置类中正确地配置了数据源。
如果你正在使用Spring Boot的自动配置特性，确保你的项目依赖中包含了正确的starter。例如，对于JPA/JDBC，你应该包含spring-boot-starter-jdbc或spring-boot-starter-data-jpa。
如果你是通过Java配置类配置数据源的，确保你的配置类上有@Configuration注解，并且@Bean方法提供了DataSource实例。

确保你的配置与你的数据库连接需求相匹配，并且所有必要的配置都已经提供。如果问题依然存在，可能需要进一步检查你的Spring Boot版本和依赖关系，以确保没有版本冲突或缺失的特性。

mysql-DBA-日志-数据库复制

2024-09-02

所有,数据库

在MySQL中，数据库复制是一种将数据从一个数据库（主数据库）自动复制到一个或多个其他数据库（从数据库）的机制。这通常是通过二进制日志（binary log）实现的，主数据库记录所有更改的二进制日志，这些日志然后可以传输到从数据库并重新应用于从数据库的数据。

以下是配置简单的MySQL数据库复制的步骤：

在主服务器上，确保有一个唯一的服务器ID，并启用二进制日志。
在每个从服务器上，配置一个唯一的服务器ID，并指定要复制的主服务器。
在主服务器上为从服务器创建一个用户账号，该账号具有复制权限。
在从服务器上启动IO线程和SQL线程以连接到主服务器并开始复制数据。

以下是相关的配置示例：

主服务器的my.cnf配置：




[mysqld]
server-id=1
log_bin=mysql-bin

创建复制用户：




CREATE USER 'replica'@'%' IDENTIFIED BY 'replica_password';
GRANT REPLICATION SLAVE ON *.* TO 'replica'@'%';

从服务器的my.cnf配置：




[mysqld]
server-id=2

开始复制：




CHANGE MASTER TO
MASTER_HOST='master_host_ip',
MASTER_USER='replica',
MASTER_PASSWORD='replica_password',
MASTER_LOG_FILE='mysql-bin.000001',
MASTER_LOG_POS=0;
 
START SLAVE;

请注意，这些配置和命令是基本的示例，您可能需要根据您的实际配置进行调整，包括指定正确的主服务器地址、日志文件和位置。在生产环境中，还需要考虑更多的配置选项，如并发、安全性、故障转移和监控等。

2024-09-02




// Spring Boot Controller 获取并处理前端请求
@RestController
@RequestMapping("/api/jvm")
public class JvmController {
 
    @Autowired
    private JvmService jvmService;
 
    // 获取所有的 JVM 监控数据
    @GetMapping("/all")
    public ResponseEntity<List<JvmDto>> getAllJvmMonitoringData() {
        List<JvmDto> jvmDtoList = jvmService.getAllJvmMonitoringData();
        return ResponseEntity.ok(jvmDtoList);
    }
 
    // 获取特定 JVM 监控数据
    @GetMapping("/{id}")
    public ResponseEntity<JvmDto> getJvmMonitoringDataById(@PathVariable("id") Long id) {
        JvmDto jvmDto = jvmService.getJvmMonitoringDataById(id);
        return ResponseEntity.ok(jvmDto);
    }
 
    // 添加新的 JVM 监控数据
    @PostMapping("/")
    public ResponseEntity<JvmDto> addNewJvmMonitoringData(@RequestBody JvmDto jvmDto) {
        jvmService.addNewJvmMonitoringData(jvmDto);
        return ResponseEntity.ok(jvmDto);
    }
 
    // 更新现有的 JVM 监控数据
    @PutMapping("/{id}")
    public ResponseEntity<JvmDto> updateExistingJvmMonitoringData(@PathVariable("id") Long id, @RequestBody JvmDto jvmDto) {
        jvmService.updateExistingJvmMonitoringData(id, jvmDto);
        return ResponseEntity.ok(jvmDto);
    }
 
    // 删除特定的 JVM 监控数据
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteJvmMonitoringDataById(@PathVariable("id") Long id) {
        jvmService.deleteJvmMonitoringDataById(id);
        return ResponseEntity.noContent().build();
    }
}

在这个代码实例中，我们定义了一个JvmController类，它使用JvmService处理所有与 JVM 监控数据相关的 HTTP 请求。这个类中的方法展示了如何使用 Spring Boot 创建 REST API，以及如何使用@RestController和@RequestMapping注解来定义路由。同时，使用了@GetMapping、@PostMapping、@PutMapping和@DeleteMapping注解来处理 GET、POST、PUT 和 DELETE 请求。这个例子为开发者提供了一个如何在 Spring Boot 中实现 REST API 的简单参考。

SpringBoot之JWT令牌校验

2024-09-02




import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import org.springframework.stereotype.Service;
 
import java.util.Date;
 
@Service
public class JwtTokenProvider {
 
    private String secretKey = "secret";
 
    // 创建JWT令牌
    public String createToken(String username) {
        long now = System.currentTimeMillis();
        Date expiryDate = new Date(now + 3600_1000); // 令牌有效期1小时
        String token = Jwts.builder()
                .setIssuedAt(new Date(now))
                .setExpiration(expiryDate)
                .claim("username", username)
                .signWith(io.jsonwebtoken.SignatureAlgorithm.HS256, secretKey)
                .compact();
        return token;
    }
 
    // 解析JWT令牌
    public Claims parseToken(String token) {
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(token)
                .getBody();
    }
}

这段代码提供了一个简单的JWT令牌生成和解析的例子。在实际应用中，你需要根据自己的需求来设置密钥、过期时间等参数。记住，在实际生产环境中，密钥应该是安全的，并且要定期更新。