分类所有下的文章

2024-09-05

所有,数据库

以下是一个简化的示例，展示了如何在C#中使用SQLite进行嵌入式数据库操作。

首先，确保安装了System.Data.SQLite库。




using System;
using System.Data.SQLite;
 
class Program
{
    static void Main()
    {
        string connectionString = "Data Source=example.db;Version=3;";
 
        using (var connection = new SQLiteConnection(connectionString))
        {
            connection.Open();
 
            // 创建表
            using (var command = new SQLiteCommand(connection))
            {
                command.CommandText = "CREATE TABLE IF NOT EXISTS Items (Id INTEGER PRIMARY KEY, Name TEXT)";
                command.ExecuteNonQuery();
            }
 
            // 添加数据
            using (var command = new SQLiteCommand(connection))
            {
                command.CommandText = "INSERT INTO Items (Name) VALUES (@name)";
                command.Parameters.AddWithValue("@name", "Item1");
                command.ExecuteNonQuery();
            }
 
            // 查询数据
            using (var command = new SQLiteCommand(connection))
            {
                command.CommandText = "SELECT * FROM Items";
                using (var reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        Console.WriteLine($"Id: {reader["Id"]}, Name: {reader["Name"]}");
                    }
                }
            }
 
            // 修改数据
            using (var command = new SQLiteCommand(connection))
            {
                command.CommandText = "UPDATE Items SET Name = @name WHERE Id = @id";
                command.Parameters.AddWithValue("@id", 1);
                command.Parameters.AddWithValue("@name", "UpdatedItem");
                command.ExecuteNonQuery();
            }
 
            // 删除数据
            using (var command = new SQLiteCommand(connection))
            {
                command.CommandText = "DELETE FROM Items WHERE Id = @id";
                command.Parameters.AddWithValue("@id", 1);
                command.ExecuteNonQuery();
            }
        }
    }
}

这段代码展示了如何在C#中使用SQLite进行基本的数据库操作，包括创建表、添加数据、查询数据、更新数据和删除数据。在实际应用中，你需要根据自己的需求对这些操作进行封装和优化。

Tomcat使用数据库连接池数据库

2024-09-05

在Tomcat中使用数据库连接池，你可以选择Tomcat自带的数据源（DataSource）或者使用第三方库，如Apache Commons DBCP或C3P0。以下是使用Tomcat JNDI数据源的一个基本配置示例：

在context.xml文件中配置数据源：




<Resource
    name="jdbc/YourDataSource"
    auth="Container"
    type="javax.sql.DataSource"
    driverClassName="com.mysql.cj.jdbc.Driver"
    url="jdbc:mysql://localhost:3306/yourdatabase"
    username="yourusername"
    password="yourpassword"
    maxActive="20"
    maxIdle="10"
    maxWait="10000"/>

在你的应用程序中，使用JNDI查找数据源并获取连接：




import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;
import java.sql.Connection;
 
public class DatabaseConnection {
 
    public Connection getConnection() throws Exception {
        Context ctx = new InitialContext();
        DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/YourDataSource");
        return ds.getConnection();
    }
}

确保context.xml文件位于正确的位置，通常它应该放在Tomcat的conf目录下或者你的应用的META-INF目录下。

注意：在实际的生产环境中，你可能需要配置更多的数据源属性，如连接验证查询、连接存活时间等，以确保连接池的健壮性和性能。

Spring Cloud Alibaba-07-RocketMQ消息驱动

2024-09-05




import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;
 
@Component
@RocketMQMessageListener(topic = "YourTopic", consumerGroup = "YourConsumerGroup")
public class YourMessageListener implements RocketMQListener<String> {
    @Override
    public void onMessage(String message) {
        // 处理接收到的消息
        System.out.println("Received message: " + message);
    }
}

这个例子展示了如何创建一个消息监听器来接收RocketMQ的消息。@RocketMQMessageListener注解指定了要监听的topic和消费者组。实现了RocketMQListener接口，并在onMessage方法中编写了接收消息后的处理逻辑。这个例子需要在具体的Spring Cloud Alibaba集成的RocketMQ环境中运行。

Spring Boot框架集成Mybatis-plus

2024-09-05

要在Spring Boot中集成MyBatis-Plus，你需要按照以下步骤操作：

在Spring Boot项目的pom.xml中添加MyBatis-Plus的依赖。




<dependencies>
    <!-- 其他依赖... -->
 
    <!-- MyBatis-Plus -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.x.x</version> <!-- 替换为最新版本 -->
    </dependency>
 
    <!-- 数据库驱动，例如MySQL -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.x.x</version> <!-- 替换为适合你的版本 -->
    </dependency>
</dependencies>

在application.properties或application.yml中配置数据库连接信息。




# application.properties 示例
spring.datasource.url=jdbc:mysql://localhost:3306/your_database?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

创建实体类对应数据库表。




import com.baomidou.mybatisplus.annotation.TableName;
 
@TableName("your_table")
public class YourEntity {
    // 实体类属性和数据库字段映射
}

创建Mapper接口。




import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
 
@Mapper
public interface YourEntityMapper extends BaseMapper<YourEntity> {
    // 这里可以添加自定义方法，MyBatis-Plus会自动生成基本CRUD操作
}

在Spring Boot启动类上添加@MapperScan注解，指定Mapper接口所在的包路径。




import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
@MapperScan("com.yourpackage.mapper") // 替换为你的Mapper接口所在包路径
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

完成以上步骤后，你就可以在你的服务中注入YourEntityMapper并使用MyBatis-Plus提供的各种方便的CRUD操作了。

PostgreSQL13 安装

2024-09-05

所有,数据库

在Linux系统中安装PostgreSQL 13的步骤通常如下：

导入PostgreSQL的公钥：




sudo rpm --import https://www.postgresql.org/media/keys/ACCC4CF8.asc

添加PostgreSQL的Yum仓库：




sudo tee /etc/yum.repos.d/postgresql.repo <<EOF
[postgresql-13]
name=PostgreSQL 13
baseurl=https://download.postgresql.org/pub/repos/yum/reporpms/EL-8-x86_64
enabled=1
gpgcheck=1
gpgkey=https://www.postgresql.org/media/keys/ACCC4CF8.asc
EOF

安装PostgreSQL 13：




sudo dnf install -y postgresql-server postgresql-contrib

初始化数据库并启动服务：




sudo /usr/pgsql-13/bin/postgresql-13-setup initdb
sudo systemctl enable postgresql-13
sudo systemctl start postgresql-13

确认PostgreSQL服务运行状态：




sudo systemctl status postgresql-13

登录到PostgreSQL：




sudo -i -u postgres
psql

以上步骤适用于基于RPM的Linux发行版（如CentOS、Red Hat Enterprise Linux、Fedora等），且假设您使用的是Enterprise Linux 8，因为PostgreSQL 13不支持EL7。如果您使用的是其他版本的EL，请根据实际情况调整仓库的baseurl。

2024-09-05

以下是一个简化的示例，展示了如何使用Spring Boot和JdbcTemplate与Postgres数据库交互：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
 
@SpringBootApplication
public class ReactiveRestWebappApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(ReactiveRestWebappApplication.class, args);
    }
}
 
@RestController
class DataController {
 
    private final JdbcTemplate jdbcTemplate;
 
    @Autowired
    public DataController(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
 
    @GetMapping("/data")
    public String getData() {
        return jdbcTemplate.queryForObject("SELECT data FROM my_table LIMIT 1", String.class);
    }
 
    @PostMapping("/data")
    public int addData(@RequestBody String data) {
        return jdbcTemplate.update("INSERT INTO my_table (data) VALUES (?)", data);
    }
}

这个代码示例提供了一个简单的Spring Boot应用程序，它使用JdbcTemplate与Postgres数据库进行交互。它包括一个REST控制器，提供了对名为my_table的表中数据的基本GET和POST操作。这个例子展示了如何使用Spring Boot和JdbcTemplate进行数据库交互，并且可以作为更复杂应用程序的基础。

使用Spring Boot构建RESTful API

2024-09-05

以下是一个简单的Spring Boot RESTful API的示例代码，它定义了一个简单的资源User，并提供了基本的CRUD操作。




import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.ArrayList;
 
@RestController
@RequestMapping("/api/users")
public class UserController {
 
    private static final List<User> users = new ArrayList<>();
 
    static {
        users.add(new User(1, "Alice"));
        users.add(new User(2, "Bob"));
    }
 
    @GetMapping
    public List<User> getAllUsers() {
        return users;
    }
 
    @GetMapping("/{id}")
    public User getUserById(@PathVariable int id) {
        return users.stream().filter(user -> user.getId() == id).findFirst().orElse(null);
    }
 
    @PostMapping
    public User createUser(@RequestBody User user) {
        user.setId(users.size() + 1);
        users.add(user);
        return user;
    }
 
    @PutMapping("/{id}")
    public User updateUser(@PathVariable int id, @RequestBody User user) {
        int index = getIndex(id);
        if (index == -1) {
            return null;
        }
        user.setId(id);
        users.set(index, user);
        return user;
    }
 
    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable int id) {
        int index = getIndex(id);
        if (index == -1) {
            return "User not found";
        }
        users.remove(index);
        return "User deleted";
    }
 
    private int getIndex(int id) {
        return (int) users.stream().filter(user -> user.getId() == id).count();
    }
}
 
class User {
    private int id;
    private String name;
 
    // Constructors, getters and setters
    public User() {}
 
    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public int getId() {
        return id;
    }
 
    public void setId(int id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

这段代码提供了创建、读取、更新和删除用户的基本操作。它使用了Spring Boot的@RestController注解，这意味着控制器中的每个方法返回的数据都会自动序列化成JSON格式。同时，它使用了@RequestMapping来映射URL路径到控制器方法，并使用@GetMapping、@PostMapping、@PutMapping和@DeleteMapping注解来处理不同的HTTP请求方法。这是一个简洁且易于理解的Spring Boot RESTful API示例。

java连接oracle出现ORA-12505错误