Core Java. Lecture #12

Arrays and other annotations

//Arrays are specified in curly braces
@BugReport(..., reportedBy = {"Harry", "Carl"})

//Same as {"Harry"}
@BugReport(..., reportedBy = "Harry")

//Constructing nested annotations
@BugReport(..., ref = @Reference(id = "12345"))

//... As you can see, using the allowed types,
//you can specify an arbitrarily complex data structure

Where to use annotations

Use of annotations for declarations

Examples of the use of annotations in declarations

@Entity
public class User {

  @Caption("user")
  public User getUser(@Param("id") String userId) {

    @SuppressWarnings("unchecked")
    List<User> users = ....
  }
}


class Cache<@Immutable V> {
 ...
}

Annotate packages — in package-info.java

//package-info.java
@GPL(version="3")
package edu.phystech.corejava;
import org.gnu.GPL;

Annotate the type usage

//annotated parameter that states that userId is not `null`
User getUser(@NonNull String userId) { ... }

//Annotated type usage: each line is not `null`
List<@NonNull String> list = ...
Comparator. <@NonNull String>reverseOrder()
class Warning extends @Localized Message { ... }

List<@Localized ? extends Message> = ...

(@Localized String) text

if (text instanceof @Localized String) ...

//etc., the list of examples is not complete.
//Annotations can be almost everywhere!

Java8+: annotate type usage in this

public class Foo {
  //type usage is being annotated!
  void baz(@ReadOnly Foo this){
    ...
  }

  class Bar {
    //type usage is being annotated!
    public Bar(@ReadOnly Foo Foo.this) {
      ...
    }
  }
}

Familiar standard annotations built into the Java language

Standard annotations built into the Java language

Annotations are managed by annotations

//What code elements can be annotated
@Target({ElementType.TYPE, ElementType.METHOD})

//At what level are these annotations retained?
@Retention(RetentionPolicy.Source)
public @interface BugReport {
 ...
}

Target

RetentionPolicy

Other meta-annotations

Reflection API

Employee e = ... //assign Employee
Employee m = ... //assign Manager

//Get type information in run time
Class<? extends Employee> ce = e.getClass();
Class<? extends Employee> cm = m.getClass();

System.out.printf("%s, %s%n", ce.getName(), cm.getName());
//edu.phystech.hello.Employee, edu.phystech.hello.Manager

System.out.printf("%s, %s%n", ce.getSimpleName(), cm.getSimpleName());
//Employee, Manager

Class<T> class is parameterized

Employee e = ...;

//No cast needed!
Class<? extends Employee> c = e.getClass();

//No cast needed!
Employee newEmployee =
  ce.getDeclaredConstructor().newInstance();

//Compile-time error!
Class<? extends Number> cn = e.getClass();

Class literals

Class literals — examples

//everything is clear here
Class<String> c1 = String.class;
Class<Integer> c2 = Integer.class;

//Yes, you can!!
Class<Integer> c3 = int.class;
//And also double.class, boolean.class, etc.

//Note that c2 and c3 are significantly DIFFERENT objects.
//(for example, c3.getConstructors() returns an empty array.)

//There is nothing unexpected here, you can parameterize by arrays:
Class<int[]> c4 = int[].class;

NB: strange array class names

Dynamic way to get a meta-class

//ClassNotFoundException can be thrown
//the type parameter cannot be known in advance here
Class<?> clazz =
  Class.forName("edu.phystech.hello.Manager");

//There are two forms:

//class loader of the calling method, static initialization
static Class<?> forName(String className)
                         throws ClassNotFoundException

//custom class loader, static initialization on demand
static Class<?> forName(String name, boolean initialize,
                                   ClassLoader loader)

Resource files loading

public InputStream getResourceAsStream(String name)
public java.net.URL getResource(String name)

Analyzing class capabilities and interacting with class members

Retrieving Class Members

Accessing Class Members

Analysis of annotations in runtime

Reflection and Generics

Reflection Utilities

Class with annotated fields

public class Person {
    @Published
    private final String firstName;
    @Published
    private final String lastName;
    @Published
    private final LocalDate birthDate;
    ...
}

JsonSerializer: determine which fields are annotated with @Published

public class JsonSerializer<T> {
  private final Set<Field> publishedFields;

  public JsonSerializer(Class<T> serializedClass) {
    publishedFields = ReflectionUtils
       .getAllFields(serializedClass,
                f -> f.isAnnotationPresent(Published.class));
  publishedFields.forEach(f -> f.setAccessible(true));
}

JsonSerializer: serialize the object

public JSONObject serialize(T o) {
  JSONObject result = new JSONObject();
  for (Field f : publishedFields) {
    Object fieldValue = null;
    try { fieldValue = f.get(o); }
      catch (IllegalAccessException e) {
        throw new IllegalStateException(e); }
      if (fieldValue instanceof LocalDate) {
        result.put(f.getName(),
    ((LocalDate) fieldValue).format(DateTimeFormatter.ISO_LOCAL_DATE));
      } else {
        result.put(f.getName(), fieldValue);
      }
    }
  return result;
}

Example with Controller

public class Controller {
    private final Service service;

    @Command("foo")
    void doSomething() {
        service.foo();
    }
    @Command("bar")
    void bar() {
        service.bar();
    }
    @Command()
    void help() {
        service.help();
    }
}

CommandDispatcher

public class CommandDispatcher {
    private final Object controller;
    private final Map<String, Method> methodHashMap =
                                        new HashMap<>();
    private Method defaultMethod;

CommandDispatcher: Initialization

public CommandDispatcher(Object controller) {
  Objects.requireNonNull(controller);
  this.controller = controller;
  for (Method method : ReflectionUtils
           .getAllMethods(controller.getClass())) {
    Command command = method.getAnnotation(Command.class);
    if (command != null) {
       //Extract the parameter from the annotation
        String commandId = command.value();
        if (commandId.isEmpty()) {
            defaultMethod = method;
        } else {
            methodHashMap.put(commandId, method);
        }
    }
  }
}

CommandDispatcher: Executing the Command

public void executeCommand(String command)
  throws InvocationTargetException, IllegalAccessException {
    Method method = methodHashMap
      .getOrDefault(command, defaultMethod);
    if (method != null){
        method.invoke(controller);
    }
}

Our case study about reports and speakers

Real "layered" architecture of the server application

Attempt #1, naïve. "Let the objects create for themselves what they need"

public class DataSource {
  private ConnectionPool pool = new ConnectionPool(....);
  // parameters taken from somewhere to connect to the database ^^^^^^
  ...
}

public class SpeakerDao {
  private DataSource ds = new DataSource();
  ...
}

public class TalkDao {
  private DataSource ds = ???
    //we need one ConnectionPool for all...
    //doesn't work :-(
  ...
}

Attempt #2. Let’s put a to a single object in a static field

public class ConnectionPool {
  private final static ConnectionPool instance =
                                  new ConnectionPool(...);
  public static ConnectionPool getInstance() {
    return instance;
  }
  //we will make the constructor private so that no one is tempted
  //to create the object explicitly
  private ConnectionPool(...) {

  }
}

Attempt #2. (continued)

public class DataSource {
  private final static DataSource instance = ...
  public DataSource getInstance() {
    return instance;
  }

  private ConnectionPool pool = ConnectionPool.getInstance();

  private DataSource() {
    ...
  }
}

We just invented the "Singleton" design pattern!

Erich Gamma et al., Design Patterns: Elements of Reusable Object-Oriented Software 1994 book Classic software design book…​ …​ but partially outdated.

Singleton Pattern

Singleton brewing: attempt #1

public class Singleton {
  //Singleton creation is "hidden"
  private static final Singleton instance = new Singleton();

  public static Singleton getInstance() {
    return instance;
  }

  //We prohibit the option to create another instance "from the outside"
  private Singleton(){
  }
}

Attempt #2

public class Singleton {
    private static Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {
           instance = new Singleton();
        }
        return instance;
    }
    private Singleton(){
    }
}

Attempt #3 ?!

public class Singleton {
    private static volatile Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    private Singleton(){
    }
}

Attempt #4 ?! ?!

public class Singleton {
    private static Singleton instance;

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    private Singleton(){
    }
}

Attempt #5 ?! ?! ?!

public class Singleton {
    private static Singleton instance;
    private static final Object lock = new Object();
    public static Singleton getInstance() {
        if (instance == null)
            synchronized (lock) {
                if (instance == null)
                    instance = new Singleton();
            }
        return instance;
    }
    private Singleton() {
    }
}

Attempt #6 . . .

public class Singleton {
    private static volatile Singleton instance;
    private static final Object lock = new Object();
    public static Singleton getInstance() {
        if (instance == null)
            synchronized (lock) {
                if (instance == null)
                    instance = new Singleton();
            }
        return instance;
    }
    private Singleton() {
    }
}

Attempt #7. Code from the book "Effective Java, 3rd edition"

public class Singleton {
  private static volatile Singleton instance;
  private static final Object lock = new Object();
  public static Singleton getInstance() {
    Singleton result = instance;
    if (result == null) {
      synchronized (lock) {
        if (instance == null)
          instance = result = new Singleton();
        }
     }
     return result;
  }
}

Attempt #7. Code from the book "Effective Java, 3rd edition"

public class Singleton {
  private static volatile Singleton instance;
  private static final Object lock = new Object();
  public static Singleton getInstance() {
    Singleton result = instance;
    if (result == null) {
      synchronized (lock) {
        if (instance == null)
          instance = result = new Singleton();
        }
     }
     return result;
  }
}

The Only Correct Lazy Thread-Safe Singleton Implementation

public class Singleton {
    private static volatile Singleton instance;
    private static final Object lock = new Object();
    public static Singleton getInstance() {
        Singleton result = instance;
        if (result != null)
            return result;

        synchronized (lock) {
            if (instance == null)
                instance = new Singleton();
            return instance;
        }
    }
    private Singleton() {}
}

Attempt #8

// Correct lazy initialization in Java
public class Singleton {
    private static class SingletonHolder {
       public static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
    private Singleton() {
    }
}