java - 静态方法还是非静态方法？

Question

当我将我的应用程序移至生产环境时我应该做什么。使用 Spring + Jersey + Hibernate 的应用程序。

预期服务器点击次数/秒 - 40 到 50.. 服务器点击次数/分钟 - 1000 到 1500。对于此服务器负载，我的配置应该如何？

汤姆猫在生产过程中，如果我为 tomcat 设置这些是否可以？

初始 JVM 堆大小:256m最大 JVM 堆大小:256m最大 JVM 永久代大小:64m

如果不是请提出建议。P.S:我将它托管在自动缩放的云实例中。所以 RAM 或 CPU 没有问题。

Spring A:数据库操作的静态架构。

public class Booking {

        @Autowired // this is autowired by spring
        private SessionFactory sessionFactory; // Hibernate class

        @POST // this is Jersey (I guess this can handle 50 requests per soconds)
        @Path("/create")
        @Produces("application/json")
        public Response create(String json)  {
                ....
        DBHelper.insertIntoDb(booking, sessionFactory); // here i use static architecture. The reason why i used this is i dont want new object created for each request. (I tested with 10 request per seconds.. Will this be able to handle 50 request per second... or even 500 requests per second)
                ....
                return Response.ok(container).build();
        }
}

public class DBHelper {
         /**
     * Inserts the object in DB
     * @param object
     * @param sessionFactory
     * @return the saved object
     * @throws Exception
     * @throws ConstraintViolationException
     */
    public static Object insertIntoDb(Object object, SessionFactory sessionFactory) throws Exception, ConstraintViolationException {
        synchronized (sessionFactory) {
            Session session = sessionFactory.openSession();
            Transaction transaction = null;
            try {
                transaction = session.beginTransaction();
                if (object != null) {
                    session.save(object);
                    session.flush();
                    session.clear();
                    transaction.commit();
                    return object;
                }
            } catch (ConstraintViolationException e) {
                transaction.rollback();
                throw new ConstraintViolationException(e.toString(), null, null, null);
            } catch (Exception e) {
                transaction.rollback();
                throw new Exception(e);
            } finally {
                session.close();
            }
        }
        return object;
    }
}

B:数据库操作的非静态架构。

public class Booking {

        @Autowired // this is autowired by spring
        private SessionFactory sessionFactory; // Hibernate class

        @POST // this is Jersey (I guess this can handle 50 requests per soconds)
        @Path("/create")
        @Produces("application/json")
        public Response create(String json)  {
                ....
        new DBHelper().insertIntoDb(booking, sessionFactory); // Non static
                ....
                return Response.ok(container).build();
        }
}

public class DBHelper {
         /**
     * Inserts the object in DB
     * @param object
     * @param sessionFactory
     * @return the saved object
     * @throws Exception
     * @throws ConstraintViolationException
     */
    public Object insertIntoDb(Object object, SessionFactory sessionFactory) throws Exception, ConstraintViolationException {
        synchronized (sessionFactory) {
            Session session = sessionFactory.openSession();
            Transaction transaction = null;
            try {
                transaction = session.beginTransaction();
                if (object != null) {
                    session.save(object);
                    session.flush();
                    session.clear();
                    transaction.commit();
                    return object;
                }
            } catch (ConstraintViolationException e) {
                transaction.rollback();
                throw new ConstraintViolationException(e.toString(), null, null, null);
            } catch (Exception e) {
                transaction.rollback();
                throw new Exception(e);
            } finally {
                session.close();
            }
        }
        return object;
    }
}

A:静态架构优点:1) 我不是在创建单个对象2)所以确保我的java堆没有被填满3)减少垃圾收集器的工作缺点:1) insertIntoDd 方法可能会返回错误的对象...(我猜这...但在测试中没有遇到任何问题)。

B:非静态架构优点:1) insertIntoDd 方法肯定会返回正确的数据缺点:1)我正在创建单个对象2)Java堆可能导致OutOfMemoryException3) 垃圾收集器的更多工作

我完全糊涂了。

我该怎么办？？

Answer 1

我的建议是为您的数据库助手使用单一模式。因此，您将在单个 DBHelper 类中拥有 sessionFactory，并且它将在类中私有(private) sessionFactory 变量。这与您的静态方法更相似，但使用了正确的模式。

对于内存使用(最好从最小 250 MB 和最大 1024 MB 开始，Perm 为 256MB)。之后，您可以随着负载的增加而增加内存。

例如下面..

public final class DBHelper {

私有(private) session 工厂 session 工厂；

私有(private)静态 DBHelper 实例=null;

//私有(private)构造函数

私有(private) DBHelper() {

//在这里初始化你的 session 工厂

公共(public)静态 DBHelper getInstance() {

如果(实例 == null){

instance = new DBHelper();

返回实例；

public static Object insertIntoDb(Object object) 抛出异常，ConstraintViolationException {

//编写代码以插入数据库

公共(public)课预订{

//所以它总是使用单一的 insertDb 方法

DBHelper.getInstance().insertIntoDb(预订);

...