跳转至

深入理解 Java 中的 DAO

简介

在 Java 开发中，数据访问对象（Data Access Object，简称 DAO）模式是一种广泛应用的设计模式，它用于将业务逻辑和数据访问逻辑分离。通过使用 DAO 模式，开发人员可以更方便地管理数据访问层，提高代码的可维护性和可扩展性。本文将详细介绍 DAO 在 Java 中的基础概念、使用方法、常见实践以及最佳实践。

目录

  1. 基础概念
  2. 使用方法
    • 定义 DAO 接口
    • 实现 DAO 接口
    • 在业务逻辑中使用 DAO
  3. 常见实践
    • 数据库连接管理
    • 事务处理
    • 错误处理
  4. 最佳实践
    • 代码复用
    • 单元测试
    • 与其他框架集成
  5. 小结
  6. 参考资料

基础概念

DAO 模式主要包含以下几个部分： - DAO 接口：定义了数据访问的方法，如插入、查询、更新和删除等操作。这个接口是业务逻辑和数据访问实现之间的契约。 - DAO 实现类：实现了 DAO 接口中定义的方法，负责实际的数据访问操作，例如与数据库进行交互。 - 数据传输对象（DTO）：也称为值对象（VO），用于在不同层之间传递数据。它通常是一个简单的 JavaBean，包含了需要传输的数据字段。

使用方法

定义 DAO 接口

假设我们有一个用户实体，需要对用户数据进行操作，首先定义一个 UserDAO 接口：

public interface UserDAO {
    User findById(int id);
    List<User> findAll();
    void save(User user);
    void update(User user);
    void delete(User user);
}

在这个接口中，定义了查找用户（根据 ID 和查找所有用户）、保存用户、更新用户和删除用户的方法。

实现 DAO 接口

以使用 JDBC 连接数据库为例，实现 UserDAO 接口：

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class UserDAOImpl implements UserDAO {

    private Connection connection;

    public UserDAOImpl(Connection connection) {
        this.connection = connection;
    }

    @Override
    public User findById(int id) {
        User user = null;
        String sql = "SELECT * FROM users WHERE id =?";
        try (PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setInt(1, id);
            try (ResultSet resultSet = statement.executeQuery()) {
                if (resultSet.next()) {
                    user = new User();
                    user.setId(resultSet.getInt("id"));
                    user.setName(resultSet.getString("name"));
                    user.setEmail(resultSet.getString("email"));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return user;
    }

    @Override
    public List<User> findAll() {
        List<User> users = new ArrayList<>();
        String sql = "SELECT * FROM users";
        try (PreparedStatement statement = connection.prepareStatement(sql);
             ResultSet resultSet = statement.executeQuery()) {
            while (resultSet.next()) {
                User user = new User();
                user.setId(resultSet.getInt("id"));
                user.setName(resultSet.getString("name"));
                user.setEmail(resultSet.getString("email"));
                users.add(user);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return users;
    }

    @Override
    public void save(User user) {
        String sql = "INSERT INTO users (name, email) VALUES (?,?)";
        try (PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setString(1, user.getName());
            statement.setString(2, user.getEmail());
            statement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void update(User user) {
        String sql = "UPDATE users SET name =?, email =? WHERE id =?";
        try (PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setString(1, user.getName());
            statement.setString(2, user.getEmail());
            statement.setInt(3, user.getId());
            statement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void delete(User user) {
        String sql = "DELETE FROM users WHERE id =?";
        try (PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setInt(1, user.getId());
            statement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

在业务逻辑中使用 DAO

假设我们有一个用户服务类 UserService，在这个类中使用 UserDAO：

public class UserService {

    private UserDAO userDAO;

    public UserService(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public User findUserById(int id) {
        return userDAO.findById(id);
    }

    public List<User> findAllUsers() {
        return userDAO.findAll();
    }

    public void saveUser(User user) {
        userDAO.save(user);
    }

    public void updateUser(User user) {
        userDAO.update(user);
    }

    public void deleteUser(User user) {
        userDAO.delete(user);
    }
}

常见实践

数据库连接管理

在 DAO 实现类中，通常需要管理数据库连接。可以使用连接池技术（如 Apache Commons DBCP 或 HikariCP）来提高连接的复用性和性能。例如，使用 HikariCP：

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;

public class DatabaseUtil {

    private static HikariDataSource dataSource;

    static {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setUsername("root");
        config.setPassword("password");
        dataSource = new HikariDataSource(config);
    }

    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
}

然后在 DAO 实现类中使用 DatabaseUtil 获取连接：

public class UserDAOImpl implements UserDAO {

    @Override
    public User findById(int id) {
        User user = null;
        String sql = "SELECT * FROM users WHERE id =?";
        try (Connection connection = DatabaseUtil.getConnection();
             PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setInt(1, id);
            try (ResultSet resultSet = statement.executeQuery()) {
                if (resultSet.next()) {
                    user = new User();
                    user.setId(resultSet.getInt("id"));
                    user.setName(resultSet.getString("name"));
                    user.setEmail(resultSet.getString("email"));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return user;
    }
    // 其他方法类似
}

事务处理

在涉及多个数据操作的场景中，需要使用事务来保证数据的一致性。可以在业务逻辑层（如 UserService）中使用事务管理，例如使用 Spring 框架的事务管理：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {

    @Autowired
    private UserDAO userDAO;

    @Transactional
    public void saveAndUpdateUser(User user) {
        userDAO.save(user);
        // 假设这里有其他业务逻辑，可能会更新用户
        userDAO.update(user);
    }
}

错误处理

在 DAO 实现中，需要对数据库操作可能抛出的异常进行适当处理。可以将数据库异常转换为业务层能够理解的异常类型，例如：

public class UserDAOException extends RuntimeException {
    public UserDAOException(String message) {
        super(message);
    }

    public UserDAOException(String message, Throwable cause) {
        super(message, cause);
    }
}

public class UserDAOImpl implements UserDAO {

    @Override
    public User findById(int id) {
        User user = null;
        String sql = "SELECT * FROM users WHERE id =?";
        try (Connection connection = DatabaseUtil.getConnection();
             PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setInt(1, id);
            try (ResultSet resultSet = statement.executeQuery()) {
                if (resultSet.next()) {
                    user = new User();
                    user.setId(resultSet.getInt("id"));
                    user.setName(resultSet.getString("name"));
                    user.setEmail(resultSet.getString("email"));
                }
            }
        } catch (SQLException e) {
            throw new UserDAOException("Error finding user by id", e);
        }
        return user;
    }
    // 其他方法类似
}

最佳实践

代码复用

可以创建一个基础的 DAO 类，包含一些通用的数据访问方法，如获取连接、关闭资源等。然后让具体的 DAO 实现类继承这个基础类，以提高代码复用性。

public class BaseDAO {

    protected Connection getConnection() throws SQLException {
        return DatabaseUtil.getConnection();
    }

    protected void closeResources(Connection connection, PreparedStatement statement, ResultSet resultSet) {
        try {
            if (resultSet != null) {
                resultSet.close();
            }
            if (statement != null) {
                statement.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

public class UserDAOImpl extends BaseDAO implements UserDAO {

    @Override
    public User findById(int id) {
        User user = null;
        String sql = "SELECT * FROM users WHERE id =?";
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            connection = getConnection();
            statement = connection.prepareStatement(sql);
            statement.setInt(1, id);
            resultSet = statement.executeQuery();
            if (resultSet.next()) {
                user = new User();
                user.setId(resultSet.getInt("id"));
                user.setName(resultSet.getString("name"));
                user.setEmail(resultSet.getString("email"));
            }
        } catch (SQLException e) {
            throw new UserDAOException("Error finding user by id", e);
        } finally {
            closeResources(connection, statement, resultSet);
        }
        return user;
    }
    // 其他方法类似
}

单元测试

为 DAO 实现编写单元测试，以确保其功能的正确性。可以使用 JUnit 等测试框架，结合 Mockito 等模拟框架来模拟数据库操作。例如：

import org.junit.Test;
import org.mockito.Mockito;

import static org.junit.Assert.*;
import static org.mockito.Mockito.when;

public class UserDAOImplTest {

    @Test
    public void testFindById() {
        Connection connection = Mockito.mock(Connection.class);
        PreparedStatement statement = Mockito.mock(PreparedStatement.class);
        ResultSet resultSet = Mockito.mock(ResultSet.class);

        UserDAOImpl userDAO = new UserDAOImpl(connection);

        try {
            when(connection.prepareStatement(Mockito.anyString())).thenReturn(statement);
            when(statement.executeQuery()).thenReturn(resultSet);
            when(resultSet.next()).thenReturn(true);
            when(resultSet.getInt("id")).thenReturn(1);
            when(resultSet.getString("name")).thenReturn("John");
            when(resultSet.getString("email")).thenReturn("[email protected]");

            User user = userDAO.findById(1);
            assertNotNull(user);
            assertEquals(1, user.getId());
            assertEquals("John", user.getName());
            assertEquals("[email protected]", user.getEmail());
        } catch (SQLException e) {
            fail("Unexpected SQL exception");
        }
    }
}

与其他框架集成

DAO 模式可以与许多其他框架（如 Spring、Hibernate 等）集成。例如，在 Spring 框架中，可以使用 Spring Data JPA 来简化 DAO 的实现，通过定义接口并使用 Spring Data JPA 的注解，就可以自动生成数据访问实现。

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Integer> {
    // 可以定义自定义查询方法
    User findByName(String name);
}

小结

通过本文，我们详细介绍了 Java 中 DAO 模式的基础概念、使用方法、常见实践以及最佳实践。DAO 模式有助于分离业务逻辑和数据访问逻辑，提高代码的可维护性和可扩展性。合理运用数据库连接管理、事务处理、错误处理等常见实践，以及代码复用、单元测试和框架集成等最佳实践，可以构建出高质量、健壮的数据访问层。

参考资料

  • 《Effective Java》
  • 《Java EE 设计模式》
  • Spring 官方文档
  • Hibernate 官方文档