Java ap is you should know

by
• Lead of JUG Dortmund
• JSR EG member
• Java Developer @ Canoo Engineering AG
• JavaOne Rockstar, Java Champion
• I ❤ Star Wars
www.guigarage.com@hendrikEbbers
Hendrik Ebbers

by
Hendrik Ebbers

by
null Plugin @

you should knowJava byAPIs
How to handle null
blog.takipi.com

How to handle null
NullPointerException

How to handle null
• All of us have seen more than enough
NullPointerExceptions
• Java contains some APIs to tame the
beast

How to handle null
• Before we try to avoid NPEs we should
have a look how to handle null the
right way
• Java has null for a reason. Just use it.

How to handle null
public long getPeriode(final Date start, final Date end) {
return end.getTime() - start.getTime();
}
• This method is a typically bad
example for NPEs / null values and
how to deal with them
• Do you have an idea why? ?

How to handle null
}
Exception in thread "main" java.lang.NullPointerException
at com.guigarage.sample.Example.getPeriode(Example.java:11)
which date is null?

How to handle null
public Locale(String language, String country, String variant) { 
if (language== null || country == null || variant == null) { 
throw new NullPointerException(); 
} 
. . . 
}
JDK code . . .

How to handle null/**
* . . .
* @throws NullPointerException if start or end is null
*/
if(start == null) {
throw new NullPointerException("start must not be null");
}
if(end == null) {
throw new NullPointerException("end must not be null");
}
}

How to handle null
/**
* . . .
* @throws NullPointerException if start or end is null
*/
Objects.requireNonNull(start, "start must not be null");
Objects.requireNonNull(end, "end must not be null");
}

How to handle null
• You should use it in constructors, too
public class Periode {
private final Date start;
private final Date end;
public Periode(final Date start, final Date end) {
start = Objects.requireNonNull(start, "start must not be null");
end = Objects.requireNonNull(end, "end must not be null");
}
}

How to handle null
• Make your own util methods
public class MyUtils {
public static <T> T requireNonNull(final T value, final String name) {
return Objects.requireNonNull(value, name + " must not be null");
}
}

How to handle null
• Sometime you don't want to throw a
NPE
• In that case the use of default values is
an option

How to handle null
public boolean containsA(final String input) {
String currentInput = input;
if(currentInput == null) {
currentInput = "";
}
return currentInput.contains("A");
}

How to handle null
• Sometime you don't want to throw a NPE
• In that case the use of default values is
an option
• Java 8 provides the Optional class to
simplify this

How to handle null
public boolean containsA(final String input) {
return Optional.ofNullable(input).orElse("").contains("A");
}
create a new
Optional that wraps
a value
returns the internal value
or the given value if the
internal value is null

How to handle null
• You can use Optional internally in your
method logic
• You can use Optional as a return value
of a method
• You should not use Optional as a param

How to handle null
public Optional<Entity> findByName(final String name) {
Objects.requireNonNull(name, "name must not be null");
String query = "Select entity where name = " + name;
return Optional.ofNullable(database.executeQuery(query));
}
• This methods can be used as a starting
point for a fluent API
findByName("Java").ifPresent(entity -> table.add(entity));

How to handle null
• Another example that provides the id of
an selected element
maybe nothing is
selected
list shows "Movie"
objects that provide
title and id

How to handle null
final Integer selectedId = Optional.ofNullable(list.getSelected())
.map(i -> i.getId())
.orElse(null);
• Another example that provides the id of
an selected element

How to handle null
• Since autoboxing is a cool feature in
general it sucks if you run in NPEs
• Using Optional can help you to avoid
this exceptions

• Let's have a look at a bean -> entity
converter 
 
 
 
What could possibly go wrong
How to handle null
public class MyBean {
public Integer getCount();
}
public class MyEntity {
public void setCount(int c);
}
?

public class MyBean {
public Integer getCount();
}
How to handle null
hint : this could return null
public class MyEntity {
public void setCount(int c);
}

public MyEntity convert(final MyBean bean) {
Objects.requireNonNull(bean, "bean must not be null");
MyEntity entity = new MyEntity();
entity.setCount(bean.getCount());
return entity;
}
How to handle null
might throw a NPE since we can't
pass null as value for a primitive

public MyEntity convert(final MyBean bean) {
Objects.requireNonNull(bean, "bean must not be null");
MyEntity entity = new MyEntity();
entity.setCount(Optional.ofNullable(bean.getCount()).orElse(0));
return entity;
}
How to handle null
default value

Service Provider Interface
• Based on Interfaces it's quite easy to
define a general service and several
implementations in Java

public interface MathOperation {
String getSign();
double calc(double valA, double valB);
}

• We can provide several
implementations of math operations
• AddOperation
• SubstractOperation

public class Multiply implements MathOperation {
public String getSign() { return "*";}
double calc(double valA, double valB){
return valA * valB;
}
}

• Instances of the implementations can
be accessed by using the general
interface
• All instances can simply be stored in a
collection

List<MathOperation> operations = new ArrayList<>();
operations.add(new MultipyOperation());
operations.add(new AddOperation());
operations.add(new DivideOperation());
operations.add(new SubstractOperation());
operations.forEach(o -> {
System.out.println("Supported Operation: " + o.getSign());
});

• With Java 8 default methods we can
even define default logic for some
parts of the service
• Use defaults only if it really makes
sense!

String getSign();
default String getHelp() {
return "No help text for sign" + getSign();
}
}

• Let's think about a bigger application
• Often based on several modules /
jars
• Several jars contains several service
implementations

Application
Basic Math
Module
Math Def
Module
Special Math
Module
contains the interface

Application
Basic Math
Module
Math Def
Module
Special Math
Module
contains implementations

Application
Basic Math
Module
Math Def
Module
Special Math
Module
use implementations

Application
Basic Math
Module
Math Def
Module
Special Math
Module
depends on
depends on
depends ondepends on

Application
Basic Math
Module
Math Def
Module
Special Math
Module
One Million Dollar
Question

• Where should we define the following
method?
public List<MathOperation> getAllImplInClasspath();
?

• We can't define it in the "Math Def
Module" since this module has no
dependency to any implementation
• Method would return 
an empty list

• We can't define it in the "Basic Math" or
the "Special Math" since this modules
don't know all implementations.
• Method would not 
return all  
implementations

• Only the "Application" module knows all
implementations since it's the only
module that depends on all other
modules

Basic Math
Module
Math Def
Module
Special Math
Module
Algebra Math
Module
Geometry
Math Module
• Let's add some complexity

Customer A
Application
Basic Math
Module
Math Def
Module
Special Math
Module
Algebra Math
Module
Geometry
Math Module
Customer B
Application
Customer C
Application

• We don't want to implement the 
 
for each application
• We need something new that loads all
implementations dynamically

• Service Provider Interface (SPI)
provides a simple API to solve this issue
• Could be used to create a minimal but
powerful Plug In API

• Start by creating an interface
String getSign();
}
we already have it

• Each module that provides
implementations of the interface most
provide a service file
• File must be located under META-INF/
services/

• Name of the file must be equals to the
interface name
META-INF/services/com.canoo.math.MathOperation
file name

• File simply contains names of all
implementations
com.canoo.basic.AddOperation 
com.canoo.basic.MinusOperation
define one
implementation per line

• The Service Provider Interface (SPI) will
automatically find all implementations
at runtime
• Instances of the classes will
automatically be created
• Default constructor is needed

• You can simply iterate over all
implementations
Iterator<MathOperation> iterator = ServiceLoader.load(MathOperation.class).iterator();
 
while (iterator.hasNext()) { 
MathOperation operation = iterator.next(); 
}

• At the end we can implement the 
 
method simple in the "Math Def Module"
• The service provider  
will automatically find 
all implementations

Annotations
• Let's start with a quiz :)
• How many Java annotations are used
in the code?
?

Annotations/** 
* A helper class 
* @see Class#getModifiers() 
* 
* @author Hendrik Ebbers
* @deprecated 
*/
@Deprectaded
public class Helper {
@Important
private Logger logger = new Logger();
/** 
* Return {@code true} if the integer argument includes the {@code private} modifier, {@code false} otherwise. 
* 
* @param mod a set of modifiers 
* @return {@code true} if {@code mod} includes the {@code private} modifier; {@code false} otherwise. 
*/
@Static(false) 
public static boolean isPrivate(@Param int mod) { 
return (mod & 0x00000002) != 0; 
}
}

/** 
* A helper class 
* 
* @deprecated 
*/
@Deprectaded
@Important
/** 
* 
*/
@Static(false) 
return (mod & 0x00000002) != 0; 
}
}
Annotations

/** 
* A helper class 
* 
* @deprecated 
*/
@Deprectaded
@Important
/** 
* 
*/
@Static(false) 
return (mod & 0x00000002) != 0; 
}
}
Annotations
@Deprectated
annotation is defined
in the JRE

/** 
* A helper class 
* 
* @deprecated 
*/
@Deprectaded
@Important
/** 
* 
*/
@Static(false) 
return (mod & 0x00000002) != 0; 
}
}
Annotations
the @Important annotation is not defined in
the JRE but it's easy to create your own
custom annotations (like @Autowired in
Spring)

/** 
* A helper class 
* 
* @deprecated 
*/
@Deprectaded
@Important
/** 
* 
*/
@Static(false) 
return (mod & 0x00000002) != 0; 
}
}
Annotations
the @Static annotation is configured
by a boolean parameter

/** 
* A helper class 
* 
* @deprecated 
*/
@Deprectaded
@Important
/** 
* 
*/
@Static(false) 
return (mod & 0x00000002) != 0; 
}
}
Annotations
the @Param annotation is another
custom annotation that is used to
annotate a method param

Annotations
• Annotations can be used to add metadata to
the code
• Annotations can be added to different points
of the code
• Annotation can be parametrable
• Custom annotations can be defined

Annotations
public @interface MyAnnotation {
}

Annotations
}
access modifier name
annotation keyword

Annotations
@Documented
@Retention(RUNTIME)
@Target(METHOD)
}

Annotations
@Documented
@Retention(RUNTIME)
@Target(METHOD)
}
?

Annotations
@Documented
@Retention(RUNTIME)
@Target(ANNOTATION_TYPE)
public @interface Documented {
}

Annotations
• If an annotation is annotated with
@Documented the usage of the
annotation will be shown in JavaDoc
• The usage of @Documented has no
effect at runtime

Annotations
• The @Target annotation defines where
an annotation can be used.
• The enum ElementType defines all
supported types

Annotations
• TYPE
• FIELD
• METHOD
• PARAMETER
• CONSTRUCTOR
• LOCAL_VARIABLE
• ANNOTATION_TYPE
• PACKAGE
• TYPE_PARAMETER
• TYPE_USE[ ]

Annotations
@Target(METHOD)
}
@MyAnnotation
public void sqrt(int value) {
return 1;
}

Annotations
@Target(METHOD)
}
public void sqrt(@MyAnnotation int value) {
return 1;
}

Annotations
@Target(PARAMETER)
}
return 1;
}

Annotations
@Target({PARAMETER, METHOD})
}
@MyAnnotation
return 1;
}

Annotations
• The @Retention annotation defines
how long an annotation will be
retained.
• The enum RetentionPolicy defines all
supported types

Annotations
SOURCE CLASS RUNTIME
remove annotation at
compiletime
remove annotation at
runtime
do not remove
annotation

Annotations
SOURCE CLASS RUNTIME
general meta
information like
@Override
for example the
annotations of findbugs
All annotations that
are used at runtime

Annotations
• There are several ways how
annotations can be used
• Annotations like @Deprecated define
useful information for the developer
(IDE support) and compiler

Annotations
• Projects like Lombok use annotations
for annotation processing at compile
time
• Annotations like @Inject are used to
modify objects at runtime

Annotations
• All annotations that have a @Retention
policy that is defined as RUNTIME can
be accessed by using reflection.
• In general this is one of the tricks that
make DI or Spring work

Annotations
• How can I check for annotations in my
code at runtime
?

Annotations
Class cls = MyCustomClass.class; 
boolean val = cls.isAnnotationPresent(MyAnnotation.class);
• Reflections ;)

Annotations
• Annotations can contain parameters
public @interface Column {
String name();
}
@Column(name="Description")
private String desc;

Annotations
• If an Annotations only needs one
param it should be named as "value"
• By doing so the name must not be
specified when using the annotation

Annotations
String value();
}
@Column("Name")
private String name;

Annotations
• Annotations can define a default value
for a parameters
String name() default "";
}
@Column
private String name;

Annotations
• Additional topics:
• @Inherited
• Lists of annotations
• Meta annotations
• Annotation Processor

Java ap is you should know

More Related Content

What's hot

Similar to Java ap is you should know

More from Hendrik Ebbers

Recently uploaded

Java ap is you should know