分类后端技术下的文章

2024-09-09

升级Spring Boot中的Spring框架版本，通常涉及以下步骤：

更新pom.xml或build.gradle文件中Spring Boot依赖项的版本。
确保新版本的Spring Boot兼容你要升级到的Spring框架版本。
清理并重新构建项目。
运行集成测试以确保新版本的Spring框架没有引入任何破坏性更改。

以下是使用Maven更新Spring Boot版本的示例：




<!-- 更新Spring Boot版本 -->
<properties>
    <spring-boot.version>2.6.3</spring-boot.version>
</properties>
 
<dependencies>
    <!-- 更新Spring Boot依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>${spring-boot.version}</version>
    </dependency>
 
    <!-- 其他Spring Boot依赖 -->
</dependencies>
 
<build>
    <plugins>
        <!-- 更新Spring Boot Maven插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>${spring-boot.version}</version>
        </plugin>
    </plugins>
</build>

确保查看Spring Boot的官方文档，以了解特定版本的兼容性信息。如果你使用Gradle，请相应地更新build.gradle文件。

在更新版本之后，执行Maven命令或Gradle任务来清理并重新构建项目：




# Maven
mvn clean install
 
# Gradle
./gradlew clean build

完成后，运行应用程序以确保一切正常。如果你有集成测试套件，也要运行它们以确保新版本的Spring框架没有引入任何不兼容的改动。

System

2024-09-09

所有,java

在Linux服务器上使用宝塔面板进行Spring Boot项目的Docker部署，你需要执行以下步骤：

安装Docker：在宝塔面板中安装Docker插件。
编写Dockerfile：在Spring Boot项目根目录创建Dockerfile文件。
构建Docker镜像：使用Docker命令行工具构建镜像。
运行Docker容器：使用Docker命令行工具运行容器。

以下是示例Dockerfile内容：




# 基于官方OpenJDK镜像
FROM openjdk:11-jre-slim
 
# 指定维护者信息
LABEL maintainer="yourname@example.com"
 
# 在镜像中创建一个目录存放我们的应用
VOLUME /tmp
 
# 将jar包添加到容器中并更名为app.jar
ADD target/your-app.jar app.jar
 
# 暴露容器内的端口给外部访问
EXPOSE 8080
 
# 定义环境变量
ENV JAVA_OPTS=""
 
# 在容器启动时运行jar包
ENTRYPOINT exec java $JAVA_OPTS -Djava.security.egd=file:/dev/./urandom -jar /app.jar

在宝塔面板中执行以下Docker命令进行部署：




# 进入Spring Boot项目的Dockerfile所在目录
cd /path/to/your-spring-boot-project
 
# 构建Docker镜像
docker build -t your-app .
 
# 运行Docker容器
docker run -d -p 8080:8080 --name your-app-instance your-app

确保你的Spring Boot应用配置了正确的端口（默认是8080），以及所需的环境变量和依赖。如果需要持久化数据，记得在Dockerfile中指定卷(VOLUME)。

注意：以上步骤仅供参考，具体实施时可能需要根据项目具体情况进行调整。

- 阅读更多 -

Spring Boot集成mapstruct快速入门指南

System

2024-09-09

所有,java




import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.factory.Mappers;
 
// 定义实体类
public class Source {
    private String name;
    private int age;
    // 省略其他属性和方法
}
 
public class Target {
    private String fullName;
    private int age;
    // 省略其他属性和方法
}
 
// 定义映射器接口
@Mapper
public interface SourceTargetMapper {
    SourceTargetMapper INSTANCE = Mappers.getMapper(SourceTargetMapper.class);
 
    @Mapping(source = "name", target = "fullName")
    Target sourceToTarget(Source source);
 
    default Source targetToSource(Target target) {
        // 这里可以实现反向映射，如果不需要可以省略
        return null;
    }
}
 
// 在Spring Boot应用中使用
public class Application {
    public static void main(String[] args) {
        Source source = new Source();
        source.setName("John");
        source.setAge(30);
 
        Target target = SourceTargetMapper.INSTANCE.sourceToTarget(source);
        // 使用target对象
    }
}

这个例子展示了如何在Spring Boot项目中使用MapStruct来简化对象映射的过程。首先定义了两个简单的实体类Source和Target。然后创建了一个映射器接口SourceTargetMapper，使用@Mapping注解指定了字段的映射关系。最后在应用的主类中演示了如何使用这个映射器将一个Source对象转换为Target对象。

- 阅读更多 -

SpringCloud整合Swagger3

System

2024-09-09

所有,java

Spring Cloud整合Swagger3的步骤如下：

在Spring Cloud项目的pom.xml中添加Swagger3的依赖：




<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-boot-starter</artifactId>
    <version>3.0.0</version>
</dependency>

创建Swagger配置类，通常是一个@Configuration类，如下：




import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.info.Info;
import io.swagger.v3.oas.models.info.License;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class SwaggerConfig {
 
    @Bean
    public OpenAPI customOpenAPI() {
        return new OpenAPI()
                .info(new Info()
                        .title("Your API Title")
                        .description("Your API Description")
                        .version("1.0.0")
                        .license(new License().name("Your License").url("https://yourlicense.com")));
    }
}

确保Spring Cloud项目的application.properties或application.yml中没有禁用Swagger的配置。
启动Spring Cloud应用，并访问http://<host>:<port>/swagger-ui/index.html来查看Swagger的API文档页面。

以上步骤可以整合Swagger3到Spring Cloud项目中。如果需要针对不同的分布式环境或者微服务架构进行额外配置，可能需要添加路由配置或者修改安全策略等。

- 阅读更多 -

Django5+React18前后端分离开发实战04 开发我们的后端服务

System

2024-09-09

所有,数据库




# 假设我们已经有了Django项目和React前端项目，以下是Django后端的一个简化示例。
 
# 在Django的views.py中创建一个API视图
from django.http import JsonResponse
from django.views.decorators.http import require_http_methods
from django.views.decorators.csrf import csrf_exempt
import json
 
# 假设我们有一个简单的用户模型和序列化器
from .models import User
from .serializers import UserSerializer
 
# 创建一个视图来获取所有用户
@csrf_exempt
def users_list(request):
    # 获取所有用户
    users = User.objects.all()
    serializer = UserSerializer(users, many=True)
    return JsonResponse(serializer.data, safe=False)
 
# 创建一个视图来获取单个用户
@csrf_exempt
def user_detail(request, pk):
    try:
        user = User.objects.get(pk=pk)
    except User.DoesNotExist:
        return JsonResponse({'error': 'User does not exist'}, status=404)
    
    if request.method == 'GET':
        serializer = UserSerializer(user)
        return JsonResponse(serializer.data)
 
    elif request.method == 'PUT':
        data = json.loads(request.body)
        serializer = UserSerializer(user, data=data)
        if serializer.is_valid():
            serializer.save()
            return JsonResponse(serializer.data)
        return JsonResponse(serializer.errors, status=400)
 
    elif request.method == 'DELETE':
        user.delete()
        return JsonResponse({'message': 'User was deleted successfully.'})
 
# 注册路由
# urls.py
from django.urls import path
from .views import users_list, user_detail
 
urlpatterns = [
    path('users/', users_list),
    path('users/<int:pk>/', user_detail),
]

这个示例展示了如何在Django中创建一个简单的RESTful API，包括获取所有用户和获取单个用户的接口。同时，它演示了如何使用JsonResponse返回JSON格式的响应，以及如何处理HTTP GET, PUT 和 DELETE 请求。注意，这个示例假设你已经有了User模型和UserSerializer，并且已经在Django项目中正确设置了路由。

- 阅读更多 -

L03_Redis知识图谱

System

2024-09-09

所有,redis

Redis 是一个开源的使用 C 语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value 数据库，并提供多种语言的 API。

以下是一个简单的 Python 示例，展示如何使用 Redis 的 Python 客户端 redis-py 来连接 Redis 服务器并执行一些基本操作：




import redis
 
# 连接到 Redis 服务器，默认运行在本地主机上，默认端口为 6379
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 设置键值对
r.set('key', 'value')
 
# 获取键的值
value = r.get('key')
print(value)  # 输出 b'value'，因为 Redis 返回的是字节字符串
 
# 检查键是否存在
exists = r.exists('key')
print(exists)  # 输出 True 或 False
 
# 删除键
r.delete('key')
 
# 获取数据库中所有的键
keys = r.keys('*')
print(keys)  # 输出所有键的列表
 
# 关闭连接
r.close()

这个示例展示了如何使用 redis-py 库来连接 Redis 服务器，设置键值对，获取键对应的值，检查键是否存在，删除键，获取所有键的列表，并在最后关闭连接。

- 阅读更多 -

ORACLE 11G AWR SNAPSHOT自动生成及保留时间设置

System

2024-09-09

所有,数据库

在Oracle 11g中，AWR（Automatic Workload Repository）报告的快照是自动生成的，保留策略由以下参数控制：

DBA_HIST_WRR_CONTROL：控制快照间隔。
DBA_HIST_GRANULARITY：控制快照的粒度。
DBA_HIST_SNAPSHOT：保存已生成的快照信息。
DBA_HIST_WR_CONTROL：控制保留策略。

快照间隔通过DBA_HIST_WRR_CONTROL动态参数设置，默认每1小时生成一次。保留策略通过DBA_HIST_WR_CONTROL参数设置，默认保留最近7天的数据。

要查看当前的快照间隔和保留设置，可以使用以下SQL命令：




-- 查看快照间隔
SELECT * FROM DBA_HIST_WRR_CONTROL;
 
-- 查看保留策略
SELECT * FROM DBA_HIST_WR_CONTROL;

如果需要修改这些设置，可以使用DBMS_WORKLOAD_REPOSITORY包中的过程。例如，要改变保留时间，可以使用DBMS_WORKLOAD_REPOSITORY.MODIFY_SNAPSHOT_SETTINGS过程。




-- 修改保留时间为30天
BEGIN
  DBMS_WORKLOAD_REPOSITORY.MODIFY_SNAPSHOT_SETTINGS(
    retention => 30*24,  -- 保留30天的数据
    interval => NULL    -- 不修改快照间隔
  );
END;
/

请注意，修改这些设置可能需要足够的权限，并且这些设置在实例重启后将保持有效。

在Oracle 11g中，AWR报告快照的生成和保留是自动进行的，但是用户可以根据需要进行调整。

System

2024-09-09

所有,elasticsearch

在2024年，进行ElasticSearch数据迁移的最新方法可能包括以下几种：

Elasticsearch Reindex API: 使用Elasticsearch自带的Reindex API可以在不同的Elasticsearch集群或者同一集群内的不同索引间迁移数据。




POST /_reindex
{
  "source": {
    "index": "source_index"
  },
  "dest": {
    "index": "dest_index"
  }
}

Snapshot and Restore: 使用Elasticsearch的快照和恢复功能可以迁移整个Elasticsearch集群或者集群中的某些索引。




# 创建快照
PUT /_snapshot/my_backup

# 恢复快照到新集群
POST /_snapshot/my_backup/snapshot_1/_restore

Logstash: 使用Logstash进行数据迁移，可以同步Elasticsearch数据到另一个Elasticsearch集群。




input {
  elasticsearch {
    hosts => ["http://old_es_host:9200"]
    index => "old_index"
  }
}
 
output {
  elasticsearch {
    hosts => ["http://new_es_host:9200"]
    index => "new_index"
  }
}

Elasticsearch SQL: 使用Elasticsearch SQL插件，可以将数据导出为CSV格式，然后通过其他方式进行迁移。




POST /_sql?format=txt
{
  "query": "SELECT * FROM \"old_index\""
}

Elasticsearch HQ: 第三方工具Elasticsearch HQ提供了一个图形界面来迁移数据。
Elasticsearch-dump: 使用elasticsearch-dump工具可以迁移数据。




elasticdump \
  --input=http://oldhost:9200/my_index \
  --output=http://newhost:9200/my_index \
  --type=data

请注意，这些方法可能需要根据实际情况进行调整，比如数据量大小、网络条件、集群配置等因素。在实际操作时，应该根据具体的需求和环境选择最适合的迁移方法。

- 阅读更多 -

redis的持久化

System

2024-09-09

所有,redis

Redis的持久化主要有两种方式：RDB（Redis DataBase）和AOF（Append Only File）。

RDB：定时将内存中的数据快照保存到磁盘的一个压缩二进制文件中。可以配置定时任务来控制快照的频率。

配置示例：




save 900 1      # 900秒内至少1个键被修改则触发保存
save 300 10     # 300秒内至少10个键被修改则触发保存
save 60 10000   # 60秒内至少10000个键被修改则触发保存
dbfilename dump.rdb  # RDB文件名
dir ./  # RDB文件存储目录

AOF：每个写命令都通过append操作保存到文件中。在服务重启时，通过重放这些命令来恢复数据。
配置示例：
```
appendonly yes  # 开启AOF
appendfilename "appendonly.aof"  # AOF文件名
appendfsync everysec  # 每秒同步一次至磁盘
```

可以同时使用RDB和AOF，以此来结合二者的优势。

注意：在实际生产环境中，应当根据数据的重要性和服务的可用性要求来选择合适的持久化策略。如果对数据持久性要求极高，应使用AOF，并配合适当的文件系统备份策略。如果对性能有较高要求，可以使用RDB，并适当调整保存快照的频率。

System

2024-09-09

所有,数据库

LengthFieldBasedFrameDecoder是Netty框架中的一个解码器，用于解决TCP协议下的拆包和粘包问题。

解码器的工作原理是根据指定的长度字段来确定一个完整的数据帧的开始和结束位置，从而正确地拆分出原始的数据包。

以下是一个使用LengthFieldBasedFrameDecoder的示例代码：




import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
 
public class EchoServer {
 
    private int port;
 
    public EchoServer(int port) {
        this.port = port;
    }
 
    public void start() throws Exception {
        final EchoServerHandler serverHandler = new EchoServerHandler();
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(1024, 0, 2, 0, 2));
                     ch.pipeline().addLast(serverHandler);
                 }
             })
             .option(ChannelOption.SO_BACKLOG, 128)
             .childOption(ChannelOption.SO_KEEPALIVE, true);
 
            ChannelFuture f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
 
    public static void main(String[] args) throws Exception {
        int port = 8080;
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        }
        new EchoServer(port).start();
    }
}

在上述代码中，LengthFieldBasedFrameDecoder被添加到了ChannelPipeline中。它的构造方法参数说明如下：

1024：表示对于单个数据帧的最大长度限制。
0：表示长度字段的起始位置。
2：表示长度字段本身的长度。
0：表示长度字段中包含的数据部分起始于帧中的何处。
2：表示长度字段的计量单位。

这个解码器通过定义帧的开始和结束，以及长度字段的位置和大小，有效地解决

- 阅读更多 -