如何重用java代码块

Question

I want to reuse block of java code.

This is full code block:

    Session session = HibernateUtil.getSessionFactory().openSession();
    try {
        session.beginTransaction();

        // begin of different part  
        Criteria criteria=session.createCriteria(Table.class);
        if(filters!=null)
            createFilter(criteria, filters, null,null);                 
        long count=(long)criteria.setProjection(Projections.rowCount()).uniqueResult();
        this.setRowCount((int) count);
        // end of different part

        session.getTransaction().commit();
    } catch (HibernateException e) {
        if(session.getTransaction()!=null)
            session.getTransaction().rollback();
        e.printStackTrace();
    } finally {
        session.flush();
        session.close();
    }
}

And I need to use blocks:

    Session session = HibernateUtil.getSessionFactory().openSession();
    try {
        session.beginTransaction();

and

        session.getTransaction().commit();
    } catch (HibernateException e) {
        if(session.getTransaction()!=null)
            session.getTransaction().rollback();
        e.printStackTrace();
    } finally {
        session.flush();
        session.close();
    }
}

many times in different classes. But the middle part will be different. Is there any way to do it?

Answer 1

I'm going to make an example from a stripped down version of your code, so that it works without Hibernate.

Original code:

public class MyClass {
    private int rowCount;

    public void doStuff() {
        Object session = new Object();

        try {
            session.getClass();  // represents session.getTransaction();

            // begin of different part
            String s = session.toString();
            System.out.println(s);
            this.setRowCount(5);
            // end of different part

            session.getClass();  // represents commit
        } catch (Exception e) {
            e.printStacktrace();
        } finally {
            System.out.println("Do some cleanup");
        }
    }

    public void setRowCount(int count) {
        rowCount = count;
    }
}

This would be called from some other place as:

MyCLass obj = new MyClass();
obj.doStuff();

Now for the changes. I'm going to use lambda expressions plus define an interface with the annotation @FunctionalInterface . This is because the apply method in the interface will return an Exception . The standard functional interfaces in Java 8 don't support that.

First the new interface:

@FunctionalInterface
public interface MyFunction {
    void apply(Object session, MyClass self) throws Exception;
}

Now the changes in the original code:

change from

    public void doStuff() {

to

    public void doStuff(MyFunction func) {

Remove the part labelled different code and replace it with:

    func.apply(session, this);

And the calling from:

obj.doStuff();

to

obj.doStuff((session, self) -> {
    String s = session.toString();
    System.out.println(s);
    self.setRowCount(5);
});

---

If Java 8 is not an option, remove @FunctionalInterface in the interface. Then call doStuff() like this:

obj.doStuff(new MyFunction() {
    @Override
    public void apply(Object session, MyClass self) throws Exception {
        String s = session.toString();
        System.out.println(s);
        self.setRowCount(5);
    }
});

Answer 2

The following is an example using Runnable as functional interface. If you need to pass params, you could also write your own.

To be clean, you could also write your own functional interface, because Runnable is normally used when it's about Threading.

public class RunnableExample {

    public static void main(String[] args) {
        RunnableExample example = new RunnableExample();
        example.general(() -> {
            System.out.println("specificA");
        });
        example.general(() -> {
            System.out.println("specificB");
        });
    }

    public void general(Runnable specific) {
        System.out.println("general start");
        specific.run();
        System.out.println("general end");
    }
}

Output:

general start
specificA
general end
general start
specificB
general end

Answer 3

Try using a helper class like this:

{
    Session session = null;
    try {
        session = DBHelper.getSession();

        // begin of different part  
        Criteria criteria=session.createCriteria(Table.class);
        if(filters!=null)
            createFilter(criteria, filters, null,null);                 
        long count=(long)criteria.setProjection(Projections.rowCount()).uniqueResult();
        this.setRowCount((int) count);
        // end of different part

        DBHelper.commit(session);
    } catch (HibernateException e) {
        DBHelper.rollback(session);
        e.printStackTrace();
    } finally {
        DBHelper.close(session);
    }
}

// Helper Class

class DBHelper{
    public static Session getSession() throws HibernateException{   
        Session session = HibernateUtil.getSessionFactory().openSession();
        session.beginTransaction();
        return session;
    }

    public static void rollback(Session session) throws HibernateException{
        if(session.getTransaction()!=null)
            session.getTransaction().rollback();
    }

    public static void commit(Session session) throws HibernateException{
        session.getTransaction().commit();
    }

    public static void close(Session session){
        if(session!=null){
            try{
                session.flush();
                session.close();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}