分类后端技术下的文章

Java网络开发（Tomcat同步数据分页）—— 用Jsp语法到实现数据的分页展示到只看自己的数据 + 模糊查询 &amp；迭代升级_jsp 模糊查询

2024-08-28

以下是一个简化的JSP分页逻辑示例，用于展示如何在JSP页面中实现数据的分页展示。




<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.stream.Collectors" %>
<%@ page import="java.util.Collections" %>
<%@ page import="java.util.Comparator" %>
<%@ page import="java.util.Date" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
 
<%
    // 假设这是从数据库获取的所有数据
    List<Date> allData = new ArrayList<>();
    // 填充数据...
 
    // 每页显示的条目数
    int itemsPerPage = 10;
    // 当前页码
    int currentPage = 1;
    // 总页数
    int totalPages = (int) Math.ceil(allData.size() / (double) itemsPerPage);
 
    // 如果请求中有页码参数，则用它来设置当前页码
    if (request.getParameter("page") != null) {
        try {
            currentPage = Integer.parseInt(request.getParameter("page"));
            if (currentPage < 1 || currentPage > totalPages) {
                currentPage = 1;
            }
        } catch (NumberFormatException e) {
            currentPage = 1;
        }
    }
 
    // 计算当前页数据的起始和结束索引
    int fromIndex = (currentPage - 1) * itemsPerPage;
    int toIndex = Math.min(fromIndex + itemsPerPage, allData.size());
 
    // 对所有数据进行分页
    List<Date> currentPageData = allData.stream()
            .skip(fromIndex)
            .limit(toIndex - fromIndex)
            .collect(Collectors.toList());
 
    // 反转列表以显示最新的数据
    Collections.reverse(currentPageData);
%>
 
<html>
<head>
    <title>分页示例</title>
</head>
<body>
    <h1>分页示例</h1>
    <ul>
        <% for (Date data : currentPageData) { %>
            <li><%= data.toString() %></li>
        <% } %>
    </ul>
 
    <% if (currentPage > 1) { %>
        <a href="?page=<%= currentPage - 1 %>">上一页</a>
    <% } %>
    <% for (int i = 1; i <= totalPages; i++) { %>
        <a href="?page=<%= i %>"><%= i %></a>
    <% } %>
    <% if (currentPage < totalPages) { %>
        <a href="?page=<%= currentPage + 1 %>">下一页</a>
    <% } %>
</body>
</html>

这个示例展示了如何在JSP页面中使用Java代码来处理数据的分页。它首先设置每页显示的数据量，然后根据请求中的页码参数来确定当前页码，并计算出当前页的数据。最后，它在HTML列表中显示当前页的数据，并提供分页导航链接。这个例子简单且直接地展示了分页逻辑，并且可以很容易地被集成到实际的Web应用程序中。

- 阅读更多 -

SQLiteC/C++接口详细介绍之sqlite3类

System

2024-08-28

所有,数据库

在SQLite中，sqlite3类是用于表示数据库连接的主要类。它提供了数据库连接的各种操作，如打开、关闭数据库，执行SQL语句等。

以下是sqlite3类的一些常用方法：

构造函数：
```
sqlite3::sqlite3() noexcept;
```
这是sqlite3类的默认构造函数，它不接受任何参数，创建一个新的sqlite3对象。
打开数据库：
```
int sqlite3::open(const char* filename, sqlite3** db = nullptr) noexcept;
```
这个方法尝试打开一个SQLite数据库文件。如果文件不存在，并且在指定的模式下创建数据库，则会创建一个新的数据库。如果db不是nullptr，那么open方法会将数据库连接的句柄存储在db指向的位置。
关闭数据库：
```
int sqlite3::close() noexcept;
```
这个方法关闭数据库连接，释放所有未完成的操作。
执行SQL语句：
```
int sqlite3::exec(const char* sql, int (*callback)(void*,int,char**,char**), void* arg, char** errmsg = nullptr) noexcept;
```
这个方法执行SQL语句。如果callback不是nullptr，那么对于每一行结果，callback函数都会被调用。arg是传递给callback的参数。如果操作失败，并且errmsg不是nullptr，那么错误消息会被存储在errmsg指向的位置。
执行查询：
```
int sqlite3::get_table(const char* sql, char*** resultp, int* nrow, int* ncolumn, char** errmsg = nullptr) noexcept;
```
这个方法执行查询SQL语句，并将结果存储在二维数组中。结果数组的大小是nrow行ncolumn列。每行的列值是通过resultp返回的。如果操作失败，并且errmsg不是nullptr，那么错误消息会被存储在errmsg指向的位置。
释放结果：
```
void sqlite3::free_table(char** result) noexcept;
```
这个方法释放由get_table方法分配的结果表。

以上是sqlite3类的一些常用方法，具体使用时需要包含SQLiteC++头文件并链接SQLite库。

示例代码：




#include <sqlite_modern_cpp.h>
#include <iostream>
 
int main() {
    // 创建一个sqlite3数据库连接对象
    sqlite::database db("example.db");
 
    // 打开数据库
    try {
        db.open();
 
        // 执行SQL语句
        db.exec("CREATE TABLE IF NOT EXISTS user (id INTEGER PRIMARY KEY, name TEXT);");
        db.exec("INSERT INTO user (name) VALUES ('Alice');");
 
        // 查询数据
        auto res = db.exec("SELECT id, name FROM user;");
        for (auto& row : res) {
            std::cout << row[0] << ": " << row[1] << std::endl;
        }
    } catch (const sqlite::exception& e) {
        std::cerr << e.what() << std::endl;
        return 1;
    }
 
    // 关闭数据库
    db.close();
 
    return

- 阅读更多 -

oracle 19c安装实操

System

2024-08-28

所有,数据库

Oracle 19c的安装步骤取决于操作系统和安装选项。以下是一个基本的安装示例：

从Oracle官网下载Oracle Database 19c安装文件。
确保你的系统满足Oracle 19c的最小系统要求。
创建Oracle用户和组：




# 以root用户执行
groupadd oinstall
groupadd dba
useradd -g oinstall -G dba -m oracle
passwd oracle

设置Oracle环境变量，编辑oracle用户的.bash_profile或.bashrc文件：




# 以oracle用户执行
nano ~/.bash_profile
 
# 添加以下内容
export ORACLE_BASE=/home/oracle/app/oracle
export ORACLE_HOME=$ORACLE_BASE/product/19c/dbhome_1
export ORACLE_SID=ORCL
export PATH=$PATH:$ORACLE_HOME/bin
 
# 保存退出

设置系统参数，例如在/etc/sysctl.conf文件中设置：




fs.file-max = 6815744
kernel.sem = 250 32000 100 128
net.ipv4.ip_local_port_range = 9000 65500
net.core.rmem_default=262144
net.core.rmem_max=4194304
net.core.wmem_default=262144
net.core.wmem_max=1048576

应用系统参数更改：




sysctl -p

创建必要的文件夹：




mkdir -p /home/oracle/app/oracle
chown -R oracle:oinstall /home/oracle/app/oracle
chmod -R 775 /home/oracle/app/oracle

以oracle用户登录，解压下载的Oracle安装文件，并运行安装程序：




# 以oracle用户登录
unzip LINUX.X64_193000_db_home.zip
cd dbhome/
./runInstaller

安装程序启动后，遵循图形化安装向导进行数据库的安装配置。
安装完成后，运行Oracle的配置脚本来完成安装：




# 以oracle用户登录
cd $ORACLE_HOME/oui/bin
./runInstaller -silent -responseFile /home/oracle/response/OracleDB.rsp

安装完成后，配置Oracle实例：




sqlplus / as sysdba
 
SQL> STARTUP

最后，配置监听器和tnsnames：




netca

和




netmgr

这些步骤提供了一个基本的Oracle 19c数据库安装过程。具体步骤可能会根据你的操作系统和环境而有所不同。在执行安装之前，请确保查看Oracle的安装指南以获取特定于你系统的详细指导。

System

2024-08-28

所有,java

在Spring框架中，ApplicationContextAware 接口允许一个类获取Spring应用上下文的引用。以下是一个简单的实现 ApplicationContextAware 的工具类示例：




import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
 
@Component
public class ApplicationContextProvider implements ApplicationContextAware {
 
    private static ApplicationContext context;
 
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        context = applicationContext;
    }
 
    public static ApplicationContext getApplicationContext() {
        return context;
    }
 
    public static <T> T getBean(Class<T> beanClass) {
        return context.getBean(beanClass);
    }
}

使用这个工具类，你可以在任何地方通过 ApplicationContextProvider.getBean() 方法获取Spring容器中的bean，而无需在组件内部进行依赖注入。

如果你遇到问题，请确保：

工具类被Spring扫描到，通常是通过将其放在组件扫描的包下，或者通过 @ComponentScan 指定扫描路径。
工具类被正确地注册为Spring的bean，通过 @Component 注解。
检查是否有多个Spring配置文件，确保工具类所在的配置文件被加载。
如果使用Java配置，请确保 @Configuration 类中有 @Bean 方法用来创建 ApplicationContextProvider 的实例。

如果以上都确认无误，但问题依然存在，请提供更详细的错误信息，例如异常堆栈跟踪、配置文件代码片段等，以便进一步分析解决问题。

- 阅读更多 -

宝塔面板docker部署hasura+postgresql

System

2024-08-28

所有,数据库

以下是使用宝塔面板部署Hasura和PostgreSQL的基本步骤，包括Docker的配置。请注意，这是一个概述性的指南，因为宝塔面板的具体操作和步骤可能会根据版本和配置的不同而略有差异。

确保您的服务器已安装Docker。
使用宝塔面板安装Docker服务。
在宝塔面板的“软件商店”中搜索并安装Docker插件。
创建一个Docker容器来运行PostgreSQL数据库，例如使用官方的postgres镜像。
创建另一个Docker容器来运行Hasura，可以使用Hasura提供的graphql-engine镜像。

以下是一个简单的示例Docker命令，用于部署Hasura和PostgreSQL：




# 运行PostgreSQL容器
docker run --name some-postgres -e POSTGRES_PASSWORD=mysecretpassword -d postgres
 
# 运行Hasura容器，连接到上面运行的PostgreSQL数据库
docker run --name some-hasura -e HASURA_GRAPHQL_DATABASE_URL=postgres://postgres:mysecretpassword@some-postgres:5432/postgres -e HASURA_GRAPHQL_ENABLE_CONSOLE=true -p 8080:8080 -d hasura/graphql-engine

请注意，您需要替换some-postgres和some-hasura为您自己的容器名称，mysecretpassword为您选择的数据库密码。

宝塔面板提供了图形化的界面来管理Docker容器，因此您可以通过宝塔面板的相关界面来执行上述操作，而不是直接使用Docker命令行。

请确保在实际部署时，根据安全最佳实践来设置复杂的密码，并且根据实际需求来配置其他环境变量和网络设置。

System

2024-08-28

所有,数据库




#include <QApplication>
#include <QTableView>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QVariant>
#include <QDebug>
 
int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
 
    // 连接SQLite数据库
    QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
    db.setDatabaseName(":memory:"); // 使用内存数据库
    bool ok = db.open();
    if (!ok) {
        qDebug() << "无法打开数据库!";
        return -1;
    }
 
    // 执行SQL创建表和插入数据
    QSqlQuery query;
    ok = query.exec("CREATE TABLE people (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)");
    if (!ok) {
        qDebug() << "创建表失败!";
        return -2;
    }
    ok = query.exec("INSERT INTO people (name, age) VALUES ('Alice', 30)");
    if (!ok) {
        qDebug() << "插入数据失败!";
        return -3;
    }
 
    // 将查询结果显示在QTableView中
    QTableView tableView;
    tableView.setModel(db.model()); // 使用数据库模型作为表格模型
    tableView.show();
 
    return app.exec();
}

这段代码演示了如何在Qt中使用SQLite数据库，创建一个表并插入一些数据，然后使用QTableView来显示这些数据。这是一个简单的例子，展示了如何将数据库操作和界面展示结合起来。在实际应用中，你可能需要添加错误处理、数据库连接参数、表的结构定义等。

System

2024-08-28

所有,数据库

以下是使用Oracle Docker Container 21c搭建Oracle服务器的步骤和示例代码：

确保你的系统上安装了Docker。
从Oracle Container Registry拉取Oracle Database 21c的Docker镜像：




docker pull store/oracle/database-enterprise:21.3.0

运行Oracle容器，设置环境变量ORACLE_PWD为你想要设置的数据库密码：




docker run -d -p 1521:1521 --name oracle-db \
   -e ORACLE_PWD=<your_password> \
   -e ORACLE_CHARACTERSET=AL32UTF8 \
   -v [your_volume]:/opt/oracle/oradata \
   store/oracle/database-enterprise:21.3.0

替换<your_password>为你自己的密码，并且将[your_volume]替换为你希望持久化Oracle数据文件的宿主机目录。

等待数据库启动完成，可以通过以下命令查看容器日志：




docker logs -f oracle-db

使用数据库客户端连接到数据库，使用你设置的用户名（默认是sys 或 system）和密码。

以上步骤会启动一个Oracle数据库容器，并且将默认的1521端口映射到宿主机上。你可以使用任何兼容Oracle数据库的客户端软件连接到这个数据库服务器。

- 阅读更多 -

简单的spring boot tomcat版本升级

System

2024-08-28

所有,java

在Spring Boot项目中升级Tomcat服务器版本，你需要更新pom.xml文件中的spring-boot-starter-tomcat依赖的版本。以下是一个如何操作的例子：

打开你的Spring Boot项目的pom.xml文件。
找到spring-boot-starter-tomcat依赖的定义。
修改<version>标签为你想要升级的Tomcat版本。
保存pom.xml文件并重新构建项目。

例子：




<!-- 修改前的依赖定义 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <version>你的当前版本</version>
</dependency>
 
<!-- 修改后的依赖定义，假设升级到9.0.46 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <version>9.0.46</version>
</dependency>

确保新版本与Spring Boot的版本兼容。如果你使用的是Spring Boot 2，你可以查看它支持的Tomcat版本在这里。

升级后，运行Maven命令（例如mvn clean install）来重新构建项目，确保所有的依赖都正确解析和使用新的Tomcat版本。

- 阅读更多 -

spring cloud alibaba可落地灰度发布方案

System

2024-08-28

所有,java




import com.alibaba.csp.sentinel.command.handler.ModifyParamFlowRuleHandler;
import com.alibaba.csp.sentinel.datasource.ReadableDataSource;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
 
// 假设这是一个从外部获取的ParamFlowRule列表的方法
private List<ParamFlowRule> fetchExternalRules() {
    // 从外部获取规则的逻辑
    // 这里只是一个示例，实际情况需要根据具体情况实现
    String ruleJson = "外部获取的规则JSON字符串";
    return JSON.parseArray(ruleJson, ParamFlowRule.class);
}
 
public void publishGrayRelease() {
    // 获取外部规则列表
    List<ParamFlowRule> externalRules = fetchExternalRules();
 
    // 使用Sentinel提供的API将规则发布到内存态
    ParamFlowRuleManager.loadRules(externalRules);
 
    // 如果需要将规则同步到外部存储，可以在这里添加同步逻辑
    // 比如将规则发送到Nacos或者Apollo等配置中心
}

这个代码示例展示了如何从外部获取参数化的流量控制规则，并使用Sentinel提供的API将其加载到内存态，以便进行灰度发布。在实际应用中，你需要根据具体的环境和需求来实现获取规则的逻辑。

- 阅读更多 -

Scrapy-连接数据库

System

2024-08-28

所有,数据库

为了使用Scrapy连接数据库，你需要使用Scrapy的item pipeline来将爬取的数据存储到数据库中。以下是一个使用SQLite数据库的例子：

首先，安装数据库驱动（如果你使用的是SQLite）：




pip install pysqlite3

然后，在你的Scrapy项目中创建一个新的pipeline：




import sqlite3
 
class MyPipeline(object):
    def __init__(self):
        self.conn = sqlite3.connect('mydatabase.db')
        self.cur = self.conn.cursor()
        self.cur.execute('''CREATE TABLE IF NOT EXISTS items
                          (id INTEGER PRIMARY KEY, url TEXT, title TEXT, description TEXT)''')
        self.conn.commit()
 
    def process_item(self, item, spider):
        self.cur.execute("INSERT INTO items (url, title, description) VALUES (?, ?, ?)",
                         (item['url'], item['title'], item['description']))
        self.conn.commit()
        return item
 
    def close_spider(self, spider):
        self.conn.close()

在你的settings.py文件中启用这个pipeline：




ITEM_PIPELINES = {
    'myproject.pipelines.MyPipeline': 300,
}

确保将myproject.pipelines.MyPipeline替换为你实际的pipeline路径。

这个pipeline会在每个item通过时被调用，并将数据插入到名为items的SQLite表中。如果你使用的是其他数据库，如MySQL或PostgreSQL，你需要安装相应的数据库驱动（例如mysqlclient或psycopg2），并在pipeline中修改连接和查询逻辑以适应你的数据库。

- 阅读更多 -