java - 如果类可以无状态操作，请避免构造新对象

Question

(这个问题已在代码审查中关闭，所以我想我应该在这里问)

假设我有一家这样的工厂(来自采访):

public class ControllersFactoryImpl implements ControllersFactory {

    private final SessionKeeper sessionKeeper;
    private final ScoreKeeper scoreKeeper;

    public ControllersFactoryImpl(final SessionKeeper sessionKeeper, final ScoreKeeper scoreKeeper) {
        this.sessionKeeper = sessionKeeper;
        this.scoreKeeper = scoreKeeper;
    }

    @Override
    public Controller makeLoginController(final int userId) {
        return new LoginController(userId, sessionKeeper);
    }

    @Override
    public Controller makePostUserScoreController(final int levelId, final String session, final int score) {
        return new AddScoreController(levelId, session, score, sessionKeeper, scoreKeeper);
    }

    @Override
    public Controller makeHighScoreController(final int levelId) {
        return new HighScoreController(levelId, scoreKeeper);
    }
}

由于要求之一是同时处理多个调用(例如数百万个)，他们告诉我，这个解决方案可以改进，因为通过这种方式，我们会产生大量新对象(因为我总是调用 new)，这些对象正在执行单个无状态操作，并且垃圾收集器在尝试清理它们时可能会遇到问题。

Controller 是一个具有单个方法 execute() 的接口(interface)。

避免使用构造函数是让我困惑的事情，因为我能想到的唯一方法是为执行方法提供一个 var-args 参数，但我不太喜欢这个解决方案，因为这样代码并不真正可读。

你还有其他选择吗？

这是 Controller 的代码:

public interface Controller {
    String execute();
}

这就是使用 Controller 的地方:

Controller controller = null;
try {
    if (exchange.isGet()) {
        final Matcher mLogin = loginPattern.matcher(path);
        if (mLogin.matches()) {
            controller = factory.makeLoginController(Integer.parseInt(mLogin.group(1)));
            contentType = TEXT_PLAIN;
        }
        Matcher mHighScore = highScorePattern.matcher(path);
        if (mHighScore.matches()) {
            controller = factory.makeHighScoreController((Integer.parseInt(mHighScore.group(1))));
            contentType = TEXT_CSV;
            exchange.setContentDisposition("attachment; fileName=data.csv");
        }
    } else if (exchange.isPost()) {
        final Matcher mScore = userScorePattern.matcher(path);
        if (mScore.matches()) {
            final Matcher mSession = sessionKeyPattern.matcher(httpExchange.getRequestURI().getQuery());
            if (mSession.matches()) {
                final Scanner s = new Scanner(httpExchange.getRequestBody());
                final int score = Integer.parseInt(s.hasNext() ? s.next() : "0");
                controller = factory.makePostUserScoreController(Integer.parseInt(mScore.group(1)), mSession.group(1), score);
                contentType = TEXT_PLAIN;
            }
        }
    }
    if (controller != null) {
        exchange.sendOk();
        buildResponse(exchange, controller, contentType);
    } else exchange.sendNotFound();

} catch (ExpiredSessionException e) {
    exchange.sendUnauthorized();
    exchange.setContentType(TEXT_PLAIN);
    exchange.setContentType("Session Expired");
} catch (Exception e) {
    log(e.getMessage());
    httpExchange.sendResponseHeaders(500, 0);
} finally {
    httpExchange.getResponseBody().close();
}

免责声明:我知道 if-else 情况，但由于当时我没有时间重构这部分。

可以按照您想要的方式更改代码。

private void buildResponse(Exchange exchange, Controller controller, String contentType) throws IOException {
    exchange.setContentType(contentType);
    exchange.setContent(controller.execute());
}

Answer 1

since one of the requirements was to handle several call at the time (like millions) they told me that this solution could be improved because in this way we had a huge spawning of new objects (since I'm always calling new)

这听起来像是一个非常非常不成熟的优化。该程序是否执行任何实际工作，例如读取文件或迭代某些内容？如果是这样，那么会创建许多更大的对象，并且关心 Controller 的创建是荒谬的。

无论如何，已经分配了一个扫描仪。

<小时/>

你的 Controller 并不是真正的无状态，它充其量是不可变的。它的状态包括例如levelId、session、score、sessionKeeper、scoreKeeper。

execute method a var-args argument

这意味着创建一个数组......与您想要避免的开销大致相同。

<小时/>

无论如何，看起来 Controller 目前只是使设计变得复杂，你最好不要使用它。但是，随着程序的增长，您可能会发现使用 Controller 是一个好主意，因为它可以很好地分离不同的操作。

我只是按原样尝试一下。获取数百万个请求，确定瓶颈，并在出现问题时重新设计。在遇到性能问题之前，请尽可能保持设计简洁。

简洁的设计意味着灵活的设计，这是优化的最佳起点。针对想象中的问题进行完美优化的代码是一团不可维护的困惑，在面对实际问题时变得缓慢并且无望改进。

<小时/>

如果您确实必须消除 Controller 的创建，那么您就无法在其中存储任何信息。所以你可以创建一个

enum Controller {
    LOGIN {
        ...
    }
    POST_USERS_SCORE {
        ...
    }
    HIGH_SCORE {
        ...
    }

    abstract execute(int levelId, String session, int score);
}

其中每个实现都会忽略它不需要的参数。这有点困惑，但没有可变设计那么困惑。使用可变 Controller ，您可以池化并回收它们，但这很少是一个好主意。