Reading data from multiple different resource bundle property files in Java I have class structure to read the data from resource bundle (property files).
import java.util.Locale;
import java.util.Objects;
import java.util.ResourceBundle;

/**
 * The class will be used to read the resource bundle to achieve localization
 * and internationalization
 *
 */
public class ResourceBundleReader {

  private String resourceBundle = null;

  /**
   * Constructor of the class
   *
   * @param resourceBundle
   * @throws NullPointerException
   *           if resourceBundle is null
   */
  public ResourceBundleReader(final String resourceBundle) {

    Objects.requireNonNull(resourceBundle);

    this.resourceBundle = resourceBundle;
  }

  /**
   * Return message by input key for default locale
   *
   * @param key
   * @return
   */
  public String getMessage(final String key) {

    return getMessage(key, Locale.getDefault());
  }

  /**
   * Return message by input key for input locale locale
   *
   * @param key
   * @return
   */
  public String getMessage(final String key, final Locale locale) {
    final ResourceBundle mybundle = ResourceBundle.getBundle(resourceBundle, locale);
    return mybundle.getString(key);
  }
}

As there are multiple type of resource bundles, I have created individual implementation for that. For example below two:
Exception Message:
public final class ExceptionMessageResolver {

  private static final String EXCEPTION_MESSAGES_RESOURCE = &quot;exceptionmessages&quot;; //$NON-NLS-1$

  private static final ResourceBundleReader RESOURCE_BUNDLE_READER = new ResourceBundleReader(
      EXCEPTION_MESSAGES_RESOURCE);

  /**
   * Private constructor to prevent instantiation Constructor of the class
   */
  private ExceptionMessageResolver() {
    super();
  }

  /**
   * return exception message by default locale
   *
   * @param key
   * @return
   */
  public static String getMessage(final String key) {

    return getMessage(key, Locale.getDefault());
  }

  /**
   * Return exception message for input locale
   *
   * @param key
   * @param locale
   * @return
   */
  public static String getMessage(final String key, final Locale locale) {
    return RESOURCE_BUNDLE_READER.getMessage(key, locale);
  }

}

Label Messages:
public final class ResourceLabelResolver {

  private static final String LABEL_RESOURCE = &quot;resourcelabels&quot;; //$NON-NLS-1$

  private static final ResourceBundleReader RESOURCE_BUNDLE_READER = new ResourceBundleReader(LABEL_RESOURCE);

  /**
   * Private constructor to prevent instantiation Constructor of the class
   */
  private ResourceLabelResolver() {
    super();
  }

  /**
   * return label message by default locale
   *
   * @param key
   * @return
   */
  public static String getMessage(final String key) {

    return getMessage(key, Locale.getDefault());
  }

  /**
   * Return label message for input locale
   *
   * @param key
   * @param locale
   * @return
   */
  public static String getMessage(final String key, final Locale locale) {
    return RESOURCE_BUNDLE_READER.getMessage(key, locale);
  }

}

Is there any more elegant way for this? Or any way to create abase class for my two readers to prevent duplicate methods in code?
I don't see the need to implement sub classes in your code example above. You need inheritance only if you add specific implementation on the sub class. All you need is to create an interface to encapsulate the resolver (IResourceBundle) for abstraction, then create a factory for them.
public interface IResourceBundle {
    String getMessage(final String key);
    String getMessage(final String key, final Locale locale);
}

public enum ResourceBundles {
    EXCEPTION_MESSAGE(&quot;exceptionmessages&quot;),
    LABEL(&quot;resourcelabels&quot;);    
    private String bundleName;
    private ResourceBundles(String name) {
        bundleName = name;
    }
    public String toString() {
        return bundleName;
    }
}

public final class ResourceResolverFactory {
    private Map&lt;ResourceBundles, IResourceBundle&gt; resolvers;
    private ResourceResolverFactory() {
        resolvers = new HashMap&lt;ResourceBundles, IResourceBundle&gt;();
    }
    public IResourceBundle getBundle(final ResourceBundles resourceBundle) {
        IResourceBundle resolver = resolvers.get(resourceBundle);
        if(resolver != null) {
            return resolver;
        }
        resolver = new ResourceBundleReader(resourceBundle.toString());
        resolvers.put(resourceBundle, resolver);
        return resolver;
    }
    private static final ResourceResolverFactory instance = new ResourceResolverFactory();
    public static ResourceResolverFactory getInstance() {
        return instance;
    }
}

public class ResourceBundleReader implements IResourceBundle {
    private String resourceBundle = null;
    public ResourceBundleReader(final String resourceBundle) {
        Objects.requireNonNull(resourceBundle);
        this.resourceBundle = resourceBundle;
    }
    public String getMessage(final String key) {
        return getMessage(key, Locale.getDefault());
    }
    public String getMessage(final String key, final Locale locale) {
        final ResourceBundle mybundle = ResourceBundle.getBundle(resourceBundle, locale);
        return mybundle.getString(key);
    }
}

public class Main {
    public static void main(String[] args) {
        ResourceResolverFactory factory = ResourceResolverFactory.getInstance();
        IResourceBundle exceptionMessageResolver = factory.getBundle(ResourceBundles.EXCEPTION_MESSAGES_RESOURCE);    
        // do something with exceptionMessageResolver
        IResourceBundle labelResolver = factory.getBundle(ResourceBundles.EXCEPTION_MESSAGES_RESOURCE);
        // do something with labelResolver
    }
}

In this case, adding more resource bundle means adding new enum in ResourceBundles not introducing new sub-class.