直接在 Android 客户端代码中硬编码数据库连接信息（如 IP、用户名、密码）并直接连接到数据库服务器是极其危险且不推荐的做法，这会暴露你的数据库凭据，导致数据泄露、服务器被攻击等严重安全问题。

正确的做法是采用客户端-服务器架构：

1. Android 客户端：负责用户界面和用户交互。
2. 中间层（服务器/API）：这是一个你搭建的 Web 服务器（例如使用 Node.js, Java Spring Boot, Python Flask/Django 等），它作为“桥梁”，接收来自客户端的请求，与数据库进行交互，然后将处理结果返回给客户端。
3. 数据库服务器：存储和管理数据。

这种架构的好处是：

• 安全性：数据库凭据只存在于服务器端，客户端无法直接访问。
• 解耦：客户端和数据库可以独立开发、部署和升级。
• 可扩展性：可以轻松应对大量并发请求。

详细步骤指南

我们将以最主流的技术栈为例进行讲解：

• Android 客户端：使用 Kotlin 和 Retrofit 库进行网络请求。
• 服务器：使用 Java Spring Boot 框架。
• 数据库：使用 MySQL。

第一步：搭建服务器端（API 层）

这是连接数据库的核心部分。

1. 创建 Spring Boot 项目： 使用 Spring Initializr (https://start.spring.io/) 快速创建一个项目，需要添加以下依赖：

   • Spring Web: 用于创建 RESTful API。
   • Spring Data JPA: 用于简化数据库操作。
   • MySQL Driver: 用于连接 MySQL 数据库。
   • Lombok (可选): 简化 Java 代码。

2. 配置数据库连接： 在 src/main/application.properties 文件中配置数据库信息：

   # MySQL 数据库配置
   spring.datasource.url=jdbc:mysql://你的数据库服务器IP:3306/你的数据库名?useSSL=false&serverTimezone=UTC
   spring.datasource.username=你的数据库用户名
   spring.datasource.password=你的数据库密码
   spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
   # JPA 配置
   spring.jpa.hibernate.ddl-auto=update # 开发时使用 update，生产环境建议用 validate
   spring.jpa.show-sql=true # 打印生成的 SQL 语句，方便调试
   spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL8Dialect

3. 创建数据实体类： 创建一个 Java 类，对应数据库中的一张表。

   
   （图片来源网络，侵删）

   import jakarta.persistence.*;
   import lombok.Data;
   @Entity // 标记这是一个 JPA 实体
   @Table(name = "users") // 对应数据库中的 users 表
   @Data // Lombok 注解，自动生成 getter, setter, toString 等
   public class User {
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       private Long id;
       @Column(nullable = false)
       private String username;
       @Column(nullable = false)
       private String email;
   }

4. 创建数据访问层： 创建一个接口，继承 JpaRepository，Spring Data JPA 会自动为你实现基本的 CRUD (增删改查) 操作。

   import org.springframework.data.jpa.repository.JpaRepository;
   import org.springframework.stereotype.Repository;
   @Repository
   public interface UserRepository extends JpaRepository<User, Long> {
       // 你可以在这里自定义查询方法，
       // User findByUsername(String username);
   }

5. 创建服务层： 编写业务逻辑，调用数据访问层。

   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Service;
   @Service
   public class UserService {
       @Autowired
       private UserRepository userRepository;
       public User createUser(User user) {
           return userRepository.save(user);
       }
       public User getUserById(Long id) {
           return userRepository.findById(id).orElse(null);
       }
       // 其他业务方法...
   }

6. 创建控制器： 创建 REST API 端点，供客户端调用。

   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.web.bind.annotation.*;
   @RestController
   @RequestMapping("/api/users") // 定义基础路径
   public class UserController {
       @Autowired
       private UserService userService;
       // POST 请求，创建新用户
       @PostMapping
       public User createUser(@RequestBody User user) {
           return userService.createUser(user);
       }
       // GET 请求，根据 ID 获取用户
       @GetMapping("/{id}")
       public User getUserById(@PathVariable Long id) {
           return userService.getUserById(id);
       }
   }

你的服务器已经准备好了,当你启动这个 Spring Boot 应用后，它就会监听一个端口（默认是 8080），并提供 /api/users 这样的 API 接口。

第二步：配置 Android 客户端

1. 添加网络权限： 在 app/src/main/AndroidManifest.xml 文件中，必须声明网络访问权限。

   <uses-permission android:name="android.permission.INTERNET" />

   为了在 Android 9 (API 28) 及以上版本上允许 HTTP 明文通信（仅用于开发，生产环境应使用 HTTPS），你还需要在 <application> 标签内添加：

   <application
       ...
       android:usesCleartextTraffic="true">
       ...
   </application>

2. 添加 Retrofit 依赖： 在 app/build.gradle.kts (或 app/build.gradle) 文件中添加 Retrofit 和 Gson (用于 JSON 解析) 的依赖。

   // build.gradle.kts
   dependencies {
       // ... 其他依赖
       implementation("com.squareup.retrofit2:retrofit:2.9.0")
       implementation("com.squareup.retrofit2:converter-gson:2.9.0")
       implementation("com.squareup.okhttp3:logging-interceptor:4.11.0") // 用于打印日志
   }

3. 创建网络请求接口： 定义一个接口，描述所有需要从服务器获取的数据操作。

   import retrofit2.Call
   import retrofit2.http.*
   interface ApiService {
       // 创建用户
       @POST("api/users")
       fun createUser(@Body user: User): Call<User>
       // 根据 ID 获取用户
       @GET("api/users/{id}")
       fun getUserById(@Path("id") id: Long): Call<User>
   }

   User 是一个 Kotlin 数据类，与服务器端的 User 实体对应。

   data class User(
       val id: Long?,
       val username: String,
       val email: String
   )

4. 创建 Retrofit 实例： 在应用的某个地方（例如一个单例类或 Application 类）创建并配置 Retrofit 实例。

   import retrofit2.Retrofit
   import retrofit2.converter.gson.GsonConverterFactory
   object RetrofitClient {
       private const val BASE_URL = "http://你的服务器IP:8080/" // 确保以 / 
       val instance: ApiService by lazy {
           val retrofit = Retrofit.Builder()
               .baseUrl(BASE_URL)
               .addConverterFactory(GsonConverterFactory.create())
               .build()
           retrofit.create(ApiService::class.java)
       }
   }

第三步：在 Android 中发起网络请求

现在你可以在 Activity 或 ViewModel 中使用 RetrofitClient 来调用 API 了。

示例：在 Activity 中获取用户数据

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.TextView
import android.widget.Toast
import retrofit2.Call
import retrofit2.Callback
import retrofit2.Response
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val textView: TextView = findViewById(R.id.textView)
        val button: Button = findViewById(R.id.button)
        button.setOnClickListener {
            // 调用 API 获取 ID 为 1 的用户
            RetrofitClient.instance.getUserById(1).enqueue(object : Callback<User> {
                // 请求成功时调用
                override fun onResponse(call: Call<User>, response: Response<User>) {
                    if (response.isSuccessful) {
                        // response.body() 包含了服务器返回的数据
                        val user = response.body()
                        textView.text = "用户名: ${user?.username}, 邮箱: ${user?.email}"
                    } else {
                        // 服务器返回了错误状态码，如 404, 500 等
                        textView.text = "请求失败: ${response.code()}"
                    }
                }
                // 请求失败时调用（如网络不通、解析错误等）
                override fun onFailure(call: Call<User>, t: Throwable) {
                    textView.text = "网络请求失败: ${t.message}"
                    Toast.makeText(this@MainActivity, "请检查网络连接", Toast.LENGTH_SHORT).show()
                }
            })
        }
    }
}

重要注意事项和最佳实践

1. 不要在主线程（UI 线程）中执行网络请求： 网络请求是耗时操作，如果在主线程中执行，会导致应用卡顿甚至出现 NetworkOnMainThreadException 错误。retrofit2.Call.enqueue() 方法已经自动在后台线程执行，所以是安全的，如果你使用 execute()，就必须手动切换到后台线程。

2. 使用 HTTPS 而不是 HTTP： 在生产环境中，必须使用 HTTPS 来加密客户端和服务器之间的通信，防止数据被窃听或篡改，你需要为你的服务器配置 SSL 证书。

3. 处理异步和生命周期： 在 Activity/Fragment 中发起网络请求时，如果用户在请求返回前退出了界面，可能会导致内存泄漏或尝试更新一个已销毁的 UI，可以使用 Lifecycle-aware 组件如 ViewModel 和 LiveData (或 Flow) 来更好地管理生命周期，当 ViewModel 被清除时，它会自动取消所有未完成的网络请求。

4. 错误处理和用户反馈： 网络请求可能因为各种原因失败（无网络、服务器宕机、API 错误等），务必在 onFailure 和 onResponse 的 !response.isSuccessful 分支中做好错误处理，并向用户友好的提示。

5. 数据解析的安全性： 使用像 Gson 或 Moshi 这样的库进行 JSON 解析时，要确保服务器的 JSON 结构是稳定的，如果结构可能变化，需要考虑使用更灵活的解析方式或定义更健壮的数据模型。

6. 认证与授权： 如果你的 API 需要认证，通常的做法是用户登录后，服务器返回一个 Token (如 JWT)，之后客户端每次请求都需要在 Header 中携带这个 Token，Retrofit 可以通过 Interceptor 来自动添加 Header。

连接 Android 到服务器数据库的标准流程是：

Android App (Retrofit) -> (HTTP/HTTPS) -> Web Server (Spring Boot) -> (JDBC) -> Database (MySQL)

这个流程虽然比直接连接多了一个环节,但它为你的应用提供了坚实的安全基础和良好的架构，是专业开发的必经之路，从搭建一个简单的 API 开始，然后逐步在 Android 客户端调用它，你会很快掌握这个核心技能。