1. 首页
  2. 分类
  3. 后端技术
android中的数据库操作
System
2024-09-06
所有,数据库

在Android中，数据库操作通常使用SQLiteOpenHelper类来管理数据库的创建和版本管理。以下是一个简单的例子，展示了如何创建和使用SQLite数据库：




import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
 
public class DatabaseHelper extends SQLiteOpenHelper {
 
    // 数据库名称
    private static final String DATABASE_NAME = "mydatabase.db";
    // 数据库版本
    private static final int DATABASE_VERSION = 1;
    // 创建用户表的SQL语句
    private static final String CREATE_TABLE_USERS = "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, email TEXT);";
 
    public DatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
 
    @Override
    public void onCreate(SQLiteDatabase db) {
        // 创建表
        db.execSQL(CREATE_TABLE_USERS);
    }
 
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // 这里处理数据库升级的逻辑
    }
}

使用数据库：




DatabaseHelper dbHelper = new DatabaseHelper(context);
SQLiteDatabase db = dbHelper.getWritableDatabase();
 
// 插入数据
ContentValues values = new ContentValues();
values.put("name", "John Doe");
values.put("email", "johndoe@example.com");
db.insert("users", null, values);
 
// 查询数据
Cursor cursor = db.query("users", new String[]{"id", "name", "email"}, "name = ?", new String[]{"John Doe"}, null, null, null);
 
// 更新数据
values.put("email", "newemail@example.com");
db.update("users", values, "id = ?", new String[]{"1"});
 
// 删除数据
db.delete("users", "id = ?", new String[]{"1"});
 
// 关闭Cursor和数据库
cursor.close();
db.close();

这个例子展示了如何创建一个SQLiteOpenHelper的子类，用于管理数据库的创建和版本管理。同时，演示了如何执行基本的数据库操作，如插入、查询、更新和删除。在实际应用中，你需要根据具体需求来扩展这些操作。

- 阅读更多 -
《MySQL DBA 修炼之道》第五章 查询优化
System
2024-09-06
所有,数据库

第五章主要讨论了MySQL查询优化的方法，包括查询优化的基本步骤、优化器的工作原理、常用的优化技巧等。

以下是一个简单的查询优化示例，假设我们有一个orders表，我们想优化一个查询语句：




SELECT * FROM orders WHERE order_date >= '2021-01-01' AND order_date < '2022-01-01';

为了优化这个查询，我们可以考虑以下几点：

  1. 确保order_date字段已经被索引。
  2. 使用复合索引（如果适用），其中包括order_date和其他常用的查询条件字段。
  3. 避免使用SELECT *，只选择需要的列。
  4. 使用范围查询而不是全表扫描，利用索引的有效性。

优化后的查询可能看起来像这样：




SELECT order_id, order_date, total_price FROM orders
WHERE order_date >= '2021-01-01' AND order_date < '2022-01-01';

此外，我们还可以使用EXPLAIN语句来查看MySQL是如何执行查询的，并根据其输出来进一步优化查询。




EXPLAIN SELECT order_id, order_date, total_price FROM orders
WHERE order_date >= '2021-01-01' AND order_date < '2022-01-01';

这个EXPLAIN语句将显示查询的执行计划，包括是否使用了索引，是全表扫描还是范围查询，以及其他一些关键信息，帮助DBA决定是否需要进一步的优化。

- 阅读更多 -
Python3 re — 正则表达式
System
2024-09-06
所有,python

Python 的 re 模块提供了对正则表达式的支持。

以下是一些常用的 Python3 re 模块的方法和代码示例：

  1. re.match()

match 函数从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none。




import re
 
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.match('com', 'www.runoob.com').span())  # 不在起始位置匹配
  1. re.search()

search 方法会扫描整个字符串并返回第一个成功的匹配。




import re
 
print(re.search('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.search('com', 'www.runoob.com').span())  # 不在起始位置匹配
  1. re.findall()

findall 方法扫描整个字符串并返回所有成功的匹配。




import re
 
print(re.findall('www', 'www.runoob.com'))  # 在起始位置匹配
print(re.findall('com', 'www.runoob.com'))  # 不在起始位置匹配
  1. re.split()

split 方法将一个字符串通过正则表达式进行分割。




import re
 
print(re.split('\W+', 'runoob, runoob, runoob.com'))
  1. re.sub()

sub 方法用于替换字符串中匹配正则表达式的部分。




import re
 
print(re.sub(r'\d', 'H', 'runoob 123, runoob 456'))
  1. re.fullmatch()

fullmatch 函数检查整个字符串是否匹配给定的模式。




import re
 
print(re.fullmatch('www', 'www.runoob.com'))  # 在起始位置匹配
print(re.fullmatch('com', 'www.runoob.com'))  # 不在起始位置匹配
  1. re.compile()

compile 函数用于编译正则表达式，生成一个正则表达式对象，可以用于 match() 和 search() 方法查找字符串。




import re
 
pattern = re.compile('www')
 
print(pattern.search('www.runoob.com').span())
print(pattern.match('www.runoob.com').span())
  1. re.purge()

purge 方法清除编译的正则表达式模式的缓存。




import re
 
for i in range(10):
    re.compile('#' + str(i))
 
print(len(re.purge()))

以上就是 Python3 re 模块的一些常用方法和代码示例。

- 阅读更多 -
Java实战：Spring Boot 利用 ThreadPoolTaskExecutor 批量插入百万级数据
System
2024-09-06
所有,java



import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
@Service
public class BulkInsertService {
 
    @Resource
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;
 
    public void bulkInsert(List<DataObject> dataList) throws InterruptedException {
        int batchSize = 1000; // 假设每个批次大小为1000
        int batchCount = (int) Math.ceil((double) dataList.size() / batchSize);
        CountDownLatch latch = new CountDownLatch(batchCount);
        ExecutorService executorService = Executors.newFixedThreadPool(batchCount);
 
        try {
            for (int i = 0; i < batchCount; i++) {
                int start = i * batchSize;
                int end = Math.min(start + batchSize, dataList.size());
                List<DataObject> batchData = dataList.subList(start, end);
                executorService.submit(new InsertTask(batchData, latch, threadPoolTaskExecutor));
            }
            latch.await(); // 等待所有批次插入完成
        } finally {
            executorService.shutdown();
        }
    }
 
    private static class InsertTask implements Runnable {
        private List<DataObject> data;
        private CountDownLatch latch;
        private ThreadPoolTaskExecutor executor;
 
        public InsertTask(List<DataObject> data, CountDownLatch latch, ThreadPoolTaskExecutor executor) {
            this.data = data;
            this.latch = latch;
            this.executor = executor;
        }
 
        @Override
        public void run() {
            try {
                // 假设的数据库批量插入方法
                dbBatchInsert(data);
            } catch (Exception e) {
                // 异常处理逻辑
            } finally {
                latch.countDown(); // 完成一个批次
            }
        }
    }
 
    // 假设的数据库批量插入方法
    private void dbBatchInsert(List<DataObject> data) {
        // 实现数据库批量插入逻辑
    }
}

这个代码示例展示了如何使用ThreadPoolTaskExecutor来实现数据的批量插入。它首先将数据列表分割成多个批次，然后使用CountDownLatch来确保当所有批次完成后主线程能够继续执行。每个批次作为一个任务被提交到线程池中执行，实现了并行处理。这种方法在处理大量数据插入时能够提升性能。

- 阅读更多 -
Spring Cloud Gateway RCE漏洞原理分析与复现（CVE-2022-22947）
System
2024-09-06
所有,java

Spring Cloud Gateway RCE（远程代码执行）漏洞是由于Spring Cloud Gateway在处理HTTP请求时未能正确处理由特制HTTP请求造成的。攻击者可以通过构造恶意的HTTP请求，利用此漏洞执行任意代码。

漏洞原理

Spring Cloud Gateway是一个基于Project Reactor的API网关，用于路由和过滤HTTP请求。在处理HTTP请求时，如果配置了Hystrix断路器，且没有正确地处理Spring.cloud.gateway.filter.remove-hystrix-headers配置项，攻击者可以通过修改HTTP请求头部，利用表达式注入执行任意代码。

漏洞影响

Spring Cloud Gateway 3.1.x及以前版本都受此漏洞影响。

复现步骤

  1. 确保Spring Cloud Gateway的版本低于或等于3.1.x。
  2. 修改应用配置，如下所示：



spring:
  cloud:
    gateway:
      routes:
      - id: vulnerable_route
        uri: https://example.com
        filters:
        - Hystrix=command
        - RemoveHystrixHeaders=true
  1. 发送一个包含恶意表达式的HTTP请求，如下所示：



GET / HTTP/1.1
Host: your-gateway-host
Hystrix-Concurrency-Strategy: com.example.MyConcurrencyStrategy
  1. 如果配置了Hystrix-Concurrency-Strategy头部，并且其值是一个表达式，攻击者可能会触发代码执行。

修复建议

  1. 升级到安全版本：将Spring Cloud Gateway升级到3.1.x之后的版本。
  2. 应用安全补丁：如果不能立即升级，请应用官方提供的安全补丁。
  3. 审查配置：审查和更新Spring Cloud Gateway的配置，确保不会配置不安全的选项。

代码修复示例




spring:
  cloud:
    gateway:
      routes:
      - id: secure_route
        uri: https://example.com
        filters:
        - Hystrix=command
        - RemoveHystrixHeaders=true

在这个修复的配置中，RemoveHystrixHeaders被设置为true，这意味着Hystrix相关的头部信息不会被传递到下游服务。这是一个更为安全的配置，可以减少潜在的攻击面。

- 阅读更多 -
Oracle中的行列转换
System
2024-09-06
所有,数据库

在Oracle中，行列转换通常可以通过使用CASE语句或PIVOT操作来实现。以下是一个使用PIVOT操作的例子：

假设我们有一个名为sales_data的表，其结构如下：




CREATE TABLE sales_data (
  year NUMBER,
  product VARCHAR2(50),
  sales_person VARCHAR2(50),
  amount NUMBER
);

我们可以插入一些示例数据：




INSERT INTO sales_data (year, product, sales_person, amount) VALUES (2021, 'ProductA', 'SalesPerson1', 100);
INSERT INTO sales_data (year, product, sales_person, amount) VALUES (2021, 'ProductA', 'SalesPerson2', 150);
INSERT INTO sales_data (year, product, sales_person, amount) VALUES (2021, 'ProductB', 'SalesPerson1', 200);
INSERT INTO sales_data (year, product, sales_person, amount) VALUES (2021, 'ProductB', 'SalesPerson2', 250);

要将sales_person的销售额由行转换为列，我们可以使用以下查询：




SELECT year, product,
       SUM(CASE WHEN sales_person = 'SalesPerson1' THEN amount ELSE 0 END) AS SalesPerson1,
       SUM(CASE WHEN sales_person = 'SalesPerson2' THEN amount ELSE 0 END) AS SalesPerson2
FROM sales_data
GROUP BY year, product;

如果您的Oracle数据库版本支持PIVOT，则可以使用以下查询：




SELECT * FROM (
  SELECT year, product, sales_person, amount
  FROM sales_data
)
PIVOT (
  SUM(amount)
  FOR sales_person IN ('SalesPerson1' AS SalesPerson1, 'SalesPerson2' AS SalesPerson2)
);

这将输出一个结果集，其中SalesPerson1和SalesPerson2的销售额被转换成了行中的列。

- 阅读更多 -
Spring Boot2 系列教程Spring Boot 整合 JdbcTemplate
System
2024-09-06
所有,java



import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
 
import java.util.List;
import java.util.Map;
 
@Repository
public class CustomJdbcDao {
 
    private final JdbcTemplate jdbcTemplate;
 
    @Autowired
    public CustomJdbcDao(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
 
    public List<Map<String, Object>> getAllUsers() {
        return jdbcTemplate.queryForList("SELECT * FROM users");
    }
 
    public Map<String, Object> getUserById(int id) {
        return jdbcTemplate.queryForMap("SELECT * FROM users WHERE id = ?", id);
    }
 
    public int createUser(String name, String email) {
        return jdbcTemplate.update("INSERT INTO users(name, email) VALUES (?, ?)", name, email);
    }
 
    public int updateUser(int id, String name, String email) {
        return jdbcTemplate.update("UPDATE users SET name = ?, email = ? WHERE id = ?", name, email, id);
    }
 
    public int deleteUserById(int id) {
        return jdbcTemplate.update("DELETE FROM users WHERE id = ?", id);
    }
}

这个代码示例展示了如何在Spring Boot应用程序中使用JdbcTemplate来执行基本的数据库操作。这包括查询、插入、更新和删除操作。代码中的方法提供了对应的数据库操作，并且可以直接在Spring服务层中使用。

- 阅读更多 -
Spring Cloud 智慧工地源码（PC端＋移动端）项目平台、监管平台、大数据平台
System
2024-09-06
所有,java

这个问题看起来是在寻求一个关于Spring Cloud的大型项目的代码实现，但是需要注意的是，提问中并没有具体的问题或者需求，只是提到了项目的一些特性。因此，我无法提供一个具体的代码实例。

不过，我可以提供一个简化的示例，展示如何使用Spring Cloud创建一个简单的服务注册与发现的例子。

首先，你需要在你的pom.xml中添加Spring Cloud的依赖：




<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
 
<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>

然后，你可以创建一个使用@EnableEurekaServer注解的Spring Boot应用来作为服务注册中心：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
 
@EnableEurekaServer
@SpringBootApplication
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

在application.properties或application.yml中配置Eureka服务器：




server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.serviceUrl.defaultZone=http://localhost:${server.port}/eureka/

这个例子展示了如何使用Spring Cloud Eureka实现一个简单的服务注册中心。对于更复杂的项目，你可能需要配置更多的参数，并且实现额外的特性，如服务提供者的注册与发现，负载均衡，断路器模式等。

- 阅读更多 -
一文吃透Spring集成MyBatis
System
2024-09-06
所有,java

Spring整合MyBatis主要涉及到以下几个步骤：

  1. 引入依赖：在项目的pom.xml中引入Spring和MyBatis的相关依赖。
  2. 配置Spring：配置Spring的applicationContext.xml文件，包括数据源、事务管理器以及扫描Service层的Bean。
  3. 配置MyBatis：配置SqlSessionFactory以及Mapper扫描。
  4. 编写Mapper接口和XML映射文件。
  5. 使用Spring的注入功能注入Mapper接口到Service层。

以下是一个简化的例子：

pom.xml依赖配置




<dependencies>
    <!-- Spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.14</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>
    <!-- MyBatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.10</version>
    </dependency>
    <!-- 数据库驱动和连接池 -->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.5</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.29</version>
    </dependency>
</dependencies>

applicationContext.xml




<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <!-- 数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/mydb"/>
        <property name="user" value="root"/>
        <property name="password" value="password"/>
    </bean>
 
    <!-- SqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mapperLocations" value="classpath:mappers/*.xml"/>
    </bean>
 
    <!-- 扫描Mapper接口 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.example.mapper"/>
    </bean>
 
    <!-- 事务管理
- 阅读更多 -
Copyright © 2025 Tech Blog
All Right Reserved | 京ICP备19053165号