Возможно ли использовать шаблон Cake с Java8?

Ответ 1

С вдохновением от других ответов я придумал следующую (грубую) иерархию классов, которая похожа на шаблон торта в Scala:

interface UserRepository {
    String authenticate(String username, String password);
}

interface UserRepositoryComponent {
    UserRepository getUserRepository();
}

interface UserServiceComponent extends UserRepositoryComponent {
    default UserService getUserService() {
        return new UserService(getUserRepository());
    }
}

class UserService {
    private final UserRepository repository;

    UserService(UserRepository repository) {
        this.repository = repository;
    }

    String authenticate(String username, String password) {
        return repository.authenticate(username, password);
    }
}

interface LocalUserRepositoryComponent extends UserRepositoryComponent {
    default UserRepository getUserRepository() {
        return new UserRepository() {
            public String authenticate(String username, String password) {
                return "LocalAuthed";
            }
        };
    }
}

interface MongoUserRepositoryComponent extends UserRepositoryComponent {
    default UserRepository getUserRepository() {
        return new UserRepository() {
            public String authenticate(String username, String password) {
                return "MongoAuthed";
            }
        };
    }
}

class LocalApp implements UserServiceComponent, LocalUserRepositoryComponent {}
class MongoApp implements UserServiceComponent, MongoUserRepositoryComponent {}

Вышеприведенные компиляции на Java 8 по состоянию на 9 января 2013 года.

Итак, может ли Java 8 сделать торт-подобный паттерн? Да.

Является ли он столь же кратким, как Scala, или столь же эффективным, как и другие шаблоны в Java (например, инъекции зависимостей)? Вероятно, нет, в приведенном выше эскизе потребовалось много файлов и не было столь же кратким, как Scala.

Вкратце:

• Self-types (по необходимости для шаблона пирога) можно эмулировать путем расширения базового интерфейса, который мы ожидаем.
• Интерфейсы не могут иметь внутренние классы (как отмечено @Owen), поэтому вместо этого мы можем использовать анонимные классы.
• val и var могут быть эмулированы с использованием статического hashmap (и ленивой инициализации) или клиентом класса, просто сохраняющим значение на их стороне (например, UserService).
• Мы можем обнаружить наш тип, используя this.getClass() в методе интерфейса по умолчанию.
• Как отмечает @Owen, типы, зависящие от пути, невозможны с использованием интерфейсов, поэтому полный шаблон торта по своей сути невозможно. Вышеизложенное показывает, однако, что его можно использовать для инъекций зависимостей.

Ответ 2

Недавно я сделал небольшую доказательную концепцию. Вы можете увидеть сообщение в блоге здесь: http://thoredge.blogspot.no/2013/01/cake-pattern-in-jdk8-evolve-beyond.html и здесь github repo: https://github.com/thoraage/cake-db-jdk8

В принципе, вы можете это сделать, но вы сталкиваетесь с двумя препятствиями, которые делают его менее гладким, чем Scala. Во-первых, черты Scala могут иметь состояние, а интерфейс Java не может. Многие модули нуждаются в состоянии. Это можно устранить, создав компонент общего состояния для хранения этой информации, но это должно быть в классе. По крайней мере, частично. Вторая проблема заключается в том, что вложенный класс в интерфейсе более похож на статический вложенный класс в классе. Таким образом, вы не можете получить доступ к методам интерфейсов непосредственно из класса модуля. Метод интерфейса по умолчанию имеет доступ к этой области и может добавить это в конструктор класса модуля.

Ответ 3

Несколько экспериментов не предполагают:

• Вложенные классы автоматически статичны. Это по своей сути нецелесообразно:

  interface Car {
      class Engine { }
  }
  
  // ...
      Car car = new Car() { };
      Car.Engine e = car.new Engine();
  
  error: qualified new of static class
      Car.Engine e = car.new Engine();
  

• Итак, по-видимому, это вложенные интерфейсы, хотя сложнее уговорить сообщения об ошибках:

  interface Car {
      interface Engine { }
  }
  
  // ...
      Car car = new Car() { };
      class Yo implements car.Engine {
      }
  
   error: package car does not exist
          class Yo implements car.Engine {
  
   // ...
  
  class Yo implements Car.Engine {
  }                                                                                                      
  
  
   // compiles ok.
  

Итак, без классов-членов класса, у вас нет типов, зависящих от типа, которые в основном необходимые для шаблона пирога. По крайней мере, нет, не в прямом смысле, это невозможно.

Ответ 4

Возможно, вы можете сделать что-то подобное в Java 8

interface DataSource
{
    String lookup(long id);
}  

interface RealDataSource extends DataSource
{
    default String lookup(long id){ return "real#"+id; }
}  

interface TestDataSource extends DataSource
{
    default String lookup(long id){ return "test#"+id; }
}  

abstract class App implements DataSource
{
    void run(){  print( "data is " + lookup(42) ); }
}  


class RealApp extends App implements RealDataSource {}

new RealApp().run();  // prints "data is real#42"


class TestApp extends App implements TestDataSource {}

new TestApp().run();  // prints "data is test#42"

Но это ничуть не лучше, чем простой/старый подход

interface DataSource
{
    String lookup(long id);
}  

class RealDataSource implements DataSource
{
    String lookup(long id){ return "real#"+id; }
}  

class TestDataSource implements DataSource
{
    String lookup(long id){ return "test#"+id; }
}  

class App
{
    final DataSource ds;
    App(DataSource ds){ this.ds=ds; }

    void run(){  print( "data is " + ds.lookup(42) ); }
}  


new App(new RealDataSource()).run();  // prints "data is real#42"


new App(new TestDataSource()).run();  // prints "data is test#42"

Ответ 5

Игнорируя новую функциональность на Java 8, теоретически вы можете сделать Cake Pattern в Java 5 и выше, используя время компиляции AspectJ ITDs.

AspectJ DTO позволяет создавать Mixins. Единственное, что раздражает то, что вам придется сделать два артефакта: аспект (ITD) и интерфейс. Однако ITD позволяют делать некоторые сумасшедшие вещи, такие как добавление аннотаций к классам, которые реализуют интерфейс.