【已解决】报错“copying a param with shape torch.Size([1280, 1280]) from checkpoint”
System
2024-09-03
所有,AIGC

报错信息不完整，但根据提供的部分信息，可以推测这是关于PyTorch框架在处理深度学习模型时遇到的一个错误。错误信息中提到了torch.Size([1280, 1280])，这表明有一个形状为1280x1280的张量正在被复制，并且这个操作要么是在使用了CUDA的环境下进行的，要么涉及到了GPU内存的分配与使用。

错误的可能原因是：

  1. 尝试将一个大的张量复制到GPU内存中，但GPU内存不足以存储这个张量。
  2. 代码中可能存在逻辑错误，导致了不必要的大型张量复制。

解决方法：

  1. 检查模型的内存消耗，优化模型结构或减少批量大小，以减少内存需求。
  2. 如果使用了CUDA，可以尝试减少工作数据量或使用更大的GPU。
  3. 检查代码逻辑，避免不必要的大型张量复制。
  4. 如果可能，尝试使用更现代的硬件，或者增加硬件资源（如增加显存更大的GPU）。

由于错误信息不完整，请根据实际情况进行相应的调整和优化。

- 阅读更多 -
基于redisson实现发布订阅（多服务间用避坑）
System
2024-09-03
所有,redis

在多服务环境下，使用Redisson实现发布订阅模式时，需要确保所有服务实例都使用相同的Redis节点或集群。这样，即使消息发布者和订阅者分布在不同的服务中，它们也能够接收到同样的消息。

以下是使用Redisson进行发布订阅的基本步骤和示例代码：

  1. 添加Redisson依赖到项目中。
  2. 配置Redisson客户端。
  3. 创建发布者和订阅者。

以下是一个简单的例子：




import org.redisson.Redisson;
import org.redisson.api.RTopic;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
 
public class RedissonPubSubExample {
 
    public static void main(String[] args) {
        // 配置Redisson客户端连接到Redis服务器
        SingleServerConfig config = new SingleServerConfig();
        config.setAddress("redis://127.0.0.1:6379");
 
        // 创建Redisson实例
        Redisson redisson = Redisson.create(config);
 
        // 获取一个Topic对象
        RTopic<String> topic = redisson.getTopic("myTopic");
 
        // 创建订阅者
        topic.addListener(String.class, (channel, message) -> {
            System.out.println("Received message: " + message);
        });
 
        // 发布消息
        topic.publish("Hello, Redisson!");
 
        // 关闭Redisson客户端
        redisson.shutdown();
    }
}

在这个例子中，我们配置了Redisson客户端连接到本地运行的Redis服务器。然后，我们创建了一个RTopic对象，该对象代表了一个发布订阅频道。我们向该频道添加了一个监听器，该监听器会在有消息发布到该频道时接收消息。最后，我们通过publish方法发布了一条消息，并在订阅者接收到消息后关闭了Redisson客户端。

确保所有服务实例使用相同的Redis节点或集群，并且订阅的频道名称相同。这样，即使发布者和订阅者分布在不同的服务中，它们也能够通过Redis进行正确的消息传递。

- 阅读更多 -
elementUI 表格滚动分页加载请求数据
System
2024-09-03
所有,elementui

在使用Element UI的表格（el-table）进行滚动加载时，你可以监听表格的滚动事件，并在用户滚动到表格底部时触发加载更多数据的操作。以下是一个简单的例子：




<template>
  <el-table
    :data="tableData"
    height="400"
    @scroll="handleScroll"
    v-loading="loading"
  >
    <!-- 列配置 -->
  </el-table>
</template>
 
<script>
export default {
  data() {
    return {
      tableData: [],
      loading: false,
      page: 1,
      pageSize: 10,
      total: 0,
    };
  },
  methods: {
    fetchData() {
      this.loading = true;
      // 模拟异步请求数据
      setTimeout(() => {
        // 这里应该是发起请求获取数据
        const start = (this.page - 1) * this.pageSize;
        const end = start + this.pageSize;
        this.tableData = Array.from({ length: this.pageSize }, (_, i) => ({
          id: start + i,
          name: `Name ${start + i}`,
          // ...其他数据
        }));
        this.total = 100; // 假设总数据量为100
        this.loading = false;
      }, 1000);
    },
    handleScroll(event) {
      const target = event.target;
      // 检查是否滚动到底部
      if (target.scrollHeight - target.scrollTop <= target.clientHeight) {
        if (this.tableData.length < this.total) {
          this.page += 1;
          this.fetchData();
        }
      }
    }
  },
  mounted() {
    this.fetchData();
  }
};
</script>

在这个例子中，我们设置了表格的height属性，使其可以滚动。当表格滚动到底部时，我们通过监听scroll事件来判断并加载更多数据。fetchData方法用于异步获取数据，并模拟了一个请求过程。在实际应用中，你需要替换这部分代码以发起真实的网络请求，并处理返回的数据。

- 阅读更多 -
springboot实现过滤器
System
2024-09-03
所有,java

在Spring Boot中实现一个过滤器，你需要定义一个过滤器类并实现javax.servlet.Filter接口。然后，你可以使用@WebFilter注解或者在配置类中用@Bean注解来注册这个过滤器。

下面是一个简单的例子：

  1. 创建过滤器类：



import javax.servlet.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
 
public class SimpleCORSFilter implements Filter {
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletResponse res = (HttpServletResponse) response;
        res.setHeader("Access-Control-Allow-Origin", "*");
        res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT");
        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
        chain.doFilter(request, response);
    }
 
    @Override
    public void init(FilterConfig filterConfig) {
        // 初始化代码，如果有必要的话
    }
 
    @Override
    public void destroy() {
        // 销毁代码，如果有必要的话
    }
}
  1. 注册过滤器：



import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class FilterConfig {
 
    @Bean
    public FilterRegistrationBean simpleCORSFilter() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(new SimpleCORSFilter());
        registration.addUrlPatterns("/*");
        registration.setName("simpleCORSFilter");
        registration.setOrder(1);
        return registration;
    }
}

在这个例子中，SimpleCORSFilter过滤器设置了响应头，允许跨域资源共享。然后，我们通过FilterRegistrationBean将其注册为一个Spring Bean，并指定它应用于所有URL模式("/*")。

- 阅读更多 -
MySQL自传
System
2024-09-03
所有,数据库

MySQL自传是一个非常形象的比喻，它是指MySQL数据库的复制过程中，一台服务器（主服务器）将数据发送到另一台服务器（从服务器）的过程。在MySQL中，自传可以是基于行的复制（row-based replication）或者是基于语句的复制（statement-based replication）。

在MySQL中设置自传，你需要在主服务器上配置一个用户，该用户拥有对从服务器复制操作的权限，然后在主服务器上记录二进制日志（binary log），这些日志包含了所有导致数据改变的SQL语句。然后，从服务器连接到主服务器，并请求这些日志文件，最后应用这些日志到自己的数据库上。

以下是一个简化的例子，展示如何在主服务器上创建复制用户和配置二进制日志：




-- 在主服务器上
CREATE USER 'replica'@'%' IDENTIFIED BY 'replica_password';
GRANT REPLICATION SLAVE ON *.* TO 'replica'@'%';
SHOW MASTER STATUS;

在从服务器上，你需要配置一个连接到主服务器的复制用户，并开始复制过程：




-- 在从服务器上
CHANGE MASTER TO
  MASTER_HOST='主服务器IP',
  MASTER_USER='replica',
  MASTER_PASSWORD='replica_password',
  MASTER_LOG_FILE='记录的log文件名',
  MASTER_LOG_POS=记录的log位置;
 
START SLAVE;

这只是一个基本的设置示例，实际的自传配置可能会涉及更多的配置选项，比如过滤复制的数据、使用SSL连接、处理复制延迟等等。

- 阅读更多 -
Spring Boot 中 Controller 接口参数注解全攻略与实战案例详解
System
2024-09-03
所有,java

在Spring Boot中，Controller接口参数注解用于绑定HTTP请求的数据到方法参数。以下是一些常用的参数注解及其使用方法：

  1. @RequestParam：用于将请求参数绑定到方法参数上，可以是URL查询字符串或者POST请求的表单数据。



@GetMapping("/search")
public String search(@RequestParam String query) {
    // 处理查询参数
}
  1. @PathVariable：用于将URI模板中的变量绑定到方法参数上。



@GetMapping("/users/{userId}")
public User getUser(@PathVariable Long userId) {
    // 根据用户ID获取用户信息
}
  1. @RequestBody：用于将请求体绑定到一个对象上，通常用于POST或PUT请求。



@PostMapping("/users")
public User createUser(@RequestBody User user) {
    // 创建一个新用户
}
  1. @RequestHeader：用于将请求头部信息绑定到方法参数上。



@GetMapping("/data")
public ResponseEntity<String> getData(@RequestHeader("Token") String token) {
    // 处理带有Token的请求头
}
  1. @CookieValue：用于将cookie值绑定到方法参数上。



@GetMapping("/cookie")
public String getCookieValue(@CookieValue("sessionId") String sessionId) {
    // 获取名为sessionId的cookie值
}
  1. @ModelAttribute：用于将请求参数绑定到模型属性上。



@PostMapping("/submit")
public String submitForm(@ModelAttribute FormData formData) {
    // 处理表单提交的数据
}
  1. @MatrixVariable：用于将URI路径段中的矩阵变量绑定到方法参数上。



@GetMapping("/cars/{brand}")
public String getCarModels(@PathVariable String brand, @MatrixVariable Map<String, String> matrixVars) {
    // 处理矩阵变量
}

以上注解可以根据需要结合Spring Boot的功能进行灵活使用，以实现参数的有效绑定和处理。在实际开发中，开发者可以根据HTTP请求的不同特性和参数的位置来选择合适的注解。

- 阅读更多 -
Linux（linux版本 centos 7） 下安装 oracle 19c详细教程（新手小白易上手）
System
2024-09-03
所有,数据库

由于篇幅限制，这里提供一个简化的指导，主要是安装Oracle数据库的关键步骤。请确保在执行以下命令之前已经满足了Oracle 19c的系统要求，并已经创建了相应的用户和组。

  1. 下载Oracle 19c软件包：

    从Oracle官方网站下载Oracle Database 19c的安装包。

  2. 安装必要的依赖包：



sudo yum install -y oracle-database-preinstall-19c
  1. 设置环境变量：



export ORACLE_HOME=/u01/app/oracle/product/19.0.0/dbhome_1
export PATH=$PATH:$ORACLE_HOME/bin
  1. 解压Oracle软件包并运行安装程序：



unzip LINUX.X64_193000_db_home.zip -d /u01/app/oracle/product/19.0.0/dbhome_1
cd /u01/app/oracle/product/19.0.0/dbhome_1
./runInstaller
  1. 执行安装后的脚本：



sudo /u01/app/oraInventory/orainstRoot.sh
sudo /u01/app/oracle/product/19.0.0/dbhome_1/root.sh
  1. 创建并配置Oracle实例：



dbca
  1. 配置监听器和网络服务：



netca
  1. 启动和打开数据库：



sqlplus / as sysdba
SQL> startup
SQL> alter database open;

以上步骤为安装Oracle 19c的关键步骤，确保在执行时已经根据系统环境做出相应的调整。

- 阅读更多 -
Spring Boot + Spring Security + JWT 从零开始
System
2024-09-03
所有,java

以下是一个简化的Spring Boot + Spring Security + JWT的示例代码，用于创建一个初始项目框架。

  1. 在pom.xml中添加依赖：



<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
</dependencies>
  1. 配置SecurityConfig.java：



import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurer;
 
@EnableWebSecurity
public class SecurityConfig implements WebSecurityConfigurer {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/authenticate").permitAll()
            .anyRequest().authenticated()
            .and()
            .addFilter(new JwtAuthenticationFilter(authenticationManager()));
    }
}
  1. 创建JwtAuthenticationFilter.java：



import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.filter.OncePerRequestFilter;
import io.jsonwebtoken.Jwts;
 
public class JwtAuthenticationFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
        String header = request.getHeader("Authorization");
        if (header == null || !header.startsWith("Bearer ")) {
            chain.doFilter(request, response);
            return;
        }
        String token = header.substring(7);
        String username = Jwts.parser()
            .setSigningKey("secretkey".getBytes())
            .parseClaimsJws(token)
            .getBody()
            .getSubject();
 
        if (username != null) {
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken
- 阅读更多 -
Linux环境在非root用户中搭建(java-tomcat-redis)
System
2024-09-03
所有,redis

在Linux环境中，非root用户安装Java、Tomcat和Redis的步骤如下：

  1. 安装Java



# 下载Java
wget https://download.java.net/openjdk/jdk11/ri/openjdk-11+28_linux-x64_bin.tar.gz
 
# 解压Java
tar -xvf openjdk-11+28_linux-x64_bin.tar.gz
 
# 移动Java到合适的目录
mv jdk-11 /usr/local/java
 
# 配置环境变量
echo 'export JAVA_HOME=/usr/local/java' >> ~/.bashrc
echo 'export PATH=$PATH:$JAVA_HOME/bin' >> ~/.bashrc
 
# 应用环境变量
source ~/.bashrc
 
# 验证Java安装
java -version
  1. 安装Tomcat



# 下载Tomcat
wget https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.62/bin/apache-tomcat-9.0.62.tar.gz
 
# 解压Tomcat
tar -xvf apache-tomcat-9.0.62.tar.gz
 
# 移动Tomcat到合适的目录
mv apache-tomcat-9.0.62 /usr/local/tomcat
 
# 启动Tomcat
/usr/local/tomcat/bin/startup.sh
 
# 验证Tomcat是否启动，可以访问 http://localhost:8080
  1. 安装Redis



# 安装Redis依赖
sudo apt-get update
sudo apt-get install build-essential tcl
 
# 下载Redis
wget http://download.redis.io/releases/redis-6.2.6.tar.gz
 
# 解压Redis
tar xzf redis-6.2.6.tar.gz
 
# 编译Redis
cd redis-6.2.6
make
 
# 安装Redis
sudo make install
 
# 启动Redis服务器
redis-server
 
# 验证Redis是否启动，可以使用redis-cli ping命令

注意：以上步骤假设你的Linux环境是基于Debian或Ubuntu的，如果是基于其他Linux发行版，可能需要调整相应的包管理器命令（如apt-get）。另外，非root用户安装软件时，可能需要在安装路径下有写权限，或者使用如sudo命令提升权限。

- 阅读更多 -
oracle 体系架构图
System
2024-09-03
所有,数据库

在Oracle数据库中，一个常见的架构图可以包含以下组件：

  1. 实例（Instance）：运行数据库的Oracle软件实体，处理用户会话和数据库操作。
  2. 数据库（Database）：存储数据的文件集合，包括数据文件、控制文件、重做日志文件和参数文件等。
  3. 表空间（Tablespace）：数据库中的逻辑区域，用于存储数据库对象，如表、索引等。
  4. 用户（User）：在数据库中拥有权限的实体，用于访问和管理自己的数据。
  5. 角色（Role）：一组权限的集合，用于简化用户权限管理。
  6. 视图（View）：一个虚拟表，提供数据库中数据的特定视图。
  7. 序列（Sequence）：生成数字序列的数据库对象。
  8. 触发器（Trigger）：数据库中的一种特殊类型的存储过程，它在某些数据库操作发生时自动执行。
  9. 存储过程（Procedure）和函数（Function）：预编译的PL/SQL代码块，可以接受参数、执行逻辑操作，并返回结果。
  10. 包（Package）：用于封装和组织相关过程、函数、触发器和变量的模块。

以下是一个简化的Oracle架构图示例：




            +------------------+
            |      实例        |
            +------------------+
                     |
                     v
            +------------------+
            |      数据库      |
            +------------------+
                     |
       +--------------+--------------+
       |              |              |
+----------+    +----------+    +----------+
| 表空间  |    | 表空间  |    | 表空间  |
+----------+    +----------+    +----------+
       |              |              |
       v              v              v
+----------+    +----------+    +----------+
|  用户    |    |  用户    |    |  用户    |
+----------+    +----------+    +----------+
       |              |              |
       v              v              v
+----------+    +----------+    +----------+
|  视图    |    |  视图    |    |  视图    |
+----------+    +----------+    +----------+
       |              |              |
       v              v              v
+----------+    +----------+    +----------+
|  序列    |    |  序列    |    |  序列    |
+----------+    +----------+    +----------+
       |              |              |
       v              v              v
+----------+    +----------+    +----------+
| 存储过程 |    | 存储过程 |    | 存储过程 |
+----------+    +----------+    +----------+
       |              |              |
       v              v              v
+----------+    +----------+    +----------+
|  函数    |    |  函数    |    |  函数    |
+----------+    +----------+    +----------+
       |              |              |
       v              v              v
+----------+    +----------+    +----------+
|   包     |    |   包     |    |   包     |
+----------+    +----------+    +----------+

这个架构图提供了Oracle数据库的基本组件，并展示了它们之间的关系。在实际的Oracle数据库系统中，还会涉及到更多的高级特性和组件，如分区、归档、自管理的存储等。

- 阅读更多 -
Copyright © 2025 Tech Blog
All Right Reserved | 京ICP备19053165号