Proxy deep-dive java-one_20151027_001

prepare for…..
Proxy Deep Dive
JavaOne 2015 20151027
1
@SvenRuppert

@SvenRuppert
has been coding java since 1996
Fellow / Senior Manager
reply Group
Germany - Munich
2

@SvenRuppert
3

@SvenRuppert
Projects in the ﬁeld of:
•Automobile-industry
•Energy
•Finance / Leasing
•Space- Satellit-
•Government / UN / World-bank
Where?
•Europe
•Asia - from India up to Malaysia
3

prepare for…..
Proxy Deep Dive - the ﬁrst steps
some words about Adapter, Delegator
and the ﬁrst Proxy
4
@SvenRuppert

Why a Proxy ?
6
@SvenRuppert
Proxies you can use them for :
generic parts inside your application
hiding technical stuff
decouple parts of your applications

Why a Proxy ?
7
@SvenRuppert
but it must be easy to use like…

Why a Proxy ?
7
@SvenRuppert
ﬁnal InnerDemoClass original = new InnerDemoClass();

Why a Proxy ?
7
@SvenRuppert
ﬁnal InnerDemoInterface demoLogic =

Why a Proxy ?
7
@SvenRuppert
ProxyBuilder.createBuilder(InnerDemoInterface.class, original)

Why a Proxy ?
7
@SvenRuppert
.addLogging()

Why a Proxy ?
7
@SvenRuppert
.addLogging()
.addMetrics()

Why a Proxy ?
7
@SvenRuppert
.addLogging()
.addMetrics()
.addSecurityRule(() -> true)

Why a Proxy ?
7
@SvenRuppert
.addLogging()
.addMetrics()

Why a Proxy ?
7
@SvenRuppert
.addLogging()
.addMetrics()
.build();

Why a Proxy ?
8
@SvenRuppert

Why a Proxy ?
8
@SvenRuppert
@Inject
@Proxy(virtual = true, metrics = true)
Service service;

Adapter v Proxy - Pattern Hello World
9
@SvenRuppert
Diﬀerence between Proxy and Adapter

Adapter - or called Wrapper
maybe : Use an Adapter if you have to use an incompatible
interface between two systems.
In detail I am using/talking about an Adapter with Delegator.
10
@SvenRuppert

11
@SvenRuppert

public class LegacyWorker { 
public void writeTheStrings(String[] strArray){ 
Arrays.stream(strArray).forEach(System.out::println); 
} 
}
11
@SvenRuppert

} 
}
11
public interface WorkerAdapter { 
public void workOnSomething(List<String> stringListe); 
}
@SvenRuppert

} 
}
11
public interface WorkerAdapter { 
public void workOnSomething(List<String> stringListe); 
}
public class Adapter implements WorkerAdapter { 
private LegacyWorker worker = new LegacyWorker(); 
@Override 
public void workOnSomething(List<String> stringListe) { 
ﬁnal String[] strings = stringListe.toArray(new String[0]); 
worker.writeTheStrings(strings); 
} 
}
@SvenRuppert

public class Main { 
public static void main(String[] args) { 
ﬁnal ArrayList<String> strings = new ArrayList<>(); 
Collections.addAll(strings, „A","B","C","D");
 
new Adapter().workOnSomething(strings); 
} 
}
12
@SvenRuppert

 
} 
}
12
• No need to know the LegacyWorker
@SvenRuppert

 
} 
}
12
• No inheritance between LegacyWorker and Adapter
@SvenRuppert

 
} 
}
12
• only a transformation of an interface
@SvenRuppert

 
} 
}
12
• only a transformation of an interface
• same creation time for Delegator and Adapter
@SvenRuppert

Proxy - the easiest version
13
@SvenRuppert
We need a few steps to come from an Adapter with
Delegator to a Proxy

13
• We need to know the LegacyWorker
@SvenRuppert

13
• Inheritance between LegacyWorker and Adapter
@SvenRuppert

13
• do not use it like an Adapter !
@SvenRuppert

13
• do not use it like an Adapter !
@SvenRuppert
please show the code

Proxy - the easiest version - (Delegator)
14
@SvenRuppert

public interface Service { 
String work(String txt); 
}
14
@SvenRuppert

}
14
@SvenRuppert
public class ServiceImpl implements Service { 
public String work(String txt) { 
return "ServiceImpl - " + txt; 
} 
}

}
14
@SvenRuppert
} 
}
public class ServiceProxy implements Service { 
private Service service = new ServiceImpl(); 
public String work(String txt) { return service.work(txt); } 
}

Security Proxy
15
@SvenRuppert

Security Proxy
15
@SvenRuppert
}

Security Proxy
15
@SvenRuppert
}
What could we
change now ?

Security Proxy
15
@SvenRuppert
}
What could we
change now ?
SecurityProxy:
execute only if it is allowed

Security Proxy
15
@SvenRuppert
}
What could we
change now ?
SecurityProxy:
execute only if it is allowed
public class ServiceSecurityProxy implements Service { 
private String code; //who will set this ? 
if(code.equals(„hoppel")) { return service.work(txt); } 
else { return "nooooop"; } 
} 
}

Remote Proxy - JDK only
16
@SvenRuppert

16
@SvenRuppert
}

16
@SvenRuppert
}
What could we
change now ?

16
@SvenRuppert
}
What could we
change now ?
RemoteProxy:
execute outside of my process

16
@SvenRuppert
}
What could we
change now ?
RemoteProxy:
Service proxy = new ServiceRemoteProxy(); 
String hello = proxy.work(„Hello");

16
@SvenRuppert
}
What could we
change now ?
RemoteProxy:
Service proxy = new ServiceRemoteProxy(); 
String hello = proxy.work(„Hello");
some work needed

17
@SvenRuppert

17
@SvenRuppert
Interface

17
@SvenRuppert
Proxy
Interface

17
@SvenRuppert
Proxy
Interface
remote communication

17
@SvenRuppert
Proxy
Interface
Interface

17
@SvenRuppert
Proxy
Remote
Service
Interface
Interface

17
@SvenRuppert
Proxy
Remote
Service
Interface
Interface
client

17
@SvenRuppert
Proxy
Remote
Service
Interface
Interface
client server

18
@SvenRuppert
@WebService 
@SOAPBinding(style = SOAPBinding.Style.RPC) 
@WebMethod 
public String work(String txt); 
}

19
@SvenRuppert
Proxy
Remote
Service
Interface
Interface
client server

20
@SvenRuppert
@SOAPBinding(style = SOAPBinding.Style.RPC) 
@WebService(endpointInterface = "org.rapidpm.Service") 
@Override 
} 
}

21
@SvenRuppert
Proxy
Remote
Service
Interface
Interface
client server

22
@SvenRuppert
final String address = "http://localhost:9999/ws/service"; 
final ExecutorService threadPool = Executors.newFixedThreadPool(10); 
final Endpoint endpoint = Endpoint.create(new ServiceImpl()); 
endpoint.setExecutor(threadPool); 
endpoint.publish(address); 
System.out.println("endpoint = " + endpoint.isPublished());

23
@SvenRuppert
Proxy Remote
Service
Interface
Interface
client server

24
@SvenRuppert
public class ServiceRemoteProxy implements Service { 
 
private URL url; 
private Service realSubject; 
ﬁnal String namespaceURI = "http://rapidpm.org/"; 
ﬁnal String localPart = "ServiceImplService"; 
 
public ServiceRemoteProxy() { 
try { 
url = new URL("http://localhost:9999/ws/service?wsdl"); 
QName qname = new QName(namespaceURI, localPart); 
javax.xml.ws.Service service = javax.xml.ws.Service.create(url, qname); 
realSubject = service.getPort(Service.class); 
} catch (MalformedURLException e) { 
e.printStackTrace(); 
} 
} 
public String work(String txt){ 
return realSubject.work(txt); 
} 
}

25
@SvenRuppert
Proxy
Remote
Service
Interface
Interface
client server

25
@SvenRuppert
Proxy
Remote
Service
Interface
Interface
client server
• remote communication

25
@SvenRuppert
Proxy
Remote
Service
Interface
Interface
client server
• most of this is technology based work

25
@SvenRuppert
Proxy
Remote
Service
Interface
Interface
client server
• most of this is technology based work
• goal: developer will see no remote
communication

Virtual Proxy
26
@SvenRuppert
}

Virtual Proxy
26
@SvenRuppert
}
What could we
change now ?

Virtual Proxy
26
@SvenRuppert
}
What could we
change now ?
Virtual Proxy:
create the Delegator later

Virtual Proxy
26
@SvenRuppert
}
What could we
change now ?
Virtual Proxy:
create the Delegator later
public class VirtualService implements Service { 
private Service service = null; 
if(service == null) { service = new ServiceImpl(); } 
return service.work(txt); 
} 
}

Virtual Proxy
27
@SvenRuppert
if(service == null) { service = new ServiceImpl(); }
 
} 
}

Virtual Proxy
27
@SvenRuppert
 
} 
}
This is NOT ThreadSafe

Virtual Proxy
27
@SvenRuppert
 
} 
}
ﬁxed decision for
an implementation

Virtual Proxy
27
@SvenRuppert
 
} 
}
ﬁxed decision for
an implementation
how to combine it with
a FactoryPattern ?

Virtual Proxy
28
@SvenRuppert

Virtual Proxy
28
@SvenRuppert
public interface ServiceFactory { 
Service createInstance(); 
}

Virtual Proxy
28
@SvenRuppert
public interface ServiceFactory { 
Service createInstance(); 
}
public interface ServiceStrategyFactory { 
Service realSubject(ServiceFactory factory); 
}

Virtual Proxy - Not - ThreadSafe
29
@SvenRuppert

29
@SvenRuppert
private ServiceFactory serviceFactory = ServiceImpl::new;

29
@SvenRuppert
public class ServiceStrategyFactoryImpl implements ServiceStrategyFactory { 
Service realSubject; 
public Service realSubject(ﬁnal ServiceFactory factory) { 
if (realSubject == null) { 
realSubject = factory.createInstance(); 
} 
return realSubject; 
} 
}

30
@SvenRuppert

30
@SvenRuppert
public class ServiceProxy implements Service {

30
@SvenRuppert

30
@SvenRuppert
private ServiceStrategyFactory strategyFactory = new ServiceStrategyFactoryImpl();

30
@SvenRuppert
public String work(String txt) {

30
@SvenRuppert
} 
}

30
@SvenRuppert
return
} 
}

30
@SvenRuppert
return strategyFactory
} 
}

30
@SvenRuppert
return strategyFactory .realSubject(
} 
}

30
@SvenRuppert
return strategyFactory .realSubject(serviceFactory
} 
}

30
@SvenRuppert
return strategyFactory .realSubject(serviceFactory).work(txt);
} 
}

Virtual Proxy - Synchronized
31
@SvenRuppert

31
@SvenRuppert

31
@SvenRuppert
public class ServiceStrategyFactorySynchronized implements ServiceStrategyFactory { 
public synchronized Service realSubject(ﬁnal ServiceFactory factory) { 
} 
} 
}

31
@SvenRuppert
public class ServiceStrategyFactorySynchronized implements ServiceStrategyFactory { 
public synchronized Service realSubject(ﬁnal ServiceFactory factory) { 
} 
} 
}
This is ThreadSafe

Virtual Proxy - Method Scoped
32
@SvenRuppert

32
@SvenRuppert

32
@SvenRuppert
public class ServiceStrategyFactoryMethodScoped implements
ServiceStrategyFactory { 
public Service realSubject(ﬁnal ServiceFactory factory) {  
return factory.createInstance(); 
} 
}

Combining Proxies
33
@SvenRuppert
Security Proxy Virtual ProxyRemote Proxy
Security ProxyVirtual ProxyRemote Proxy
Security ProxyVirtual Proxy Remote Proxy
VirtualProxies are mostly the last one
combining Proxies is easy
SecurityProxies are mostly the ﬁrst one ?

Combining Proxies - SecureVirtualProxy
34
@SvenRuppert
Security Proxy Virtual Proxy
public class VirtualProxy implements Service { 
public VirtualProxy() { out.println("VirtualProxy " + now()); } 
} 
}
public class SecureVirtualProxy implements Service { 
public SecureProxy() { out.println("SecureProxy " + now()); } 
private Service service = new VirtualProxy(); 
//SNIPP…. 
if(code.equals("hoppel")) { return service.work(txt); } 
return { return "nooooop"; } 
} 
}

34
@SvenRuppert
} 
}
//SNIPP…. 
} 
}
hard wired proxies

34
@SvenRuppert
} 
}
//SNIPP…. 
} 
}
hard wired proxies
What could we
change now ?

35
@SvenRuppert
hard wired proxies
What could we
change now ?
we need a Generic Proxy

35
@SvenRuppert
hard wired proxies
What could we
change now ?
since JDK1.3 we have it

35
@SvenRuppert
hard wired proxies
What could we
change now ?
since JDK1.3 we have it
the DynamicProxy

prepare for…..
Proxy Deep Dive - DynamicProxies
some words about :
how to use and how to extend….but.. also what is not nice
36
@SvenRuppert

Dynamic Proxy - Hello World
38
@SvenRuppert
How to use it ?

38
@SvenRuppert
How to use it ?
java.lang.reﬂect.Proxy

38
@SvenRuppert
How to use it ?
we need an interface : here Service

38
@SvenRuppert
How to use it ?
we need an implementation : here ServiceImpl

38
@SvenRuppert
How to use it ?
Service proxyInstance = Service.class.cast( Proxy.newProxyInstance( 
Service.class.getClassLoader(), 
new Class<?>[]{Service.class}, 
new InvocationHandler() { 
private ﬁnal ServiceImpl service = new ServiceImpl(); 
@Override 
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
return method.invoke(service, args); 
} 
} 
) 
);

38
@SvenRuppert
How to use it ?
Service proxyInstance = Service.class.cast( Proxy.newProxyInstance( 
Service.class.getClassLoader(), 
new Class<?>[]{Service.class}, 
@Override 
return method.invoke(service, args); 
} 
} 
) 
);
OK, step by step , please

39
@SvenRuppert

39
@SvenRuppert
Service proxyInstance = Service.class.cast (

39
@SvenRuppert
Proxy.newProxyInstance (

39
@SvenRuppert
Service.class.getClassLoader(),

39
@SvenRuppert
new Class<?>[]{Service.class},

39
@SvenRuppert
@Override 
public Object invoke(Object proxy, Method m, Object[] args) throws Throwable { 
return m.invoke(service, args); 
} 
}

39
@SvenRuppert
@Override 
} 
}
) 
);

39
@SvenRuppert
@Override 
} 
}
) 
);
how to make a VirtualProxy ?

Dynamic Virtual Proxy
40
@SvenRuppert
) 
);

Dynamic Virtual Proxy
40
@SvenRuppert
private ﬁnal ServiceImpl service; 
@Override 
} 
}
) 
);

Dynamic Proxy - make it generic
41
@SvenRuppert
@Override 
} 
} 
) 
);

41
@SvenRuppert
@Override 
} 
} 
) 
);
get it from outside

41
@SvenRuppert
@Override 
} 
} 
) 
);
get it from outside
we will remove it

41
@SvenRuppert
@Override 
} 
} 
) 
);
get it from outside
we will remove it
we will get it from outside

41
@SvenRuppert
@Override 
} 
} 
) 
);
get it from outside
we will remove it
we will get it from outside
and ﬁnally we will call it ProxyGenerator

42
@SvenRuppert
public class ProxyGenerator { 
public static P makeProxy(Class subject, P realSubject) { 
Object proxyInstance = Proxy.newProxyInstance( 
subject.getClassLoader(), 
new Class<?>[]{subject}, 
@Override 
public Object invoke(final Object proxy, final Method m, final Object[] args) throws Throwable { 
return m.invoke(realSubject, args); 
} 
} 
); 
return subject.cast(proxyInstance); 
} 
}

43
@SvenRuppert
public class ProxyGenerator { 
public static P makeProxy(Class subject, P realSubject) { 
Object proxyInstance = Proxy.newProxyInstance( 
subject.getClassLoader(), 
new Class<?>[]{subject}, 
(proxy, m, args) -> m.invoke(realSubject, args) 
); 
return subject.cast(proxyInstance); 
} 
}

44
@SvenRuppert
with DynamicProxies
- we are writing less (more generic) code
- we can create Virtual-/Remote-/Security Proxies

44
@SvenRuppert
with DynamicProxies
- we are writing less (more generic) code
- we can create Virtual-/Remote-/Security Proxies
but how to combine Proxies more generic ?

45
@SvenRuppert
for this we have to switch from

45
@SvenRuppert
Factory-Method-Pattern

45
@SvenRuppert
Factory-Method-Pattern
Builder-Pattern

DynamicProxyBuilder
46
@SvenRuppert
Security Proxy Virtual ProxySecurity Proxy
let´s think about Two possible ways:

DynamicProxyBuilder
46
@SvenRuppert
1 Security Proxy with 2 Rules and 1 VirtualProxy

DynamicProxyBuilder
46
@SvenRuppert
2 Security Proxies with 1 Rule and 1 VirtualProxy

DynamicProxyBuilder
46
@SvenRuppert
2 Security Proxies with 1 Rule and 1 VirtualProxy
OK, we need a generic CascadedProxy

DynamicProxyBuilder
47
@SvenRuppert
OK, we need a generic CascadedProxy
Proxy n
Proxy n-1
Proxy n-2
Proxy n-3
a child must know his parent
ﬁrst we only add different DynamicProxies
always the same target interface

DynamicProxyBuilder
48
@SvenRuppert
for example: add n SecurityRules

DynamicProxyBuilder
48
@SvenRuppert
public interface SecurityRule { 
boolean checkRule(); 
}

DynamicProxyBuilder
48
@SvenRuppert
}
functional interface

DynamicProxyBuilder
48
@SvenRuppert
private List<SecurityRule> securityRules = new ArrayList<>();
}

DynamicProxyBuilder
48
@SvenRuppert
private List<SecurityRule> securityRules = new ArrayList<>();
}
Collections.reverse(securityRules); 
securityRules.forEach(this::build_addSecurityRule);

DynamicProxyBuilder
49
@SvenRuppert
private ProxyBuilder<I, T> build_addSecurityRule(SecurityRule rule) { 
final ClassLoader classLoader = original.getClass().getClassLoader(); 
final Class<?>[] interfaces = {clazz}; 
final Object nextProxy = Proxy.newProxyInstance( 
classLoader, interfaces, 
private T original = ProxyBuilder.this.original; 
final boolean checkRule = rule.checkRule(); 
if (checkRule) { 
return method.invoke(original, args); 
} else { 
return null; 
} 
} 
}); 
original = (T) clazz.cast(nextProxy); 
return this; 
}

DynamicProxyBuilder
49
@SvenRuppert
if (checkRule) { 
} else { 
return null; 
} 
} 
}); 
return this; 
}
last child

DynamicProxyBuilder
49
@SvenRuppert
if (checkRule) { 
} else { 
return null; 
} 
} 
}); 
return this; 
}
last child
work on child

DynamicProxyBuilder
49
@SvenRuppert
if (checkRule) { 
} else { 
return null; 
} 
} 
}); 
return this; 
}
last child
work on child
set child for next level

DynamicProxyBuilder
49
@SvenRuppert
if (checkRule) { 
} else { 
return null; 
} 
} 
}); 
return this; 
}
how this will be used ?
last child
work on child
set child for next level

DynamicProxyBuilder
50
@SvenRuppert

DynamicProxyBuilder
50
@SvenRuppert
.addLogging()

DynamicProxyBuilder
50
@SvenRuppert
.addLogging()
.addMetrics()

DynamicProxyBuilder
50
@SvenRuppert
.addLogging()
.addMetrics()
.build();

DynamicProxyBuilder
51
@SvenRuppert

DynamicProxyBuilder
51
@SvenRuppert
Until now, we had only a cascade of one interface

DynamicProxyBuilder
51
@SvenRuppert
how to deal with different interfaces ?

DynamicProxyBuilder
51
@SvenRuppert
how to deal with different interfaces ?
we need a generic NestedBuilder

NestedBuilder - The Beginning
52
@SvenRuppert

53
@SvenRuppert

53
@SvenRuppert
Car car = Car.newBuilder() 
.withEngine(engine) 
.withWheelList(wheels) 
.build();

53
@SvenRuppert
.build();
Engine engine = Engine.newBuilder().withPower(100).withType(5).build();

53
@SvenRuppert
.build();
List<Wheel> wheels = new ArrayList<>(); 
wheels.add(wheel1); 
wheels.add(wheel3);

53
@SvenRuppert
.build();
wheels.add(wheel3);
}

53
@SvenRuppert
.build();
Wheel wheel1 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build();  
Wheel wheel2 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build(); 
Wheel wheel3 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build();
wheels.add(wheel3);
}

54
@SvenRuppert
.build();
wheels.add(wheel3);

55
@SvenRuppert
.build();
wheels.add(wheel3);

55
@SvenRuppert
.build();

55
@SvenRuppert
.build();
//List<Wheel> wheels = new ArrayList<>(); 
// wheels.add(wheel1); 
// wheels.add(wheel3);

55
@SvenRuppert
.build();
List<Wheel> wheelList = WheelListBuilder.newBuilder() 
.withNewList() 
.addWheel(wheel1) 
.build();

55
@SvenRuppert
.build();
.withNewList() 
.build(); //more robust if you add tests at build()

55
@SvenRuppert
.build();
.withNewList() 
}
}

55
@SvenRuppert
.build();
.withNewList() 
}
}
how to combine ?

56
@SvenRuppert
.build();
.withNewList() 
.build();
}
}
how to combine ?

57
@SvenRuppert
.build();
// Wheel wheel1 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build();  
// Wheel wheel2 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build(); 
// Wheel wheel3 = Wheel.newBuilder().withType(2).withColour(3).withSize(4).build();
// List<Wheel> wheelList = WheelListBuilder.newBuilder() 
.withNewList() 
.build();

57
@SvenRuppert
.build();
// List<Wheel> wheelList = WheelListBuilder.newBuilder() 
.withNewList() 
.build();

57
@SvenRuppert
.build();

57
@SvenRuppert
.build();
List<Wheel> wheels = wheelListBuilder 
.addWheel().withType(1).withSize(2).withColour(2).addWheelToList() 
.build();

58
@SvenRuppert
.build();
.build();

58
@SvenRuppert
.build();
.build();
WheelBuilder

58
@SvenRuppert
.build();
.build();
WheelBuilder
WheelListBuilder

59
@SvenRuppert
.build();
.build();

59
@SvenRuppert
.build();
.build();
now we have to combine all

59
@SvenRuppert
.build();
.build();

59
@SvenRuppert
.build();

59
@SvenRuppert

59
@SvenRuppert
.addEngine().withPower(100).withType(5).done() 
.addWheels() 
.done() 
.build();

NestedBuilder - The Pattern
60
@SvenRuppert
public abstract class NestedBuilder<T, V> {
protected T parent;
public abstract V build()
public > P  
withParentBuilder(T parent) { 
this.parent = parent; 
return (P) this; 
}

60
@SvenRuppert
protected T parent;
public abstract V build()
public > P  
withParentBuilder(T parent) { 
this.parent = parent; 
return (P) this; 
}
parent will connect itself…

61
@SvenRuppert

61
@SvenRuppert
public T done() {

61
@SvenRuppert
public T done() {
Class<?> parentClass = parent.getClass();

61
@SvenRuppert
public T done() {
try { 
V build = this.build(); 
String methodname = "with" + build.getClass().getSimpleName(); 
Method method = parentClass.getDeclaredMethod( 
methodname, build.getClass()); 
method.invoke(parent, build); 
} catch (NoSuchMethodException  
| IllegalAccessException | InvocationTargetException e) { 
}

61
@SvenRuppert
public T done() {
try { 
}
}

61
@SvenRuppert
public T done() {
try { 
}
}
connect itself with parent

62
@SvenRuppert

62
@SvenRuppert
the basic steps in short words

62
@SvenRuppert
the Parent-Builder will hold the Child-Builder

62
@SvenRuppert
the Parent-Builder will have a addChild - Method

62
@SvenRuppert
the Child-Builder will extend the NestedBuilder

62
@SvenRuppert
the Child-Builder will extend the NestedBuilder
the rest could be generated with a  
default Builder-Generator

63
@SvenRuppert
public class Parent { 
private KidA kidA; 
private KidB kidB; 
//snipp..... 
public static ﬁnal class Builder { 
// to add manually 
private KidA.Builder builderKidA = KidA.newBuilder().withParentBuilder(this); 
private KidB.Builder builderKidB = KidB.newBuilder().withParentBuilder(this); 
 
public KidA.Builder addKidA() { 
return this.builderKidA; 
} 
public KidB.Builder addKidB() { 
return this.builderKidB; 
} 
//---------

63
@SvenRuppert
//snipp..... 
 
} 
} 
//---------
connect itself with child

63
@SvenRuppert
//snipp..... 
 
} 
} 
//---------
connect itself with child
switch to Child-Builder

64
@SvenRuppert
public static ﬁnal class Builder  
extends NestedBuilder<Parent.Builder, KidA> {

64
@SvenRuppert
only extends on Child-Builder
public static ﬁnal class Builder  
extends NestedBuilder<Parent.Builder, KidA> {

65
@SvenRuppert

65
@SvenRuppert
Parent build = Parent.newBuilder() 
 
.addKidA().withNote("A").done() 
.addKidB().withNote("B").done() 
 
.build(); 
System.out.println("build = " + build);

65
@SvenRuppert
 
 
.build(); 
and a child could be a parent in the same time

65
@SvenRuppert
 
 
.build(); 
and a child could be a parent in the same time
.addKidA().withNote("A")
.addKidB().withNote("B").done()
.done() 
.build();

NestedProxyBuilder - The Goal
66
@SvenRuppert
handwritten , params for diff Proxies

Combining Proxies
67
@SvenRuppert
Security Proxy Virtual ProxyRemote Proxy
Security ProxyVirtual ProxyRemote Proxy
Security ProxyVirtual Proxy Remote Proxy
VirtualProxies are mostly the last one
combining Proxies is easy
SecurityProxies are mostly the ﬁrst one ?

DynamicProxyBuilder
68
@SvenRuppert
One functionality leads to one Proxy Instance
runtime overhead for every Proxy - but
make the ﬁrst design simple.. optimize later

DynamicObjectAdapter - orig Version
69
@SvenRuppert
the original Version of the DynamicObjectAdapter
was written by Dr. Heinz Kabutz

70
@SvenRuppert

70
@SvenRuppert
Proxy

70
@SvenRuppert
Proxy
orig /
adapter

70
@SvenRuppert
Proxy
orig /
adapter
invoke orig

70
@SvenRuppert
Proxy
orig /
adapter
invoke orig
invoke adapter

70
@SvenRuppert
Proxy
orig /
adapter
invoke orig
invoke adapter
Goal: do not need to write an
Adapter with Delegator

71
@SvenRuppert
core concept:
switching between method implementations

71
@SvenRuppert
core concept:
switching between method implementations
how to identify a method?

DynamicObjectAdapter - orig. Version
72
@SvenRuppert
String doWork_A(); 
} 
 
public static class ServiceImpl implements Service { 
public String doWork_A() { 
return ServiceImpl.class.getSimpleName(); 
} 
}

73
@SvenRuppert
how to identify a method?
public class MethodIdentifier { 
private final String name; 
private final Class[] parameters; 
 
public MethodIdentifier(Method m) { 
name = m.getName(); 
parameters = m.getParameterTypes(); 
} 
// we can save time by assuming that we only compare against 
// other MethodIdentifier objects 
public boolean equals(Object o) { 
MethodIdentifier mid = (MethodIdentifier) o; 
return name.equals(mid.name) && 
Arrays.equals(parameters, mid.parameters); 
} 
public int hashCode() { return name.hashCode(); } 
}

74
@SvenRuppert

74
@SvenRuppert
private static class DOAInvocationHandler<T extends I, I> implements InvocationHandler {

74
@SvenRuppert
private Map<MethodIdentiﬁer, Method> adaptedMethods = new HashMap<>();

74
@SvenRuppert
private T original;

74
@SvenRuppert
private T original; private Object adapter;

74
@SvenRuppert
private void addAdapter(Object adapter) {

74
@SvenRuppert
this.adapter = adapter;

74
@SvenRuppert
ﬁnal Class<?> adapterClass = adapter.getClass();

74
@SvenRuppert
Method[] methods = adapterClass.getDeclaredMethods();

74
@SvenRuppert
for (Method m : methods) {

74
@SvenRuppert
final MethodIdentifier key = new MethodIdentifier(m);

74
@SvenRuppert
adaptedMethods.put(key, m);

74
@SvenRuppert
} 
}

74
@SvenRuppert
} 
}
public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {

74
@SvenRuppert
} 
}
//SNIPP

74
@SvenRuppert
} 
}
} 
}
//SNIPP

75
@SvenRuppert
}
} 
}
//SNIPP

75
@SvenRuppert
}
try { 
} 
}
//SNIPP

75
@SvenRuppert
}
Method other = adaptedMethods.get(key);
try { 
} 
}
//SNIPP

75
@SvenRuppert
}
try { 
if (other != null) { return other.invoke(adapter, args); }
} 
}
//SNIPP

75
@SvenRuppert
}
try { 
else { return m.invoke(original, args); }
} 
}
//SNIPP

75
@SvenRuppert
} catch (InvocationTargetException e) { throw e.getTargetException(); } 
}
try { 
} 
}
//SNIPP

75
@SvenRuppert
}
try { 
} 
}
//SNIPP
what could be a problem ?

75
@SvenRuppert
}
try { 
} 
}
//SNIPP
what could be improved ?

76
@SvenRuppert

76
@SvenRuppert
}

76
@SvenRuppert
}
public class Adapter_A { 
public String doWork_A() { .. } 
}

76
@SvenRuppert
}
public class Adapter_A { 
public String doWork_A() { .. } 
}
public class Adapter_B { 
public String doWork_B() { .. } 
}

77
@SvenRuppert
Proxy
orig /
adapter
invoke orig
invoke adapter

DynamicObjectAdapter - ext. Version
78
@SvenRuppert
ﬁrst extension !

79
@SvenRuppert
String doWork_A(String txt); 
String doWork_B(String txt); 
}
public static class ServiceImpl implements Service { 
 
public String doWork_A(String txt) { 
return "doWorkd_A_Original"; 
} 
 
public String doWork_B(String txt) { 
return "doWorkd_B_Original"; 
} 
}

80
@SvenRuppert
}
public interface ServiceAdapter_A { 
} 
 
public interface ServiceAdapter_B { 
}

80
@SvenRuppert
}
} 
 
}

81
@SvenRuppert
private Map<MethodIdentiﬁer, Method> adaptedMethods = new HashMap<>(); 
private Map<MethodIdentiﬁer, Object> adapters = new HashMap<>(); 
 
private T original; 
private Class<T> target;

81
@SvenRuppert
 

81
@SvenRuppert
 
adapters.put(key, adapter);

81
@SvenRuppert
 
} 
}
adapters.put(key, adapter);

82
@SvenRuppert
 

82
@SvenRuppert
 
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

82
@SvenRuppert
 
try { 
final MethodIdentifier key = new MethodIdentifier(method); 

82
@SvenRuppert
 
try { 
if (other != null) { 
return other.invoke(adapters.get(key), args); 
} else { 
}

82
@SvenRuppert
 
} catch (InvocationTargetException e) { 
throw e.getTargetException(); 
} 
}
try { 
if (other != null) { 
return other.invoke(adapters.get(key), args); 
} else { 
}

DynamicObjectAdapter - ext. Version @SvenRuppert
 
if you will use this without a Builder
you can add useless Adapter !!

DynamicObjectAdapter - ext. Version @SvenRuppert
 
if you will use this without a Builder
you can add useless Adapter !!
Add some typed with-Methods

DynamicObjectAdapter - orig Version @SvenRuppert
public AdapterBuilder<T> withDoWork_A(ServiceAdapter_A adapter) { 
addAdapter(adapter); 
return this; 
}

return this; 
}
remember

return this; 
}
remember public interface Service { 
}

return this; 
}
remember public interface Service { 
}
}

How to use this?

How to use this?
Service service = AdapterBuilder.<Service>newBuilder()

How to use this?
.withTarget(Service.class)

How to use this?
.withOriginal(new ServiceImpl())

How to use this?
.withDoWork_A((txt) -> txt + "_part")

.build();
How to use this?

How to use this like a mock ?

.withOriginal(null)

.build();
.withOriginal(null)

generated DynamicObjectAdapterBuilder @SvenRuppert
To much boring code to write
but we want to have a type-safe version
if wrong… compile must break

To much boring code to write
but we want to have a type-safe version
What could we
change now ?
if wrong… compile must break

remember

remember
}

remember
}
} 
 
}

use Annotation Processing

create a marker like
@DynamicObjectAdapterBuilder

@Retention(RetentionPolicy.SOURCE) 
@Target(ElementType.TYPE) 
public @interface DynamicObjectAdapterBuilder { 
}

@Retention(RetentionPolicy.SOURCE) 
@Target(ElementType.TYPE) 
public @interface DynamicObjectAdapterBuilder { 
}
public class AnnotationProcessor extends AbstractProcessor

with every compile you will get actual

Functional-Interfaces for the Adapters

Functional-Interfaces for the Adapters
generated AdapterBuilder

StaticObjectAdapter @SvenRuppert
to avoid the latency of the dynamic Proxy
we could implement static ObjectAdapter
the basic idea is the same as we had  
with the DynamicObjectAdapter

split the interface into Functional Interfaces
create for every Functional Interface an attribute
at runtime: if an attribute  
is available invoke the method …..
otherwise use the delegator

String doWorkA(String txt); 
String doWorkB(String txt); 
}

}
public interface Service_DoWorkA_Adapter{  
String doWorkA(ﬁnal String txt);  
} 
public interface Service_DoWorkB_Adapter{  
String doWorkB(ﬁnal String txt);  
}

public class ServiceStaticObjectAdapter implements Service {

private Service service;

private Service_DoWorkA_Adapter doWorkAAdapter;

private Service_DoWorkB_Adapter doWorkBAdapter;

public String doWorkA(ﬁnal String txt) {
}

if (this.doWorkAAdapter != null)
}

if (this.doWorkAAdapter != null) return this.doWorkAAdapter.doWorkA(txt);
}

return service.doWorkA(txt)
}

return service.doWorkA(txt)
}
We can generate
this !

generated StaticObjectAdapter @SvenRuppert
with AnnotationProcessing
split the interface with @StaticObjectAdapter
write functional interfaces
generate the StaticObjectAdapter
mark the Adapter with @IsObjectAdapter

prepare for…..
Proxy Deep Dive -
StaticVirtualProxy - at Runtime
some words about :
how it works..and what you can do with this..
96
@SvenRuppert

generate Static Proxies at Runtime @SvenRuppert
this is based on the
Newsletter Nr 180 and Nr 181
from Dr. Heinz Kabutz
http://www.javaspecialists.eu/archive/Issue181.html
http://www.javaspecialists.eu/archive/Issue180.html

questions are:

questions are:
How to compile In-Memory ?

questions are:
What is the right ClassLoader ?

you will need the JavaCompiler from tools.jar

a holder for the SourceCode

public class GeneratedJavaSourceFile extends SimpleJavaFileObject { 
 
private CharSequence javaSource; 
 
 
 
public GeneratedJavaSourceFile(String className, CharSequence javaSource) { 
super(URI.create(className + ".java"), Kind.SOURCE); 
this.javaSource = javaSource; 
} 
 
public CharSequence getCharContent(boolean ignoreEncodeErrors) 
throws IOException { 
return javaSource; 
} 
}

public class GeneratedJavaSourceFile extends SimpleJavaFileObject { 
 
private CharSequence javaSource; 
 
 
 
public GeneratedJavaSourceFile(String className, CharSequence javaSource) { 
super(URI.create(className + ".java"), Kind.SOURCE); 
this.javaSource = javaSource; 
} 
 
public CharSequence getCharContent(boolean ignoreEncodeErrors) 
return javaSource; 
} 
}
the generated source code

a holder for the ByteCode

public class GeneratedClassFile extends SimpleJavaFileObject { 
private ﬁnal ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); 
 
public GeneratedClassFile() { 
super(URI.create("generated.class"), Kind.CLASS); 
} 
 
public OutputStream openOutputStream() { 
return outputStream; 
} 
 
public byte[] getClassAsBytes() { 
return outputStream.toByteArray(); 
} 
}

public class GeneratedClassFile extends SimpleJavaFileObject { 
private ﬁnal ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); 
 
public GeneratedClassFile() { 
super(URI.create("generated.class"), Kind.CLASS); 
} 
 
public OutputStream openOutputStream() { 
return outputStream; 
} 
 
public byte[] getClassAsBytes() { 
return outputStream.toByteArray(); 
} 
}
the generated ByteCode

a ForwardingJavaFileManager

public class GeneratingJavaFileManager  
extends ForwardingJavaFileManager<JavaFileManager> { 
 
private ﬁnal GeneratedClassFile gcf; 
 
 
public GeneratingJavaFileManager(  
StandardJavaFileManager sjfm,  
GeneratedClassFile gcf) { 
super(sjfm); 
this.gcf = gcf; 
} 
public JavaFileObject getJavaFileForOutput( 
Location location, String className, 
JavaFileObject.Kind kind, FileObject sibling) 
return gcf; 
} 
}

 
 
 
super(sjfm); 
this.gcf = gcf; 
} 
return gcf; 
} 
}
will force the  
JavaCompiler to write  
to this instance

 
 
 
super(sjfm); 
this.gcf = gcf; 
} 
return gcf; 
} 
}
the generated ByteCode
will force the  
JavaCompiler to write  
to this instance

the compile task itself

GeneratedJavaSourceFile gjsf = new GeneratedJavaSourceFile(className, javaSource);

DiagnosticCollector<JavaFileObject> dc = new DiagnosticCollector<>();

JavaCompiler jc = ToolProvider.getSystemJavaCompiler();

StandardJavaFileManager stdFileManager = jc.getStandardFileManager(dc, null, null);

GeneratedClassFile gcf = new GeneratedClassFile();

GeneratingJavaFileManager ﬁleManager  
= new GeneratingJavaFileManager(stdFileManager, gcf);

JavaCompiler.CompilationTask task  
= jc.getTask(null, ﬁleManager, dc, null, null, singletonList(gjsf));

return task.call();
JavaCompiler.CompilationTask task  
= jc.getTask(null, ﬁleManager, dc, null, null, singletonList(gjsf));

could be: public Unsafe.deﬁneClass()

or: private static Proxy.deﬁneClass0()

both versions are
depending on the
selected JVM

both versions are
depending on the
selected JVM
but this solution will have  
no roundtrip over the hard disc

both versions are
depending on the
selected JVM
but this solution will have  
no roundtrip over the hard disc
will create and compile  
Proxies at runtime

prepare for…..
Proxy Deep Dive - Summary
what we reached, what we could do now
105
@SvenRuppert

Summary
107
@SvenRuppert
we got type-safe ProxyBuilder
..type-safe generated DynamicObjectAdapter
..at runtime we could change the chain of Proxies
..could be used for
(Dynamic)
Dependency Injection Implementations

Summary
108
@SvenRuppert
If you are interested…
have a look at RapidPM on github
rapidpm-proxybuilder
rapidpm-dynamic-cdi
rapidpm-microservice
or contact me ;-) @SvenRuppert

Summary
108
@SvenRuppert
If you are interested…
have a look at RapidPM on github
rapidpm-proxybuilder
rapidpm-dynamic-cdi
rapidpm-microservice
or contact me ;-) @SvenRuppert
Thank You !!!

Proxy deep-dive java-one_20151027_001

Recommended

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to Proxy deep-dive java-one_20151027_001 (20)

More from Sven Ruppert (13)

Recently uploaded (20)

Proxy deep-dive java-one_20151027_001