如何将Java类A中Method1的ResultSet及变量传入类B方法

直接传递ResultSet到类B是不推荐的做法——它依赖于数据库连接的状态，一旦连接关闭或者ResultSet被释放，类B就无法读取数据了，而且这种设计也不符合面向对象的封装原则。更好的方式是把从数据库查询到的数据提取出来，封装成一个实体类，再把这个实体（或实体列表）传递给类B使用。

下面是具体的实现步骤和代码示例：

1. 创建数据实体类 #

先定义一个Node类，用来存放你从ResultSet中提取的id、name、par、lvl这些字段，提供对应的构造方法和Getter/Setter：

public class Node {
    private int id;
    private String name;
    private String parent;
    private int level;

    // 构造方法
    public Node(int id, String name, String parent, int level) {
        this.id = id;
        this.name = name;
        this.parent = parent;
        this.level = level;
    }

    // Getter和Setter方法
    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getParent() { return parent; }
    public void setParent(String parent) { this.parent = parent; }
    public int getLevel() { return level; }
    public void setLevel(int level) { this.level = level; }
}

2. 修改类A，提取数据并返回实体列表 #

修改A类的method1方法，不再持有ResultSet作为成员变量，而是把查询结果转换成Node对象的列表，同时注意及时关闭数据库资源（避免泄漏）：

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class A {
    // 假设stmt、conn、query、success这些变量已经正确初始化/定义
    public List<Node> method1() {
        List<Node> nodeList = new ArrayList<>();
        ResultSet rs = null;
        
        try {
            rs = stmt.executeQuery(query);
            // 遍历ResultSet，把数据封装到Node对象中
            while (rs.next()) {
                int id = rs.getInt("node_Id");
                String name = rs.getString("node_Name");
                String parent = rs.getString("node_Parent");
                int level = rs.getInt("node_Level");
                
                nodeList.add(new Node(id, name, parent, level));
                // 保留原来的打印逻辑（如果需要）
                System.out.println(id + " " + name + " " + parent + " " + level);
            }
            
            // 事务处理
            if (success == 0) {
                conn.rollback();
            } else {
                conn.commit();
            }
        } catch (Exception e) {
            // 异常处理：回滚事务+打印日志
            try {
                if (conn != null) conn.rollback();
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        } finally {
            // 关闭数据库资源，必须放在finally块保证执行
            try {
                if (rs != null) rs.close();
                if (stmt != null) stmt.close();
                if (conn != null) conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        return nodeList;
    }
}

3. 修改类B，接收实体列表并使用数据 #

让B类的usage方法接收List<Node>参数，这样就能直接访问每个Node对象里的id、name等变量了：

import java.util.List;

public class B {
    public void usage(List<Node> nodeList) {
        // 遍历列表，处理每个Node的数据
        for (Node node : nodeList) {
            int id = node.getId();
            String name = node.getName();
            String parent = node.getParent();
            int level = node.getLevel();
            
            // 这里写你需要的业务逻辑
            System.out.println("类B中处理数据：ID=" + id + ", 名称=" + name + ", 父节点=" + parent + ", 层级=" + level);
        }
    }
}

4. 调用示例 #

在主程序或者其他业务代码中，这样调用就能实现类A和类B的数据传递：

public class Main {
    public static void main(String[] args) {
        A a = new A();
        List<Node> nodes = a.method1();
        
        B b = new B();
        b.usage(nodes);
    }
}

为什么不直接传递ResultSet？ #

• 资源绑定问题：ResultSet依赖数据库连接，一旦连接关闭，ResultSet就无法读取数据了，很容易导致SQLException。
• 封装性差：把数据库底层对象暴露给业务类（类B），违反了单一职责原则，类B不需要知道数据库查询的细节。
• 复用性低：ResultSet是游标式的，只能单向遍历一次，无法重复使用，而实体类可以多次访问数据。

内容的提问来源于stack exchange，提问作者Shaun Tait