Lecture 15 from the IAG0040 Java course in TTÜ. See the accompanying source code written during the lectures: https://github.com/angryziber/java-course Gives an overview of more advanced Java topics.

1. Java course - IAG0040
Advanced stuff:
Ant, Scripting,
Spring, Hibernate
Anton Keks 2011

2. Ant
●
Ant == Another Neat Tool, http://ant.apache.org/
●
In short, it is a cross-platform make for Java
●
Is the de-facto standard build tool for Java projects
● You just have to write an XML file, describing the
build process
– usually named build.xml
– Java IDEs provides auto-completion, running, and
sometimes debugging of Ant build files
●
It is also very good for automating of complex tasks
Java course – IAG0040 Lecture 15
Anton Keks Slide 2

3. Hello, Ant!
● <?xml version="1.0"?>
<project name="HelloAnt" default="sayHello"
basedir=".">
<property name="text.hello"
value="Hello, Ant!"/>
<target name="sayHello">
<echo>${text.hello}</echo>
</target>
<target name=”compile” depends=”sayHello”>
<javac srcdir=”src” destdir=”bin”/>
</target>
</project>
Java course – IAG0040 Lecture 15
Anton Keks Slide 3

4. Ant essentials
● The root tag is <project> that defines the name of the project
● <property> defines global properties for usage within the file
– name and value are mandatory attributes
– properties are further referenced as ${name}
● <target> specifies runnable build targets (sequences of
actions) that can depend on each other
– name specifies target's name
– if and unless can check whether certain property is set
– depends – comma-separated list of other targets
– description can be used for documenting
Java course – IAG0040 Lecture 15
Anton Keks Slide 4

5. Ant essentials (cont)
● Within targets, Ant tasks can be used
– There are many predefined tasks, e.g. echo
– You can define tasks yourself or run other targets with
<antcall>
– You can use 3rd-party tasks from jar files
● Many tasks use FileSets
– they are filters using patterns to select specific files
– ? matches a character, * matches zero or more characters, **
matches zero or more directories (processed recursively)
– <fileset dir=”${basedir}” includes=”**/*.java”/>
● <include> and <exclude> can be specified within
Java course – IAG0040 Lecture 15
Anton Keks Slide 5

6. Most common Ant tasks
● Filesystem tasks:
– copy, delete, get, mkdir, move, rename, touch, chmod
● Remote tasks:
– ftp, scp, sshexec, telnet, setproxy, mail, cvs, cvschangelog
● Compilation and Deployment:
– javac, javadoc, rmic, depend, jar, tar, zip, war, gzip
● Testing
– junit, junitreport
● Miscellaneous
– echo, exec, fail, sleep, buildnumber, condition
● More info at http://ant.apache.org/manual/tasksoverview.html
●
Tons of 3rd party tasks available
Java course – IAG0040 Lecture 15
Anton Keks Slide 6

7. Java Scripting
●
Java 1.6 introduced embedded scripting
– allows running of scripts inside of the JVM
●
scripts can be written in many languages, e.g.
JavaScript, Ruby, Groovy, Python, etc
● each language needs its engine to be available
●
JavaScript is available by default (Mozilla Rhino)
– Scripts and Java classes can interoperate
● Reasons
– Java is a platform, not only a language
– interoperability, faster development of non-critical code,
specific domain usage, etc
Java course – IAG0040 Lecture 15
Anton Keks Slide 7

8. Java Scripting API
●
Java Scripting API is in javax.script package
●
ScriptEngine – interface for implementing of different
scripting languages
●
ScriptEngineFactory – interface for implementing
ScriptEngine factories, provides detailed information about
the language
●
ScriptEngineManager – class for registering and obtaining of
ScriptEngines
● ScriptEngineManager mgr = new ScriptEngineManager();
ScriptEngine jsEngine =
mgr.getEngineByName("JavaScript");
jsEngine.eval("print('Hello, world!')");
Java course – IAG0040 Lecture 15
Anton Keks Slide 8

9. Evaluation / Invocation
● ScriptEngine's eval() method accepts both String and Reader
– so the script can come from virtually any source
– ScriptEngine engine = mgr.getEngineByExtension("js");
engine.eval(new InputStreamReader(
this.getClass().getResourceAsStream(“runme.js”)));
● Engines implementing Invocable can invoke individual
functions or methods
– engine.eval( "function sayHello() {" +
" println('Hello, world!');" +
"}");
((Invocable)engine).invokeFunction("sayHello");
● Engines implementing Compilable can precompile scripts
– ((Compilable)engine).compile("print('Hello')").eval();
Java course – IAG0040 Lecture 15
Anton Keks Slide 9

10. Java Binding
● Java classes are available to scripts and can be used
using the language's syntax, e.g. JavaScript:
– importPackage(java.util)
var javaDate = new Date()
var dateString = javaDate.toString()
●
ScriptEngine provides put() and get() methods for
storing/retrieving bound variables
– engine.put(“javaDate”, new Date());
engine.eval(“print(javaDate.toString())”);
● Objects can be returned from scripts to Java using the
return from eval() or invokeXXX() methods as Objects
– Rhino maps numbers to Double, strings to String
Java course – IAG0040 Lecture 15
Anton Keks Slide 10

11. Spring Framework
● http://www.springframework.org/
● The leading full-stack Java/J2EE application framework
●
Spring delivers significant benefits for many projects, reducing
development effort and costs while improving test coverage
and quality
● Was created as an alternative/companion to J2EE
– J2EE should be easier to use
– Reduces the complexity cost of using interfaces to zero
– JavaBeans offer a great way of configuring applications
– OO design is more important than any implementation technology
– Checked exceptions are overused in Java
– Testability is essential
Java course – IAG0040 Lecture 15
Anton Keks Slide 11

12. Spring Features
●
Advertised features:
– The most complete lightweight container
– A common abstraction layer for transaction management
– A JDBC abstraction layer
– Integration with Hibernate, Toplink, JDO, and iBATIS
– AOP functionality
– A flexible MVC web application framework
●
Most of these can be used in both Java SE and Java EE
●
Spring allows for reusable business and data access objects
that are not tied to specific services (POJO-based approach)
Java course – IAG0040 Lecture 15
Anton Keks Slide 12

13. Spring Overview
Java course – IAG0040 Lecture 15
Anton Keks Slide 13

14. AOP
●
Aspect-Oriented Programming
– a new approach to programming since OOP
● Solves the problem of cross-cutting concerns in the
code, e.g. logging or database transactions spread in
different places
– Usually there is functionality that is spread in many places
– AOP allows to write this code as an aspect
– Aspects alter the behavior of base-code by applying advice
(additional behavior) over a quantification of join points
– Join points are points in the structure or execution of a
program; they are specified using pointcuts (descriptions
of sets of join points)
Java course – IAG0040 Lecture 15
Anton Keks Slide 14

15. Dependency Injection / IoC
●
Dependency Injection == Inversion of Control (IoC)
– is a design pattern upon which Spring's core is based
●
Is a way to achieve loose coupling
– it allows for complete separation of interfaces and
implementations
– concrete implementations of classes are injected on
demand as configured
– responsibility of object creation is removed from objects
● Spring defines BeanFactory for that purpose
● The container (BeanFactory) injects dependencies
into beans hence the term IoC
Java course – IAG0040 Lecture 15
Anton Keks Slide 15

16. BeanFactories
● BeanFactory actually instantiates, configures, and manages state of
beans
●
There are several default implementations
– XmlBeanFactory – bean definitions are in XML files
– DefaultListableBeanFactory – bean definitions specified
programmatically
●
XmlBeanFactory loads XML bean definition file from a specified
Resource, i.e. FileSystemResource, ClassPathResource, UrlResource,
etc
●
ApplicationContext is an extension to BeanFactory, providing
additional more complex features
● The following basic methods are provided: getBean, getType,
isSingleton, containsBean
Java course – IAG0040 Lecture 15
Anton Keks Slide 16

17. Bean definition XML
● Bean definition file:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans">
<bean id="..." class="...">...</bean>
<bean id="..." class="...">...</bean>
...
</beans>
● Many beans can be defined and configured this way
● Beans define class names, properties, constructor arguments, collaborator
beans (dependencies), etc
● Beans can be singletons (scope=”singleton”, default) or prototypes
● Autowiring means injection of dependencies automatically either byName or
byType (autowire attribute, default is none)
● A bean can have FactoryBean specified that creates bean instances
Java course – IAG0040 Lecture 15
Anton Keks Slide 17

18. ORM
●
Object-Relational Mapping
– links relational databases to object-oriented language concepts,
creating a “virtual object database”
● The goal is to be able to store and retrieve Java objects or
their hierarchies using the database
● The most basic scenario:
– Java class corresponds to a DB table
– Class fields correspond to columns in the table
– Java object (instance) corresponds to a row in the table
●
Basic usage (storing and retrieving):
– orm.save(myObject);
– myObject = orm.load(MyObject.class, objectId);
Java course – IAG0040 Lecture 15
Anton Keks Slide 18

19. Hibernate
●
http://www.hibernate.org/
●
Is the de-facto standard open-source ORM
(Object-Relational Mapping) tool
– Lets you develop persistent classes following OO
idiom, including association, inheritance,
polymorphism, composition, and collections
– Provides its own portable object-oriented HQL
language in addition to native SQL as well as Criteria
and Example APIs
●
Can be used for persisting of POJOs to database
Java course – IAG0040 Lecture 15
Anton Keks Slide 19

20. Hibernate Mapping
●
Mappings are usually expressed as XML files
● Mapping of class Dog to table DOGS using mapping file Dog.hbm.xml:
● <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="net.azib.Dog" table="DOGS">
<id name="id" column="uid" type="long">
<generator class="increment"/>
</id>
<property name="name"/>
<property name="dateOfBirth" type="date"/>
<property name="weight" column="mass"/>
</class>
</hibernate-mapping>
Java course – IAG0040 Lecture 15
Anton Keks Slide 20

21. Hibernate Sessions
●
Session is a conversation between the application and the
persistent store (short-lived, single-threaded)
– wraps and hides the real JDBC connection
– is used for storing/retrieving of persistent objects
●
SessionFactory is used for creation of Sessions. It caches
compiled mappings (long-lived, thread-safe)
●
Persistent objects are POJOs, they can be attached to a Session
– Upon retrieval, objects are automatically attached to the
session
– Attached objects are automatically checked for changes and
stored if needed
● Session provides methods like: get, load, save, update, find, etc
Java course – IAG0040 Lecture 15
Anton Keks Slide 21

22. Hibernate basic overview
Java course – IAG0040 Lecture 15
Anton Keks Slide 22

23. Hibernate complex example
Java course – IAG0040 Lecture 15
Anton Keks Slide 23