Tagged articles
Database Connection
39 articles · Page 1 of 1

java1234Jan 27, 2026 · Backend Development
This article presents seven concrete Spring Boot startup optimization techniques—including lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration pruning, class‑loading shortcuts, lazy database connections, and GraalVM native compilation—backed by real‑world benchmarks that reduce launch times by up to 71% across e‑commerce, micro‑service, logistics and payment services.
Auto-configurationClass LoadingDatabase Connection
0 likes · 9 min read

This guide explains how to configure a MySQL client to connect through a bastion host using an SSH tunnel, covering both the standard local connection settings and the jump‑server parameters needed when direct external access is prohibited.
Bastion-HostDatabase ConnectionJump Server
0 likes · 3 min read

This article examines the detailed steps and timing of establishing a MySQL connection from Java, measuring over 200 ms per connection, and demonstrates how proper connection closing and connection pooling can dramatically reduce latency in high‑traffic web applications.
Connection PoolingDatabase ConnectionJava
0 likes · 8 min read

This article measures the exact time cost of establishing a MySQL connection from Java, breaks down the TCP handshake, authentication, and protocol steps with Wireshark captures, and shows why connection pooling is essential for high‑traffic web applications.
Connection PoolingDatabase ConnectionJava
0 likes · 8 min read

This article examines the detailed steps and timing of establishing a MySQL connection from a Java web application, measuring network round‑trips and total latency, and demonstrates how even a minimal connection can consume hundreds of milliseconds, making connection pooling essential for high‑traffic services.
Database ConnectionJavaMySQL
0 likes · 8 min read

Learn how to establish, use, and close MySQL database connections in PHP with detailed MySQLi and PDO examples, covering object‑oriented syntax, prepared statements, error handling, and best practices for secure and efficient backend development.
Database ConnectionMySQLMySQLi
0 likes · 4 min read

This article explains why a Java application using the Kingbase JDBC driver may encounter SocketTimeoutException during reads, analyzes the underlying socket timeout settings in both the driver and Druid connection pool, and provides a step‑by‑step solution to correctly configure timeouts and avoid repeated failures.
Database ConnectionDruidJDBC
0 likes · 12 min read

This article dissects the MySQL connection process in Java, measuring each handshake and authentication step with Wireshark to reveal why establishing a single database connection can consume around 200 ms, and why connection pooling is essential for high‑traffic applications.
Connection PoolingDatabase ConnectionJava
0 likes · 8 min read

This article explains what streaming queries are, why MyBatis's Cursor requires an open database connection, and presents three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to correctly implement MyBatis streaming queries in Spring applications while avoiding common pitfalls.
CursorDatabase ConnectionJava
0 likes · 6 min read

Facing a soaring AWS bill despite stable traffic, we traced the cost to over‑provisioned EC2 instances and leaking database connections, then upgraded to Spring Boot 3.5 and applied targeted pool, transaction, and JPA tweaks, achieving a 45% reduction in monthly spend while boosting performance and reliability.
Database Connectionaws-cost-optimizationperformance-tuning
0 likes · 16 min read

This article investigates the time cost of establishing and closing MySQL connections in Java web applications, using Wireshark packet captures and code examples to demonstrate that a single connection can take over 200 ms, highlighting the importance of connection pooling and performance optimizations.
Connection PoolingDatabase ConnectionJava
0 likes · 7 min read

This article investigates the time cost of establishing and closing a MySQL connection from a Java web application, using Wireshark packet captures and simple code examples to quantify latency and illustrate why connection pooling is essential for high‑traffic services.
Connection PoolingDatabase ConnectionJava
0 likes · 7 min read

This article investigates the detailed steps and time consumption of establishing and closing a MySQL connection from a Java web application, using Wireshark packet captures and code examples to demonstrate why connection pooling is essential for high‑traffic services.
Connection PoolingDatabase ConnectionJava
0 likes · 7 min read

This article examines how a Java web application connects to a MySQL database, measuring each step of the TCP handshake, authentication, and setup with Wireshark, and demonstrates that a single connection can take over 200 ms, highlighting the importance of connection pooling.
Connection PoolingDatabase ConnectionJava
0 likes · 6 min read

This article dissects the MySQL connection process using Java and Wireshark, revealing that establishing a single connection can consume over 200 ms, which scales to hours of latency for high‑traffic sites, highlighting the necessity of connection pooling and related optimizations.
Database ConnectionMySQLWireshark
0 likes · 7 min read

This article analyzes the detailed steps and timing of establishing and closing a MySQL connection from Java, using Wireshark traces to show that even a minimal connection can consume over 200 ms, highlighting the need for connection pooling in high‑traffic web applications.
Connection PoolingDatabase ConnectionJava
0 likes · 8 min read

This article examines the detailed steps and timing of establishing a MySQL database connection using Java, measures the latency of the TCP handshake and authentication phases, and demonstrates why connection pooling is essential for high‑traffic web applications.
Connection PoolingDatabase ConnectionJava
0 likes · 7 min read

This article investigates the time consumption of creating and closing a MySQL connection from a Java application, measuring each network and protocol step with Wireshark and code examples, and demonstrates why connection pooling is essential for high‑traffic web services.
Connection PoolingDatabase ConnectionJava
0 likes · 6 min read

The article measures the exact time cost of establishing and closing a MySQL connection from Java, breaks down each network and protocol step with Wireshark captures, and shows how these latencies add up to hundreds of milliseconds, making connection pooling essential for high‑traffic web services.
Connection PoolingDatabase ConnectionJava
0 likes · 9 min read

This tutorial explains how to connect PHP to databases using both mysqli and PDO, covering connection setup, error handling, executing queries, and properly closing the connection, with complete code examples for each method.
Database ConnectionMySQLMySQLi
0 likes · 4 min read

This article examines the detailed steps and performance impact of creating a MySQL connection from a Java web application, measures the latency of the handshake and authentication using Wireshark, and demonstrates why connection pooling is essential for high‑traffic services.
Connection PoolingDatabase ConnectionJava
0 likes · 6 min read

This article investigates the time overhead of establishing MySQL database connections in Java web applications, detailing the TCP handshake, authentication steps, and measured latency using Wireshark, and demonstrates why connection pooling is essential to avoid hundreds of milliseconds per request.
Connection PoolingDatabase ConnectionJava
0 likes · 7 min read

Learn how to connect Go applications to MySQL using the native driver and the GORM ORM, covering driver installation, basic connection code, database configuration, query execution, and best practices for model definition and handling common pitfalls.
Database ConnectionGORMMySQL
0 likes · 9 min read

This article analyzes why a Spring service encounters "connection closed" errors during long‑running transactions, explains how MyBatis and Druid manage connections, and provides a programmatic‑transaction solution that splits large operations into smaller units to prevent connection leaks and timeouts.
Database ConnectionDruidSpring
0 likes · 11 min read

This article explains the motivation behind object pooling in Java, walks through the core classes of Commons Pool 2 with a Jedis example, details key configuration parameters, presents JMH benchmark results that show a five‑fold throughput gain, and analyzes HikariCP’s design tricks and common interview questions about pool tuning.
Commons Pool 2Database ConnectionHikariCP
0 likes · 16 min read

This article explains Java object pooling concepts, introduces the Commons Pool 2 library and its usage with Redis's Jedis client, compares it with the high‑performance HikariCP database connection pool, and presents JMH benchmark results demonstrating significant throughput gains, while also covering configuration parameters and interview questions.
Commons-PoolDatabase ConnectionHikariCP
0 likes · 15 min read

This article explains how Baidu Intelligent Cloud’s low‑code platform “AiSuDa” enables developers to create API orchestration flows, integrate Function‑as‑a‑Service nodes, and connect directly to external or built‑in databases, providing a no‑code alternative to traditional backend development for data‑driven applications.
API orchestrationDatabase ConnectionFaaS
0 likes · 19 min read

This article examines how a MySQL connection is created from a Java web application, breaking down the TCP handshake, authentication, and variable‑setting steps with Wireshark captures, measuring latency, and demonstrating why connection pooling is essential to avoid hundreds of milliseconds of overhead per request.
Database ConnectionJavaMySQL
0 likes · 7 min read

This article investigates how much time a simple Java program spends establishing and closing a MySQL connection, measures the latency of each TCP and MySQL handshake step with Wireshark, and demonstrates why connection pooling is essential for high‑traffic web services.
Connection PoolingDatabase ConnectionJava
0 likes · 8 min read

This article explains how MyBatis streaming queries work via the Cursor interface, why keeping the database connection open is essential, and presents three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to correctly handle streaming data in Spring applications.
CursorDatabase ConnectionJava
0 likes · 9 min read

This tutorial explains how to connect a Python program to a MySQL database in three clear steps—installing the driver, using it with basic connection code, and optionally employing an ORM like Peewee for higher‑level database interactions—complete with ready‑to‑run examples.
Database ConnectionMySQLMySQLdb
0 likes · 3 min read

This guide explains how to enable the PDO extension, configure php.ini, write connection code with proper error handling, and debug SQL statement errors to resolve common MySQL connection problems in PHP on Windows environments.
Database ConnectionMySQLtroubleshooting
0 likes · 3 min read

This article explains what a streaming query is, introduces MyBatis's Cursor interface and its methods, demonstrates common pitfalls such as the cursor being closed prematurely, and provides three practical solutions using SqlSessionFactory, TransactionTemplate, and @Transactional to keep the database connection alive during streaming reads.
CursorDatabase ConnectionJava
0 likes · 7 min read

This tutorial walks through configuring a Django project to use MySQL instead of the default SQLite, covering database creation, settings adjustments, required package installation, migrations, and a complete example with URLs, views, templates, and server startup.
Database ConnectionDjangoMySQL
0 likes · 8 min read

This article introduces DBeaver, a free open‑source Java‑based database management tool, covering its cross‑platform installation, JDBC support for a wide range of relational and NoSQL databases, step‑by‑step connection setup, and how to generate ER diagrams from existing schemas.
DBeaverDatabase ConnectionER diagram
0 likes · 6 min read

When deploying a Spring Boot application on CentOS, MySQL connections may throw CommunicationsException or SSLHandshakeException due to JDK mismatches, socket path errors, SSL settings, timeout defaults, or configuration issues, and this guide explains each cause and provides concrete fixes.
CentOSDatabase ConnectionJDK
0 likes · 9 min read

The author, a former PHP engineer at Mafengwo, chronicles a two‑day crash‑course in Java and Spring Boot, detailing the adoption of Lombok, Druid, Maven, and various annotations while navigating pitfalls such as bean scopes, database connections, and data format mismatches before successfully launching the new service.
Database ConnectionLombokbackend development
0 likes · 13 min read

This guide walks through configuring JMeter to connect to MySQL and Oracle databases via JDBC, covering driver installation, JMeter component setup, request creation, result verification, and troubleshooting common connection errors for performance testing.
Database ConnectionJDBCJMeter
0 likes · 4 min read


ITPUBJun 13, 2016 · Databases
When an Oracle user password includes the '@' character, standard sqlplus login fails with a connection string parsing error; escaping the '@' by using backslashes or enclosing the password in double quotes restores successful connection.
Database ConnectionEscape CharacterOracle
0 likes · 3 min read
