如何在Java中避免具有相同方法主体但不同返回类型的重复代码？

huangapple
go评论136阅读模式
英文:

How can I avoid duplicate code with the same method body but different return types in Java?

问题

以下是您提供的内容的翻译部分：

想法：

当我在使用 Hibernate 时，我发现每次都需要编写某种代码。所以我将它们移到另一个方法作为包装器。在那里，将会有一个作为参数的函数接口，这样我就可以在这些上下文方法中添加一些代码。

问题：

这是我的两个方法。一个返回 Object，而另一个返回 List。我如何精确地泛化并使这两个方法合为一个，以避免代码重复。

  1. public Object objectReturnContext(Function<Session, Object> function) {
  2.     // ...
  3. }
  5. public List<T> listReturnContext(Function<Session, List<T>> function) {
  6.     // ...
  7. }

更好地理解，这是我的整个类。如果有人能给我提供更好的方法，我将非常感激。我已经在这个问题上花了几天时间。

  1. package com.go_task.database;
  3. import javax.persistence.Table;
  4. // ... （其他 import 语句）
  6. public abstract class QueryExecutionContext <T> {
  7.     // ...
  8.     // （其他方法和属性）
  9. }

我已经在 BaseDaoImpl.java 中扩展了 QueryExecutionContext。所以我需要知道两件事。

  1. 我的方法是否可行。我在这里使用的是纯 Hibernate，没有使用 Spring Boot。
  2. 如果可以的话，请告诉我如何解决 objectReturnContext() 和 listReturnContext() 方法中的代码重复问题。
英文:

The Idea:

When I was using hibernate I saw that everytime I had to write some sort of code. So I moved them to another method as wrapper. Where there will be functional interface as argument so that I can append some code in those context methods.

Problem:

Here is my two methods. One returns Object while another one is returning List. How can I exactly generify and make those two methods as one so that I can avoid code duplication.

  1. public Object objectReturnContext(Function&lt;Session, Object&gt; function) {
  2.     Object object = null;
  3.     Transaction transaction = null;
  5.     try {
  6.         Session session = HibernateUtil.sessionFactory().getCurrentSession();
  7.         transaction = session.beginTransaction();
  8.         object = function.apply(session);
  9.         transaction.commit();
  10.     } catch (NoResultException exception) {
  11.         if (transaction != null) transaction.rollback();
  12.         return object;
  13.     } catch (HibernateException exception) {
  14.         if (transaction != null) transaction.rollback();
  15.         exception.getStackTrace();
  16.     }
  18.     return object;
  19. }
  22. public List&lt;T&gt; listReturnContext(Function&lt;Session, List&lt;T&gt;&gt; function) {
  23.     List&lt;T&gt; object = null;
  24.     Transaction transaction = null;
  26.     try {
  27.         Session session = HibernateUtil.sessionFactory().getCurrentSession();
  28.         transaction = session.beginTransaction();
  29.         object = function.apply(session);
  30.         transaction.commit();
  31.     } catch (NoResultException exception) {
  32.         if (transaction != null) transaction.rollback();
  33.         return object;
  34.     } catch (HibernateException exception) {
  35.         if (transaction != null) transaction.rollback();
  36.         exception.getStackTrace();
  37.     }
  39.     return object;
  40. }

For better understanding, This is my whole class. If anyone can advice me any better way I will be very thankful. I have been into this for last few days.

  1. package com.go_task.database;
  4. import javax.persistence.Table;
  5. import org.hibernate.HibernateException;
  6. import org.hibernate.Session;
  7. import org.hibernate.Transaction;
  8. import javax.persistence.NoResultException;
  9. import javax.persistence.criteria.CriteriaBuilder;
  10. import javax.persistence.criteria.CriteriaQuery;
  11. import javax.persistence.criteria.Root;
  12. import java.util.ArrayList;
  13. import java.util.List;
  14. import java.util.function.Consumer;
  15. import java.util.function.Function;
  18. public abstract class QueryExecutionContext &lt;T&gt; {
  20.     public Class&lt;T&gt; entity;
  21.     public String tableName;
  23.     public QueryExecutionContext(Class&lt;T&gt; entity) {
  24.         this.entity = entity;
  25.         this.tableName = entity.getAnnotation(Table.class).name();
  26.     }
  28.     public List&lt;T&gt; criteriaContext(CriteriaContextRunner&lt;Session, Root&lt;T&gt;,
  29.             CriteriaQuery&lt;T&gt;, CriteriaBuilder, List&lt;T&gt;&gt; runner) {
  30.         List&lt;T&gt; data = new ArrayList&lt;&gt;();
  31.         Transaction transaction = null;
  32.         try {
  33.             Session session = HibernateUtil.sessionFactory().getCurrentSession();
  34.             transaction = session.beginTransaction();
  35.             CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
  36.             CriteriaQuery&lt;T&gt; criteriaQuery =
  37.                     criteriaBuilder.createQuery(entity);
  38.             Root&lt;T&gt; root = criteriaQuery.from(entity);
  39.             data = runner.apply(session, root, criteriaQuery, criteriaBuilder);
  40.             transaction.commit();
  41.         } catch (HibernateException exception) {
  42.             if (transaction != null) transaction.rollback();
  43.             exception.getStackTrace();
  44.         }
  46.         return data;
  47.     }
  49.     public Object singleCriteriaContext(CriteriaContextRunner&lt;Session, Root&lt;T&gt;,
  50.             CriteriaQuery&lt;T&gt;, CriteriaBuilder, Object&gt; runner) {
  51.         Object data = null;
  52.         Transaction transaction = null;
  53.         try {
  54.             Session session = HibernateUtil.sessionFactory().getCurrentSession();
  55.             transaction = session.beginTransaction();
  56.             CriteriaBuilder criteriaBuilder = session.getCriteriaBuilder();
  57.             CriteriaQuery&lt;T&gt; criteriaQuery =
  58.                     criteriaBuilder.createQuery(entity);
  59.             Root&lt;T&gt; root = criteriaQuery.from(entity);
  60.             data = runner.apply(session, root, criteriaQuery, criteriaBuilder);
  61.             transaction.commit();
  62.         } catch (HibernateException exception) {
  63.             if (transaction != null) transaction.rollback();
  64.             exception.getStackTrace();
  65.         }
  67.         return data;
  68.     }
  70.     public Object objectReturnContext(Function&lt;Session, Object&gt; function) {
  71.         Object object = null;
  72.         Transaction transaction = null;
  73.     
  74.         try {
  75.             Session session = HibernateUtil.sessionFactory().getCurrentSession();
  76.             transaction = session.beginTransaction();
  77.             object = function.apply(session);
  78.             transaction.commit();
  79.         } catch (NoResultException exception) {
  80.             if (transaction != null) transaction.rollback();
  81.             return object;
  82.         } catch (HibernateException exception) {
  83.             if (transaction != null) transaction.rollback();
  84.             exception.getStackTrace();
  85.         }
  86.     
  87.         return object;
  88.     }
  89.     
  90.     public List&lt;T&gt; listReturnContext(Function&lt;Session, List&lt;T&gt;&gt; function) {
  91.         List&lt;T&gt; object = null;
  92.         Transaction transaction = null;
  93.     
  94.         try {
  95.             Session session = HibernateUtil.sessionFactory().getCurrentSession();
  96.             transaction = session.beginTransaction();
  97.             object = function.apply(session);
  98.             transaction.commit();
  99.         } catch (NoResultException exception) {
  100.             if (transaction != null) transaction.rollback();
  101.             return object;
  102.         } catch (HibernateException exception) {
  103.             if (transaction != null) transaction.rollback();
  104.             exception.getStackTrace();
  105.         }
  106.     
  107.         return object;
  108.     }
  110.     public void noReturnContext(Consumer&lt;Session&gt; consumer) {
  111.         Transaction transaction = null;
  113.         try {
  114.             Session session = HibernateUtil.sessionFactory().getCurrentSession();
  115.             transaction = session.beginTransaction();
  116.             consumer.accept(session);
  117.             transaction.commit();
  118.         } catch (HibernateException exception) {
  119.             if (transaction != null) transaction.rollback();
  120.             exception.getStackTrace();
  121.         }
  122.     }
  123. }

I have extented QueryExecutionContext in my BaseDaoImpl.java later on. So I need to know 2 things.

  1. Is my approch is ok or not. Im using pure hibernate and nothing else. No spring boot here.
  2. If so then tell me how can I solve the code duplication in objectReturnContext() and listReturnContext() method.

答案1

得分: 8

Object/List&lt;T&gt; 参数可以是泛型参数 U：

  1. public <U> U returnContext(Function<Session, U> function) {
  2.     U object = null;
  3.     Transaction transaction = null;
  5.     try {
  6.         Session session = HibernateUtil.sessionFactory().getCurrentSession();
  7.         transaction = session.beginTransaction();
  8.         object = function.apply(session);
  9.         transaction.commit();
  10.     } catch (NoResultException exception) {
  11.         if (transaction != null) transaction.rollback();
  12.         return object;
  13.     } catch (HibernateException exception) {
  14.         if (transaction != null) transaction.rollback();
  15.         exception.getStackTrace();
  16.     }
  18.     return object;
  19. }

U 将根据您传递给方法的 function 参数进行推断。如果像这样调用它：

  1. Object o = returnContext(s -> {
  2.     ...
  3.     return new Object(); // 仅为示例
  4. });

那么 U 就是 Object。

如果像这样调用它：

  1. List<T> list = returnContext(s -> {
  2.     ...
  3.     return new ArrayList<T>(); // 仅为示例
  4. });

那么 U 就是 ArrayList<T>。

英文:

The Object/List&lt;T&gt; parameter could be a generic parameter U:

  1. public &lt;U&gt; U returnContext(Function&lt;Session, U&gt; function) {
  2.     U object = null;
  3.     Transaction transaction = null;
  5.     try {
  6.         Session session = HibernateUtil.sessionFactory().getCurrentSession();
  7.         transaction = session.beginTransaction();
  8.         object = function.apply(session);
  9.         transaction.commit();
  10.     } catch (NoResultException exception) {
  11.         if (transaction != null) transaction.rollback();
  12.         return object;
  13.     } catch (HibernateException exception) {
  14.         if (transaction != null) transaction.rollback();
  15.         exception.getStackTrace();
  16.     }
  18.     return object;
  19. }

U will be inferred depending on what function you pass into the method. If you call it like:

  1. Object o = returnContext(s -&gt; {
  2.     ...
  3.     return new Object(); // just an example
  4. });

Then U is Object.

If you call it like:

  1. List&lt;T&gt; list = returnContext(s -&gt; {
  2.     ...
  3.     return new ArrayList&lt;T&gt;(); // just an example
  4. });

Then U is ArrayList&lt;T&gt;.

huangapple
  • 本文由 发表于 2020年10月2日 21:04:00
  • 转载请务必保留本文链接：https://go.coder-hub.com/64172046.html
  • code-duplication
  • generics
  • hibernate
  • java
  • oop
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定