java - 在任何情况下，通过 DAO 模式中的构造函数传递的连接都会不安全吗？

Question

我正在使用 DAO 模式。就我而言，DAO 不会打开或关闭连接；相反，连接是通过构造函数传递给它的；它使用该连接来执行其工作。在任何情况下，通过构造函数传递到 DAO 层的连接都会不安全吗？如果是，请告诉我怎么做。

这就是我的使用方式:

这是所有 DAO 实现的父级:

public abstract class SuperDAO {
    private Connection connection;
    public SuperDAO(Connection connection) { this.connection = connection; }
    public Connection getConnection() { return this.connection; }
}

这是用户业务对象:

public class User {
    private String userId;
    private String password;
    public String getUserId() { return this.userId; }
    public void setUserId(String userId) { this.userId = userId; }
    public String getPassword() { return this.password; }
    public void setPassword(String password) { this.password = password; }
} 

这是 User 业务对象的 DAO:

public interface UserDAO {
    User getUser(String userId, String password);
}

这是User业务对象的DAO的SQL Server实现:

public class SQLServerUserDAO extends SuperDAO implements UserDAO {
    public SQLServerUserDAO(Connection connection) { super(connection); }
    public User getUser(String userId, String password) { 
        // perform task; use getConnection() for connection; dont close connection 
    }
}

这是 DAO 工厂:

public abstract class DAOFactory {
    public static final int SQL_SERVER = 1;
    protected Connection connection;

    public static DAOFactory getDAOFactory(int factoryType, Connection connection) {
        DAOFactory daoFactory = null;

        switch (factoryType) {
        case SQL_SERVER:
            daoFactory = new SQLServerDAOFactory();
            daoFactory.connection = connection;
            break; 
        }

        return daoFactory;
    }

    public abstract UserDAO getUserDAO();
}

这是 DAO Factory 的 SQL Server 实现:

public class SQLServerDAOFactory extends DAOFactory {
    public UserDAO getUserDAO() {
        UserDAO userDAO = new SQLServerUserDAO(connection);
        return userDAO;
    }
}

这就是我使用它的方式:

Connection connection = null;

try {
    connection = ... // obtain a connection;
    DAOFactory daoFactory = DAOFactory.getDAOFactory(DAOFactory.SQL_SERVER, connection);
    UserDAO userDAO = daoFactory.getUserDAO();
    ...
} finally {
    connection.close();
}

在什么情况下此代码会被破坏？请告知。

谢谢

Answer 1

Can connection passing through constructor to DAO layer be unsafe in any case?

不，您使用它的方式是安全的。

但是，你是reinventing the wheel 。而是使用现有的 ORM tool .

In which cases this code will be broken?

如果您使用容器管理的事务，并且当您的 DAO 代码在事务上下文中执行时，您在事务上下文外部获取连接，那么它将被破坏。

例如，这会很糟糕:

@Stateless
public static class MyBean implements MyBusinessInterface {
    @TransactionAttribute(TransactionAttributeType.REQUIRES_NEW)
    public void doSomething(Connection connection) {
        new SomeDAO().doSomething(connection);
    }
}

换句话说，如果您根本不使用容器管理的事务，或者您从与 DAO 相同的事务上下文中的托管连接池获取连接，那么您的代码就没有问题。

注意:在finally中 block ，你有潜力NullPointerException尝试调用close()在空连接变量上。

如果您这样做，您将始终有一个连接需要关闭:

Connection connection = //obtain a connection
try {
    DAOFactory daoFactory = DAOFactory.getDAOFactory(DAOFactory.SQL_SERVER, connection);
    UserDAO userDAO = daoFactory.getUserDAO();
    // etc
} finally {
    connection.close();
}