阅读开源框架,总结Java类的定义

简介: 阅读开源框架,总结Java类的定义

Java的类是自定义的引用类型,是对职责相关的行为与数据的一种封装,用以表现一种业务领域或者技术领域的概念。在不同的场景,类包含的成员可能有所不同,大体可以分为如下五类:

  • 数据类:可以视为是持有数据的容器,类的成员只包含了字段,以及与字段有关的get/set方法
  • 实体类:既包含了体现状态的字段,又包含了操作这些状态的方法
  • 服务类:只有方法(行为)没有字段(状态),可以理解为提供内聚职责的服务
  • 函数类:如果定义的公开方法只有唯一一个,可以理解为它封装的其实是一个函数,通常用匿名类或者Lambda表示
  • 工具类:只包含一系列静态方法,通常不支持对该类型的实例化


数据类



在Presto框架中定义的ClientSession可以认为是这样一种数据类。除了构造函数外,它只定义了字段与对应的get()方法(实际上,在框架的源代码中,在ClientSession类中还定义了一系列静态工厂方法,但本质上说,ClientSession还是一个数据类),用以持有客户端Session所必须的数据:

public class ClientSession {
   private final URI server;
   private final String use;
   private final String source;
   private final String clientInfo;
   private final String catalog;
   private final String schema;
   private final TimeZoneKey timeZone;
   private final Locale locale;
   private final Map<String, String> properties;
   private final Map<String, String> preparedStatements;
   private final String transactionId;
   private final boolean debug;
   private final Duration clientRequestTimeout;
   public ClientSession(
           URI server,
           String user,
           String source,
           String clientInfo,
           String catalog,
           String schema,
           String timeZoneId,
           Locale locale,
           Map<String, String> properties,
           String transactionId,
           boolean debug,
           Duration clientRequestTimeout)    {
       this(server, user, source, clientInfo, catalog, schema, timeZoneId, locale, properties, emptyMap(), transactionId, debug, clientRequestTimeout);
   }
   public ClientSession(
           URI server,
           String user,
           String source,
           String clientInfo,
           String catalog,
           String schema,
           String timeZoneId,
           Locale locale,
           Map<String, String> properties,
           Map<String, String> preparedStatements,
           String transactionId,
           boolean debug,
           Duration clientRequestTimeout)   {
       this.server = requireNonNull(server, "server is null");
       this.user = user;
       this.source = source;
       this.clientInfo = clientInfo;
       this.catalog = catalog;
       this.schema = schema;
       this.locale = locale;
       this.timeZone = TimeZoneKey.getTimeZoneKey(timeZoneId);
       this.transactionId = transactionId;
       this.debug = debug;
       this.properties = ImmutableMap.copyOf(requireNonNull(properties, "properties is null"));
       this.preparedStatements = ImmutableMap.copyOf(requireNonNull(preparedStatements, "preparedStatements is null"));
       this.clientRequestTimeout = clientRequestTimeout;
       // verify the properties are valid
       CharsetEncoder charsetEncoder = US_ASCII.newEncoder();
       for (Entry<String, String> entry : properties.entrySet()) {
           checkArgument(!entry.getKey().isEmpty(), "Session property name is empty");
           checkArgument(entry.getKey().indexOf('=') < 0, "Session property name must not contain '=': %s", entry.getKey());
         checkArgument(charsetEncoder.canEncode(entry.getKey()), "Session property name is not US_ASCII: %s", entry.getKey());
           checkArgument(charsetEncoder.canEncode(entry.getValue()), "Session property value is not US_ASCII: %s", entry.getValue());
       }
   }
   public URI getServer()    {
       return server;
   }
   public String getUser()    {
       return user;
   }
   public String getSource()    {
       return source;
   }
   public String getClientInfo()    {
       return clientInfo;
   }
   public String getCatalog()    {
       return catalog;
   }
   public String getSchema()    {
       return schema;
   }
   public TimeZoneKey getTimeZone()    {
       return timeZone;
   }
   public Locale getLocale()    {
       return locale;
   }
   public Map<String, String> getProperties()    {
       return properties;
   }
   public Map<String, String> getPreparedStatements()    {
       return preparedStatements;
   }
   public String getTransactionId()    {
       return transactionId;
   }
   public boolean isDebug()    {
       return debug;
   }
   public Duration getClientRequestTimeout()    {
       return clientRequestTimeout;
   }
   @Override
   public String toString()    {
       return toStringHelper(this)
               .add("server", server)
               .add("user", user)
               .add("clientInfo", clientInfo)
               .add("catalog", catalog)
               .add("schema", schema)
               .add("timeZone", timeZone)
               .add("locale", locale)
               .add("properties", properties)
               .add("transactionId", transactionId)
               .add("debug", debug)
               .toString();
   }
}


这样包含数据或状态的对象通常会作为参数在方法调用之间传递,体现了诸如配置、视图模型、服务传输数据、协议数据等概念。除此之外,我们应尽量避免定义这样的对象去体现某种业务概念,因为基于“信息专家”模式,好的面向对象设计应该是将数据与操作这些数据的行为封装在一起。


实体类



这是最为常见的一种类定义,也是符合面向对象设计原则的,前提是定义的类必须是高内聚的,原则上应该满足单一职责原则。例如JDK定义的Vector展现了一种数据结构,因而它持有的字段与方法应该仅仅与队列操作与状态有关:

public class Vector<E>
   extends AbstractList<E>
   implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
   protected Object[] elementData;
   protected int elementCount;
   protected int capacityIncrement;
   public Vector(int initialCapacity, int capacityIncrement) {
       super();
       if (initialCapacity < 0)
           throw new IllegalArgumentException("Illegal Capacity: "+
                                             initialCapacity);
       this.elementData = new Object[initialCapacity];
       this.capacityIncrement = capacityIncrement;
   }
 public Vector(int initialCapacity) {
       this(initialCapacity, 0);
   }
 public synchronized void setSize(int newSize) {
       modCount++;
       if (newSize > elementCount) {
           ensureCapacityHelper(newSize);
       } else {
           for (int i = newSize ; i < elementCount ; i++) {
               elementData[i] = null;
           }
       }
       elementCount = newSize;
   }
   public synchronized int size() {
       return elementCount;
   }
   public synchronized boolean isEmpty() {
       return elementCount == 0;
   }
   public boolean contains(Object o) {
       return indexOf(o, 0) >= 0;
   }
   public synchronized E firstElement() {
       if (elementCount == 0) {
           throw new NoSuchElementException();
       }
       return elementData(0);
   }
   public synchronized void insertElementAt(E obj, int index) {
       modCount++;
       if (index > elementCount) {
           throw new ArrayIndexOutOfBoundsException(index
                                                   + " > " + elementCount);
       }
       ensureCapacityHelper(elementCount + 1);
       System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
       elementData[index] = obj;
       elementCount++;
   }
   public synchronized void addElement(E obj) {
       modCount++;
       ensureCapacityHelper(elementCount + 1);
       elementData[elementCount++] = obj;
   }
   public synchronized boolean removeElement(Object obj) {
       modCount++;
       int i = indexOf(obj);
       if (i >= 0) {
           removeElementAt(i);
           return true;
       }
       return false;
   }
   public synchronized void removeAllElements() {
       modCount++;
       // Let gc do its work
       for (int i = 0; i < elementCount; i++)
           elementData[i] = null;
       elementCount = 0;
   }
}

如下类的定义则体现了一种业务概念,方法changePriceTo()实际上表现的是一种业务规则,而它要操作的数据就是Product类自身持有的字段sellingPrice:

public class Product extends Entity<Identity> {
   private final List<Option> options;
   private Price sellingPrice;
   private Price retailPrice;
   public Product(Identity id, Price sellingPrice, Price retailPrice)  {
       super(id);
       this.sellingPrice = sellingPrice;
       if (!sellingPriceMatches(retailPrice) {
           throw new PricesNotInTheSameCurrencyException("Selling and retail price must be in the same currency");
       }
       this.retailPrice = retailPrice;
       options = new List<Option>();
   }
   public void changePriceTo(Price newPrice) {
       if (!sellingPriceMatches(newPrice)) {
           throw new PricesNotInTheSameCurrencyException("You cannot change the price of this product to a different currency");
       }
       sellingPrice = newPrice;
   }
   public Price savings() {
       Price savings = retailPrice.minus(sellingPrice);
       if (savings.isGreaterThanZero())
           return savings;
       else
           return new Price(0m, sellingPrice.currency);
   }
   private bool sellingPriceMatches(Price retailPrice) {
       return sellingPrice.sameCurrency(retailPrice);
   }
   public void add(Option option) {
       if (!this.contains(option))
           options.Add(option);
       else
           throw new ProductOptionAddedNotUniqueException(string.Format("This product already has the option {0}", option.ToString()));
   }
   public bool contains(Option option) {
       return options.Contains(option);
   }
}


服务类



只有方法没有状态的类定义是对行为的封装,行为的实现要么是通过操作内部封装的不可变私有数据,要么是通过操作传入的参数对象实现对状态的修改。由于参数传入的状态与服务类自身没有任何关系,因此这样的类通常也被视为无状态的类。以下代码是针对升级激活包的验证服务:

public class PreActivePackageValidator {
   public long validatePreActivePackage(ActiveManifest  activeManifest) {
         validateSamePackageType(activeManifest);
         validateNoTempPackage(activeManifest);
         validateNoPackageRunning(activeManifest);
         validateAllPackagesBeenDownloaded(activeManifest);
         validateNoFatherPackageBakStatus(activeManifest);
         validatePackageNum(activeManifest);
   }
   private void validateSamePackageType(ActiveManifest  activeManifest) {
       int packakeType = activeManifest.getPackageType();
       for (UpagrdePackage pkg : activeManifest.getPackages()) {
           if (packageType != pkg.getPackageType()) {
               throw new PackagePreActiveException("pre active exist different type package");
           }
       }
   }
}


服务类还可以操作外部资源,例如读取文件、访问数据库、与第三方服务通信等。例如airlift框架定义的ConfigurationLoader类,就提供加载配置文件内容的服务:

public class ConfigurationLoader {
   public Map<String, String> loadProperties()
           throws IOException    {
       Map<String, String> result = new TreeMap<>();
       String configFile = System.getProperty("config");
       if (configFile != null) {
           result.putAll(loadPropertiesFrom(configFile));
       }
       result.putAll(getSystemProperties());
       return ImmutableSortedMap.copyOf(result);
   }
   public Map<String, String> loadPropertiesFrom(String path)
           throws IOException    {
       Properties properties = new Properties();
       try (Reader reader = new FileReader(new File(path))) {
           properties.load(reader);
       }
       return fromProperties(properties);
   }
   public Map<String, String> getSystemProperties()    {
       return fromProperties(System.getProperties());
   }
}


函数类



可以将函数类理解为设计一个类,它仅仅实现了一个接口,且该接口只定义一个方法。使用时,我们会基于依赖倒置原则(DIP)从接口的角度使用这个类。为了重用的目的,这个类可以单独被定义,也可能体现为匿名类,或者Java 8中的Lambda表达式。


单独类形式


例如,在Presto中定义了PagesIndexComparator接口,提供了比较方法以用于支持对页面索引的排序。接口的定义为:

public interface PagesIndexComparator {
   int compareTo(PagesIndex pagesIndex, int leftPosition, int rightPosition);
}


Presto定义了该接口的实现类SimplePagesIndexComparator,该类就是一个函数类:

public class SimplePagesIndexComparator
       implements PagesIndexComparator {
   private final List<Integer> sortChannels;
   private final List<SortOrder> sortOrders;
   private final List<Type> sortTypes;
   public SimplePagesIndexComparator(List<Type> sortTypes, List<Integer> sortChannels, List<SortOrder> sortOrders)   {
       this.sortTypes = ImmutableList.copyOf(requireNonNull(sortTypes, "sortTypes is null"));
       this.sortChannels = ImmutableList.copyOf(requireNonNull(sortChannels, "sortChannels is null"));
       this.sortOrders = ImmutableList.copyOf(requireNonNull(sortOrders, "sortOrders is null"));
   }
   @Override
   public int compareTo(PagesIndex pagesIndex, int leftPosition, int rightPosition)   {
       long leftPageAddress = pagesIndex.getValueAddresses().getLong(leftPosition);
       int leftBlockIndex = decodeSliceIndex(leftPageAddress);
       int leftBlockPosition = decodePosition(leftPageAddress);
       long rightPageAddress = pagesIndex.getValueAddresses().getLong(rightPosition);
       int rightBlockIndex = decodeSliceIndex(rightPageAddress);
       int rightBlockPosition = decodePosition(rightPageAddress);
       for (int i = 0; i < sortChannels.size(); i++) {
           int sortChannel = sortChannels.get(i);
           Block leftBlock = pagesIndex.getChannel(sortChannel).get(leftBlockIndex);
           Block rightBlock = pagesIndex.getChannel(sortChannel).get(rightBlockIndex);
           SortOrder sortOrder = sortOrders.get(i);
           int compare = sortOrder.compareBlockValue(sortTypes.get(i), leftBlock, leftBlockPosition, rightBlock, rightBlockPosition);
           if (compare != 0) {
               return compare;
           }
       }
       return 0;
   }
}


我们看到SimplePagesIndexComparator类的逻辑相对比较复杂,构造函数也需要传入三个参数:List<Type> sortTypes,List<Integer> sortChannels和List<SortOrder> sortOrders。虽然从接口的角度看,其实代表的是compare的语义,但由于逻辑复杂,而且需要传入三个对象帮助对PagesIndex进行比较,因而不可能实现为匿名类或者Lambda表达式。在Presto中,对它的使用为:

public class PagesIndexOrdering {
   private final PagesIndexComparator comparator;
   public PagesIndexOrdering(PagesIndexComparator comparator)  {
       this.comparator = requireNonNull(comparator, "comparator is null");
   }
   public PagesIndexComparator getComparator()  {
       return comparator;
   }
   /**
   * Returns the index of the median of the three positions.
   */
   private int median3(PagesIndex pagesIndex, int a, int b, int c)    {
       int ab = comparator.compareTo(pagesIndex, a, b);
       int ac = comparator.compareTo(pagesIndex, a, c);
       int bc = comparator.compareTo(pagesIndex, b, c);
       return (ab < 0 ?
               (bc < 0 ? b : ac < 0 ? c : a) :
               (bc > 0 ? b : ac > 0 ? c : a));
   }
}


匿名类形式


同样在该框架下定义的IntComparator接口,它的实现就完全不同了。首先是该接口的定义:

public interface IntComparator {
   /** Compares the given primitive types.
   *
   * @see java.util.Comparator
   * @return A positive integer, zero, or a negative integer if the first
   * argument is greater than, equal to, or smaller than, respectively, the
   * second one.
   */
   int compare(int k1, int k2);
}
在针对整型数据提供排序功能时,用到了IntComparator接口:
public final class IntBigArray {
   public void sort(int from, int to, IntComparator comparator)    {
       IntBigArrays.quickSort(array, from, to, comparator);
   }
}


但由于提供整型数据的比较逻辑相对简单,在Presto中并没有定义显式的函数类,而是使用了Lambda表达式:

groupIds.sort(0, groupByHash.getGroupCount(), (leftGroupId, rightGroupId) ->
               Long.compare(groupByHash.getRawHash(leftGroupId), groupByHash.getRawHash(rightGroupId)));

这里的Lambda表达式其实也可以理解为是一个函数类。


函数重用形式


还有一种特殊的函数类,它的定义形式与后面介绍的工具类非常相似,同样是定义了一组静态方法,但它的目的不是提供工具或辅助功能,而是将其视为函数成为被重用的单元。这时,需要用到Java 8提供的方法引用(method reference)语法。例如我们要对List<Apple>集合进行过滤,过滤条件分别为颜色与重量,这时可以在Apple类中定义两个静态方法:

public class Apple {
   public static boolean isGreenApple(Apple apple) {
       return "green".equals(apple.getColor());
   }
   public static boolean isHeavyApple(Apple apple) {
       return apple.getWeight() > 150;
   }
}


这两个方法实际上满足函数接口Predicate<Apple>的定义,因此可以在filter方法中传入这两个方法的引用:

public List<Apple> filter(Predicate<Apple> predicate) {
   ArrayList<Apple> result = new ArrayList<>();
   for (Apple apple : apples) {
       if (predicate.test(apple)) {
           result.add(apple);
       }
   }
   return result;
}
public List<Apple> filterGreenApples() {
   return filter(Apple::isGreenApple);
}
public List<Apple> filterHeavyApples() {
   return filter(Apple::isHeavyApple);
}


此时Apple类可以认为是一个函数类,但准确地说法是一系列可以被重用的函数的容器。与工具类不同的是,这些函数并不是被直接调用,本质上讲,其实是作为“高阶函数”被传递给其他方法而被重用。虽然说实例方法也可以采用这种方式而被重用,但静态方法的调用会更加简单。


工具类


在许多项目或开源项目中,随处可见工具类的身影。无需实例化的特性使得我们使用工具类的方式时变得非常的便利,也不需要考虑状态的维护。然而越是方便,我们越是要警惕工具类的陷阱——设计出臃肿庞大无所不能的上帝工具类。工具类仍然要遵循高内聚的原则,只有强相关的职责才能放到同一个工具类中。


在定义工具类时,通常有三类命名范式:

  • 名词复数形式:工具类其实就是一系列工具方法的容器,当我们要针对某种类型(或对象)提供工具方法时,可以直接将工具类命名为该类型的复数形式,例如操作Collection的工具类可以命名为Collections,操作Object的工具类可以命名为Objects,而与前置条件有关的工具类则被命名为Preconditions。
  • 以Util为后缀:这体现了工具(Utility)的语义,当我们在类名中看到Util后缀时,就可以直观地了解到这是一个工具类。例如ArrayUtil类是针对数组的工具类,DatabaseUtil是针对数据库操作的工具类,UuidUtil是针对Uuid的工具类。
  • 以Helper为后缀:这种命名相对较少,但许多框架也采用这种命名方式来体现“辅助类”的含义。例如在Druid框架中,就定义了JobHelper、GroupByQueryHelper等辅助类。


工具类是无需实例化的,因此在定义工具类时,尽可能将其声明为final类,并为其定义私有的构造函数。例如Guava框架提供的Preconditions工具类:

public final class Preconditions {
   private Preconditions() {
   }
   public static void checkArgument(boolean expression) {
       if(!expression) {
           throw new IllegalArgumentException();
       }
   }
   //other util methods
}
相关文章
|
15天前
|
Java 开发者
Java面试题:请解释内存泄漏的原因,并说明如何使用Thread类和ExecutorService实现多线程编程,请解释CountDownLatch和CyclicBarrier在并发编程中的用途和区别
Java面试题:请解释内存泄漏的原因,并说明如何使用Thread类和ExecutorService实现多线程编程,请解释CountDownLatch和CyclicBarrier在并发编程中的用途和区别
17 0
|
15天前
|
设计模式 安全 Java
Java面试题:设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题,Java内存模型定义了线程如何与内存交互,包括原子性、可见性、有序性,并发框架提供了更高层次的并发任务处理能力
Java面试题:设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题,Java内存模型定义了线程如何与内存交互,包括原子性、可见性、有序性,并发框架提供了更高层次的并发任务处理能力
30 1
|
15天前
|
安全 Java 开发者
Java面试题:什么是Java 15中的密封类以及其限制?还有哪些其他特性用于限制类继承的机制吗?
Java面试题:什么是Java 15中的密封类以及其限制?还有哪些其他特性用于限制类继承的机制吗?
18 1
|
15天前
|
设计模式 存储 安全
Java面试题:设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池,并解释其背后的原理。结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
Java面试题:设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池,并解释其背后的原理。结合观察者模式与Java并发框架,设计一个可扩展的事件处理系统
25 1
|
16天前
|
Java 调度
Calendar类在Java中的应用
Calendar类在Java中的应用
|
20天前
|
开发框架 Java Android开发
Java中的类反射与动态代理详解
Java中的类反射与动态代理详解
|
22天前
|
Java 数据安全/隐私保护
|
22天前
|
Java 数据安全/隐私保护
Java中的类继承与多态详解
Java中的类继承与多态详解
|
22天前
|
设计模式 Java
Java中的动态加载与卸载类
Java中的动态加载与卸载类
|
3天前
|
存储 算法 Java
Java类是在什么时候加载到JVM中的?加载类时,实际上加载的是什么
Java类是在什么时候加载到JVM中的?加载类时,实际上加载的是什么