Presentation of all the new stuff in Java 1.5 from 2007.

1. JDK 1.5 and modern patterns Peter Antman, CTO, 2007 Mogul

3. The base to using J2EE effectively

5. Interceptors

6. Dependency Injection/IoC

7. AOP

9. New for loop

10. Autoboxing

11. Varargs

12. Enums

13. Static import

14. Annotations

15. New concurrency libraries

16. New stuff in java.lang.System, java.util.*

17. New management API and tools (JMX)

18. Better runtime (gc)

19. And more...

22. A type parameter

23. Generics is parameterized classes (and methods)

26. No more typecasts

27. Only use arrays for performance critical work

28. Cleaner code for simple cases

32. The generic type informations is lost in byte code

36. Done by prepending a type parameter

41. Can put both Integer and Double

42. ln.add(new Double(3.14));

43. List<Integer> li = new List<Integer>();

44. May only take Integer and subclasses, not Double

45. ln = new List<Integer>(); // Compile error

46. Not OK, Integer can not risk being a Double

48. To be able to read from an inheritable generic class one must use the extends wildcard

51. <? super T> say that any type that is a parent to T used to parameterized a generic class will make that class a subtype of the declaring class

52. Look at List<? super Number> . What is List<Object>?

53. Since Object is a supertype of Number List<Object> is a subtype of List<? super Number>!

56. Wildcard not allowed at top level during instance creation

57. Bounded type variables

58. Multiple bounds

59. Unbounded generics

60. Arrays and generics

61. Exceptions

65. Objects inheriting from java.lang.Object

66. Primitives have no common parent

67. Autoboxing - primitives Primitives does not work well with Collections or any other class that work on Object void visit(String page) { int val = 0; if (stats.containsKey(page)) { val = ((Integer) stats.get(page)).intValue(); } Integer newVal = new Integer(++val) ; stats. put (page, newVal); }

75. Requires recompilation of all using classes when changed

76. Not nice to print

77. Lot of work to implements ones own enums

80. Iterates over Iteratable, enums and arrays

81. Avoids local variables List<Integer> ints = Arrays.asList(1,2,3); for (int i: ints) System.out.println(&quot;I: &quot; + i); int[] ints2 = new int[]{1,2,3}; for (int i: ints2) System.out.println(&quot;I: &quot; + i); for(Rgb c: Rgb.values()) System.out.println(&quot;C: &quot; +c);

83. Avoids antipattern that inherits static variable through interface

84. Use with caution Math.PI * 2 import static java.lang.Math.PI; PI * 2; Possible, but seldom recommended, to do wildcard import

86. Metadata that can be attached to a package, class, interface, field, method, parameter, constructor or local variable

87. No inherent logic, only a placeholder for data

88. May be available in source code, byte code and at runtime

89. Is used by other tools and runtime components: these may change the behavior of a program

91. generate documentation

92. generate deployment descriptor

93. read deployment info from class/at runtime,

94. add aspects

95. inject objects

97. Attributes may have default values

98. The value() attribute is special

99. Attributes may only be primitives, String, Class, enums, annotations and arrays of these

100. Annotations always have parent java.lang.annotation.Annotation @interface MyAnnotation { String value(); String myDefault() default &quot;[Default Value]&quot;; }

102. Target tells where an annotation is valid

103. Retention tells where an annotation is available, i.e source, binary, runtime import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import java.lang.annotation.ElementType; @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @interface MyAnnotation {

105. Are compile time dependent on provider

106. Are not runtime dependent when not introspected

107. May be used together with package, class, interface, field, method, parameter, constructor and local variables @MyAnnotation(“value”) public class MyClass { @MyAnnotation(value = “value”) int var = ...; @MyAnnotation(“value”, myDefault=”noDefault”) public void method() @MyAnnotation(“value”) public MyClass(@MyAnnotation(“param”) String arg) {

109. If classes are not available they silently “disappear” @HiddenAnnotation(&quot;Ha&quot;) public static void main(final String[] args) throws Exception{ Method m = AnnotationTest.class. getMethod(&quot;main&quot;, String[].class); Annotation[] as = m.getDeclaredAnnotations() ; for (Annotation a: as) { if (a instanceof HiddenAnnotation){ System.out.println(&quot;Value=&quot; + ((HiddenAnnotation)a).value() ); } } }

111. Contains interfaces and core classes which makes it easier and safer to work with concurrency

112. Never write concurrent code without checking this library

114. Pools of Threads and other things

115. Concurrent collaboration

116. Asynchronous invocations

117. Advanced locking

118. Atomic operations on objects (not just ints)

120. Failfast iterators: clone state before iterating

122. Uses new techniques and algorithms to handle different usage patterns effectively

124. weakly consistent iterators

126. Optimized for reads: does not block reads even when its updated

127. Does often not block on updates either

128. Weakly consistent iterators

129. Atomic check and take action methods V putIfAbsent(K key, V value); boolean remove(Object key, Object value); V replace(K key, V value); boolean replace(K key, V oldValue, V newValue);

132. Safe for concurrent operations but no synchronized reads

133. Use when mostly used with concurrent reads

134. Typical usecase: listeners

135. Costly to write to

136. Snapshot iterators, not possible to modify collection through them

140. LinkedBlockingQueue – unbound by default

141. ArrayBlockingQueue – bounded queue

142. PriorityBlockingQueue – a blocking thread safe priority queue

143. DeleayQueue – entered items only available after a delay

144. SynchronousQueue – empty queue, rendevouz, two colaborating threads

145. BlockingQueue - example final BlockingQueue<String> bq = new LinkedBlockingQueue<String>(); Thread c = new Thread(new Runnable(){ public void run() { while(true) { try { String s = bq.take(); System.out.println(&quot;Took &quot; + s); } catch(InterruptedException e){} } } }); Thread p = new Thread(new Runnable(){ int counter = 0; public void run() { while(true) { try { bq.put(&quot;b&quot; + counter++); } catch(InterruptedException e){} } } }); c.start(); p.start();

147. Use instead of manually creating Threads

148. Not necessarily asynchronous

149. One method: void Excecute(Runnable); Executor exe = Executors.newFixedThreadPool(10); exe.execute(task);

151. Provides management methods

152. May track submitted task and get result back

153. Uses Future and Callable Callable<String> worker = new Callable<String>() { int c = 0; public String call() { try {Thread.sleep(2000L);}catch(Exception ignore){} return &quot;jobb no &quot; + c++; } }; ExecutorService exe = Executors.newSingleThreadExecutor(); Future<String> result = exe.submit(worker); while(!result.isDone()) { // Do something other } String s = result.get();

155. volatile but with conditional atomicity

156. Finer granularity of locking (hardware based)

157. Non blocking

158. Built on optimistic assumptions: do it, check and redo

159. Non blocking counting AtomicLong at = new AtomicLong(); // one thread, no synchronzied long current = at.get(); // another thread increment, no sync at.incrementAndGet();

161. More flexible locks and mutex than builtin

162. Great to handle many reads, few writes ReadWriteLock locks = new ReentrantReadWriteLock(); public void read() { Lock readLock = locks.readLock(); readLock.lock(); try { // Do read, multiple threads allowed } finally { readLock.unlock(); } } public void write() { Lock writeLock = locks.writeLock(); writeLock.lock(); try { // Do write, only one thread } finally { writeLock.unlock(); } }

164. Arrays.toString([] ) and Arrays.deepToString(Object[] )

165. Collections.reverseOrder(Comparator<T>)

166. Collections.addAll(Collection<T>, T... )

168. java.lang.StringBuilder – use instead of StringBuffer when no synchronization is needed

169. long n = System.nanoTime();

170. System.getEnv()

171. Thread.getStackTrace()

172. Thread.State s = t.getState ()

173. ThreadLocal.remove()

174. java.lang.instrument

176. The JVM is managable with jmx both locally and remote

177. When managability is turned on one may use the builtin MbeanServer

178. Managability is turned on with system properties

180. jconsole

181. Getting the mbean server and managing an object public static interface My { public String getMyName(); } public static class MyImpl implements My { String n; MyImpl(String s) { n = s; } public String getMyName(){return n;} } ArrayList servers = MBeanServerFactory.findMBeanServer(null); if (servers.size() > 0) { server = (MBeanServer)servers.get(0); StandardMBean b = new StandardMBean(new MyImpl(&quot;Peter&quot;), My.class); server.registerMBean(b, new ObjectName(&quot;test:name=Peter&quot;)); }

182. Manage the bean with jconsole

184. More detailed configuration

188. No dependencies on infrastructure

189. No infrastructure in code

190. Testability

192. Martin Fowler 2000

193. Concentrate on logic

194. No plumbing code

195. No framework dependencies

196. No special runtime requirements

197. Makes it easier to test

200. looking up a properties file

201. Really hard when testing

203. Classes implements frameworks hooks and marker interfaces

204. Container make external resources available through these hooks

205. EJB: setSessionContext(SessionContext ctx)

206. Also hard to test: requires deployment in runtime environment public void service(ServiceManager sm) { ds = (DataSource)sm.lookup(“myDataSource”); }

208. Must known container: Spring

209. A class declares setter for any external dependencies

210. These dependencies are handled by container

211. After object is created the dependencies are injected by invoking the correct set-methods

212. Much easier to test

213. Hard to know when an object is really “ready”, one often needs one or more life cycle callbacks! public void setDataSource(DataSource ds)

215. Same as type 2, but objects always get their full dependencies at creation

216. No life cycle methods needed

217. Many dependencies lead to cluttered constructors

218. Optional dependencies harder to handle

219. Property type configuration not as straight forward

221. Dependency Injection

222. Martin Fowler 2004

223. From JDK 1.5 dependency injection primarily seems to be done with annotations

225. thread/context injections

226. Dependency Injection - annotation @DataSource DataSource ds; MyClass(@DataSource ds) { @DataSource public void setDataSource(DataSource ds)

228. Based on the decorator pattern

229. Intercept call to a POJO and add framework logic

230. JBoss revolutionized the interceptor pattern in its EJB container

231. The servlet spec popularized it through the introduction of servlet filter

232. Plumbing logic is moved out from the POJO

233. Foundation laid with introduction of Proxy in JDK 1.3

234. Only possible on method level by default

235. Simple logging interceptor Object target; LoggingInterceptor(Object target) { this.target = target; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { log(&quot;TRACE&quot;, &quot;Calling &quot; + method.getName()); return method.invoke(target, args); } My m = (My)Proxy.newProxyInstance(Thread.currentThread(). getContextClassLoader(), new Class[]{My.class}, new LoggingInterceptor(new MyImpl())); String s = m.hello();

240. First part static class ThreadLocalInterceptor<T> implements InvocationHandler { Object target; Class targetClass; ThreadLocal<T> local; ThreadLocalInterceptor(Object target, ThreadLocal<T> local) { this.target = target; this.local = local; targetClass = target.getClass(); }

241. ThreadLocalInterceptor – part 2 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // Need to use real target class! Method targetMethod = targetClass. getDeclaredMethod(method.getName(), method.getParameterTypes()); InjectThreadLocal a = targetMethod. getAnnotation(InjectThreadLocal.class); if (a != null) { Field f = targetClass.getField(a.name()); if (f != null) { Object tl = local.get(); if (f.getType().isAssignableFrom(tl.getClass())) { f.set(target, tl); } } } return method.invoke(target, args); }

245. Interceptors taken to a new layer

246. Cross Cutting Concerns

247. Not just method inteceptions

248. join point – where to join in

249. point cuts – pointer to join points

250. advice – aspect to join in

251. Much more...

252. mogul .slut på presentation Kontakt: [email_address]