<think>我们被要求在不使用Spring Boot的情况下，使用纯Java搭建后端服务并连接
MySQL数据库。这通常涉及以下步骤：
1. 准备环境：安装
MySQL数据库，并确保它正在运行。
2. 创建
数据库和表：在
MySQL中创建所需的
数据库和表。
3. 在Java项目中添加
MySQL驱动
依赖：我们需要一个JDBC驱动来连接
MySQL。
4. 编写Java
代码：
a. 加载
数据库驱动。
b. 建立
数据库连接。
c. 创建Statement或PreparedStatement对象。
d. 执行SQL语句。
e. 处理结果集（如果适用）。
f. 关闭连接和语句。
由于不使用Spring Boot，我们将使用纯JDBC（Java Database Connectivity）来连接
数据库。
### 步骤1：安装
MySQL
确保已经安装
MySQL并启动服务。创建一个
数据库（例如`mydb`）和表（例如`users`）。这里我们假设已经创建了一个表：
```sql
CREATE TABLE users (
id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(100) NOT NULL,
email VARCHAR(100) NOT NULL
);
```
### 步骤2：创建Java项目
使用任何IDE（如IntelliJ IDEA或Eclipse）创建一个新的Java项目。
### 步骤3：添加
MySQL驱动
依赖
如果使用Maven，在`
pom.xml`中添加以下
依赖：
```xml
<dependencies>
<dependency>
<groupId>
mysql</groupId>
<artifactId>
mysql-connector-java</artifactId>
<version>8.0.33</version> <!-- 使用最新版本 -->
</dependency>
</dependencies>
```
如果使用Gradle，添加：
```groovy
dependencies {
implementation '
mysql:
mysql-connector-java:8.0.33'
}
```
如果不使用构建工具，下载
MySQL Connector/J的JAR
文件并添加到项目的类路径中。
### 步骤4：编写Java
代码连接
数据库
下面是一个简单的示例，展示如何连接
数据库、插入一条记录并查询所有记录。
```java
import java.sql.*;
public class Main {
//
数据库连接信息
private static final String URL = "jdbc:
mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC";
private static final String USER = "root";
private static final String PASSWORD = "yourpassword"; // 替换为你的密码
public static void main(String[] args) {
Connection connection = null;
try {
// 1. 加载驱动（新版本驱动可以自动注册，所以这一步可以省略，但显式加载也无妨）
Class.forName("com.
mysql.cj.jdbc.Driver");
// 2. 建立连接
connection = DriverManager.getConnection(URL, USER, PASSWORD);
// 3. 插入数据
String insertSQL = "INSERT INTO users (name, email) VALUES (?, ?)";
PreparedStatement insertStatement = connection.prepareStatement(insertSQL);
insertStatement.setString(1, "John Doe");
insertStatement.setString(2, "john@example.com");
int rowsInserted = insertStatement.executeUpdate();
System.out.println(rowsInserted + " row(s) inserted.");
// 4. 查询数据
String selectSQL = "SELECT * FROM users";
Statement selectStatement = connection.createStatement();
ResultSet resultSet = selectStatement.executeQuery(selectSQL);
while (resultSet.next()) {
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
String email = resultSet.getString("email");
System.out.println("ID: " + id + ", Name: " + name + ", Email: " + email);
}
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
} finally {
// 5. 关闭连接
try {
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
```
### 说明
- **连接字符串（URL）**：`jdbc:
mysql://localhost:3306/mydb`，其中`mydb`是
数据库名。参数`useSSL=false`表示不使用SSL连接，`serverTimezone=UTC`设置时区（避免时区问题）。
- **驱动类名**：
MySQL Connector/J 8.0及以上使用`com.
mysql.cj.jdbc.Driver`，旧版本（5.x）使用`com.
mysql.jdbc.Driver`。
- **使用PreparedStatement**：插入数据时使用`PreparedStatement`可以防止SQL注入，并且更高效。
- **资源关闭**：在`finally`块中关闭连接，确保资源释放。
### 构建后端服务
上面的
代码只是一个控制台程序。要构建后端服务，通常需要创建一个Web服务来处理HTTP请求。我们可以使用Java内置的HttpServer（从Java 1.6开始）或者使用轻量级的框架如Javalin、
Spark等，但这里我们使用纯Java的HttpServer。
下面是一个使用`com.sun.net.httpserver`包创建简单HTTP服务的例子，该服务将处理对`/users`的GET请求，并返回用户列表的JSON。
#### 添加JSON处理库
由于需要返回JSON，我们可以添加一个简单的JSON库，如`org.json`（或使用其他库如Gson、Jackson等）。这里我们使用`org.json`，在Maven中添加：
```xml
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20231013</version>
</dependency>
```
#### 创建HTTP服务
```java
import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
import org.json.JSONArray;
import org.json.JSONObject;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.sql.*;
public class SimpleHttpServer {
private static final String URL = "jdbc:
mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC";
private static final String USER = "root";
private static final String PASSWORD = "yourpassword";
public static void main(String[] args) throws IOException {
HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
server.createContext("/users", new UsersHandler());
server.setExecutor(null); // 使用默认的executor
server.start();
System.out.println("Server started on port 8000");
}
static class UsersHandler implements HttpHandler {
@Override
public void handle(HttpExchange exchange) throws IOException {
if ("GET".equals(exchange.getRequestMethod())) {
try {
// 查询
数据库
JSONArray users = getUsersFromDB();
String response = users.toString();
exchange.getResponseHeaders().set("Content-Type", "application/json");
exchange.sendResponseHeaders(200, response.getBytes().length);
OutputStream output = exchange.getResponseBody();
output.write(response.getBytes());
output.close();
} catch (Exception e) {
e.printStackTrace();
String response = "Error: " + e.getMessage();
exchange.sendResponseHeaders(500, response.getBytes().length);
OutputStream output = exchange.getResponseBody();
output.write(response.getBytes());
output.close();
}
} else {
exchange.sendResponseHeaders(405, -1); // 方法不允许
}
}
private JSONArray getUsersFromDB() throws SQLException, ClassNotFoundException {
JSONArray users = new JSONArray();
Connection connection = null;
try {
Class.forName("com.
mysql.cj.jdbc.Driver");
connection = DriverManager.getConnection(URL, USER, PASSWORD);
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("SELECT * FROM users");
while (resultSet.next()) {
JSONObject user = new JSONObject();
user.put("id", resultSet.getInt("id"));
user.put("name", resultSet.getString("name"));
user.put("email", resultSet.getString("email"));
users.put(user);
}
} finally {
if (connection != null) {
connection.close();
}
}
return users;
}
}
}
```
### 运行
运行`SimpleHttpServer`的main方法，然后访问`http://localhost:8000/users`，将看到返回的JSON格式的用户列表。
### 总结
通过以上步骤，我们使用纯Java（不
依赖Spring Boot）搭建了一个简单的后端服务，并连接了
MySQL数据库。我们使用了JDBC进行
数据库操作，并利用Java内置的HttpServer创建了HTTP服务。虽然这是一个非常基础的例子，但它展示了不使用框架如何构建后端服务。
§§相关问题§§
1. 如何优化纯Java JDBC连接
数据库的性能？
2. 在纯Java后端服务中如何处理
数据库连接池？
3. 除了内置的HttpServer，还有哪些轻量级框架可以用于构建Java后端服务？</think>### 如何使用纯Java搭建后端服务并连接
MySQL数据库
在不使用Spring Boot的情况下，使用纯Java搭建后端服务并连接
MySQL数据库需要以下步骤：
#### 1. **环境准备**
- 安装
MySQL数据库（[官网下载](https://dev.
mysql.com/downloads/
mysql/)）
- 创建
数据库和表（示例SQL）：
```sql
CREATE DATABASE mydb;
USE mydb;
CREATE TABLE users (
id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(100) NOT NULL,
email VARCHAR(100) NOT NULL
);
```
#### 2. **添加
MySQL驱动
依赖**
- **Maven项目**（`
pom.xml`）：
```xml
<dependency>
<groupId>
mysql</groupId>
<artifactId>
mysql-connector-java</artifactId>
<version>8.0.33</version> <!-- 使用最新版本 -->
</dependency>
```
- **非Maven项目**：手动下载[JAR
文件](https://mvnrepository.com/artifact/
mysql/
mysql-connector-java)并添加到类路径。
#### 3. **编写JDBC连接
代码**
```java
import java.sql.*;
public class
MySQLDemo {
//
数据库连接信息
private static final String URL = "jdbc:
mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC";
private static final String USER = "root";
private static final String PASSWORD = "your_password"; // 替换为实际密码
public static void main(String[] args) {
try {
// 1. 加载驱动
Class.forName("com.
mysql.cj.jdbc.Driver");
// 2. 建立连接
try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD)) {
System.out.println("
数据库连接成功！");
// 3. 插入数据
String insertSQL = "INSERT INTO users (name, email) VALUES (?, ?)";
try (PreparedStatement pstmt = conn.prepareStatement(insertSQL)) {
pstmt.setString(1, "张三");
pstmt.setString(2, "zhangsan@example.com");
pstmt.executeUpdate();
}
// 4. 查询数据
String selectSQL = "SELECT * FROM users";
try (Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(selectSQL)) {
while (rs.next()) {
System.out.println("ID: " + rs.getInt("id") +
", Name: " + rs.getString("name"));
}
}
}
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
}
}
}
```
#### 4. **关键点说明**
- **驱动类名**：
MySQL 8.0+ 使用 `com.
mysql.cj.jdbc.Driver`
- **连接参数**：
- `useSSL=false`：禁用SSL（生产环境应启用）
- `serverTimezone=UTC`：避免时区错误
- **资源管理**：使用 `try-with-resources` 自动关闭连接/语句
- **安全建议**：
- 密码存储：使用环境变量或配置
文件（避免硬编码）
- SQL注入：必须使用 `PreparedStatement` 替代字符串拼接
#### 5. **扩展为Web服务**
使用Java内置 `HttpServer` 创建RESTful API：
```java
import com.sun.net.httpserver.*;
import java.io.*;
import java.sql.*;
import java.net.InetSocketAddress;
public class SimpleHttpServer {
public static void main(String[] args) throws IOException {
HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
server.createContext("/users", new UsersHandler());
server.start();
System.out.println("Server running on port 8000");
}
static class UsersHandler implements HttpHandler {
@Override
public void handle(HttpExchange exchange) throws IOException {
if ("GET".equals(exchange.getRequestMethod())) {
try (Connection conn = DriverManager.getConnection(URL, USER, PASSWORD)) {
StringBuilder response = new StringBuilder();
try (Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
while (rs.next()) {
response.append("ID: ").append(rs.getInt("id"))
.append(", Name: ").append(rs.getString("name"))
.append("\n");
}
}
exchange.sendResponseHeaders(200, response.length());
try (OutputStream os = exchange.getResponseBody()) {
os.write(response.toString().getBytes());
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
```
#### 6. **运行与测试**
1. 编译运行Java程序
2. 访问 `http://localhost:8000/users` 查看数据
3. 使用Postman测试API
### 性能优化建议
1. **连接池**：使用HikariCP或DBCP管理连接
```java
HikariConfig config = new HikariConfig();
config.setJdbcUrl(URL);
config.setUsername(USER);
config.setPassword(PASSWORD);
HikariDataSource ds = new HikariDataSource(config);
```
2. **线程池**：为 `HttpServer` 配置线程池
3. **异常处理**：添加SQL异常重试机制
> **注意事项**：纯JDBC方案需手动处理事务、连接生命周期和资源清理，复杂度高于Spring Boot的JPA或MyBatis方案[^1][^2]。
本文提供使用Apache Spark连接并读取SQLServer及MySQL数据库的具体代码示例，并展示了如何配置pom文件来添加对应的数据库驱动依赖。
扫一扫
1979
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
