JAOO / Goto Conference 2010: NoSQL - an Overview (Emil Eifrem)
This talk gave a general introduction to NoSQL. Emil is CEO of Neo Technology, the company behind the Neo4j NoSQL database.
Emil started by talking about the name "NoSQL":
- He is unhappy about it - like almost everyone else
- It it not "No to SQL"
- It is also not "Never SQL"
- It is rather "Not only SQL"
He gave four reasons why NoSQL is import
- The exponential growth in data. I did some research and actually IDC says that 2009 the amount of data grew 62% to 800 billion gigabytes (0.8 Zettabytes). 2010 we will create 1.2 Zettabyte. This is clearly exponential growth - something we should be afraid of.
- We are seeing more and more connected data. While we used to have tex documents it is now about hypertext, blog, user generated content etc.
- Also the data is more and more semi structured. User generated content is a good example again. And also we are looking for information rather by using full text search and not detailed queries.
- The architecture changes from integration with a common database to individual systems with their own private database each. This enables specific databases for specific challengers.
It is unlikely that relational stores will solve these problems. Also it means that NoSQL won't replace relational stores. They solve different problems and there is more than enough data for all kinds of databases.
Emil then discusses the four types of NoSQL:
- Key-value stores are basically globally available Maps. Examples are Project Voldemort or Tokyo Cabinet/Tyrant. Their strength are the simple data model and they are great at scaling out horizontally. However, their weakness is the simplistic data model and they are a poor fit for complex data.
ColumnFamily / BigTable stores are a big table with column families i.e. you can have a lot of columns and structure them. Examples are HBase, HyperTable or Apache Cassandra.
Document databases store collections of documents with a document being a key-value collection. Documents might be represented as JSON etc. Examples are CouchDB or MongoDB.
- Graph databases use nodes with properties and typed relationships with properties. Examples include Sones GraphDB, InfiniteGraph and Neo4j.
Challenges for NoSQL in his opinion are:
Mindshare and product usability
Tool support for development and operations
Middleware support in frameworks etc.
Very interesting was the demo that he did with Michael Hunger. It showed a prototype of an integration of Neo4j into Spring Roo. It showed how parts of the entity object could be stored in Neo4j and other parts in a relational store with JPA. This will probably become more and more common place: Certain parts of a customer are a good fit for a relational database while the relations to other customers or items might be a good fit for a graph database. This model allows to combine both approaches and use the better solutions for the problem at hand.
Labels: Emil Eifrem, Goto Conference, JAOO2010, NoSQL
JAOO / Goto Conference 2010: Spring Framework 3.0 On The Way To 3.1 (Jürgen Höller)
In this talk Jürgen showed the current step in the evolution of Spring i.e. the step from version 3.0 to 3.1. As most of the readers will be familiar with 3.0 I will not go into much detail concerning the first part of the talk.
Version 3.0.5 will be the last version for the 3.0 family. The first milestone for Spring 3.1 is scheduled for November - so it won't be long until you get something to play with.
Environment Specific Beans
One important feature will be environment specific beans. Applications usually run on several different environments. There is at least the Java SE environment you use for JUnit tests. You might do staging on a Tomcat server and production on a Java EE server. Beans that manage access to other system might be replaced by mocks for some of them. The goal of the environment specific beans is to deal with these differences in infrastructure while the deployment units are not changed. Usually operations insists that deployment units must not be changed between tests and production.
There are already ways to deal with this challenge. However, if this is supported as a first class part of the configuration it will be much easier and elegant to use. There are still discussions how this feature will be implemented so the details of this feature are not set
in stone.
The Spring Beans will be grouped by environment. The environment itself will be determined by an API that you can extend yourself for maximum flexibility. Placeholders will be resolved depending on the environment.
A possible syntax could be:
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<property name="driverClass" value="${database.driver}"/>
<property name="jdbcUrl" value="${database.url}"/>
<property name="username" value="${database.username}"/>
<property name="password" value="${database.password}"/>
</bean>
<beans profile="embedded">
<jdbc:embedded-database id="dataSource" type="H2">
<jdbc:script location="/WEB-INF/database/schema-member.sql"/>
<jdbc:script location="/WEB-INF/database/schema-activity.sql"/>
<jdbc:script location="/WEB-INF/database/schema-event.sql"/>
<jdbc:script location="/WEB-INF/database/data.sql"/>
</jdbc:embedded-database>
</beans>
As you can see the beans element is reused to also cover different environments. As mentioned above the actual implementation might be different - and of course the engineers are happy if you have any feedback!
Improvements for the Java Application Configuration
Java Application Configuration with
@Configuration was already introduced in Spring 3.0. In the upcoming release it will be improved to also cover a functionality that resembles the XML namespaces. These namespace are used throughout the framework to configure features like transactions or aop. As the following code sample shows one possible implementation uses a fluent API - in this case to create something that resembles
<tx:annotation-driven
/>.
@Configuration
public void AppConfig {
@Autowired
private DataSource dataSource;
@Bean
public RewardsService rewardsService() {
return new RewardsServiceImpl(dataSource);
}
@Bean
public PlatformTransactionManager txManager() {
return new DataSourceTransactionManager(dataSource);
}
public TransactionConfiguration txConfig() {
return annotationDrivenTx().withTransactionManager(txManager());
}
}
Cache Abstraction
The Spring modules project offered some integration for caching and there is also a very basic cache abstraction. In Spring 3.1 there will be support for EhCache, GemFire, Coherence, etc. Several will be shipped with Spring core but it will also be possible to plug in custom adapters if necessary. The caching itself can then be configured using annotations for example:
@Cacheable
public Owner loadOwner(int id);
@Cacheable(condition="name.length < 10")
public Owner loadOwner(String name);
@CacheInvalidate
public void deleteOwner(int id);
As you can see methods can be marked as cacheable. This can be fine tuned using SpEL (Spring Expression Language). Other methods can be marked as invalidating the cache.
Conversation Management
This feature will allow a user to handle multiple orders in a web application simultaneously - for example in several browser windows or tabs. The state of these must be isolated from one another. The HttpSession is not an option for this because windows share the same
HttpSession.
Spring will manage the window id e.g. by using MVC session form attributes. This is a much simpler problem than the flow support in Spring Web Flow that allows for a simpler solution.
Keeping Up
Spring 3.1 will also support Servlet 3.0 on servers like Tomcat 7 or GlassFish 3. This will include the automatic registration of framework listeners which will make it even easier to use Spring in these settings. Also the support for JSF 2.0 will be improved e.g. for conversations.
Sum Up
Spring 3.1 optimizes Spring in several ways. As the version number indicated polishing and improvements are the main subjects. In particular the cache abstraction is interesting as nowadays a lot of applications need this kind of feature to build scalable solutions.
Labels: Goto Conference, JAOO2010, Jürgen Höller
