Tech Blog

2024-09-06

在Oracle数据库中，您可以使用以下SQL查询来检查用户的密码过期时间：




SELECT username, profile, password_expire_date
FROM dba_users
WHERE password_expire = 'YES';

这个查询会返回所有设置了密码过期策略的用户，以及他们的密码过期时间。如果您想要查询特定用户的密码过期时间，可以使用以下查询：




SELECT username, profile, password_expire_date
FROM dba_users
WHERE username = 'YOUR_USER_NAME';

将 'YOUR_USER_NAME' 替换为您想要查询的用户名。

请注意，执行这些查询需要您具有访问 dba_users 视图的权限。如果您没有这些权限，您可能需要联系数据库管理员来获取这些信息。

- 阅读更多 -

浅谈Spring Cloud Ribbon原理及其使用方法

System

2024-09-06

所有,java

Ribbon是一个基于HTTP和TCP的客户端负载均衡器，它是Netflix发布的开源项目。在Spring Cloud中，Ribbon被整合在其子项目Spring Cloud Netflix中，用于客户端的负载均衡。

Ribbon的工作机制：

所有客户端服务在启动时，都会到Eureka Server获取所有服务端列表。
当客户端需要调用服务时，Ribbon会根据特定的负载均衡策略选择一个服务端。
然后发送请求到该服务端。

Ribbon的负载均衡策略：

简单轮询（RoundRobin）
随机（Random）
最小响应时间（BestAvailable）
重试机制（ClientConfigEnabled）
重试机制+响应时间权重（Retry）
响应数据权重（ResponseTimeWeighted）
自定义策略

使用方法：

在Spring Cloud项目中引入Spring Cloud Netflix的依赖。
在application.properties或application.yml中配置Ribbon的相关属性。
使用@LoadBalanced注解让RestTemplate支持Ribbon。
在服务调用时，通过服务名进行调用。

示例代码：




@Configuration
public class RibbonConfig {
    @Bean
    @LoadBalanced
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
 
@RestController
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;
 
    @GetMapping("/consumer")
    public String consumer() {
        return restTemplate.getForObject("http://SERVICE-PROVIDER/provider", String.class);
    }
}

在这个例子中，RestTemplate被@LoadBalanced注解修饰，使得Ribbon能够根据服务名SERVICE-PROVIDER进行负载均衡。当consumer()方法被调用时，Ribbon会选择一个可用的服务端实例，然后发起对该实例的请求。

- 阅读更多 -

MongoDB 中的锁分析

System

2024-09-06

所有,数据库

MongoDB 中的锁通常指的是用于控制并发操作的内部机制。MongoDB 是一个基于文档的非关系型数据库（NoSQL），它使用写时复制（Copy-on-Write，COW）来提高并发性能。MongoDB 不提供传统的锁机制，如行锁，而是使用更高级别的锁，如全局锁（global lock）或数据库级锁。

在 MongoDB 中，全局锁确保一次只有一个操作可以修改数据库。这是通过获取全局写锁实现的，这意味着在任何时候只有一个写操作可以执行。读操作可以并行执行，因为它们不修改数据。

MongoDB 3.2 引入了一种新的锁机制，称为读写锁（read-write lock），用于集合级别的并发控制。这意味着对于集合的读写操作可以并发执行，但对于同一集合的写操作会串行化。

MongoDB 的锁分析可以通过以下方式进行：

使用 mongolock 工具分析锁的使用情况。
查看 MongoDB 日志文件，特别是与锁相关的信息。
使用数据库统计信息命令，如 db.serverStatus() 来获取锁的相关信息。
使用 mongotop 和 mongostat 等工具来监控数据库操作。

以下是一个简单的 MongoDB 查询示例，用于获取数据库的统计信息，这可能包含锁的相关数据：




db.serverStatus().lock

请注意，锁的分析和监控应该在了解 MongoDB 内部锁机制的前提下进行，并且这些方法可能会随着 MongoDB 版本的更新而变化。

- 阅读更多 -

vue+element UI 使用el-cascader实现全选功能

System

2024-09-06

所有,elementui

在Vue中使用Element UI的el-cascader组件时，可以通过监听节点选择事件来实现全选功能。以下是一个简单的实现示例：




<template>
  <el-cascader
    :options="options"
    v-model="selectedOptions"
    @change="handleChange"
    :props="{ multiple: true, checkStrictly: true }"
  ></el-cascader>
  <el-button @click="selectAll">全选</el-button>
</template>
 
<script>
export default {
  data() {
    return {
      selectedOptions: [],
      options: [
        {
          value: 'all',
          label: '全部',
          children: [
            {
              value: 'option1',
              label: '选项1'
            },
            {
              value: 'option2',
              label: '选项2'
            },
            // ...更多选项
          ]
        }
      ]
    };
  },
  methods: {
    handleChange(value) {
      if (value.includes('all')) {
        this.selectedOptions = ['all'];
      }
    },
    selectAll() {
      this.selectedOptions = ['all'];
    }
  }
};
</script>

在这个示例中，我们定义了一个带有全选项的el-cascader组件，并通过按钮点击触发selectAll方法。当用户手动选择全选项时，handleChange方法会被触发，并更新selectedOptions以保持只选择了全选项。如果需要实现真正的全选功能（选择所有子选项），则需要更复杂的逻辑来处理选项的选择。

System

2024-09-06

所有,java




import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import java.util.concurrent.CompletableFuture;
 
@Service
public class AsyncService {
 
    @Async
    public void executeAsyncTaskWithoutCallback() {
        // 这是一个异步的无回调任务
        System.out.println("执行异步无回调任务: " + Thread.currentThread().getName());
    }
 
    @Async
    public CompletableFuture<String> executeAsyncTaskWithCallback() {
        // 这是一个异步的有回调任务
        System.out.println("执行异步有回调任务: " + Thread.currentThread().getName());
        return CompletableFuture.completedFuture("任务执行完成");
    }
}
 
// 在主程序中调用
public class Application {
    public static void main(String[] args) {
        AsyncService asyncService = new AsyncService();
        asyncService.executeAsyncTaskWithoutCallback();
 
        CompletableFuture<String> future = asyncService.executeAsyncTaskWithCallback();
        future.thenAccept(result -> System.out.println("异步任务返回结果: " + result));
    }
}

这个代码示例展示了如何在Spring Boot应用中使用@Async注解来异步地执行任务。executeAsyncTaskWithoutCallback方法是一个不带回调的简单异步任务，而executeAsyncTaskWithCallback方法返回一个CompletableFuture，可以在其上添加回调函数来处理异步执行的结果。在主程序中，我们调用这两个方法来演示如何执行异步任务。

System

2024-09-06

所有,数据库

在PostgreSQL中进行SQL手工注入测试，可以通过构造恶意的输入来执行非预期的SQL查询。以下是一个简单的示例，展示了如何在不安全的代码中注入自定义的SQL语句：




-- 假设我们有以下函数用于登录，但是没有进行适当的输入验证或清理
CREATE OR REPLACE FUNCTION login(username text, password text) RETURNS boolean AS $$
BEGIN
    -- 假设用户名和密码正确返回true，这里应该有对输入的验证
    RETURN EXISTS (SELECT 1 FROM users WHERE name = username AND pass = password);
END;
$$ LANGUAGE plpgsql;
 
-- 正常的登录尝试
SELECT login('user', 'pass');
 
-- 现在，如果我们想要进行SQL注入，我们可以通过' or '1'='1来绕过验证
SELECT login(''' or '1'='1', 'pass');

在第二个查询中，我们通过构造' or '1'='1作为用户名，使得SQL查询变成了：




SELECT EXISTS (SELECT 1 FROM users WHERE name = '' or '1'='1' AND pass = 'pass');

这将导致查询总是返回true，因为'1'='1'条件始终为真。这只是一个简单的示例，实际的注入可能更复杂，取决于具体的查询和数据库结构。

为了防御此类攻击，开发者应该使用参数化查询（例如使用$1, $2来代替直接拼接用户输入），强制输入验证，使用ORM或安全的抽象层，并定期进行安全审计。

- 阅读更多 -

Spring Boot实现简单的Oracle数据库操作

System

2024-09-06

所有,java




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
 
@Repository
public class OracleRepository {
 
    private final JdbcTemplate jdbcTemplate;
 
    @Autowired
    public OracleRepository(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
 
    public int create(String sql) {
        return jdbcTemplate.update(sql);
    }
 
    public int update(String sql) {
        return jdbcTemplate.update(sql);
    }
 
    public int delete(String sql) {
        return jdbcTemplate.update(sql);
    }
 
    public Object queryForObject(String sql, Class<?> type) {
        return jdbcTemplate.queryForObject(sql, type);
    }
}

这段代码提供了一个简单的Oracle数据库操作类，使用Spring JdbcTemplate来执行SQL语句。它展示了如何使用依赖注入来注入JdbcTemplate，以及如何通过这个模板来执行增删改查操作。这个类可以被进一步扩展，以适应更复杂的数据库交互需求。

- 阅读更多 -

【微服务】springboot 适配多数据源设计与实现

System

2024-09-06

所有,java




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
 
// 数据源配置类
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import javax.sql.DataSource;
 
@Configuration
public class DataSourceConfig {
 
    @Bean
    @Primary
    public DataSource dataSource1() {
        // 配置第一个数据源
        return new DataSource(); // 示例，应该是数据源的实例
    }
 
    @Bean
    public DataSource dataSource2() {
        // 配置第二个数据源
        return new DataSource(); // 示例，应该是数据源的实例
    }
}
 
// 实体管理器配置类
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
 
import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.Map;
 
@Configuration
public class EntityManagerConfig {
 
    @Primary
    @Bean(name = "entityManagerFactory1")
    public LocalContainerEntityManagerFactoryBean entityManagerFactory1(
        EntityManager entityManager,
        @Qualifier("dataSource1") DataSource dataSource1,
        Map<String, Object> properties
    ) {
        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource1);
        em.setPackagesToScan("com.example.domain1"); // 设置实体类所在的包
        em.setJpaVendorAdapter(jpaVendorAdapter());
        em.setJpaPropertyMap(properties);
        return em;
    }
 
    @Bean(name = "entityManagerFactory2")
    public LocalContainerEntityManagerFactoryBean entityManagerFactor

System

2024-09-06

所有,java

报错解释：

ClassNotFoundException 表示类加载器在尝试加载指定的类时未找到该类。这里的错误信息显示找不到的类是 org.springframework.boot.context.properties.ConfigurationProperties。这通常意味着该类不在应用程序的类路径上，即在编译时未能正确引入相应的依赖库。

解决方法：

确认项目的依赖管理文件（如 Maven 的 pom.xml 或 Gradle 的 build.gradle）中是否包含了 Spring Boot 的起步依赖，并且版本是正确的。

对于 Maven，你需要在 pom.xml 中添加：




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>你的Spring Boot版本</version>
</dependency>

对于 Gradle，在 build.gradle 中添加：




dependencies {
    implementation 'org.springframework.boot:spring-boot-starter'
}

如果已经有了起步依赖，请检查是否正确地安装和导入了所有的依赖库。在 IDE 中通常可以通过自动刷新依赖或手动触发依赖下载来解决。
如果你是在编译时手动管理依赖，确保所有需要的 JAR 文件都在类路径上。
如果你使用的是 IDE，尝试重新导入项目或刷新 Maven 项目。
如果以上步骤都不能解决问题，请检查是否有任何网络问题导致依赖无法正确下载。

- 阅读更多 -

007 CentOS 7.9 apache-tomcat-9.0.89安装及配置

System

2024-09-06

所有,java




#!/bin/bash
# 安装Java环境
yum install java-1.8.0-openjdk-devel -y
 
# 验证Java安装
java -version
 
# 创建Tomcat用户
groupadd tomcat
useradd -s /bin/false -g tomcat -d /opt/tomcat tomcat
 
# 解压Tomcat到/opt/tomcat
tar xf apache-tomcat-9.0.89.tar.gz -C /opt/
ln -s /opt/apache-tomcat-9.0.89 /opt/tomcat
 
# 设置权限
chown -R tomcat:tomcat /opt/tomcat
 
# 设置Tomcat的环境变量
cat >> /opt/tomcat/bin/setenv.sh <<EOF
CATALINA_HOME=/opt/tomcat
CATALINA_BASE=/opt/tomcat
CATALINA_TMPDIR=/opt/tomcat/temp
JRE_HOME=/usr/lib/jvm/java-1.8.0-openjdk
CLASSPATH=\$JRE_HOME/lib/rt.jar:\$CATALINA_HOME/lib/servlet-api.jar:\$CATALINA_HOME/lib/jsp-api.jar
EOF
chmod +x /opt/tomcat/bin/setenv.sh
 
# 设置为服务
cat >> /etc/systemd/system/tomcat.service <<EOF
[Unit]
Description=Tomcat 9 servlet container
After=network.target
 
[Service]
Type=forking
 
User=tomcat
Group=tomcat
 
Environment="JAVA_HOME=/usr/lib/jvm/jre"
Environment="CATALINA_PID=/opt/tomcat/temp/tomcat.pid"
Environment="CATALINA_HOME=/opt/tomcat"
Environment="CATALINA_BASE=/opt/tomcat"
Environment="CATALINA_OPTS=-Xms512M -Xmx1024M -server -XX:+UseParallelGC"
Environment="JAVA_OPTS=-Djava.awt.headless=true -Djava.security.egd=file:/dev/./urandom"
 
ExecStart=/opt/tomcat/bin/startup.sh
ExecStop=/opt/tomcat/bin/shutdown.sh
 
[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable tomcat.service

这段代码首先通过yum安装Java环境，然后创建了一个名为tomcat的用户来运行Tomcat服务。接着，它将Tomcat解压到/opt/目录并创建一个符号链接指向新的目录。然后设置相应的权限，并为Tomcat创建一个setenv.sh文件，以设置环境变量。最后，它将Tomcat配置为systemd服务，以便可以使用systemctl命令来管理Tomcat服务。

- 阅读更多 -