在 Web 开发中，后端与数据库的连接是核心环节之一。无论是简单的博客系统还是复杂的企业级应用，都离不开高效、安全、稳定的数据库连接。本文将系统全面地梳理网站后端连接数据库的核心知识点，从连接原理到最佳实践，涵盖 JDBC、连接池、ORM 框架、事务管理、性能优化等各个方面，帮助开发者建立完整的知识体系。

一、数据库连接基础

1.1 数据库连接原理

应用服务器 → 数据库驱动 → 网络连接 → 数据库服务器
     ↓            ↓           ↓           ↓
  连接请求 → 建立连接 → 传输数据 → 执行SQL → 返回结果

连接过程：
加载数据库驱动
建立网络连接（TCP/IP）
进行身份认证
创建会话
执行 SQL 语句
返回结果
关闭连接（释放资源）

1.2 数据库驱动
常用 JDBC 驱动：

xml
<!-- Maven 依赖 -->
<!-- MySQL -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.33</version>
</dependency>

<!-- PostgreSQL -->
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.6.0</version>
</dependency>

<!-- Oracle -->
<dependency>
    <groupId>com.oracle.database.jdbc</groupId>
    <artifactId>ojdbc8</artifactId>
    <version>21.9.0.0</version>
</dependency>

<!-- SQL Server -->
<dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
    <version>12.4.0.jre11</artifactId>
</dependency>

<!-- H2（内存数据库） -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <version>2.2.220</version>
</dependency>

1.3 JDBC 基础连接

java
import java.sql.*;

public class JDBCDemo {

    // 数据库连接参数
    private static final String URL = "jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC";
    private static final String USERNAME = "root";
    private static final String PASSWORD = "123456";

    // 1. 基础连接示例
    public void basicConnection() {
        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        try {
            // 加载驱动（可选，JDBC 4.0+ 自动加载）
            Class.forName("com.mysql.cj.jdbc.Driver");

            // 建立连接
            conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
            System.out.println("数据库连接成功");

            // 创建 Statement
            stmt = conn.createStatement();

            // 执行查询
            rs = stmt.executeQuery("SELECT * FROM users");

            // 处理结果
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("username");
                System.out.println("ID: " + id + ", Name: " + name);
            }

        } catch (ClassNotFoundException e) {
            System.err.println("驱动加载失败: " + e.getMessage());
        } catch (SQLException e) {
            System.err.println("数据库连接失败: " + e.getMessage());
        } finally {
            // 关闭资源（顺序：ResultSet → Statement → Connection）
            try {
                if (rs != null) rs.close();
                if (stmt != null) stmt.close();
                if (conn != null) conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    // 2. PreparedStatement（防止 SQL 注入）
    public void preparedStatementExample() {
        String sql = "SELECT * FROM users WHERE username = ? AND age > ?";

        try (Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            // 设置参数
            pstmt.setString(1, "张三");
            pstmt.setInt(2, 18);

            // 执行查询
            try (ResultSet rs = pstmt.executeQuery()) {
                while (rs.next()) {
                    System.out.println(rs.getString("username"));
                }
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 3. 批处理操作
    public void batchExample() {
        String sql = "INSERT INTO users (username, age) VALUES (?, ?)";

        try (Connection conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            // 关闭自动提交
            conn.setAutoCommit(false);

            // 添加批处理
            for (int i = 0; i < 1000; i++) {
                pstmt.setString(1, "user" + i);
                pstmt.setInt(2, 20 + i % 50);
                pstmt.addBatch();
            }

            // 执行批处理
            int[] results = pstmt.executeBatch();

            // 提交事务
            conn.commit();

            System.out.println("批量插入完成: " + results.length);

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

二、连接池技术

2.1 为什么需要连接池
不使用连接池的问题：
每次请求都需要创建和关闭连接，开销大
高并发时数据库连接数爆炸
资源浪费，性能低下
连接池的优势：
复用连接，减少创建/销毁开销
限制最大连接数，保护数据库
管理连接生命周期
提供连接健康检查

2.2 HikariCP（推荐）

xml
<!-- Maven 依赖 -->
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>5.0.1</version>
</dependency>

java
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class HikariCPDemo {

    // 配置方式1：编程式配置
    public DataSource createDataSource() {
        HikariConfig config = new HikariConfig();

        // 基础配置
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC");
        config.setUsername("root");
        config.setPassword("123456");

        // 连接池大小配置
        config.setMaximumPoolSize(10);           // 最大连接数
        config.setMinimumIdle(5);                // 最小空闲连接
        config.setIdleTimeout(600000);            // 空闲超时（10分钟）
        config.setConnectionTimeout(30000);       // 连接超时（30秒）
        config.setMaxLifetime(1800000);           // 连接最大生命周期（30分钟）

        // 验证配置
        config.setConnectionTestQuery("SELECT 1");
        config.setValidationTimeout(5000);

        // 其他配置
        config.setPoolName("MyHikariPool");
        config.setRegisterMbeans(true);

        return new HikariDataSource(config);
    }

    // 配置方式2：配置文件方式
    // hikari.properties
    /*
    dataSourceClassName=com.mysql.cj.jdbc.MysqlDataSource
    dataSource.url=jdbc:mysql://localhost:3306/mydb
    dataSource.user=root
    dataSource.password=123456
    maximumPoolSize=10
    minimumIdle=5
    connectionTimeout=30000
    idleTimeout=600000
    maxLifetime=1800000
    */

    public DataSource createDataSourceFromFile() {
        HikariConfig config = new HikariConfig("/hikari.properties");
        return new HikariDataSource(config);
    }
}

2.3 Druid（阿里）

xml
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.20</version>
</dependency>

java
import com.alibaba.druid.pool.DruidDataSource;
import javax.sql.DataSource;
import java.util.Properties;

public class DruidDemo {

    public DataSource createDataSource() {
        DruidDataSource dataSource = new DruidDataSource();

        // 基础配置
        dataSource.setUrl("jdbc:mysql://localhost:3306/mydb?useSSL=false");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");

        // 连接池配置
        dataSource.setInitialSize(5);           // 初始化连接数
        dataSource.setMinIdle(5);               // 最小空闲连接
        dataSource.setMaxActive(20);             // 最大活跃连接
        dataSource.setMaxWait(60000);            // 获取连接最大等待时间

        // 连接保持配置
        dataSource.setTimeBetweenEvictionRunsMillis(60000);  // 检查空闲连接的间隔
        dataSource.setMinEvictableIdleTimeMillis(300000);    // 连接最小空闲时间
        dataSource.setMaxEvictableIdleTimeMillis(600000);    // 连接最大空闲时间

        // 验证配置
        dataSource.setValidationQuery("SELECT 1");
        dataSource.setTestWhileIdle(true);
        dataSource.setTestOnBorrow(false);
        dataSource.setTestOnReturn(false);

        // 监控配置
        dataSource.setFilters("stat,wall,log4j");  // 开启监控和防火墙

        return dataSource;
    }

    // 配置文件方式
    public DataSource createFromProperties() {
        Properties props = new Properties();
        props.setProperty("url", "jdbc:mysql://localhost:3306/mydb");
        props.setProperty("username", "root");
        props.setProperty("password", "123456");
        props.setProperty("initialSize", "5");
        props.setProperty("maxActive", "20");
        props.setProperty("minIdle", "5");

        return DruidDataSourceFactory.createDataSource(props);
    }
}

2.4 Tomcat JDBC Pool

xml
<dependency>
    <groupId>org.apache.tomcat</groupId>
    <artifactId>tomcat-jdbc</artifactId>
    <version>10.1.15</version>
</dependency>

java
import org.apache.tomcat.jdbc.pool.DataSource;
import org.apache.tomcat.jdbc.pool.PoolProperties;

public class TomcatPoolDemo {

    public DataSource createDataSource() {
        PoolProperties p = new PoolProperties();

        p.setUrl("jdbc:mysql://localhost:3306/mydb");
        p.setUsername("root");
        p.setPassword("123456");
        p.setDriverClassName("com.mysql.cj.jdbc.Driver");

        p.setInitialSize(5);
        p.setMaxActive(20);
        p.setMinIdle(5);
        p.setMaxIdle(10);
        p.setMaxWait(30000);

        p.setValidationQuery("SELECT 1");
        p.setTestOnBorrow(true);
        p.setTestWhileIdle(true);

        p.setTimeBetweenEvictionRunsMillis(60000);
        p.setMinEvictableIdleTimeMillis(300000);

        return new DataSource(p);
    }
}

三、Spring 框架中的数据库连接

3.1 配置数据源
application.yml 配置：

spring:
  datasource:
    # 基础配置
    url: jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

    # HikariCP 配置
    hikari:
      maximum-pool-size: 10
      minimum-idle: 5
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
      connection-test-query: SELECT 1
      pool-name: MyHikariPool

    # Druid 配置
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      initial-size: 5
      max-active: 20
      min-idle: 5
      max-wait: 60000
      filters: stat,wall,slf4j
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        login-username: admin
        login-password: admin

Java 配置：

@Configuration
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }

    // 自定义 HikariCP 配置
    @Bean
    public DataSource customDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setUsername("root");
        config.setPassword("123456");
        config.setMaximumPoolSize(20);
        config.setMinimumIdle(5);
        config.setConnectionTimeout(30000);
        config.setIdleTimeout(600000);
        config.setMaxLifetime(1800000);
        return new HikariDataSource(config);
    }

    // 多数据源配置
    @Bean
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

3.2 JdbcTemplate 使用

@Repository
public class UserDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

    // 查询单条记录
    public User findById(Long id) {
        String sql = "SELECT id, username, age FROM users WHERE id = ?";
        return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), id);
    }

    // 查询列表
    public List<User> findAll() {
        String sql = "SELECT id, username, age FROM users";
        return jdbcTemplate.query(sql, (rs, rowNum) -> {
            User user = new User();
            user.setId(rs.getLong("id"));
            user.setUsername(rs.getString("username"));
            user.setAge(rs.getInt("age"));
            return user;
        });
    }

    // 插入并返回主键
    public long insert(User user) {
        String sql = "INSERT INTO users (username, age) VALUES (?, ?)";
        KeyHolder keyHolder = new GeneratedKeyHolder();

        jdbcTemplate.update(connection -> {
            PreparedStatement ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            ps.setString(1, user.getUsername());
            ps.setInt(2, user.getAge());
            return ps;
        }, keyHolder);

        return keyHolder.getKey().longValue();
    }

    // 批量插入
    public int[] batchInsert(List<User> users) {
        String sql = "INSERT INTO users (username, age) VALUES (?, ?)";
        return jdbcTemplate.batchUpdate(sql, users, 100, (ps, user) -> {
            ps.setString(1, user.getUsername());
            ps.setInt(2, user.getAge());
        });
    }

    // 命名参数查询
    public List<User> findByCondition(String username, Integer age) {
        String sql = "SELECT * FROM users WHERE username = :username AND age > :age";
        MapSqlParameterSource params = new MapSqlParameterSource();
        params.addValue("username", username);
        params.addValue("age", age);

        return namedParameterJdbcTemplate.query(sql, params, new BeanPropertyRowMapper<>(User.class));
    }
}

来源：
https://dnuhf.cn/category/food.html

网站后端连接数据库知识点大全（一）

一、数据库连接基础

二、连接池技术

三、Spring 框架中的数据库连接

热门文章

最新文章

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

网站后端连接数据库知识点大全（一）

一、数据库连接基础

二、连接池技术

三、Spring 框架中的数据库连接

热门文章

最新文章

相关电子书