Ruslan's blog

Android Emulator Snapshot

2011-11-24T21:02:00.001+02:00

Here I'm going to describe a simple way to decrease a start up time of the Android Emulator. This is possible after snapshot saving and loading option is enabled.

Open your terminal and enter the command:


 $ android

Open Android Virtual Device Manager from menu Tools -> Manage AVDs... You'll see a window like this:

Select your working AVD from the list and click on "Edit" button. In the opened dialog check on to enable Snapshot. Save changes. Then click on the "Start..." button and check "Launch from snapshot" and "Save to snapshot" options.

If you haven't enabled "Saving to snapshot" option before, it may take a time to start the emulator first time. After it is started, you can close it and start again. This time emulator will be started much faster.

MOBI version of The Architecture of Open Source Applications book

2011-11-22T20:29:00.001+02:00

The Architecture of Open Source Applications is a great book where one can find the description of the architecture of the 25 open source applications, like Eclipse, LLVM, Mercurial, HDFS and Berkley DB. This book is free to read in the HTML format online, but if you want to get a PDF or Kindle version, you'll need to buy it either at Lulu.com or at Amazon.com.

Of course the recommended way is to buy the book, as all royalties from these sales will be donated to Amnesty International. But you can download a MOBI version for Kindle of this book for free, just continue reading.

First, want to tell a short story. After I found a free SICP version for Kindle compiled from HTML files at github.com/twcamper/sicp-kindle, I was looking for a chance to create something like that myself. And then I found the AOSA book. It has an HTML version, and I wanted to have a MOBI version to read it in my Kindle.

And so I made a Kindle version of The Architecture of Open Source Applications book and currently it's available from github.com/rkhmelyuk/aosa-mobi.

Download a Kindle version of the AOSA

SyncTab

2011-11-17T21:12:00.001+02:00

I've released today an updated version of a SyncTab Android application.

Well, a few words about what is a SyncTab. SyncTab is an application to send an interesting links and browser tabs from Android phone to desktop browser (current only Chrome is supported). To start using SyncTab, user need only to download and install Android application and Chrome extension. User will need to register an account using either Android application or Chrome extension and then he/she can easily send tabs from phone to desktop. There is more information about this in the Getting Started article.

So what's new in the version 0.6? Not much:

added an about page to show current user name, website link, link to submit issue or contact
get the correct page title and description with regards to the page charset

But I have more plans for version 0.7:

share tabs from browser to the phone
tag and filter shared tabs

So try SyncTab now, and wait for a new features.

Mobile website with jQuery Mobile

2011-11-03T00:31:00.000+02:00

In my previous post I've described how to add support of mobile version of website using django. In this post I'm going to stop on front-end side of mobile website.

From the beginning, I wanted to create a simple mobile version from scratch and use a similar to original website look. But, after some investigation, I've changed my plans. I decided to use some framework to create a mobile website. So I found two popular such frameworks: Sencha Touch and jQuery Mobile. Whilst Sencha Touch looks awesome and production ready, while jQuery Mobile is still in release candidate stage, I stopped on the second one. This choice was very simple for me: jQuery products usually are qualitative, there is a strong community behind them and they introduce new versions very quick. Nevertheless Sencha Touch is a good product too.

I'm not going to describe how I used jQuery Mobile step by step, but only list of some facts and tips. First of all, I was using jQuery Mobile version 1.0 RC2, and that means, it wasn't a production-ready version yet. Even so, I found a few bugs or maybe just a things that need an improvement.

I just love such structures as lists. So will list a fact using a list =).

You should read a manual first and follow a standard layout mechanism, like declare header, content and footer sections. This will save you a lot of time.

<div data-role="page">
           <div data-role="header">
               <a href="{% url m_home %}" data-icon="home" class="ui-btn-left">Home</a>
               <a href="{% url m_help %}" data-icon="help" class="ui-btn-right">Help</a>
              {% block header %} <h1>[App Name]</h1>{% endblock %}
           </div>

           <div data-role="content">
            {% block content %}{% endblock %}
           </div>

           <div id="footer" data-role="footer">  Copyright © 2011 ... </div>
       </div>

It's a good practice to add Home/Back and Help buttons to the header or footer panel. The navigation bar can be also added to the header, where it looks very natural:

<div data-role="header">
   <a href="{% url m_home %}" data-icon="home" class="ui-btn-left">Home</a>
   <a href="{% url m_help %}" data-icon="help" class="ui-btn-right">Help</a>
   {% block header %}<h1>[AppName]</h1>{% endblock %}

   <div data-role="navbar">
      <ul>
         <li><a href="{% url m_download %}">Download</a></li>
         <li><a href="{% url m_contact %}">Contact</a></li>
         ...
      </ul>
   </div>
</div>

Fixed position of header and footer isn't working as it's expected. Well, expected it to be fixed always, while content is scrolling. But currently it just disappears when user starts scrolling and shows back after a second or so scrolling is ended.
Hash anchor links (#something) aren't working yet.
Can't show an image as a page, instead shows an "undefined" text. If you have a links that reference images, you must specify rel="external" for them.
Use header to specify page title, rather than do it in the h1 element in the content section.
Use collapsible blocks for long pages. For instance, I've found them very helpful to organize a help page with many different topics.

You may also want to embrace collapsible blocks using collapsible set.
For large image, don't show original version of it on page, but prefer thumbnail image as a link to the original version of image.
Use list view where possible. For instance, a main help page contains a list of articles which are references to the appropriate pages.
Buttons should be with icons where possible. You can easily add icon to the button with the data-icon="[icon]" attribute. The list of available icons is on jQuery Mobile website.
Make website as simple as possible: structure should be simple, navigation bar should contain only the most used links. Remember, that it's still hard to work fully with websites on mobiles.

Well, that's all as for now. Hope that would be helpful.

Mobile website with Django

2011-11-03T00:29:00.002+02:00

Although I'm not a web guy, but more specialized on backend logic, I had a very interesting experience today creating a website version for mobiles. I had a simple website with a few pages, minimum server side logic and a slice of documentation there. This website perfectly works for desktop and tablet browsers, but is not that good for mobiles. I use to call this website as "normal" version throughout this post. It's important to have a working mobile version of website, as website is about Android application.

A little bit about technologies and task. Website is running on Django as well as mobile version should be too. Mobile version of website should be much simpler than normal version, not so beautiful, but must do own job well: allow users to know about the product, download and access to the documentation.

I decided to use the same django application for both normal and mobile website versions. I found a few different ways to add mobile website, for example: redirect to another django application, replace TEMPLATE_DIRS setting with a version that points to mobile templates if user is using mobile browser or just check and use different logic/templates in every view method. As I wanted to have a different structure for mobile website, I decided to go by my own way.

Mobile website path should be prefixed with /m/ rather than be the same or use a different domain name. So, if normal website download page is http://example.com/download/, then mobile download page should be http://example.com/m/download/. Django should check every user request whether it's from mobile browser or not using a User-Agent metadata, and if so, redirect to the mobile version of the page. In other words, if user opens a /download/ page from mobile browser, then she will be redirected to the /m/download/ page. But if she opens a /m/download page, then no redirects happen - just a mobile version of page is returned to user.

I've created different templates and views for mobile version of website. Normal version of website has references only to the normal pages and mobile version of website has references only to the mobile pages. This was done to avoid not necessary redirects that could slow down a work with website. Thus, I had a different version of URL patterns for website in project's urls.py:

urlpatterns = patterns('website.views',
    url(r'^$', 'home', name='home'),
    url(r'^download/$', 'download', name='download'),
    url(r'^screenshots/$', 'screenshots', name='screenshots'),
    url(r'^contact/$', 'contact', name='contact'),
    ... 
)

urlpatterns += patterns('website.mobile',
    url(r'^m/$', 'home', name='m_home'),
    url(r'^m/download/$', 'download', name='m_download'),
    url(r'^m/screenshots/$', 'screenshots', name='m_screenshots'),
    url(r'^m/contact/$', 'contact', name='m_contact'),
    ...
)

As you see, website.views are responsible for handling normal website pages, while website.mobile for handling mobile website pages.

Now need to redirect mobile browser users to the mobile version of website. For this purpose, I wrote a custom middleware called MobileWebsiteMiddleware. The task of this middleware is to check if user is from a popular mobile platform and needs to be redirected to the mobile version of website. The other responsibility is to redirect users from mobile to the normal version of website in case if request isn't from mobile browser. This is an extract option, that should be disabled while testing.

class MobileWebsiteMiddleware(object):

    MOBILE_PREFIX = '/m/'
    MOBI_REG = re.compile(
        '(iphone|windows ce|mobile|phone|symbian|mini|pda|ipod|mobi|blackberry|playbook|vodafone|kindle)',
        re.IGNORECASE)

    def process_request(self, request):

        if 'HTTP_USER_AGENT' in request.META:
            userAgent = request.META.get('HTTP_USER_AGENT')
            matches = self.MOBI_REG.search(userAgent)
            path = request.path_info

            if matches:
                # from mobile browser, check if need to redirect to mobile
                if not path.startswith(self.MOBILE_PREFIX):
                    # need to redirect to mobile version
                    return HttpResponseRedirect('/m' + path)
            elif path.startswith(self.MOBILE_PREFIX):
                    # need to redirect to normal version
                    return HttpResponseRedirect(path[2:])

        return None

If you'll check the list list of user agent patterns in MOBI_REG you wouldn't find neither iPad nor Android. I want to show a "normal" website for tablets. "Android" keyword is used in User Agent for both mobiles and tablets. While Mobile Android browsers pass a User Agent with a "mobile" keyword, but Tablet Android browsers don't do that. Thus, I will have a normal version for desktop and tablets browsers, but mobile version for mobiles and Kindle.

Now I have a simple website, that has two different version: one for desktop and tablet browsers and another for mobile browsers. User will be automatically redirected to the right version of website which depends on used device.

In my next post I'm going to tell more about using jQuery Mobile to build a mobile version of website.

Django: use global variables on rendering templates

2011-10-31T21:55:00.000+02:00

Problem

Some settings or global value is used in every template or, for example, in base layout template. This value should be passed as context variable to each template. I call such value a global context variable in this post.

For instance, it can be a Google Analytics Code, which should be used in production, but not in staging or development environments. In this case, it’s fine to move GA code to the settings file (of course, if different settings used for different environments). Though need to find a way to get the value from the settings and pass it to the template context before rendering.

Solutions

There are a few simple solutions that solve the described problem:

Add global variable to the template context in every view. But according to DRY and good sense this is a bad solution.
Write a tag to fetch setting value by name and output it. Nice solution and flexible enough in case we need to show different settings in different pages. The only disadvantage is fetching setting value each time it’s accessed. But in most cases this is a minor.
Write a context processor. In the documentation said that context processor is a method that takes a request object as argument and returns a dictionary of items to be merged into the context. In other words, context processor returns a dictionary of items that will be available in template on render phase. In our case, we can get setting value and return from our own context processor method.
```
from django.conf import settings

def global_vars(request):
    return {'GA_CODE': settings.GA_CODE}
```
Also, need to declare our context processor in settings.TEMPLATE_CONTEXT_PROCESSORS:
```
TEMPLATE_CONTEXT_PROCESSORS = (
   . . . 
   'synctab.website.context_processors.global_vars',
)
```
From now, GA_CODE context variable can be used in any template, and will be processed correctly.

In my opinion, the best decision for fixed list of globally accessed template context variables is a custom context provider. It's also a right way, if most or all templates use same global variables. Otherwise, it's good to write a few tags to cover access to the global state, like settings.

tmpfs: work with your data even faster

2011-10-14T12:04:00.001+03:00

Currently improving IDEA performance by copying cache files into the RAM using tmpfs. Actually, tmpfs and ramfs are good ideas.

As described in Wikipedia: tmpfs is intended to appear as a mounted file system, but stored in volatile memory instead of a persistent storage device. Simply put, when you copy a file to such FS, this means that you copy a file to the RAM. When you create a file in this FS, this means you create a file in RAM. When you delete a file in this FS, this means you delete a file in a RAM. And so on.

The negative side of tmpfs is that it's not backed by any storage: on restart or system crash you'll lost your files and data stored in tmpfs. But on system start you can either copy files from the disk to the memory again and continue to work.

In case of IDEA cache, I will need to write a simple script that periodically copies the cache from tmpfs to the disk. So, on restart, I can simply restore cache, and don't need to wait while re-caching is done.

So, how to create a tmpfs storage? It's pretty easy to do with next commands. Here I create an empty directory tmp and mount it as tmpfs filesystem.

# mkdir ~/tmp
# mount -t tmpfs -o size=500m tmpfs ~/tmp

Option size=500m limits memory usage to 500m. tmpfs also supports flushing content to the swap when need. This is one of the main differences between tmpfs and ramfs. ramfs is not limited and can grow dynamically, and the used memory can't be freed or flush to swap. The negative side of such dynamic nature of ramfs is that system can hung when no free memory left.

To read from and write content to RAM is much much faster than to do the same operations with a file on disk. It's pretty good optimization if you need to support read-only content or content that can easily be restored when need.

Such type of content is a hosted website. You can decrease page or resource loading time by moving them from hard disk to the memory filesystem.

 # mkdir /var/www/www.example.com
 # mount -t tmpfs -o size=50M tmpfs /var/www/www.example.com
 # cp -R /home/www/www.example.com/* /var/www/www.example/com

To mount tmpfs automatically on system load, you will need to add another record to yours /etc/fstab configuration file. The only you need to do now is execute next command on system start:

 # cp -R /home/www/www.example.com/* /var/www/www.example/com

As a summary, tmpfs is a good way to work with large amount of files or data that need to be accessed or processed quickly. Such data also is either read-only or can be easily recreated. Samples of such data are static websites, website resources, temporary cache etc. When need to process large amount of data, you can also split it into small pieces and process each one by one. tmpfs is also takes a limited amount of RAM, and can increase over that amount.

Performance Optimization for Android

2011-10-11T15:47:00.001+03:00

Here is the list of the performance optimization tips when developing Android applications:

Avoid creating objects if you don’t need them.
Avoid memory allocation if you can work without it.
Array of ints is preferred than array of Integers.
Two parallel arrays of ints are a lot more efficient than an array of (int,int) objects. Two parallel arrays of Foo and Bar are a lot more efficient than an array of (Foo,Bar) objects.
Avoid creating short-term temporary objects if you can.
Make your method static. Invocations will be about 15%-20% faster. It's also good practice, because you can tell from the method signature that calling the method can't alter the object's state.
It's reasonable to follow common object-oriented programming practices and have getters and setters in the public interface, but within a class you should always access fields directly.
Direct field access is about 7x faster than invoking a trivial getter.
Use static final for constants.
Prefer for-each loop.
Declare fields and methods accessed by inner classes to have package access, rather than private access.

Read Designing for Performance article from Android Dev Guide to find more details and samples.

List also available as gist.

Rename of GitHub account and Deploy Keys

2011-10-05T17:20:00.000+03:00

Today I've fixed failed builds that were caused by renaming GitHub account. Bamboo couldn't pull the changes from GitHub master repository after rename.

So, I corrected the account name in the .git/config file for origin remote. But this didn't help - I had same the same problem to pull the changes.

That was a security problem: GitHub denied access to the repository, because I don't have access to the old repository (of course, that because account name was changed).

After some investigation, I decided to drop existing Deploy Key and create the same again.
And Voilà! This small manipulation fixed the problem with access to the GitHub repository and now builds are green again.

Hightlights: How Browsers Work

2011-09-11T20:11:00.001+03:00

This is a short summary of great article How Browses Work by Tali Garsiel. My opinion that it is a must-read article not only for web developers, but for everyone who want to know how browsers work.

I’m not a web developer, but was interesting in this article to know more about how browsers work inside. This article can help to understand the process of rendering html page, loading and processing CSS and JavaScript files by browser.

Here I list of my highlights after reading How Browsers Read article:

As you can see, browser needs to build a few different trees: DOM tree, rendering tree, style rules tree, style context tree etc.

The rendering engine will start getting the contents of the requested document from the networking layer. This will usually be done in 8K chunks.

To render a page faster, browser doesn’t wait while all page and css and scripts are loaded. Instead browser loads a chunk of html code, parse it and build a DOM and rendering trees. Then rendering tree is used to paint the page, so user can see it. If we know the size of chunk, we can predict how fast is html page processed. If the html page size is under 8K (or whatever specific browser limit), we should expect it to load much faster.

For better user experience, the rendering engine will try to display contents on the screen as soon as possible. It will not wait until all HTML is parsed before starting to build and layout the render tree.

The algorithm is expressed as a state machine. Each state consumes one or more characters of the input stream and updates the next state according to those characters. The decision is influenced by the current tokenization state and by the tree construction state. This means the same consumed character will yield different results for the correct next state, depending on the current state.

Special state machine used to parse HTML document. I was interesting how they parse HTML, because it’s pretty hard to parse such forgiving language. From this article it’s clear that state machine is used to parse the document. In article described:

The input to the tree construction stage is a sequence of tokens from the tokenization stage The first mode is the"initial mode". Receiving the html token will cause a move to the "before html" mode and a reprocessing of the token in that mode. This will cause a creation of the HTMLHtmlElement element and it will be appended to the root Document object.The state will be changed to "before head". We receive the "body" token. An HTMLHeadElement will be created implicitly although we don't have a "head" token and it will be added to the tree.

Browsers use stack to order tags correctly and fix a mix of opened/closed tags. Opened tags are added to the stack, and when they are closed and corrected, they are inserted into the DOM tree. As result DOM tree is always in correct state. Different browsers handle new DOM elements differently: either provide dirty bit or fire events. While parsing document DOM elements are processed and added to the Rendering tree, that becomes a source for painting phase.

When the parsing is finished browser will mark the document as interactive and start parsing scripts that are in "deferred" mode - those who should be executed after the document is parsed. The document state will be then set to "complete" and a "load" event will be fired.

The model of the web is synchronous. Authors expect scripts to be parsed and executed immediately when the parser reaches a <script> tag. The parsing of the document halts until the script was executed. If the script is external then the resource must be first fetched from the network - this is also done synchronously, the parsing halts until the resource is fetched. This was the model for many years and is also specified in HTML 4 and 5 specifications. Authors could mark the script as "defer" and thus it will not halt the document parsing and will execute after it is parsed. HTML5 adds an option to mark the script as asynchronous so it will be parsed and executed by a different thread.

Asynchronous scripts can be loaded faster maybe even before page is rendered, because browser does not need to wait to load it. Still there is a single rendering thread, so after script is loaded, any changes to the tree will be applied and processed by main thread.

While executing scripts, another thread parses the rest of the document and finds out what other resources need to be loaded from the network and loads them. This way resources can be loaded on parallel connections and the overall speed is better. Note - the speculative parser doesn't modify the DOM tree and leaves that to the main parser, it only parses references to external resources like external scripts, style sheets and images.

This is how browser can parse the document and load resources, like CSS, scripts and images.

The style contexts contain end values. The values are computed by applying all the matching rules in the correct order and performing manipulations that transform them from logical to concrete values. For example - if the logical value is percentage of the screen it will be calculated and transformed to absolute units. The rule tree idea is really clever. It enables sharing these values between nodes to avoid computing them again. This also saves space.

As it said in article, handling style correctly was made very clever. A tree structure and other optimizations help to handle correctly styles inheritance and large number or styles properties.

In the article also said:

All the matched rules are stored in a tree. The bottom nodes in a path have higher priority. The tree contains all the paths for rule matches that were found. Storing the rules is done lazily. The tree isn't calculated at the beginning for every node, but whenever a node style needs to be computed the computed paths are added to the tree.

As result, real values (like height, margin etc) for each style are not computed till they needed.

After parsing the style sheet, the rules are added one of several hash maps, according to the selector. There are maps by id, by class name, by tag name and a general map for anything that doesn't fit into those categories. If the selector is an id, the rule will be added to the id map, if it's a class it will be added to the class map etc. This manipulation makes it much easier to match rules. There is no need to look in every declaration - we can extract the relevant rules for an element from the maps. This optimization eliminates 95+% of the rules, so that they need not even be considered during the matching process.

Hash maps are used as indexes. This is another performance optimization.

Before repainting, webkit saves the old rectangle as a bitmap. It then paints only the delta between the new and old rectangles.

Well, another performance and usability optimization.

The browsers try to do the minimal possible actions in response to a change. So changes to an elements color will cause only repaint of the element. Changes to the element position will cause layout and repaint of the element, its children and possibly siblings. Adding a DOM node will cause layout and repaint of the node. Major changes, like increasing font size of the "html" element, will cause invalidation of caches, relyout and repaint of the entire tree.

Expected optimization - the larger change the more relayout and repaint is needed.

Get Total Commits Number in Git

2011-09-11T12:57:00.002+03:00

In a few weeks there will be an anniversary as I've started working on current project. So I decided to find out the total number of made commits from the project begin. While it's obvious for Subversion, in Git you need something more that just look at the revision number.

First, I came out with a simple command that prints the total number of commits:


$ git log --pretty=format:'%h' | wc -l

prints out

This is a bit primitive and that wouldn't be such a simple solution if need to find the total number of commits per author.I didn't want to believe there is not better way to get the total number of commits per author with standard Git tool.

After a few minutes of research I found there is a simple and powerful util git shortlog.

So next command


$ git shortlog -n -s

prints out


  2317  Ruslan Khmelyuk
   104  Author_1
    53  Author_2
     9  unknown
     2  Author_3

I've summed the commit numbers for each committer and found that the total commits number by git shortlog command is 2485 and that is equal to the result of git log | wc -l command. While git rev-list -all | wc -l command prints there are 2488 commits in the repository. Strange.

Short investigation helped me to understand that both commands working fine and show correct number. The difference between commands


$ git log --pretty=format:'%h' | wc -l
$ git shortlog -n -s

and


$ git rev-list --all | wc-l

is in the source they're using to calculate commits list.

git log and git shortlog use current branch commits log, while git rev-list uses all repository as source of commits list.I had 3 more commits in the other branch, so in my local repository I had in total 2488 commits.

Even more, If you need to calculate the total number of commits in the remote repository, you will need to use git rev-list command:


$ git fetch origin
$ git rev-list --remotes | wc -l

Thus I can say, that git rev-list command works best to find out the total number of made commits.

Lazy loading on demand in CMS

2011-08-21T12:45:00.004+03:00

Context:
Application is responsible for generating pages from templates. User can edit such templates to show data from storage. Data shown on the page are defined by template, each template can show separate set of data (for instance, news, tasks, articles etc.)

Problem:
How to render a user defined template correctly, so any provided by user or application data can be included into template in runtime and have a good performance of rendering?

Solution:
Lets view the problem from MVC point:
View is a template defined by user, and can use any data entered by user (news, blog articles, tasks etc.)
Model is data that should be used by a template engine to render a View.
Controller is a place where user can prepare the Model, that will be sent to a template engine to generate specified View.

As we can’t predict what kind of data are used in any particular View (it could be news, blog articles etc.), the simplest implementation is to fetch all data from storage and push them as a Model to the template engine. In this case template engine will render a View correctly, as all required data are available from the Model. The bad side of this approach is a very slow performance as we need to fetch all data and put them as Model again and again for each request. The more data and different types of data we have to use to populate a Model, the more time this phase will take.

Another approach is to analyze template on save or before render, to fetch all types of data we may need to render it right. For example, before saving a template, we found that it contains a references to blog articles and latest news. Although, we may need to run such operation only once and populate the model only with specified type of data, there is a large number of case not covered by this method: using predefined macros, including other templates and access to data that will be need in runtime, for instance: a single article with specified id, a list of latest 5 articles or anything else that need to be fetched dynamically.

If we think more about the last case, where we need to fetch data dynamically, we will find that it's much easier and better to populate Model not with data, but with data access objects. Of course, in this case we will need to create these data access objects on each request, to pass a context to theme and use them while rendering, it’s still much better (and faster), then populate Model with all data.

When I say a data access object, I don’t mean this object should get the data directly from database or any other storage. But I mean that this object can store request context and can access a restricted set of data, e.g. the list of news posted by current user only or the list of tasks that belongs to current user.

OK, hope your engine template supports methods call and you can get the list of 5 latest news just as simple as saying ${news.latest(5)} or get current user information just with ${user.profile()}.

But here I would like to propose another way to access those less dynamical data. For instance, we need to show user profile information or list of active tasks. Of course, this can be done with appropriate DAO from Model, but there is another way.

This another way helps to save templates clean, - without calling all those DAO methods, but also without prefetching data on the Controller side. This way is based upon a famous Lazy Loading technique.

Although, this may look a bit harder to implement, it brings us a few valuable benefits. First of all, as I said before, code looks clean and easier for user to work with. It's much pleasant to write ${news.latest} than ${news.latest()} and ${user.profile.firstName} than ${user.profile().firstName}.

Second, and it's related to the lazy loading too, we load data once and only when it's needed. The emphasis in on the word 'once'. When we hit our object from the Model first time, it's loading data, which then are available since and to the end of rendering phase. So no matter, from what part of template you access it, it will use already loaded data without touching a storage again. When I say "any part of template", I mean it can be anything available in template engine: macro, function or included template. In this case, you don't need to use a variable or local cache to store loaded data, as you may need to do with data access objects.

Third, lazy loaded data can be complex structures. For instance, we load a current user profile. Profile object is a structure that contains user names, characteristics, address, contact information and a list of followings profiles. Here, address and contact information are embedded objects, which are stored in separate tables/collections and list of followings is a reference to another a few profile objects. If you need to output user full name, you just don't want to load address information, contact information and list of followings. That's where we can also use lazy loading to save user time and server powers. We load address information when need, we load the list of followings when need, we load contact information of some following only when need.

In my next article I’m going to show a simple implementation of lazy loading technique for FreeMarker template engine, which is my favourite one for many years.

Neverending Groovy: compareTo() simple as it can be with <=>

2011-08-04T12:45:00.004+03:00

Groovy introduced a new operator to compare two values: <=>.

When you use this operator for 2 values a <=> b, Groovy translates this to code something like that a.compareTo(b). Well that's not the true, as it also can handle null values correctly. So you wouldn't get NPE, when you compare value with null or vice versa. For instance, next script:


a = null
b = 12

println "a.compareTo(b) = " + (a <=> b)
println "a.compareTo(a) = " + (a <=> a)
println "b.compareTo(b) = " + (b <=> b)

outputs


  a.compareTo(b) = -1
  a.compareTo(a) = 0
  b.compareTo(b) = 0

where we can see, that null values are handled correctly, without any runtime exceptions.

With such operator we could write really nice and simple code to allow multiple comparisons for object values.

Lets we have a class Person with firstName, lastName and age data:


class Person {
    String firstName
    String lastName
    int age
}

And we need to sort a list of Persons by age, than by name (first by last name, than by first name). Assume, this is standard sorting mode, so we may prefer to implement Comparable interface:


class Person implements Comparable {
    String firstName
    String lastName
    int age

    int compareTo(Person other) {
      ...
    }
}

Method compareTo() isn't implemented yet. So lets try to implement in Java first. It would look something like this:


int compareTo(Person other) {
        if (other == null) {
            return 1;
        }

        int result = 0;
        if (this.age > other.age) {
            result = 1;
        }
        else if (this.age < other.age) {
            result = -1;
        }
        if (result == 0) {
            if (this.lastName != null && other.lastName != null) {
                result = this.lastName.compareTo(other.lastName);
                if (result == 0) {
                    if (this.firstName != null && other.firstName != null) {
                        result = this.firstName.compareTo(other.firstName);
                    }
                    else {
                        result = this.firstName != null ? 1 : -1;
                    }
                }
            }
            else {
                result = this.lastName != null ? 1 : -1;
            }
        }
        return result;
    }

Hm... Looks ugly! Too much if's, too much checks, too much 0, 1 and -1. Hard to see the logic behind the code ((.

And here how this can be written with Groovy's <=> operator:


  int compareTo(Person other) {
        age <=> other.age ?: lastName <=> other.lastName ?: firstName <=> other.firstName
    }

And a simple test:


def john = new Person(firstName: 'John', lastName: 'Doe', age: 25)
def mark = new Person(firstName: 'Mark', lastName: 'White', age: 25)

print "john <=> mark = " + (john <=> mark)

prints


  john <=> mark = -1

As for me, it looks wonderful.

"A Story of Caching"

2011-05-15T23:16:00.007+03:00

I was playing with memcached a few days ago. Never used it before, so spent some time to read documentation and FAQ.

While reading FAQ, I found the link to the page with A Story of Caching, and decided to share link to this story here.

IMHO, this is the best non-technical technical documentation, that I've read recently. In this story, they use simple but widespread use cases of developing web application and using cache in this web application.

If you don't know what's for memcached, than read this story.
If you don't know what's the primary features of memcached, than read this story.
If you don't know if you need memcached, than read this story.

Assign <#nested> to variable in FreeMarker

2011-03-22T12:02:00.005+02:00

FreeMarker is awesome template engine. I'm still wonder how much powerful it is and how flexible it can be when you need. Last week, when I was writing a simple macro to render tweets using user defined template, my though was that it may be good to define this template as macro nested content. For instance:


  <@tweets 'rkhmelyuk', 10>
      [picture] [username]: <br/>
      [message]<br/>
      <a href="[url]">[date]</a>
  </@tweets>

Pretty simple, but the only way for me was to load tweets using Twitter API through JSONP protocol. So my macro was need to generate a javascript code, that should correctly define callback and fetch tweets. Callback function simply applies received JSON data to the user defined template.

And here is the problem. How to get macro's nested content into javascript variable? Well, who ever used FreeMarker knows that nested content can be rendered with command <#nested/>. This could be a solution, but isn't. Why? Because I need to do extra preparing of template to put it as a javascript string. I need to remove newlines and replace quotes. So the best decision is to put nested content as Freemarker variable and do preparation over it first and than insert into javascript. And here is the power of Freemarker. This was possible and easy to do with <#assign/> or <#local/> command:


 <#local layout><#nested/></#local>
 <#-- Now layout variable contains a template defined as nested -->
 <script type="text/javascript">
    function callback_${id}(data) {
       var layout = "${layout?SomePreparationsGoHere}";
       renderTweets(layout, data);
    }
 </script>

In this code, the nested content is assigned to variable layout. Then we generates a javascript code and insert layout variable as string, but first do some preparations.

I also like flexibility of Freemarker. I hope that could find a time and describe some other tips about it soon.

Facebook was failing to parse OG meta tags

2011-03-22T12:01:00.014+02:00

Last week was having awful time fighting with strange work of Facebook. We had a page with OG meta tags and a Facebook Like button on the page. And Facebook was discarding to parse the page and extract data from OG meta tags. Using URL linter didn't help to find the problem but show the same information - page isn't parsed, OG meta tags are not used.

So I tried to check next things to find the issue:

whether property attribute in used <meta/> tags

whether correct fb:app_id meta tag value is set

whether nginx returns correct page when facebook requests the page

whether correct namespaces added to the <html/> tag

whether we are using UTF-8 encoding

and something other, don't remember all my tests

And was checking web page through URL Linter each time. With no success. Facebook discarded parsing the page and fetching page title with other data from meta tags.

So I reviewed response/request data through firebug to find suspicious things. I found one scanty detail: Content-Type header had value "text/html;charset=utf-8;charset=UTF-8".
I must say, this one web page is generated by application using user-defined template. Grails controller is responsible for handling request and renders output like:


  render text: context.out, contentType: "text/html;charset=$AppConstant.RENDER_CHARSET"

where AppConstant.RENDER_CHARSET equals to "UTF-8". But the rendered page had Content-Type equal to "text/html;charset=utf-8;charset=UTF-8". And my thought was to fix header value to have something like "text/thml;charset=UTF-8" and hoped this may help. So I changed code to be like:


  render text: context.out, contentType: "text/html"

Content-Type header value now is "text/html;charset=utf-8". So I tried URL Lint again. I wasn't expecting much from Facebook this time either, but miracle happened! Everything works fine now. I know, that is my fault, but, nevertheless, thank you Facebook for "nice" time spending :).

Linux tools to generate password

2011-02-13T16:09:00.011+02:00

Few days ago was looking for simple tool to generate passwords in linux console.
As result of my searching are 3 useful tools. They are:

makepasswd

pwgen

apg

Install: sudo apt-get install apg

Asks to enter random data, that should be used to generate new password.
Example:


Please enter some random data (only first 16 are significant)
(eg. your old password):>
Opt8Ovuf (Opt-EIGHT-Ov-uf)
Uc1Gryec (Uc-ONE-Gryec)
jadJoav5 (jad-Joav-FIVE)
IshtIvawam3 (Isht-Iv-aw-am-THREE)
lakVosAfUrg7 (lak-Vos-Af-Urg-SEVEN)
dyijDus8 (dyij-Dus-EIGHT)

You can pass random string as parameter and use many different options:


$ apg -n 10 -m 8 -x 12 somerandomdata

Will generate 10 passwords with min length 8 and max length 12.

makepasswd

Install: sudo apt-get install makepasswd

Generates password, by default one. User may need to use options to set length of password and count of passwords. For example:


$ makepasswd --count=10 --minchars=5 --maxchars=10

Results:


mzd4f9q
gUWamL
NYiUXrYvq3
6hWDXKA
gQpu20IJGD
BSAT5ASFX
37FcKyLPb
ma7pC66A
cFpWPBy
0oTNhT7

pwgen

Install: sudo apt-get install pwgen

My favorite tool to generate password. By default generates 160 different passwords each with length 8 symbol. Programs takes 2 parameters:
- 1st is the length of the password and
- 2nd is the count of passwords to generates. For example:


$ pwgen 12 24

Results:


oHo2iethieze cheiS6ohPeed Oozufiorohv9 eic3aethei4L hiRohYie6Ue4 aephoiDieb0y
hieTh8eizaeK aid1EeNgaiSe yoh6chohX9ha aiPhae7dieMe wedooD8nai7y aic7deeB9eS8
ohFor3Achied Thaequu4aiph zaeghiem7keT Shee5ooxaex0 wePh2eiNgien aicohroo2Go3
Aagh0gahcah0 Zie8eazaitah aoha9AeXi7Bo Oojoob0oosh6 Olahgh4aeji6 oobae9UZ2phi

Open Source: core library

2010-12-27T21:24:00.012+02:00

Few months ago, after I moved to GitHub, one of my util projects was open sourced. It was, simply called, core: https://github.com/rkhmelyuk/core. I have written this library few years ago and was actively using on Java projects. In some places it crosses with Apache Commons Lang library, but I, actually, like my child more :)

I'd like to describe some key classes and show samples of use. Some of them are enumerated below.

StringUtils contains few oftenly used methods, like:

isEmpty(), isBlank(), isNotEmpty(), isNotBlank(), isBlankTrimmed(), isNotBlankTrimmed() - used to check whether string is empty or not. The difference between empty and blank, is that empty is either null or empty string, while blank is always blank string and can't be null.

cut() - used to cut string if length is more than specified and appends with specified suffix. The only difference is that this method tries to split by space, so don't cut the word. Sample:
String string = "some string goes here"; assertEquals "some string...", StringUtils.cut(string, 15, "...");
trimIfNotNull() - if input string is not null, then trim it and return result:
String string = " Hello "; assertEqual "Hello", StringUtils.trimIfNotNull(string); assertNull StringUtils.trimIfNotNull(null);
replaceNotAlphaNumeric() - replace all characters that are not letter or digit with specified one or "_" by default.

ConversionUtils contains some simple but useful methods to convert string value to numeric and boolean types. Contains methods getInteger(), getLong(), getBoolean(), getDouble(), getDate(), getFloat():


   assertEquals 1, ConversionUtils.getInteger("1");
   assertNull ConversionUtils.getInteger("hello");
   assertEquals 5, ConversionUtils.getInteger("hello", 5);

KeyGenerator was created to generate API keys, passwords and other random stuff. It has one highly configurable method and few helpful methods that uses it. There is a way to generate keys with alpha and/or numeric and/or special symbols.

That would be hard to write assertions for samples, but here are simple use cases:


  KeyGenerator.generateKey(10, KeyGenerator.WITH_ALPHA_LOW | KeyGenerator.WITH_ALPHA_UP);
  KeyGenerator.generateStrongKey(100);
  KeyGenerator.generateSimpleKey(20);
  KeyGenerator.generateAlphaKey(20);

After I found some issues with Apache Commons-Lang ToStringBuilder, I wrote my own replacement, and called it... ToStringBuilder :) It is very simple in use:


   class Blog {
      private String name;
      private String author;
      private int year;

      public String toString() {
          new ToStringBuilder(Blog.class)
              .field("name", name)
              .field("author", author)
              .field("year", year)
              .toString();
      }
   }

   Blog blog = new Blog();
   blog.setName("Java UA");
   blog.setAuthor("Ruslan Khmelyuk");
   blog.setYear(2010);

   assertEquals "Blog[name=Java UA, author=Ruslan Khmelyuk, year=2010]", blog.toString();

There are much more interesting tools, like ArgumentAssert and StateAssert used to assert arguments and program state respectively.

CollectionUtils also contains few useful methods, and I'm not going to describe them here.

Library is open to review and use. Still it's definitely not the best one and, I think, has value only for me.

Neverending Groovy: map with default values

2010-12-16T23:04:00.006+02:00

More and more Groovy openings for me every day!

Just today, I found that there is a way to setup default value for map entry, if absent. In some cases it may be very handy.

For example, I need to prepare a map with words counts. This simple task should be coded simple too, like:


def map = [:]
words.each { word -> map[word]++ }

But it's not working and fails with NPE exception. Why? Because it's hard to increment null.

Although, there is simple way to avoid this problem even using Groovy API:


def map = [:]
words.each { word -> map[word] = map.get('word', 0) + 1

Here 2nd parameter of map.get() method is the default value, returned if there is no value for key 'word'. And now it's working fine!
Still there is another way, and, as for me, it helps to make code clean and safe. Safe because default logic can be used elsewhere we want to use our map object.


def map = [:].withDefault { 0 }
words.each { word -> map[word]++ }

I bet there is a better way and I'm going to find it...

MySQL pager

2010-11-15T17:55:00.006+02:00

I very liked to use psql command. Among different usability things, it uses less command to show query results. That was the thing I always wanted to have in mysql command. And was sure that's not possible, and till today was suffered in silence.

But today, quite unexpected for me, I found option pager for mysql command. This option let me set the program, I want to use to see query search results. So, to use less program, I was just need to start mysql with --pager parameter:


$ mysql --pager=less

or in mysql console:


mysql> pager=less

Now I'm happy to use it! And you should try too :)

Neverending Groovy

2010-11-13T23:33:00.005+02:00

Вже кілька місяців коджу в основному на Groovy. Прекрасна мова, прекрасна підтримка від IntelliJIdea. Часто знаходжу все нові і кращі спрособи реалізації деколи тривіальних речей.

Для прикладу, необхідно отримати список із значень певного поля кожного елементу списку. Спочатку, я писав доволі простий і зрозумілий код, ясно ще під впливом Java:


List names = []
for (Person person : persons) {
   names << person.firstName
}

З часом я удосконалювався і коду ставало менше:


def names = []
persons.each { names << it.firstName }

Виглядає дуже навіть зрозуміло, пишеться швидко і ще швидше читається.
Але і це не був край досконалості, і трохи пізніше я почав писати вже:


def names = persons.collect { it.firstName }

І цей кусок коду поражав мене тим, що був тільки 1 рядок, назва методу collect є зрозумілішою, ніж each у цьому конкретному випадку. І так, може, і писав би й дальше, якби не вирішив спробувати використати для цього spread оператора (*.). І тепер коду стало ще менше:


def names = persons*.firstName

Відмінністю від collect є не тільки простота написання, але і краща швидкодія.

І ось, в процесі написанні цієї статті, я відкрив для себе ще один спосіб. Коли починав писати цю статтю кілька хвилин тому, я вже не вірив, що може бути щось простіше, ніж використання spread оператора для вирішення моєї задачі. Але як виявилося, для отримання значення полів, використовувати spread оператор не є необхідним, і можна написати банально і просто:


def names = persons.firstName

Тож сиджу і думаю, а як можна ще простіше. Боюся зарікатися, що простіше вже бути не може, як вже зрозумів свою помилку кілька хвилин тому.

Groovy цікава мова, з якою все простіше і веселіше. Тож копати в Groovy, Python чи Ruby!

Book Review: 97 Things Every Software Architect Should Know

2010-09-05T00:27:00.009+03:00

More then year ago I bought book 97 Things Every Software Architect Should Know for myself. I was expecting to get a book with some useful technical advices how to create cool software architecture,- that's what was always interesting for me.

Instead I've got the book with 97 small articles, each 2 pages long. No technical advices, no silver bullet, no advices on what and how use design patterns or modern technologies. Truly say, after reading few articles, I was upset. And leaved the book on my bookshelf and move on.

A year later, ie a month ago, I've took this book into my hands and decided that it's time to try to read it again. (Yes, I have a habit to re-read books again a year or two later, as found that it helps to understand much more and see the forest behind the trees).

I'm still reading this - few articles per week,- but decided to note my thoughts as review in this article.

In this attempt, book is very interesting. A year later my vision was changed cardinally again and now, I think, I can understand what those guys mean when they were writing their posts. These all can be said simply in one sentence:
Software Architects are bridges between business needs, software needs, technical needs and team needs.

Especially interesting were next articles for me (remember, I'm still reading):

Don't Put Your Resume Ahead of the Requirements

It Is All About The Data

Pattern Pathology

If You Design It, You Should Be Able to Code It

Empower Developers

Chances Are, You Biggest Problem Isn't Technical

Business Drives

Great Content Creates Great Systems

Start with a Walking Skeleton

Communication Is King; Clarity and Leadership, Its Humble Servants

I'm sure articles' titles are saying enough, so will not describe them. Want know more - just go and buy (as I did :)

A week ago I was reading "Business Drives" article. And especially remembered the summary of this article: "The long-term interests of the software development team are best served when business drives". And I agree with this summary. It's sad to know, that many software developers are still in the race for better skills and modern technologies if this is in damage for the project and business.

It's one of that books, that reminds that software is making by humans for humans.

So, my advise is to get and read this book; hope you're ready for it and hope I'm too :)

PS: Just found another review of this book http://dotnet.dzone.com/news/97-things-every-software

Groovy annotations

2010-09-04T23:19:00.020+03:00

As I wrote in my last post Groovy 1.8 is still in progress. One of the new features I liked a lot is annotation support for AST transformations (i.e. @ToString, @Canonical etc.).

As I'm still acquainted with Groovy, I've decided to look what useful annotations it has already. So this post is about what was found.

There are next annotations in the groovy.lang package:

@Lazy
@Immutable
@Newify
@Singleton
@Mixin
@Category

Also want to describe them with few simple samples.

@Lazy

This annotation can be applied to class field. As result new instance for field value is created on get method call for field property. In this case Groovy generates getter method for you, that checks whether field is not initialized yet and initialize it in this case, otherwise returns its value:


@Lazy T x

generates next code:


private T $x

T getX() {
   if ($x != null)
      return $x
   else {
      $x = new T()
      return $x
   }
}

You also can do lazy field initialization with specified value, just assign this value for field with @Lazy annotation:


@Lazy T x = new T(code: 'S')

That will generate next code:


private T $x

T getX() {
   T $x_local = $x
   if ($x_local != null)
      return $x_local
   else {
      synchronized(this) {
         if ($x == null) {
            $x = new T(code: 'S')
         }
         return $x
      }
   }
}

Absolutely useful thing with only a few of keypresses. That's awesome.

Read more in GroovyDoc

@Immutable

Used to mark classes and make them immutable. That's mean that your class becomes final and nobody can change value field value and you get tuple and map based constructors. Also Groovy generated toString(), hashCode() and equals() methods for you. You should also need to be sure that fields types are immutable, primitives, strings, enums or are annotated with @Immutable.

Read more in GroovyDoc

@Newify

This annotation is perfect for DSL expressions. With it you can change creating new objects expression, for example, use


def b = Book('The Best Book Ever')

instead of


def b = new Book('The Best Book Ever')

@Singleton

Well, another annotation that makes your life easier. As you maybe already understand, this annotation is for types and make them singletons.
getInstance() method is generated for you, so simply call it when you need new instance. If you set annotation lazy parameter to be true, your singleton instance will be created on first call to this method. As for this case method supports double checking locks, you may be sure that only one instance will be created. Here is some sample:


@Singleton
class Player {
    def play() {}
    def stop() {}
}

...

Player.instance.start()

Read more in GroovyDoc and Singleton transformation.

@Mixin

Used to mix one or few types into annotated type. As result, you can have a class that have members (fields and methods) from other classes, specified in the annotation. And here is sample:


class Book {
   String name
   String author

   def find(text) {
      ....
   }
}

@Mixing(Book)
class HardBookMetadata extends Metadata {
   int pages
   String publication
}

....
def metadata = new HardBookMetadata()
metadata.title = 'Some cool title'
metadata.author = 'Ruslan Khmelyuk'
metadata.pages = 400

println metadata.find('cool')

As you see, using variable metadata of HardBookMetadata type have access to Book members.
Yeah, this also can be used with @Category.

Read more in GroovyDoc.

Waiting for Groovy 1.8

2010-08-31T21:18:00.007+03:00

Groovy 1.8 is going to be released in December 2010. First beta release is already open to download and second beta release will be ready in September.

Groovy developers team preparing for us a few important surprises.

They added more AST transformations, for different cases like @Canonical, @EqualAndHashCash, @ToString and many others. You may use such annotations to generate toString(), equals(), hashCode() methods on compilation. @InheritConstructors helps to generate inherit all parent constructors, and here is link to task.

Another interesting feature is Closure composition, so now it's possible to use special syntax to compose multiple closures, like:


def log = { a -> println(a); a }
def save = { a -> dao.save(a); a}
def notify = { a -> notificationService.notify(a); a }

// so now instead of calling notify(save(log(user)))
// you may call it like
def action = log >> save >> notify
action(user) 

// or even like
notify << save << log << user  // is that awesome or awful?!

Also they prepared few performance improvements: avoiding calling methods when it's not necessary and processing operations on integers as primary type values but not objects (like, incrementing or adding). As result Groovy can be used for mathematical calculations without performance issues. In this presentation you can read much more about this. And here are related jira tasks so anyone can watch the progress.

This issue is fixed so they can't say that "Ruby is right, Groovy is wrong" anymore :)

Annotations now can accept closure as argument:


@Validator { password.size() > 6 }
String password

This task contains more information and links.

Closure currying is a powerful thing. And now it's possible to curry right and 2nd (of three) parameter. Moreover no need to wait Groovy 1.8 to try this, because it's available right now and right here, starting from version 1.7.2 of course ;)

Well, that's all about this for now. Waiting for Groovy 1.8 and for more interesting things to be released this December.

SpringWS and Jaxb

2010-08-28T09:33:00.009+03:00

Well, truly say this small post is not about how to use SpringWS and Jaxb together. It's more about potential power of this combination. I know, that combination is in release for few years alredy and used by thousands of developers. But this article is more for guys in doubt if they really need SpringWS rather than for experienced Spring WS developers.

First of all, I want to say that Spring WS is very powerful framework. I've noticed it when version 1.0 beta was released. As everything in Spring it has good API, simple implementation model and as result it was very flexible. And this mean that you can easily introduce need changes and extensions without changing Spring WS source code.

From the beginning, the Spring WS team was saying that SpringWS should support not only low-level request processing, when you have some object that represents input XML document or build output XML document, but can use different mapping and translation libraries to make it for you. And here is a place for Jaxb.

To enable marshaling you need just to do few simple changes:

Add marshaller bean of org.springframework.oxm.jaxb.Jaxb2Marshaller type:

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
    <property name="classesToBeBound">
        <list>
            <value>GetImageRequest</value>
            <value>GetImageResponse</value>
            <value>AddImageRequest</value>
            <value>AddImageResponse</value>
        </list>
    </property>
</bean>

Add Marshaling Method Endpoint Adapter to yours spring.xml:

<bean class="org.springframework.ws.server.endpoint.adapter.GenericMarshallingMethodEndpointAdapter">
     <property name="marshaller" ref="marshaller"/>
     <property name="unmarshaller" ref="marshaller"/>
</bean>

Well, that's all :)

And then, after some testing, I found that it would be nice to trim input text fields and do other post-marshalling operations. And I was sure there was a normal way to do that with rather Spring WS or Jaxb. After a few minutes of searching, I have found the way and had completely working code that was doing what I was needed.

The catch is that Jaxb Unmarshaller supports listeners and Spring's Jaxb2Marshaller has a property unmarshallerListener, that points your listener to Unmarshaller's listeners.
With only 3 lines of configuration we have own listener called on each unmarshalling:

<bean id="marshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
   ....
   <property name="unmarshallerListener">
       <bean class="TargetHandlerUnmarshallerListener"/>
   </property>
</bean>

Here is TargetHandlerUnmarshallerListener code:

import javax.xml.bind.Unmarshaller;

public class TargetHandlerUnmarshallerListener extends Unmarshaller.Listener {

    @Override public void afterUnmarshal(Object target, Object parent) {
        super.afterUnmarshal(target, parent);

        if (target instanceof PostPopulatedHandler) {
            ((PostPopulatedHandler) target).postPopulated();
        }
    }
}

In this class I override only afterUnmarshal() method, that is called after XML is transformed to the Java object. You can also override beforeUnmarshal() method if you need.

PostPopulatedHandler is my own interface that expose only postPopulated() method. Each class knows what to do after unmarshalling, and declares it in the postPopulated() method. Of course, there can be used some annotation, but interface option is the most simple, easier and obvious way.

So, some summary is next: Spring libraries are awesome, because they always provide very good API and you always can do what you need without changing library source code. Jaxb is awesome as well. I'm noticing this, because it's always hard to write good API, especially in multifunctional libraries.

Migrate from SVN repository to Git

2010-08-28T01:04:00.011+03:00

As I was saying in my previous post it is easy to migrate you project from Subversion to Git.

Really, you will need just a few commands to run.

First of all you need to make a clone of Subversion repository using git-svn tool:


$ git svn clone --authors-file=authors.txt https://example/svn/MyRepo/trunk/project project

On this command git will go through the history of the project and fetch it into local git repository. If your subversion repository is using standard layout (i.e. trunk, branches and tags paths are present in the SVN repository root tree) than you may be interesting in --stdlayout option. You may also specify custom path for trunk or branches or tags using -T or -t or -b option respectively.

Option --authors-file contains the path to the file with committers mapping.
This file contains SVN committer mapping to git user per line.
For example:


ruslan = Ruslan <ruslan@example.com>
john = John Smith <john@smith.com>

So now you have local working copy that is managed by Git and also you have all project history in your local repository. It's easy to check what branches and tags you have using next commands:


$ cd project
$ git branches
$ git tag -l

If you have remote Git repository (maybe in GitHub), than you may want to push source code with all history to that repository. And it is not a problem, as you have already everything you need.

1. So add remote repository:


$ git remote add origin git@github.com:myname/myproject.git

2. And push to the remote repository:


$ git push origin master

3. and be happy - now you have migrated to the git repository.

Remove directory with SVN repository clone and make another clone but from git repository and continue using it:


$ cd ..
$ rm -rf project
$ mkdir project
$ cd project
$ git init
$ git remote add origin git@github.com:myname/myproject.git   
$ git pull origin master

Thats how it worked for me 2 months ago.

Git and GitHub

2010-08-25T22:46:00.007+03:00

Completely moved to Git and it's awesome. Feeling like someone unleashed my hands. Git works much faster than Subversion in everyday use. Using branches is easy and NORMAL and I'm using it day by day. No more need to have many directories with strange names and different project versions. No more fear before merging. No more failures on merging.

My opinion is that everyone must try and use some of distributed version control system, like Git or Mercurial or Bazaar. I've started using Git intensively with projects under Subversion. It was possible thanks to the git-svn project and I was working on Windows in that times. Now I'm on Linux and using git is much easier and natural. git-svn also is very useful to migrate projects from svn repository to the git repository. On checking out project you need to wait some time, because it reads the all history of repository with all changes, that is pretty long in subversion for large projects. As soon you have clone of the project svn repository, you push your changes to central git repository if any. If you need you can do commiters mapping. If you need, you can continue work with both repositories.

And what about GitHub? It's another awesome software. A lot of open source projects are using GitHub. You easily can have and use private repositories and it's pretty cheap - only $7 per month for 5 private repositories.
Each repository goes with wiki, basic issues tracker, useful reports and many others. Especially, I like Network graph, because it helps to visualize commits and merge history.

Some interesting links:
1. ProGit online book
2. Git with Subversion
3. GitCasts
3. The way GitHub helped Erlang and the way Erlang helped Github

Other related posts:
1. Git and Subversion work together

Ruslan and Linux

2010-08-25T22:14:00.007+03:00

Давненько я нічого не писав...

За такий здавалося нетривалий період часу, багато чого встигло помінятися, тому, думаю, буде що розсказати.

Мабуть, найбільшою зміною для мене був цілковитий перехід на Linux. Ось уже від початку травня я є гордим користувачем Ubuntu 10.04. Перехід видався значно простішим, ніж можна було очікувати, але це скоріше за все результат моїх попередніх поривань в цю сторону, а також нетривалого, але плідного використання Slackware.

Важко далося використання MS SQL Server на локальній машині під Linux. Не можу сказати як я вирішив цю проблемо, тому що я її не вирішив. Використовувати віртуальну машину було нереально, адже в результаті тормозило все і вся. Тому довелося використовувати віддалений сервер і в результаті працювати тільки в онлайн. Благо, тепер потреба в ньому мінімальна.

Декілька слів про Ubuntu. Зручно, приємно, вражаюче і крім цього є консоль із всіма її потугами. Через кілька тижнів використання, я вже не міг собі уявити себе без Linux, а Windows 7 почав виглядати поцікавому і, навіть можна сказати, екзотично.
А ще недавнo я для себе відкрив, що в mc можна використовувати мишку. І це могло би перевернути мій світ, але не стало ;)

Люблю консоль. Консоль та набір скриптів дозволили оптимізувати роботу в Linux та роботу по проектах.

Screen cast on linux with ffmpeg

2010-03-24T21:48:00.004+02:00

Few days ago I was happy to found the link with 10 useful Linux commands at http://www.catonmat.net/blog/top-ten-one-liners-from-commandlinefu-explained/.

The last one command was the most interesting for me, as it helps to make screen casts quickly and easy with only one command:


ffmpeg -f x11grab -s wxga -r 25 -i :0.0 -sameq ~/out.mpg

Moreover ffmpeg helps to setup video quality, convert it to FLV format, so you can publish video online with a few clicks!

Dilber and co

2010-03-14T12:13:00.001+02:00

Beautiful Code

2010-02-01T20:16:00.006+02:00

Зовсім недавно повернувся зі Львова. Купив собі в Гіаді декілька цікавих книжок. Серед них і Beautiful Code. Тільки от почав її читати.

В книзі міститься 33 історії від відомих програмістів, в яких вони діляться враженням від певного коду чи технології. Кожна історія проникнена поглядами і думками на цікаві речі, що розглядаються з призми красивого коду. Інколи код не зовсім-то й красивий на перший погляд, і автори намагаються відкрити ту красу, що побачили вони.

А ще автори не відчувають жодних рамок у виборі красивого коду, і в книзі можна зустріти C, C++, Perl, Java, Python.

Так що раджу почитати.

Реліз IntellijIDEA 9.0 (Maia)

2009-12-09T20:42:00.003+02:00

Нарешті відбувся реліз IntellijIDEA 9.0.

Для мене це було неочікувано, хоча користуюся EAP'ами вже давно. Перейшов через підтримку FreeMarker та Velocity. А пізніше добавилась перевірка коректності слів по словнику, відчутно покращилася швидкодія в останніх EAP версіях, можливість назначати кольори окремим групам файлів, потім добавилося code folding для дженериків та анонімних класів та багато іншого. Цікаво також, що є можливість генерити діаграми класів, діаграми змінених класів, підключення до Jira та YouTrack для роботи із тасками.

Версія 9.0 вийшла в двох редакція: повнофункціональна Ultimate Edition з підтримкою JavaEE та великої кількості плагінів, а також безкоштовної з відкритим кодом Community Edition.

Корисні посилання:
1. IntellijIDEA blog
2. IDEA what's new

2009-12-08T00:49:00.005+02:00

Задумався я над UML. Вчу студентів, що це дуже корисна річ, часто використовується в реальному світі. Допомогає не тільки спроектувати програму, але і донести свою думку до інших, зрозуміти чужу програму; є важливою частина документації.

І справді, UML буває корисним для того, щоб спроектувати програму, якщо це взагалі можливо зробити в повній мірі. Донести думку до інших за допомогою UML - річ також нетривіальна, хоча все залежить. Щодо технічної документації, то я прихильник думки, що найкраща документація - це сам код програми (доречі тут можна почитати про це більше).

А ще часто доводиться чути думки, що UML - це зайве, що все в голові можна спроектувати, і при цьому особливо "ясно видно динаміку". Інші не розуміють, навіщо ці квадратики та кружочки; a це й чоловічок (которий актор, чи то пак актант) взагалі смішно виглядає. Інші і не знають про це або знають, але не пробували.

Кожному своє. Я ж використовую UML, точніше ту частину, що мені справді допомагає. Я не пробую спроектувати всю систему, бо зазвичай це є неможливо через складність, величину системи чи плинність вимог. І звичайно я не завжди використовую UML, тільки коли це потрібно.

Натомість при розробці певної функції програми, що виходить поза межі стандартних шаблонів та правил проекту не можу обійтися без діаграм випадків використання, класів та послідовностей. Цих трьох діаграм для мене достатньо.

Спершу визначити список випадків використання та їх сценарії, як результат визначити список додаткових питань та білих плям в специфікації. Після цього вже на основі прецендентів паралельно будуються діаграми класів та послідовностей. Роблю це все на листочку або на боарді. Зазвичай, починаю з основного і закінчую другорядними класами та зв'язками. Найцікавіше потім переробити систему, починаючи з найпростіших другорядних класів та закінчуючи основними. Наступне просіювання починається при написанні коду. Знову ж таки, писати починаю з найпростіших і/або другорядних класів. Це не тільки дає час подумати над удосконаленням основних класів та інтерфейсів, а також прощупати це все ручками в коді, визначити білі плями, розбіжності та несходження.

Ось так вона, думка, спочатку матеріалізується на бумазі, відточується, потім перетворюється в код, і ще раз відточується.

І взагалі, дуже цікаву книжку Крега Лармана Применение UML 2.0 и шаблонов проектирования. Якщо є перша версія, то можна почитати її, як це колись зробив я. Раджу всім, особливо студентам, що хочуть зрозуміти принципи проектування та розробки ОО програмного забезпечення.

Apache JMeter

2009-12-07T00:25:00.006+02:00

Попрацював сьогодні трохи з JMeter. Давно знаю про цю програму, давно хотів навчитися її використовувати, але до сьогодні якось не складалося.

Загальне враження від неї позитивне: простий інтерфейс, зручне представлення тесту у вигляді дерева, чітко визначений життєвий цикл тесту та послідовність виконання кожного елементу тесту дозволяют швидко накидати та запустити тест. А набір лістенерів дозволяють представити отримані дані зберегти та представити у зручному вигляді: таблиці із детальними та середніми значеннями, графіки тощо.

Звичайно необовязково запускати JMeter у візуальному режимі. Можна також скористатися режимом командного рядка або сервера для розприділеного тестування. Включивши навантажувальні тести JMeter в процес збірки певних версії проекту (наприклад, тестових версій, чи спеціальних щотижневих версій), можна контролювати метрику швидкодії програми. І все це безкоштовно.

Сьогодні використовувати її проте прийшлося тільки для перевірки середньої швидкодії програми при різних навантаженнях на різних серверів. Висновок: трохи треба попрацювати над швидкодією окремих речей. А ще планую підготувати декілька простих тестових випадків і періодично знімати метрики зміни швидкодії та масштабування в процесі розробки.

Особливо цікаво також було порівняти зібраних даних з серверів та мого ноутбука. Висновок: настав час придбати собі нового звіра :).

Корисні посилання:
1. JMeter User Manual
2. http://www.scribd.com/doc/7499267/Load-Testing-With-JMeter
3. JMeter tips

Freemarker Tips

2009-11-03T23:41:00.005+02:00

I like FreeMarker. It's simple, functional and pretty fast tool.
In project we are using Freemaker with SpringMVC.

To work with message bundle are used few macros, one of them is spring.messageArgs. So today I've spent some time on searching how to pass argument to it. There was only one argument and, obviously, I was expecting that this macros could be used in next way:

<@spring.messageArgs "some.message.key" "argumentValue"/>

Unfortunately it's not so easy :(. The macros is calling method that accepts arguments as an array of objects. And string "argumentValue" isn't an array. So I found next simple solution:

<#assign args = ["Ruslan"]/>
<@spring.messageArgs "hello.man" args/>

where

hello.man = Hello {0}!

Another interesting thing about Freemarker is the way you can print numbers. If you want to print number value in argument X as a regular number rather than formatted number, you may do it in next way ${X?c}. I always forget to add ?c suffix and later receive many errors. Fortunately, it's possible to use #{X} that has the same effect. I found that it saves my time.

2009-09-13T12:10:00.002+03:00

Вітаю всіх програмістів з Днем програміста :)

Думайте - пишіть, ще раз подумайте і (пере)пишіть.

Code Generation at Java

2009-08-31T02:49:00.004+03:00

Some time ago I found how the code generation techniques are used at Java.
Java NIO exposes a set of Buffer interfaces with package level implementations that are returned while creating buffers. If you will look at those implementation classes (HeapByteBuffer or DirectByteBuffer) you will notice that they are generated. Look at the file header comments - and you will see notion that it's generated and the name of the template. You may find templates with description of it's parameters here.

Code Generation

2009-08-31T01:09:00.012+03:00

We are writing the code and this is our job. That's the art that we make. We put our thoughts, our patient, our soul to make it ideal or near to ideal. Sometimes we just write the code asap as there is no time or code is simple or we wrote similar code hundreds of times. This small article is about writing similar code again and again.

When we are writing similar code second or fourth time it's not an art and it is tedious. But that's useful to polish previous code: we can find and fix bugs, add needed logging, rewrite with better performance, make the code clean and handy to read and change etc. Often we are changing previously written code to make it better as well.
But what if you need to write similar code tens or hundreds of times? Will you change previous 20 classes because now you find the best algorithm or fixed the annoying problem with performance? Will you be glad to fix 50 classes over the project because just now you find the bug? (so it must be fixed, right?)
That will take your time, that you could spend on coding something interesting or studying some new popular technology or have a beer with your friends. And what about customer for whom this software is a business.
That's why I'm writing about code generation, the thing we all know and use often. You remember, when you're creating new project or adding new class with your favorite IDE, you got initial code so you can write your important part rather that spend time on writing the same code again and again.
While reviewing code generation tools we can divide them into external and internal. External are provided by IDE or other providers (remember famous xdoclet toolkit?). Internal is written by your team and used withing some one or few projects.
Internal code generators could be simple enough to generate only basic template source code or UI that will be changed and extended. It also can be large and complex to generate layers (domain types, DAOs and repositories etc) of your software.

Lets review next types of code generators:
1. template code generators
2. partial code generators

Template code generators run once at the begin. They are responsible for generating source code that will be rewritten or extended by developer. It's important to have clean generated code with comments for generated code and for placements where to put your code. It's good to use such generators if you have already ideal code to be generated. Ideal means that you will not need ever to change template and regenerate the same code again and again. Regenerating code will remove code written by developers with hands.

Partial code generators could be run as much as you will need. They are separated from code written by developers. For C# that would be good to use partial keyword (as I remember partial class declaration was added to have distinct generated and written by developer code for WinForms and ASP.NET); for Java extending could be used as well. We use generator to generate only similar code and put in another file, e.g. partial class definition or base abstract class. The specific code is written in derived class. While we find new bugs and improvements we need just to change templates or generator configuration and regenerate the code again.

Although code is generated it also must be easy to read it. Document your code, as you need to do it only once - in templates, so don't be lazy and stingy! For partial code generator or template code generator that is twice as important, as you are working directly with generated code.
Don't forget to add comment with notion that code is generated automatically and can be regenerated again, so other developers will think twice before changing it by hands!

Also remember that it's okay to add code generation to project step-by-step. For example, I'm the only who is using the new generator for now. I need to do so to find and fix defects, find the parts of code that could and must be generated, improve configuration and way of use. In this case the generated base code (with partial code generator) is commited too.

Use the best tools to write templates. For example I'm using Freemarker template engine to describe templates and generate source code. There are few code generators that read configuration file and generate appropriate code. For such tools performance is not as important as flexibility of templates and configuration.

Document the generator. Share source code within team. Put your generator into source code repository near to the project, but not into it. Also make and tag latest stable version as runnable scripts or program, so other developers can update and use it without spending on it additional time.

ToStringBuilder and multi-thread environment

2009-07-27T03:49:00.006+03:00

Just found some article about using Apache Commons' ToStringBuilder tool and about what a wonderful tool it is. And I decided to write about it too.

Well, there were few projects where I was able to use Apache Commons Lang tool called ToStringBuilder. It's very useful tool that helps to print information about class instance in the toString() method. I just was need to write


@Override
public String toString() {
    return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE)
            .append("Id", id)
            .append("Name", name)
            .append("Description", description)
            .toString();
}

and as result got a string with nice-look instance description. It was perfect for me.
But now I'm not using this tool. And wasn't using it for the last 10 months as well. I would be happy to use it rather than own implementation over StringBuilder but I can't.
ToStringBuilder has problems with running in multi-thread environment. If you have class A that uses ToStringBuilder and you're going to use instances of this class in different threads - be careful!

Google Books

2009-07-17T02:31:00.007+03:00

English version by Google Translate

Не секрет, що у світі Google Books відбуваються чималі зміни.
Про це все розказує сам Google.

Сервіс дуже цікавий, і сподіваюся кількість повністю доступних та щойно виданих книхо з часом збільшиться. Адже є книжки, яких вже і не купиш, а є книжки - як хочеться купити або навіть потрібно купити, але змушений часто це робити без перегляду хоч якогось контенту. Гугл може дати можливість віртуального швидкого перегляду книжки перед купівлею, - наче ви в справжньому магазині.

Подобається також можливість створювати власну бібліотеку. Або вставляти фрейв сторінку із книжкою :)

Maven допоможе!

2009-07-06T20:57:00.002+03:00

Вирішив записати декілька корисних речей, з якими доводиться мати часто справу користувачу мавена в повсякденному житті, наприклад, мені:

Запуск із ключиком -o каже мавену працювати в оффлайновому режимі, а це інколи економить час якого немає. В цьому випадку мавен шукає всі бібліотеки та плагіни в локальному репозиторії і навіть не пробує стукатися до центральних репозиторіїв за апдейтом тощо. Також корисно з повільним та нестабільним інтернетом.

Проперті maven.test.skip поможе виконати компіляцію та збірку проекту без виконання тестів. Корисно, коли середовище для тестування не готово або ж з тестами все ок, а проблема з якимись плагінами або просто треба зібрати проект, щоб викласти десь. Може запускатися таким чином: mvn install -Dmaven.test.skip=true.

Файл MVN_HOME/conf/settings.xml містить ряд корисних настройок. Однією з них є localRepository, за допомогою якої можна вказати шлях до репозиторія десь на диску відмінному від C:. Користувачі windows часто форматують C: і рідко бекаплять репозиторій. Правильний шлях може зберегти чимало часу при перевстановленні windows наступного разу.

Якщо використовується плагін мавена для генерації javadoc для проекта з декількома модулями, то може бути дуже корисно виконати агрегації згенерованої документації, а для цього можна скористатися властивістю aggregate, наприклад:
<plugin> <artifactId>maven-javadoc-plugin>/artifactId> <configuration> <aggregate>true</aggregate> </configuration> </plugin>

Список не повний, буду його розширювати як тільки буду згадувати та знаходити нові тіпси.

A Few Maven Tips

2009-07-06T00:48:00.006+03:00

Decided to write some useful things, which often helps in everyday life to Maven user, like me:

The command line argument -o said to Maven to work in offline mode and this sometimes saves time. In this case, maven is lookіng for all the libraries and plugins in the local repository and do not even tries to ping central repositories for update. Also useful with slow and unstable Internet connection.

Property maven.test.skip helps to perform project compilation without running test cases. Could be useful when the environment is not yet ready for testing or all tests green. Run command in next format: mvn install -Dmaven.test.skip=true.

File MVN_HOME/conf/settings.xml contains a number of useful settings. One of them is localRepository, through which you can specify the repository somewhere on the disk D: etc. Windows users oftenly format drive C: and rarely backups local Maven repository. Correct value for this setting can save a lot of time after re-installing windows next time.

If you are using Maven plugin to generate Javadoc for a project with multiple modules, it can be very useful to perform the aggregation of generated documentation. In this case use property aggregate, for example:
<plugin> <artifactId>maven-javadoc-plugin>/artifactId> <configuration> <aggregate>true</aggregate> </configuration> </plugin>

The list is not complete, it will expand as soon as I remember or find new tips.

Динамічний репорт за допомогою JasperReports

2009-07-05T22:30:00.000+03:00

На проекті, над яким я працював десь рік тому, постала задача виконувати динамічну генерацію друкованої версії звіту. На проекті для генерації звітів використовувався JasperReports.
Отже, постали наступні питання
1. Як виконувати динамічну генерацію звіту:
- чи є для цього API,
- чи все-таки генерувати XML, а потім його компілювати?
2. Як передавати дані?

При виборі способу генерації динамічного звіту я вирішив використати перший варіант - працювати із API JasperReports для формування представлення звіту. Ідея генерувати XML в коді мені не дуже подобалася, тому що в цьому випадку код виглядав для мене заплутаним. Крім того, зміна версії бібліотеки могла привести до помилки, яку би було тяжко визначити. З API ситуація була інакшою: досягалася непогана чистота коду із можливістю абстрагування для різних видів звітів. Та й при компіляції можна було визначити сумісність використовуваного API із версією бібліотеки.

Дивно, але на той час мене чомусь не осягнула ідея використовувати JSP, Velocity чи FreeMarker для генерації шаблону звіту. Мені здається, що на даний момент я би використав саме цей спосіб.

Тут дуже знадобився такий клас як JasperDesign та набір класів сімейства Design. До класів сімейства Design відносяться:

JRDesignField
JRDesignStyle
JRDesignStaticText
JRDesignTextField
JRDesignExpression
JRDesignBand
і багато інших.

Перелічені вище класи є найбільш використовуваними. І якщо ви працювали колись із JasperReports, створюючи звіти за допомогою JRXML файла, то вам можуть бути знайомі такі елементи, як field, style, staticText, textField, band тощо. Суть використання Design класів полягає в тому, що вони представляють собою ті ж самі елементи JRXML. Обєктна модель справді дуже проста і зручна в розумінні.
Створювати репорти динамічно просто і зручно. Але це є виключною ситуацією, оскільки завжди можна скористатися вашим олюбленим редактором XML або ж iReport.

Мені свого часу довелося створити чимало репортів за допомогою Jasper. Більшість шаблонів створювалися в редакторі XML, чимало динамічних створювалися в коді і могли поєднювати ще декілька динамічних репортів, інші просто накидувалися швидкоруч в iReport.

Для тих, кому цікаво, хочу привести декілька прикладів використання API JasperReport.

Створення елементів звіту:


     public static JRStyle getDefaultStyle() {
        JRDesignStyle style = new JRDesignStyle();
        style.setName("defaultStyle");
        style.setDefault(true);
        style.setFontName("Arial");
        style.setFontSize(8);
        style.setPdfFontName("/TTF/arial.ttf");
        style.setPdfEncoding("Identity-H");
        style.setPdfEmbedded(true);
        return style;
    }

    public static JRStyle getHeadStyle() {
        JRDesignStyle style = new JRDesignStyle();
        style.setName("headStyle");
        style.setDefault(true);
        style.setFontName("Arial");
        style.setFontSize(8);
        style.setBold(true);
        style.setPdfFontName("/TTF/arial.ttf");
        style.setPdfEncoding("Identity-H");
        style.setPdfEmbedded(true);
        return style;
    }

    public static JRDesignElement staticTextElement(String text,
                                                    int height, int width,
                                                    int x, int y,
                                                    boolean headStyle) {
        JRDesignStaticText staticText = new JRDesignStaticText();
        staticText.setText(text);
        staticText.setWidth(width);
        staticText.setHeight(height);
        staticText.setX(x);
        staticText.setY(y);
        staticText.setBorder(JRGraphicElement.PEN_THIN);
        if (headStyle) staticText.setStyle(getHeadStyle());

        return staticText;
    }

    public static JRDesignElement textFieldElement(String text, Class type,
                                                   int height, int width,
                                                   int x, int y,
                                                   boolean headStyle) {
        JRDesignTextField textField = new JRDesignTextField();
        textField.setWidth(width);
        textField.setHeight(height);
        textField.setX(x);
        textField.setY(y);
        textField.setBorder(JRGraphicElement.PEN_THIN);
        if (headStyle) textField.setStyle(getHeadStyle());

        JRDesignExpression expression = new JRDesignExpression();
        expression.setText(text);
        expression.setValueClassName(type.getName());
        textField.setExpression(expression);

        return textField;
    }

    public static JRDesignElement textFieldElement(Property property,
                                                   int height, int width,
                                                   int x, int y,
                                                   boolean headStyle) {
        JRDesignTextField textField = new JRDesignTextField();
        textField.setWidth(width);
        textField.setHeight(height);
        textField.setX(x);
        textField.setY(y);
        textField.setBorder(JRGraphicElement.PEN_THIN);
        if (headStyle) textField.setStyle(getHeadStyle());

        JRDesignExpression expression = new JRDesignExpression();
        expression.setValueClassName(property.getType().getName());
        if (property instanceof Column) {
            expression.addFieldChunk(property.getName());
        }
        else {
            expression.addParameterChunk(property.getName());
        }
        textField.setExpression(expression);

        return textField;
    }

Ініціалізація звіту:


    JasperDesign reportDesign = new JasperDesign();
    reportDesign.setName(context.getDataResult().getDataReport().reportType().getReportName());
    reportDesign.setOrientation(JasperDesign.ORIENTATION_LANDSCAPE);
    reportDesign.setIgnorePagination(true);
    reportDesign.setTopMargin(5);
    reportDesign.setBottomMargin(5);
    reportDesign.setLeftMargin(5);
    reportDesign.setRightMargin(5);
    reportDesign.setWhenNoDataType(JasperDesign.WHEN_NO_DATA_TYPE_NO_PAGES);

    reportDesign.addImport("java.lang.*");
    reportDesign.addImport("java.math.*");
    reportDesign.addImport("java.util.*");
    reportDesign.addImport("net.sf.jasperreports.engine.*");
    reportDesign.addImport("net.sf.jasperreports.engine.data.*");

    reportDesign.addStyle(getDefaultStyle());
    reportDesign.addStyle(getHeadStyle());

Заповнення звіту:


    JRDesignBand rootBand = new JRDesignBand();
    rootBand.setHeight(40);
    rootBand.setSplitAllowed(true);
    reportDesign.setDetail(rootBand); // could be setTitle() or setSummary() etc.

    rootBand.addElement(textFieldElement("Details", String.class, 
            height, 120, currentX, currentY, false));

Компіляція звіту:


    JasperReport compileReport(JasperDesign reportDesign) throws ReportException {
        try {
            log.info("Compiling report...");
            return JasperCompileManager.compileReport(reportDesign);
        }
        catch (Exception e) {
            log.error("Error to compile report, cause:", e);
            throw new ReportException("Error to compile report!", e);
        }
    }

Використання отриманого JasperReport:


    JasperDesign reportDesign = new JasperDesign();

    //
    // preparing and filling report design goes here...
    //
    
    JasperReport jasperReport = compileReport(jasperDesign);
    JasperPrint jasperPrint  = JasperFillManager.fillReport(
           jasperReport, prepareParameters(), prepareDataSource());

yUML

2009-05-09T23:13:00.013+03:00

Just linked yUML to my blog. I like that service.
There are also few articles about it here.

There are next few yUML samples:

[Document]<0..*-1[DocumentTemplate],[DocumentTemplate]-^[Template]

[DocumentTemplate]-^[Template],[ReportTemplate]-^[Template|-name;-author;-location|open();save();remove()],[FigureTemplate]-^[Template]

[Administrator]-(Create Template),[Administrator]-(Create Document)

And now Scruffy variant:

[Document]<0..*-1[DocumentTemplate],[DocumentTemplate]-^[Template],[ReportTemplate]-^[Template],[FigureTemplate]-^[Template],[Template]->[Author|firstName;lastName],[Template]->[Resource|fileName;type;version]

[Ruslan]-(Create Article), [Ruslan]-(Edit Article),
[Ruslan]-(Write Comments)

Looks great, isn't it?

Linus about Git

2009-05-09T11:28:00.003+03:00

Перше серйозне знайомство з Git було в мене після перегляду відео презентації Лінусом Торвальдсом, на якій він розсказував наскільки Git крутий, а майже все інше близьке до лайна. Як на мене, занадто він впевнено про це заявляв, але і мені Git сподобався тоже.

Відео було на англійській мові, але не давно знайшов переклад цього відео. Точніше, переклад слів Торвальдса.
http://lib.custis.ru/index.php/Линус_Торвальдс_о_GIT_на_Google_Talks

Git and Subversion works together

2009-04-25T01:55:00.008+03:00

I like the idea to use Subversion central repository with a Git local "stub" repository. With having local Git repository I have access to the all history of some branch or trunk, as I have a local copy of Subversion repository. Local commits and easy branching is a big plush for me too.

Most of us are working with Subversion repositories, as they are wide used and popular nowadays. These tool gives us advantages to work with branches, setup security, transaction commits and many more. While Git proposes easy and low cost branching, decentralized storing and low coupling developers interaction. Yes, I said low coupling, as 2 developers that are working on the same thing in parallel now are able to synchronize code locally, without central repository.

I don't know what is your experience with merging branches using Subversion, but for me it's a hell. With a few different branches, that are ready to be merged into trunk but is not, because "we don't need it in trunk now, but maybe in 2 weeks we will". Sometimes merging takes the same time as new feature development.

Now Git can help us with it, as has new operation git svn.
It's currently working fine on Linux, but you should be ready to get some unpredictable behavior on Windows. Expecting that with 1.6.3 and latest versions git-svn will work much better that with Git-1.6.2.2-preview20090408.

Git Advantages

2009-04-12T16:56:00.007+03:00

Побавився сьогодні трохи з Git. Досі я в основному працював з SVN, і тільки із централізованими системами контролю версій.
В Git знайшов кілька цікавих речей, які мені ясно сподобалися, а саме:

Розприділені SCM дозволяють мати локальний репозиторій, з яким працювати є набагато зручніше. Адже він
завжди зі мною, я можу виконувати кілька незалежних комітів, які просто потім відправляти в публічний репозиторій, коли є необхідність і можливість. Розприділені репозиторії дозволять мені також синхронізуватися з іншими програмістами без необхідності внесення змін в публічний репозиторій.
Можливість створювати декілька commit lists, для того щоб комітити різні зміни із різними коментарями. Дуже корисно для підтримки порядку.
Можливість вибудовувати ієрархію репозиторіїв. Розприділення відповідальності між програмістами тепер може бути на рівні окремого репозиторію. Річ цікава і корисна, і якщо коли-не-будь доводилося працювати із репозиторіями, що знаходяться на іншому кінці світу, заховані за тучою файерволів і взагалі частенько є недоступними, тоді мене можна буде зрозуміти.
Можливість вносити зміни в історію комітів, наприклад, видалити зайвий файл або підкорегувати коментар.
Зручна та швидка робота із бренчами.
Message при коміті є обов'язковим.
Зручна робота із git в консолі.
Нема необхідності виконувати бекапи публічного репозиторію, якщо є декілька програмістів, що мають його локальну копію.

Це тільки декілька можливостей. Мені вони здалися найкориснішими.
Звичайно, частину з них можна добитися і від SVN, але для цього треба докласти чимало часу, а інколи і грошей.

P.S.
Знайшов гарну статтю про переваги Git над SVN: http://git.or.cz/gitwiki/GitSvnComparsion і навпаки.

ClearFont setup tool for WinXP

2009-03-22T21:52:00.004+02:00

Не великий секрет - я користуюся Windows XP і наразі для мене це найкраща ОС. А заради відчуття красивого вмикаю я згладжування шрифтів ClearType.
Ось тільки кілька місяців тому змушений був відмовитися, адже на новому моніторі це згладжування виглядало просто огидно. Але не так давно знайшов прикольну тулзу від майкрософта http://www.microsoft.com/typography/ClearTypePowerToy.mspx.
Після вельми простої конфігурації, я отримав хорошу якість згладжування шрифтів.

System.nanoTime() and measurements

2009-03-22T21:25:00.004+02:00

I'm still using simple System.currentTimeMillis() when need to test performance of some part of code. It's fast and easy to use, especially to profile some algorithm while coding; performance still is an important measure used to choose between few algorithms or choose the best way how to implement algorithm.
But for some algorithms, especially in development environment System.currentTimeMillis() doesn't give any valuable results as it's hard to choose between 0ms and 0ms returned for both algorithms :) System.nanoTime() can used in such situations. It helps to get precise measurement of code execution time.
But, everyone will say that it is not important what way of implementation you'll choose if difference is less than 1ms. It doesn't matter. And they will be right. In this case it doesn't matter what is faster, even if production amount of data is much more than testing amount of data and this may affect execution time significantly. Algorithm does matter.

It always depends on algorithm!

JBoss Richfaces Refcard is ready for free download

2009-03-14T08:21:00.014+02:00

DZone provides a list of free to download and use refcards for different technologies and tools (like IDE). Few days ago new refcard was release, and it's about JBoss Richfaces. You may download it here http://refcardz.dzone.com/refcardz/richfaces.

At page http://refcardz.dzone.com/ you may download more and more refcards for yourself. Some time ago I've downloaded for Eclipse, my favorite IDE IntellijIDEA, Spring, Groovy etc. And now downoloading JBoss Richfaces refcard too.

Presentations and articles about scalable software architecture

2009-03-04T21:37:00.006+02:00

Last week was searching for interesting articles and presentations with samples of scalable and failure tolerant architecture. As result, my bookmarks increased with a number of new links to articles and videos.

Articles:

Videos & presentations:

Cловники в предметній області

2009-03-04T21:04:00.006+02:00

Словники предметної області займають вельми важливе місце при проектуванні та розробці програмного забезпечення. Не менш частіше використовуються словники в предметній області. В даному випадку, словниками можуть виступати невеликі набори даних в стилі ключ-значення, або більш складні, де кожному ключу відповідає набір значень. Прикладів таких словників є безліч, наприклад, словник країн, словник типів кредитних карточок, словник пріоритетів задач, і більш складніші словники матеріалів та продукції (за окремими вийнятками) тощо.

Ця стаття розповідає про моє бачення такого "патерна" як Словник. Важливо визначитися, що саме слід вважати словником в предметній області.

Словник – це набір термінів пов’язаних між собою певною областю використання, які проте рідко змінюються. Частіше всього, словники використовуються, для того, щоб надати користувачам вибір значень з певної множити, наприклад, країну проживання, стать, посаду тощо.

Словники складаються з записів, які собою являють пару ключ-значення. В залежності від значення словники бувають простими та складними. Простий словник, це коли певному ключу відповідає одне значення, а складний словник – ключу відповідає набір значення. Наприклад, якщо коду країни відповідає тільки назва цієї країни, то цей словник є простим, де ключем виступає код країни. Прикладом складного словника є словник матеріалів, де коду товару відповідає його назва, вартість, країна виробник, маса тощо.

Складні словники можуть бути складеними. Складеним словником називається такий, в якого одне із значень є елементом іншого словниками. Наприклад, дано складний словник країн, в якому певному коду відповідають назва та код типу країни (республіка, федерація, королівство тощо). Код типу країни вказує на словник типів країн, таким чином словник країни можна вважати складеним та залежним від словника типів країн.

Рис 1 – Різні типи словників.

Словники часто використовують при розробці програмного забезпечення, адже дають можливість групувати набори даних в окремі групи, використовувати їх в групах та асоціювати певне значення з групою. В предметної області певний набір даних може бути словником, якщо він не виступає центральним в даній предметній області. Словники повинні залишатися максимально спрощеним та піддававтися мінімальним змінам в процесі використання, в той час як центральні сутності предметної можуть бути дуже складними та змінювати часто.

Чим складніший словник, тим більше програмний продукт залежить від нього. Словники можуть з часом переростати на повноцінні набори даних. При цьому збільшується або їх складності або кількість даних.

Зі словників часто починається проектування та кодування програм, вони є об’єктом перевикористання. Якщо використовувати необхідні словники спроектовані та закодовані на попередніх проектах, то можна скоротити час на написання нових проектів. Розроблений словник може виступати незалежним компонентом, але подібні компоненти буває тяжко спроектувати, адже вони вимагають гнучкості в роботі, а також тісної залежності від них іншого коду.

Існує кілька способів зберігання даних словників: набори констант, енумерації, файли, база даних тощо. Використання констант та енумерації для зберігання елементів словника пожуть значно покращити процес кодувати та збільшити читабельність коду, але при цьому частіше всього ми втрачаємо можливість швидкої зміни «захардкодженого» набору даних. Звичайно, словник статей, може бути спокійно закодований у вигляді енумерації, але словник країн ні. Те, що словники змінюються рідко не значить, що вони ніколи не міняються. В окремих випадках є необхідність добавити нові елементи або виконати користування існуючих, і в залежності від типу програми, найкращими будуть тут зберігання словників у файлах та базах даних.

Ще однією хорошою практикою є змістовні ключі словників. Простіше працювати та підтримувати в роботі словники, що містять ключі, які легко зрозуміти та отримати інформацію про сам елемент словника. Цього тяжко досягнути якщо використовувати числові ідентифікатори. Наприклад, для словника типів кредитних карточок ключі VISA, MSTR, AMEX тощо зручніше використовувати, ніж, наприклад, 1, 2, 3. У випадку використання бази даних для зберігання словників також простіше писати запити.
Оскільки словники містять невеликі набори даних і в основному рідко змінюються, то вони частіше легко піддаються кешуванню. Але тут слід не забувати, що словники теж можуть міняти, тому програма повинна підтримувати або можливість обновити дані в кеші або виконати інвалідацію кеша або ж увімкнути підтримку дати закінчення терміни дії кешу, після якого нові дані будуть знов закешовані.

Для зберігання та використання словників можна також використовувати і інші способи. Наприклад, якщо використовується MySQL, то для роботи із таблицями з словниками можна використвувати MyISAM engine, адже він найкраще підходить для даних, що рідко змінуюються, але частіше зчитуються. Таблиці із словниками частіше піддаються повному кешуванню СУБД, а використання сладених індексів на всі колонки БД може взагалі позбавити необхідность у фізичному вводі-виводі. Збереження словників у базі даних та використання зовнішніх ключів покращує цілісність даних, і знову ж таки, не сильно впливає на ресурси для виконання запитів.

Spring MVC and RESTful web service.

2009-02-12T01:08:00.022+02:00

This article is a result of my experience on building small RESTful web service using SpringMVC 2.5. Web service is simple, it supports only few operations, most of them just retrieves data and sends back it in XML.

Well, the task is simple enough:

build secured web service for mostly getting and sometimes posting data;
REST interface is required
- but SOAP could be added later (I think that if you build SOAP web service you should wait that you'll need to provide REST API for this web service too and vise versa).

As web service is build with REST philosophy, than we need to support processing of GET, POST (well, for me it's enough) requests and return data as XML or JSON. Spring MVC as well others REST web service frameworks and API help with this too. So, what's next?

As application is build with Spring 2.5, it was the best to have some framework for building REST web service easily and easily to integrate it with Spring. Not a secret, that Spring MVC integrates with Spring better that any other web framework or REST web service framework (hm, maybe it's because it is build on Spring). Well, this is cons for using Spring MVC and it is good, but truly - this not enough yet.

Yet one requirement: SOAP web service could be added later. And if it could be added than (in most cases) it will be added. This is important, very important, because we want to build easy-to-extend software. And in case of SOAP WS I prefer to use Spring WS, that is well integrated with Spring MVC. Need also to take into consideration that some REST web service frameworks hardly integrates with Spring MVC or wanted to process all requests. That is a great pros for using Spring MVC.

You may understand what I'm implying. Yes, Spring MVC will be used to build RESTful web service.

Architecture

The main goals of architecture are:

be scalable (not to much, but enough to process thousands of requests per hour)
be extendable (SOAP must be easy to add)
do what is required and nothing more

Next decisions were made:

request should be stateless
each request should be processed as quick as possible
there will be 2 levels of caching: one cache for entities and queries (used by web service backend service), and another cache for rendered XML response (used by web service endpoint).
everything that could be changed is configured through simple XML configuration (i.e. cache configuration, security configuration, business logic configuration etc.)

The main result of made decisions & rules is request processing lifecycle, that consists of next few phases:

Authentification & Authorization (security filter)
Getting request parameters. Web service endpoint (in our case it is SpringMVC controller) parses request parameters and validates them.
If everything is okay than it tries to get XML response from cache and sends it as response to the client. This step is optional and is processed only if cache is enabled and client does not specify request as such that ignores cache.
Endpoint determines the appropriate WebService backend service and run it and get results.
Endpoint converts results into XML, prepare response and stores it at cache (if cache is enabled). After the XML response is send back to client.

So, if the request response is cached in 2nd or 1st cache levels, than response will be generated without hitting database. In my development environment caching helps to increase performance up to 1500%. In production this number is less - just 300-500%. Still these is very well.

This lifecycle helps to build a scheme of responsibilities and modules. Later each responsibility could be processed by own server or a set of servers.

Simple implemenation

Spring 2.5 gave us possibility to use annotations as for declaring services as for declaring SpringMVC controllers. Spring's annotations Controller, RequestMapping, RequestParam and flexible politic on request handle method parameters gives us brilliant instrument for building web service endpoint.
Ofcourse, hardcoding of URLs in annotations looks as not the best way for building flexible and configurable application. But, this is quite pardonable, because we will use UrlRewriteFilter. UrlRewriteFilter is very useful tool, as it will helps to rewrite URLs, get parameters from URL and do other interesting things. But for our the most important are next 2 features:

flexibility while mapping external URLs (used by users) to internal URLS (processed by endpoint controllers)
possibility to catch parameters from URL, e.g. http://example.com/book/edit/12 ->
http://exampl.com/book/edit?boodId=12 etc.

Lets look how we could use this features:
Let we have RESTful web service that returns XML with information with specified by id book. Web service clients could get this information by requesting url
http://ourservice.com/ws/rest/book/{bookId} (e.g. http://ourservice.com/ws/rest/book/12). Our application should handle this call and the information about book wit specified id.

Here is our web service controller:


@Controller
public class WebServiceEndpoint {

     @Autowired
     private BookService bookService;

     @RequestMapping(value = "webservice/book", methods = RequestMethod.GET)
     public ModelAndView getBook(@RequestParam(name="bookID", required=true)int bookId, Map<String, Object> model) {
         model.put("book", bookService.getBookById(bookId));
         return new ModelAndView("template/ws/bookInfo", model);
     }
}

Code is very simple, but it's good as for sample.

So, we have controller that processes all GET requests for 'webservice/book' resource, that should have request parameter of type integer with name 'bookID'. Endpoint just call backend service, gets information about book, put it to model map and return the ModelAndView instance with simple template that will be rendered and returned to client.

This endpoint controller can't be default process web service request. To redirect web service client request to our endpoint we will use UrlRewriteFilter


     <rule>
        <from>^/ws/rest/book/[0-9]+$</from>
        <to>/webservice/book?bookID=$1</to>
     </rule>

so request for resource http://ourservice.com/ws/rest/book/12 will be rewrited by filter to http://ourservice.com/webservice/book?bookID=12.

That's about all for now. The story looks to long. Most of us do not have enough time to read long articles :)

Simple LRU cache implementation.

2009-01-17T23:17:00.006+02:00

By this url can be found post about using LinkedHashMap as LRU cache. Also, I've found such code with a direct link as comment in Apache Roller source code.
LinkedHashMap can be used as LRU cache because it supports ordering it's elements not only by insert order, but also by access-order. Also there is protected method removeEldestEntry in the LinkedHashMap that runs in the put() and putAll() methods. If that method returns true, than least recently inserted/accessed element will be removed.

You and your's sofware expansibility.

2009-01-14T10:49:00.010+02:00

For a long time one of the scores of software I'm writing is expansibility. That's mean how fast, with minimum of changes, I can add new features or extend existed one.
I've made few notes and use them as often as possible. Here are they:
- Never or almost never requirements you are working on are complete. Even if customer told you that this is finish step and we stop work on it - that mean only - we stop the work for now and we may continue it after some time. And of course, that time may vary from few weeks to few month, so you may and you will forget the code. That's why always write comments to the code even if it is not yours!
- If you can extend the code you've write before - do it! If you need to get the list of some entities - use search engine if it exists. If search engine is not enough - extend it and use it. Be DRY principal follower!
- Write your code with one think: I will use it tomorrow too! That's mean that you should write quality code, well commented code and code that make everything you have now and a little bit more. Sure, this "a little bit more" should be result of your experience. If you don't have enough experience - use this too! Why? You'll get need experience much faster!
- Do code review! Often. Why? Because it increases the quality of your code and as result of software. And also you'll find your and yours colleagues weak and that is 50% of new experience. I like Atlassian experience with code reviewing for many tasks they do.

Simple, but important.

Spring MVC + FreeMarker + Tiles 2

2009-01-08T23:41:00.013+02:00

This is extended and translated into English version of my post Spring MVC + FreeMarker + Tiles 2. I've found that many are interested about the joint work of those frameworks.
Well, this article shows how to configure the Spring MVC application with Tiles 2 and FreeMarker. You may don't use the SpringMVC framework, and in this case you need to make by your hands all the configuration work that Spring MVC does for you.
As you may know, Freemarker is popular template engine write on Java and used by mostly by Java applications. Tiles 2 is also Java frameworks used to prepare document using one or more "tiles" - the parts that are defined separately but used to be generated at one document. For example, using tiles you can define site header/footer, news or post blocks at your site etc.
So, how did I get it working?
Simple!

In file web.xml add the freemarker configuration.


<servlet>
        <servlet-name>pages</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>

 <servlet-mapping>
        <servlet-name>pages</servlet-name>
        <url-pattern>*.page</url-pattern>
 </servlet-mapping>

<servlet>
        <servlet-name>freemarker</servlet-name>
        <servlet-class>freemarker.ext.servlet.FreemarkerServlet</servlet-class>

        <init-param>
            <param-name>TemplatePath</param-name>
            <param-value>/</param-value>
        </init-param>
        <init-param>
            <param-name>NoCache</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-paramv
            <param-name>ContentType</param-name>
            <param-value>text/html</param-value>
        </init-param>

        ....

        <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
        <servlet-name>freemarker</servlet-name>
        <url-pattern>*.ftl</url-pattern>
</servlet-mapping>

And here is the important part *-servlet.xml configuration:


<!-- Tiles 2 configuration-->
<bean id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">
        <property name="definitions">
            <list>
                <!-- the tiles configuration files are declared here --> 
                <value>/WEB-INF/defs/general.xml</value>
                <value>/WEB-INF/defs/secure.xml</value>
            </list>
        </property>
</bean>

<bean id="tilesViewResolver" class="com.javaua.spring.integration.ext.ExtUrlBasedViewResolver">
    <property name="viewClass" value="com.javaua.spring.integration.ext.ExtTilesView"/>
    <property name="exposeSpringMacroModel" value="true"/>
</bean>

<bean id="viewResolver" class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
    <property name="cache" value="true"/>
    <property name="prefix" value=""/>
    <property name="suffix" value=".ftl"/>
    <!-- if you want to use the Spring FreeMarker macros, set this property to true -->
    <property name="exposeSpringMacroHelpers" value="true"/>
</bean>

<!-- Controller that returns view = /layout/header -->
<bean name="/layout/header.page" class="com.javaua.HeaderController"/>

Also show here the part of general.xml file where Tiles definitions are set up.:


<definition name="home" extends="default">
        <put-attribute name="title" value="Home Page"/>
        <put-attribute name="body" value="/templates/home.ftl"/>
</definition>
<definition name="default" template="/templates/main.ftl">
        <put-attribute name="header" value="/layout/header.page"/>
        <put-attribute name="footer" value="/templates/layout/footer.ftl"/>
</definition>
<definition name="/layout/header" template="/templates/layout/header.ftl"/>

Source code of com.javaua.spring.integration.ext.ExtUrlBasedViewResolver class:


import org.springframework.core.Ordered;
import org.springframework.web.servlet.View;
import org.springframework.web.servlet.view.AbstractUrlBasedView;
import org.springframework.web.servlet.view.UrlBasedViewResolver;

public class ExtUrlBasedViewResolver extends UrlBasedViewResolver implements Ordered {

    private boolean exposeSpringMacroModel = false;

    public void setExposeSpringMacroModel(boolean exposeSpringMacroModel) {
        this.exposeSpringMacroModel = exposeSpringMacroModel;
    }

    protected View loadView(String viewName, Locale locale) throws Exception {
        AbstractUrlBasedView view = buildView(viewName);
        View viewObj = (View) getApplicationContext().getAutowireCapableBeanFactory().initializeBean(view, viewName);

        if (viewObj instanceof ExtTilesView) {
            ExtTilesView tilesView = (ExtTilesView) viewObj;
            tilesView.setExposeSpringMacroModel(exposeSpringMacroModel);
        }

        return viewObj;
    }

Source code of com.javaua.spring.integration.ext.ExtTilesView class:


import org.springframework.web.servlet.view.tiles2.TilesView;
import org.springframework.web.servlet.view.AbstractTemplateView;
import org.springframework.web.servlet.support.RequestContext;

import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.ServletException;
import java.util.Map;


public class ExtTilesView extends TilesView {

    private boolean exposeSpringMacroModel = false;

    public void setExposeSpringMacroModel(boolean exposeSpringMacroModel) {
        this.exposeSpringMacroModel = exposeSpringMacroModel;
    }

    @SuppressWarnings("unchecked")
    protected final void renderMergedOutputModel(Map model, HttpServletRequest request,
                                                 HttpServletResponse response) throws Exception {

        if (exposeSpringMacroModel) {
            if (model.containsKey(AbstractTemplateView.SPRING_MACRO_REQUEST_CONTEXT_ATTRIBUTE)) {
                throw new ServletException(
                        "Cannot expose bind macro helper '" +
                        AbstractTemplateView.SPRING_MACRO_REQUEST_CONTEXT_ATTRIBUTE +
                        "' because of an existing model object of the same name");
            }
            model.put(AbstractTemplateView.SPRING_MACRO_REQUEST_CONTEXT_ATTRIBUTE,
                    new RequestContext(request, getServletContext(), model));
        }

        super.renderMergedOutputModel(model, request, response);
    }
}

Why we need those two classes? Simple enough. Class ExtTilesView exposes Spring macro model which is required when using standard macros used to support work with Freemarker and Velocity typelate frameworks. And the class ExtUrlBasedViewResolver helps us to prevent view-not-found-error. Because, standard UrlBasedViewResolver is used for getting tiles view, it will throw an error when view with specified name is not found. In my case, I have two view resolvers and each will throw an error if view can't be found.
And FreeMarkerViewResolver will request for the file, while tiles requests just for XML definition. That's why I've ran the tiles view resolver as first one.

GC and performance

2009-01-08T23:08:00.006+02:00

Мабуть, нікому не секрет, що GC є дуже важливою річчю в JVM, і що вона займається звільненням памяті, що вже не використовуються. Також багатьом відомо, що є кілька різних політик виконання очистки пам'яті. Конфігурація не виглядає надто складною, є всього кілька можливих варіантів вибору політики GC:

SerialGC - встановлена по дефолту, працює найкраще якщо на машині тільки один процесор, коли виконуєть збір сміття, то програма тормозить, адже в даний момент вона не відповідає.

ParallelGC - використовується можливість виконувати мінорний (minor) збір сміття в паралельних потоках. Програма здатна відповідати на запити клієнта в момент збору сміття

ParallelOldGC - виконує мажорний (major) збір сміття в паралельних потоках

ConcMarkSweepGC - В даному випадку постійно відбувається збір сміття, програма не тормозить при зборах сміття, як це можна замітити в 3 попередніх випадках.

Таким чином, я вирішив переконфігурувати для прикладу IntellijIdea, що я використовую.


-Xms256m
-Xmx512m
-XX:MaxPermSize=120m
-XX:+UseConcMarkSweepGC
-ea
-Dawt.useSystemAAFontSettings=lcd

Для покращення швидкодії роботи, можна також установити значення ms = mx, так щоб


-Xms512m
-Xmx512m
-XX:MaxPermSize=120m
-XX:+UseConcMarkSweepGC
-ea
-Dawt.useSystemAAFontSettings=lcd

Ресурси

Java SE 6 HotSpot[tm] Virtual Machine Garbage Collection Tuning - із серії must-read

Java HotSpot VM Options - якось давно шукав подібну документацію, тепер повезло більше - знашов.

Tuning Garbage Collection Outline - цікава підбірка фактів про GC

Java Enums та перевизначення методів

2008-12-25T17:32:00.005+02:00

Читаючи книгу Programming Groovy, я дізнався про можливість перевизначати методи в enums. Про це навіть не здогадувався раніше, і це мене справді здивувало.
І справді, нехай у нас є enum в якому вказані дні в тижні:


enum DAYS {
  MON, TUE,
  WED, THU, 
  FRI, SAT, 
  SUN;

  public String is() {
     return "working";
  }
}

Що ж, MON.is().equals("working") має бути істинним; але подібне тяжко сказати, наприклад, для SUN.is().equals("working").
Звичайно тепер ми можемо визначити enum наступним чином:


enum DAYS {
  MON, TUE,
  WED, THU, 
  FRI, 
  SAT {
     public String is() {
        return "week-end, day 1";
     }
  },
  SUN {
     public String is() {
        return "week-end, day 2";
     }
  };

  public String is() {
     return "working";
  }
}

І все, тепер SUN.is().equals("week-end, day 2") == true.
Проблема вирішена, при чому, без збереження зайвого поля - вказівника на рядок.

Mac OS X

2008-12-15T03:18:00.004+02:00

Yesterday I have been fully moved to the Mac OS X. Spent all day for finding and installing software. I little bit sad, because can't find java 1.6 and 32 bit version.

I was thinking about changing used OS from Windows to Mac OS X or to Linux (Ubuntu) a very long time already. But just now found free day to move.
Still, If I'll not find the solution with java update and sound bad work then I'll become Linux (Ubuntu) user.

Google App Engine & Java

2008-10-27T23:27:00.002+02:00

Google нарешті таки вирішив, що наступна версія App Engine буде підтримувати Java. З самого початку пора. А ще би було добре позбутися декотрих дивних обмежень, як от, тривалість запиту, маскимальний розмір файлу тощо.

SoftReference & WeakReference: time of life

2008-10-27T22:20:00.012+02:00

Well, I found some free time to write few articles. This one is about the SoftReference class from Java library.
SoftReference will help you to get the best variant between using memory and performance. Soft reference means that the value wrapped in soft reference will be garbage collected only and only if there are no free memory.
More about this. First I set -verbose:gc parameter for Java machine. If this parameter is set than GC logs will be output to the console. Also was set parameter -Xmx32m. The simple code:


void test() {
    Reference<List> listRef = new SoftReference<List>(
               Arrays.asList("1", "2", "3", "4", "5"));

    List list = new LinkedList();
    for (int i = 1; i <= 5; i++) {
       list.add(new Object());

       if (i == 5) {
           if (listRef.get() == null) {
                break;
           }
           i = 1;
       }
    }
}

Here the soft reference to the long string was created. The loop adds the references to the object to the linked list. Sometimes it checks whether the soft reference to the list of strings is not gc'ed; if it is than loop is breaked. Here is the output of GC:


[GC 896K->708K(5056K), 0.0059887 secs]
[GC 1604K->1603K(5056K), 0.0064902 secs]
[GC 2499K->2498K(5056K), 0.0064698 secs]
[GC 3394K->3393K(5056K), 0.0062198 secs]
[GC 4289K->4287K(5184K), 0.0061248 secs]
[Full GC 4287K->4287K(5184K), 0.0378679 secs]
[GC 5120K->5119K(8000K), 0.0141557 secs]
[GC 6015K->6014K(8000K), 0.0069241 secs]
[GC 6910K->6908K(8000K), 0.0064464 secs]
[GC 7804K->7804K(8768K), 0.0061396 secs]
[Full GC 7804K->7804K(8768K), 0.0595140 secs]

We may see that more than one Full GC were run before the soft reference was cleaned up.
The same test for the WeakReference (change new SoftReference(...) into new WeakReference(...)) prints next output:


[GC 896K->707K(5056K), 0.0063061 secs]

So, weak reference is cleaned up after the next first GC runs.
These tests were made on Java 1.6.0_10.
The outputs for Java 1.5.0_07 are respectively


[GC 512K->387K(1984K), 0.0047419 secs]
[GC 899K->898K(1984K), 0.0046456 secs]
[GC 1410K->1409K(1984K), 0.0048894 secs]
[GC 1921K->1920K(2496K), 0.0046743 secs]
[Full GC 1920K->1920K(2496K), 0.0203305 secs]
[GC 2431K->2430K(3776K), 0.0103943 secs]
[GC 2942K->2941K(3776K), 0.0048556 secs]
[GC 3453K->3452K(4032K), 0.0047855 secs]
[Full GC 3452K->3452K(4032K), 0.0340532 secs]
[GC 3964K->3963K(6332K), 0.0044411 secs]
[GC 4475K->4474K(6332K), 0.0049126 secs]
[GC 4986K->4985K(6332K), 0.0046232 secs]
[GC 5497K->5496K(6332K), 0.0045682 secs]
[GC 6008K->6007K(6588K), 0.0047892 secs]
[Full GC 6007K->6007K(6588K), 0.0523812 secs]
[GC 6775K->6774K(10848K), 0.0061404 secs]
[GC 7542K->7540K(10848K), 0.0065743 secs]
[GC 8308K->8307K(10848K), 0.0067296 secs]
[GC 9075K->9074K(10848K), 0.0066386 secs]
[GC 9842K->9841K(10848K), 0.0066439 secs]
[GC 10609K->10608K(11488K), 0.0066955 secs]
[Full GC 10608K->10606K(11488K), 0.1112694 secs]

and


[GC 512K->387K(1984K), 0.0049869 secs]

Since, these results show that Java 6 works with memory better than Java 5 and cleans up the soft reference faster than it is in Java 5.

Spring MVC + FreeMarker + Tiles 2

2008-10-27T21:16:00.010+02:00

Може комусь і знадобиться ще. Тут описується як прикрутити Spring MVC та FreeMarker та Tiles 2 так, щоб вони жили та працювали разом.
Задача: Tiles2 повинен організовувати шаблони створені на основі FreeMarker (хоча можна і не тільки FreeMarker, можна поєднувати). Для того, щоб досягнути це необхідно виконати декотру конфігурацію. У файлі web.xml


<servlet>
        <servlet-name>pages</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
</servlet>

 <servlet-mapping>
        <servlet-name>pages</servlet-name>
        <url-pattern>*.page</url-pattern>
 </servlet-mapping>

<servlet>
        <servlet-name>freemarker</servlet-name>
        <servlet-class>freemarker.ext.servlet.FreemarkerServlet</servlet-class>

        <init-param>
            <param-name>TemplatePath</param-name>
            <param-value>/</param-value>
        </init-param>
        <init-param>
            <param-name>NoCache</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-paramv
            <param-name>ContentType</param-name>
            <param-value>text/html</param-value>
        </init-param>

        ....

        <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
        <servlet-name>freemarker</servlet-name>
        <url-pattern>*.ftl</url-pattern>
</servlet-mapping>

А тепер конфігурація pages-servlet.xml:


<!-- Конфігурація Tiles -->
<bean id="tilesConfigurer" class="org.springframework.web.servlet.view.tiles2.TilesConfigurer">
        <property name="definitions">
            <list>
                <value>/WEB-INF/defs/general.xml</value>
                <value>/WEB-INF/defs/secure.xml</value>
            </list>
        </property>
</bean>

<bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.tiles2.TilesView"/>
</bean>

<!-- Контролер повертає view = /layout/header -->
<bean name="/layout/header.page" class="au.com.at2.web.spring.HeaderController"/>

Частина файла general.xml, в якому описуються оголошення Tiles:


<definition name="home" extends="default">
        <put-attribute name="title" value="Home Page"/>
        <put-attribute name="body" value="/templates/home.ftl"/>
</definition>
<definition name="default" template="/templates/main.ftl">
        <put-attribute name="header" value="/layout/header.page"/>
        <put-attribute name="footer" value="/templates/layout/footer.ftl"/>
</definition>
<definition name="/layout/header" template="/templates/layout/header.ftl"/>

Невеличке пояснення:
Спочатку добавив новий сервлет для FreeMarker'а. Всі шаблони в мене наразі стоять в каталозі templates, в той час, як TemplatePath для FreeMarker'а - це /. Я це зробив собі на майбутнє - для добавлення нових каталогів крім templates, - адже аплікація має розширюватися (вони завжди розширюються).
В pages-servlet.xml добавив bean tilesConfigurer, який будує конфігурацію для Tiles. Оголошення же знаходяться у файлах /WEB-INF/defs/general.xml, /WEB-INF/defs/secure.xml. При конфігурації інформація із них мерджеться, отже, оголошення default є доступним і в межах secure.xml.


<put-attribute name="header" value="/layout/header.page"/>

Цей кусок значить - можна використовувати як тайл і сторінку, що обробляється DispatcherServlet, таким чинном, ми можемо мати окремі контролери для окреми тайлів. І це правильно. Без цього би було туго. Контролер au.com.at2.web.spring.HeaderController повертає view /layout/header, який оголошений як definition в general.xml.

RichFaces + JSF RI + JBossPortletBridge + Liferay Portal on JBoss AS 4.2.x

2008-10-08T02:10:00.011+03:00

The task to make few portlets for Liferay 5.1 Portal using RichFaces + JSF RI looks trivial. But it isn't.
There are few decisions:

Use Liferay listener for Sun JSF with Sun's FacesPortlet.
Use JBossPortletBridge, because it supports RichFaces and AJAX.

I choosed the second with understanding that JBossPortletBridge is in beta and everywhere says that it supports JBossPortal, but I did not find where says - "It supports Liferay too". It does not support Liferay Portal 5.0.
I found few interesting things, that anyone should know before starting write portlets with RichFaces for Liferay using JBossPortletBridge 1.0.x Beta:

RichFaces should be at least 3.2.1.
You should configure portlet as ajaxable with server side state saving policy
Override the javax.portlet.faces.GenericFacesPortlet given with JBossPortletBridge. You'll need manually setup the request attribute javax.servlet.include.path_info with correct viewId you want to process and render. Or you can setup this request attribute at the PortletExternalContextImpl class in calculateServletPath() method (remember JBossPortletBridge 1.0.x Beta).
Use <a4j:commandXXX/> components to process navigation. <h:commandXXX/> will not help ((.

Good luck!

Update:
My friend Andriy has described the solution with details and configuration samples, and you can find his post by the url http://www.liferay.com/web/guest/community/forums/-/message_boards/message/1712557. It really can be useful for you.

I've uploaded the portlet sample prototype, so it's ready and waits for you :)
http://www.esnips.com/doc/de8b5661-fb6d-4fc7-83a3-ed09aa72c695/PortletPrototype

Java 7

2008-10-03T12:49:00.011+03:00

Java 7 в процесі написання. Цікаво знати які саме зміни мають попасти в реліз Java7. Тут можна знайти, що саме планувалося в реліз Java 7 , а ось тут - статус нових фіч станом на початок серпня.

Нажаль, closures - далекі від готовності, і зважаючи, що Ніл Гафтер покинув Google і перейшов працювати в Microsoft, є ризик, що closures не увійдуть до Java7. Проте є всі шанси, що switch для рядків, порівняння enum'ів попадуть в реліз. Але от підтримка операторів +, -, *, /, % для BigDecimal - ще далекі від кінця. Хоча це мені видається не менш важливим, ніж інші нововедення.

Для тих, хто не раз відчував дискомфорт при роботі із generics в Java - слід звернути увагу на type literals і type inference.

Invokedynamic - потрібний для підтримки динамічних мов.

String.length(): підводні камні

2008-09-26T01:24:00.006+03:00

Як виявилося, не завжди length() повертає дійсну кількість символів у рядку. В класі String чимало підводних камнів та різної недокінця вірної поведінки. Одна із них стосується того, як правильно рахувати кількість символів у рядку.
Тут більше про це...

How to throw unexpected checked exceptions

2008-08-25T10:07:00.003+03:00

Today I found that it is possible to throw checked exceptions even if they are not declared in throws section.
What did we do when we have need to throw some checked exception? We do:


public void doSomething() throws CannotDoSomethingException {
    throw new CannotDoSomethingException();
}

where


public class CannotDoSomethingException extends Exception {
...
}

But we can to throw the checked exception without declaring it at throws section:


public void doSomething() {
    Thread.currenThread().stop(new CannotDoSomethingException());
}

I think that this is veeeery bad code

java.lang.String.concat()

2008-08-06T00:20:00.004+03:00

Світ класу java.lang.String є чималим. Багато речей заховано глибоко і далеко, чимало просто плавають на верху, але ми їх не завжди бачимо.

Так, наприклад, метод concat() приймає рядок і повертає рядок, який є конкатенацією даного рядка і переданого у вигляді параметра. Рядок-параметр добавляється в кінець даного рядка. Існує, щоправда, виключення, а саме: якщо рядок-параметр є пустим (себто, ""), то тоді метод concat() повертає дану стрічку. В даному випадку економиться час на виконання операції конкатенації для двух рядків. Це є перша відмінність від використання оператора конкатенації рядків "+".

Іншою різницею є те, що якщо рядок-параметр є null, то тоді java.lang.NullPointerException виникає. У випадку ж з "+", null буде замінено на рядок "null", оскільки, String.valueOf(null) повертає "null".

Assertions

2008-08-05T23:34:00.013+03:00

Well, one of the most usable feature of safe codding is assertions.
Assertions help to prevent executing code with usafe or unchecked data, for example, with null or wrong parameters, empty strings, too long strings, empty arrays or lists can be unforeseen arguments and must be checked before using.

You may remember the asserts from JUnit. Remember:


assertNotFalse(a > 5, "a cannot be equal or less then 5");

Well, in Apache Commons Lang library you may use the org.apache.commons.lang.Validate class to validate arguments or state in your code. You may use it next:


void saveEntity(Entity entity) {
    Validate.notNull(entity);
}

Then, if entity value is then java.lang.IllegalArgumentException is thrown. In other case next code is executed.

There is also overloaded version of such assert methods in Validate class or in JUnit, that helps to describe the assertion:


void saveEntity(Entity entity) {
    Validate.notNull(entity, "Entity cannot be null.");
}

I am the fun of the overloaded version of assert methods. Truly say, I think that only version with string description of assertion has right to live. That helps developers to find the source of problem quickly and also it may be used to process the errors.
The other point is to have assert-liked-validation also for state, that will throw the java.lang.IllegalStateException. This type of assertion should used for checking the result of calculation or processing, but not for arguments. So we could have something like:


void saveEntity(Entity entity) {
     ArgumentAssert.isNotNull(entity, "Entity cannot be null.");

     // create or update the entity,
     // then returns entity id, that must be not null value if everything is OK
     Integer entityId = dao.save(entity); 

     StateAssert.isNotNull(entityId, "Entity is not saved, because entity id is null.");
}

The code is not the best, but this shows how StateAssert should be used.

So, if the entityId is null, then StateAssert.isNotNull() method throws IllegalStateException. Before that, ArgumentAssert.isNotNull() method checks whether entity is not null and throws IllegalArgumentException if it is.

And every assert methods, should check whether assertions are enabled, for example, by using system properties.

And what about assert statement in Java?
It should be used, but one type of assertions support must be choosed.

Build Flex with ANT

2008-07-28T13:12:00.017+03:00

Ця стаття про виконання білда простої Flex аплікації із використанням ANT.

Мабуть, для того щоб виконати білд простої Flex аплікації слід знати тільки два тарґети:

mxmlc - білд mxml у swf файл.

html-wrapper - побудова hmtl файлів обгорток для результуючого swf файла.

Нехай, FLEX_HOME - вказує на шлях, де знаходиться на диску сам Flex, тоді, можна підключити в ANT скріпті


<taskdef resource="flexTasks.tasks" classpath="${FLEX_HOME}/ant/lib/flexTasks.jar"/>

Тоді, для того, щоб збілдити swf'ку слід виконати наступний антівський скрипт:


 <mxmlc file="${flexApps.basedir}/src/EventsView.mxml"
           context-root="/WebAppContext"
           keep-generated-actionscript="true"
           services="${webapp.basedir}/WebContent/WEB-INF/flex/services-config.xml"
           output="${flexApps.output.dir}/EventsView.swf">
       <compiler.library-path dir="${FLEX_HOME}/frameworks" append="true">
            <include name="${ipcom.basedir}/WebContent/WEB-INF/lib/"/>
       </compiler.library-path>
       <load-config filename="${FLEX_HOME}/frameworks/flex-config.xml"/>
       <source-path path-element="${FLEX_HOME}/frameworks"/>
 </mxmlc>

Отже, що собою являють атрибути:

file - файл mxml, який представляє собою флекс-аплікацію

context-root - назва контексту веб-аплікації, яка використовуватиметься для загрузки флек-аплікаціїю

services - файл із описаними сервісами.

output - шлях і назва результуючого файла.

А щоб згенерити обгортки:


<html-wrapper file="EventsView.html"
                 history="true"
                 template="express-installation"
                 application="EventsView"
                 title="Flex Events Viewer"
                 width="600" height="400"                
                 output="${flexApps.output.dir}"
                 swf="EventsView"/>

Функціональне програмування

2008-07-26T22:52:00.011+03:00

Мабуть важко не замітити, якої потуги набирає функціональне програмування останнім часом. І тому є декілька поважних причин, а саме:

використання функціональних мов програмування для написання програм, що використовують конкурентність; іншими словами фукнціональні мови програмування дозволяють писати програми, що можуть працювати і використовувати всі можливості сьогоднішніх багатоядерних процесорів;

гнучкісь функціональних мов програмування просто вражає;

написання програм за допомогою функціональних мов є досить нескладним, адже вони беруть основу з математичного визначення функції;

декотрі функціональні мови програмування (наприклад, Scala) дозволяє використовувати аспекти об'єктно-орієнтованого програмування.

Доречі, від Apache Commons є бібліотека Functor, яка дозволяє використати деякі елементи функціонального програмування в Java. Нажаль, бібліотека ще не в релізі, але будемо надіятися це не надовго. Ця бібліотека дозволить використати такі корисні речі як 1) функції вищого порядку, 2) фільтри, 3) callback функції тощо.

Більш детальнішу інформацію можна знайти там:

Functional programming in the Java language

Functional programming

Functional Programming in the Real World

Правила "Не забудь!"

2008-06-26T19:02:00.009+03:00

при добавленні нових полів до класу звернути увагу на методи hashCode(), equals() та compareTo(), - може слід добавити і туди обробку нового поля

при добавленні поля типу колекції, - надати їй початкове значення

перечитати той код, що ти написав

протестувати те, що ти закодував чи перекодував

може це можна було зробити по інакшому? якщо так, то як? а чим воно краще?

Java call stack for simple web application

2008-06-23T03:49:00.003+03:00

Interesting to see the call stack of simple action on web application written on Java, isn't it?
I found the blog story with picture of call stack from HTTP to JDBC. Here it is..

It is beautiful. A long path and only two calls to the application business and DAO methods. Comments are very interesting too.
They are from PHP developers, from administrators etc.

Зміни в блозі

2008-06-22T22:07:00.003+03:00

В результаті вивчення суті блогів, статистики блогу та власних побажань, я міняю суть даного блога із суто джавового на суто компютерний із основною орієнтацією на джаву.

Також частина блогів буде на англійській мові. Для чого це потрібно? Мабуть, для того, щоб потренуватися писати статті на англійській мові. Знадобиться ))

BlazeDS: фільтрування повідомлень, що передаються клієнтові

2008-06-20T19:49:00.018+03:00

Останні два тижні знашовся час трохи побавитися із Flex та BlazeDS. Основна задача - знайти способи передачі повідомлень від сервера до клієнта, так, щоб клієнт отримував тільки повідомлення, на які він підписався.
Задача - розглянути можливі варіанти. Можливі варіанти були вибрані, а саме:

Subtopics

Selectors

Adaptive polling

Dynamic destinations

Може є більше, але це ті, до яких я добрався і з якими я погрався.

Взагалі то, subtopics та selectors можна би було об'єднати, от тільки між ними є невеличка різниця. Використовуючи selectors, можна задати більш гнучку умову вибору повідомлень, які повинень отримувати consumer. Але зрешту, є така річ як MultiTopicsConsumer. Перевірка на те, чи слід віправляти повідомленння клієнту в залежності від підписки на сабтопік чи вибірку по хедерах, виконується на стороні сервера. Іншими словами, до клієнта приходять тільки окремі повідомлення із тих, що вислані на підписаний ним destination. Клієнт отримує повідомлення, що задовільняють необхідну умову.

Adaptive polling дозволяє розширювати функціональність BlazeDS, що відповідає за відправлення повідомлення клієнтові. Тут також слід правильно вибрати, який саме із двох презавантажених методів використовувати у вашому випадку.
Цей метод, дозволяє виконувати необхідну вам дію на повідомленнями, що передаються клієнтові. Тут ми і можемо виконувати гнучку і складну вибірку повідомлень, що ми будемо відправляти клієнтові.

За останнім способом (dynamic destinations) я виконував динамічне створення окремого destination на ту чи іншу розсилку в процесі роботи сервера. А клієнти вже підписувалися на динамічну розсилку. Явні мінуси: це ресурси на створення нової підписки (які не є вже аж такими великими, щоб вважати це проблемою), а також необхідність відстежувати життя підписки та знищувати її якщо вона вже непотрібна.

Новини: 07 червня

2008-06-08T02:28:00.004+03:00

В реліз вийшла нова версія Spring Security під номером 2.0.2. Детальніше...

OutOfMemoryError: PermGen

2008-06-02T22:31:00.026+03:00

Десь кілька місяців тому виявилося, що в проекті, над яким я працюю, знайшлася потворна бага. Відловити її було неможливо. В будь-який момент працювати з програмою ставало неможливо. В логах вивалювалася помилка OutOfMemoryError: PermGen.

Звичайно, я з цим не вперший раз стикаюся, і вирішив спробувати старий добрий спосіб - прописати параметр до Джава машини -XX:MaxPermSize. Отже, прописавши параметр -XX:MaxPerSize=256m, я запустив JBoss. І що? А нічого. Все одно програма вивалювалася... Так само непердбачувано і неочікувано :(.

Тоді я вирішив спробувати ще раз, але цього разу збільшив память для PermGen space вдвічі: -XX:MaxPerSize=512m. Особливо це мені не допомогло, добитися впевнених 24/7 так і невийшло. І було вирішено, що слід ритися вглубь, не виправляти проблему, а викорінити причину!
Порившись в інтернеті я надибав блог by Frank Kieviet, в якому розповідалося про використання утиліт для Java 6: jmap та jhat.

jmap - дозволяє створювати дампи пам'яті Java програми.
jhat - дозволяє представити інформацію дампа у зручному для користувача вигляді.

Отож, використовуючи jmap я зробив дамп heap пам'яті запущеної програми в процесі її роботи. Я виконав команду

>jmap -dump:format=b,file=dump1 3412

цим самим вказавши, що слід виконати дамп пам'яті програми, зберегти її в бінарному форматі у файлі dump1. 3412 - це pid Java програми, дамп пам'яті якої я робив. Для того, щоб отримати ідентифікатор процесу, у Windows введіть команду tasklist і знайдіть відповідний java.exe процес.

Після того, як в мене вже був збережений у файлі дамп, я скористався програмою jhat. Команда:

>jhat dump1

проаналізувала дамп і запустила веб-сервер, який по-замовчуванню слухає запити на порті 7000. Якщо потрібно буде одночасно запустити декілька jhat, то знайте - адрес порта можна змінити відповідним параметром. Слід також звернути увагу на параметр -J. Всі параметри, які задаються після -J потрапляються напряму до Java машини. В моєму випадку це знадобилося для того, щоб збільшити максимальну межу пам'яті, яку можна виділити. У випадку програми, яка працювала під JBoss AS 4.0.4, я змушений був запускати jhat компандою
>jhat -J-Xmx1536m dump

Після старту jhat, можна спокійно відкривати ваш олюблений броузер, і вводити адрес http://localhost:7000/. Тепер можна переглядати дамп пам'яті програми, використовуючи набір функціоналу, який надається програмою.

Скориставшися цією програмою, я визначив причину моєї проблеми – не всі динамічно генеровані класи вигружалися; декотрі з них так і залишалися назавжди в пам'яті. Оскільки, PermGen Space (Permananent Generated Space) - це простір в пам'яті, в якому знаходяться довгоживучі (або вічноживучі в межах запущеної java-машини) об'єкти, а серед таких є класи та 'interned strings', то зрозуміло, що суть моєї проблеми в тому, що декотрі динамічно генеровані класи продовжували генеруватися, завантажуватися в пам'ять, але навідмінно від інших, вони залишалися там навічно. Рано чи пізно вільна пам'ять завершувалася, і програма уходила в аут із знойним повідомленням "OutOfMemoryError: PermGen".

Але лікування цієї проблеми це вже зовсім інша історія... І наразі вона ще не закінчилася :(.

Реліз Spring WebFlow 2.0

2008-05-17T01:11:00.008+03:00

15 травня, Spring Framework анонсувала вихід в реліз WebFlow версії 2.0. Серед проголошених основних фіч - це "першокласна" підтримка Java Server Faces (Spring Faces), AJAX (Spring JavaScript).

Spring WebFlow використовується як доповнення до вже існуючих веб-фреймворків (наприклад, Spring MVC, JSF).
Даний фреймворк дозволяє представити веб аплікацію у вигляді flow'ів, кожен з яких містить набір станів та переходів між станами. Кожний такий flow можна уявити собі вигляді діаграми станів UML. Практично, діаграма станів використовується для того, щоб графічно змоделювати або показати набір станів в межах flow. Це є прекрасний спосіб вирішення навігації та роботи із станами в межах веб аплікації.

"Implementation Patterns" by Kent Beck

2008-05-15T22:53:00.037+03:00

В дорозі до Львову і назад я все-таки знайшов час, щоб дочитати до кінця книгу Кента Бека (Kent Beck) "Implementation Patterns". Дана книжка є таким собі збірником паттернів по написанню коду. В дечому вона перехрещується із всім відомою книгою "Code Complete". Книга орієнтована на Java програмістів; приклади в книзі приводяться на Java, розглядається навіть Collection API, виникає навіть деколи відчуття, що декотрі шаблони підточені під Java.

Взагалі, книжка має досить просту і зручну структуру. Ця стуктура позволяє вам перечитати книжку від корочки до корочки, а також користуватися як каталогом шаблонів.

В ній можна знайти такі розділи:

Theory of Programming розказує про основні цінності та принципи створюваних програм. Виділяється 3 цінності ПЗ, що слід досягати – це взаємодія, простота та розширюваність.

Class - біля 17 шаблонів (типів) класів, що зустрічатимуться програмісту при розробці програм. Цей розділ описує, які класи можуть бути, як слід виділяти та створювати класи та інтерфейси.

State. Такі шаблони, як Direct Access, Indirect Access, Variable, Field, Var Args, Parameter та ще коло 20 патернів. Ці шаблони описують стан (дані) класу, як правильно організовувати стан, як правильно оформлювати доступ, ініціалізацію тощо.

Behavior. Ще 14 шаблонів повязаних із поведінкою. У доповненні до опису шаблонів пов'язаних із станом класів, подаються також шаблони поведінки, роботи із даними. Розглядаються потоки виконання програм і шаблони повідомлень, якими обмінюються класи.

Methods. Ну і як без методів. Цій частині виділяється окремий розділ, який описує такі шаблони, як Factory Method, Helper Method, Query Method, Method Object, Creation, Composed Method etc. Я в свою чергу звернув увагу, на Method Object: перечитуючи його, я згадував усі ті рази коли він міг мені знадобитися.

Collections. Автор звертає нашу увагу на бібліотеку колекцій, що існує в Java SE. Доречі, мене зацікавили графіки-порівняння залежності часу виконання операцій від кількості елементів для різних реалізацій контейнерів.

Evolving Frameworks. Окремий розділ, присвячений фреймоворкам.

Книжка має всього 176 сторінок та опис понад 100 різних шаблонів. В цілому, книга дуже цікава! Підхід автора до постановки проблеми та висвітлення рішення мені особисто сподобався. Не буду казати, що ця книга must read, але якщо прочитаєте, то і самі все зрозумієте ;).

Spring 2.5: використання аннотацій

2008-04-26T22:21:00.036+03:00

Про те, що вийшов Spring Framework (www.springframework.org) версії 2.5, я знав вже давно (відносно давно звичайно). Читав про нові можливості даної версії, пробував навіть щось трохи. Але то все було просто так, для себе. Недавно появилася можливість побавитися із Spring 2.5 більш глибше. І я з радістю нею скористався.
Основним моментом, який був для мене цікавим - це використання анотацій у доповнення до XML конфігурації. Саме про це я вирішив трохи написати.

Головним питанням було -- навіщо анотації?
Іншими цікавими питаннями були:

які анотації можна використовувати?
як їх використовувати?
чи можливо працювати і дальше без них?
як можна включати і виключати використання анотацій?

і багато ще інших питань, які виникали по ходу справи.

Отож, про все по порядку.
Анотації не підтримуються по замовчуванню. Для того, щоб їх використовувати, потрібно вказати Spring, що ви хочете працювати і з ними тоже. Для цьому слід добавити у ваш spring.xml наступний рядок:


<context:annotation-config/>.

Namespace context підключається так


xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation=" http://www.springframework.org/schema/context
               http://www.springframework.org/schema/context/spring-context-2.5.xsd"

Після цього, в нас появляється можливість використовувати анотації.
А тепер детальніше про самі анотанції. Так ми вже можемо використовувати їх, але які вони є, навіщо вони використовуються?
Найбільш поширеною видається анотації @Autowired. Дана анотація, вказує що в контейнер Spring повинен виконати автоматичне встановлення значення. Дану анотацію можна використовувати для автоматичного встановлення значення в конструкторі, для поля класу, для сеттера. Наприклад:


public class DocumentManager {
   @Autowired
   private DocumentFinder documentFinder;
   private DocumentDao documentDao;
   private Document documentPrototype;

   @Autowired
   public DocumentManager(DocumentDao documentDao) {
       this.documentDao = documentDao;
   }

   @Autowired
   public void setPrototype(Document document) {
       documentPrototype = prototype;
   }
}

В даному випадку автозаповнення за допомогою анотації @Autowired, Spring буде виконувати на основі типів полів чи аргументів. Але виникає проблема, коли, наприклад, у вас може бути більше одного біна із типом DocumentFinder або Document. Що робити тоді, як Spring має знати яке саме значення слід вставити в певне поле? І саме тут вступає у гру анотація @Qualifier.
Анотація @Qualifier дозволяє вказати, який саме container-managed bean використовувати як значення для заповнення. Дану анотацію можна використовувати як для полів класу, так і для параметрів конструктора або інших методів, так само і для сеттерів. Назва біна, який повинен бути вставленим як значення поля чи параметра вказується як value анотації @Qualifier. Доволі просто і зручно, самі подивіться на код:


public class DocumentManager {

   @Autowired
   @Qualifier("defaultDocumentFinder")
   private DocumentFinder documentFinder;

   private DocumentDao documentDao;

   private Document documentPrototype;

   @Autowired
   public DocumentManager(@Qualifier("hibernateDocumentDao")DocumentDao documentDao) {
      this.documentDao = documentDao;
   }

   @Autowired
   public void setPrototype(@Qualifier("prototypeDocument")Document document) {
      documentPrototype = prototype;
   }
}

Доречі, Spring дозволяє за допомогою XML вказати явно, який qualifier у певного bean. Для цього використовується піделемент <qualifier> елемента <bean>. Він має такі атрибути, як:
- type - тип анотації, що використовується (про це пізніше)
- value - це значення унікальне для даного біна.

Наприклад, якщо в коді вказано:

  
@Autowired
@Qualifier("prototypeDocument")
public void setPrototype(Document document) {
   documentPrototype = prototype;
}

, то в XML


<bean class="Document">
  <qualifier value="prototypeDocument"/>
</bean>

<bean class="Document">
  <qualifier value="privateDocument"/>
</bean>

І як ви вже певно зрозуміли, при автозаповнення буде використаний перший bean, тому що його qualifier value є prototypeDocument.

Але це ще не всі можливості, які надає Spring у питанні вирішення, який саме bean повинен бути використаний для автозаповнення. Так, наприклад, ви можете створювати власні анотації, які використовувати замість @Qualifier.
Наприклад:


@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface DocumentFinder {
  String documentType();
  String finderScope();
}

тоді


@Autowired
@DocumentFinder(documentType="MSWord", finderScope="local")
private DocumentFinder documentFinder;

а в XML


<bean class="DocumentFinder">
   <qualifier type="annotation.DocumentFinder">
      <attribute name="documentType" value="MSWord"/>
      <attribute name="finderScope" value="local"/>
   </qualifier>
</bean>

І це ще навіть не всі можливості...
Так, наприклад, я не розказав про @Resource. А також і не згадав досі про можливість використання компонентів, які оголошенні за допомогою анотацій.

Але про це все або читайте в туторіалі від Spring або вже у наступній статті.

Кешування другого рівня в Hibernate.

2007-12-16T19:04:00.001+02:00

Частина II: Бібліотеки кешування для Hibernate

Кеш другого рівня в Hibernate може бути підключеним і може бути в межах процесу або кластера. Можуть бути різні реалізації кешу другого рівня, існують кілька вже готових реалізацій на основі готових движків кешування. Але можна реалізувати власний движок і підключити його за допомогою реалізації інтерфейсу org.hibernate.cache.CacheProvider.

Визначають наступні провайдери кешу другого рівня

- EHCache. Підтримка кешування другого рівня в межах одного процесу однієї віртуальної машини. Може виконувати зберігання кешу як в оперативній памяті, так і на диск. Підтримує кешування запитів.

- OSCache (OpenSymphony Cache). Підтримка кешування другого рівня в межах одного процесу однієї віртуальної машини. Підтримує кешування запитів.

- SwarmCache. Підтримка кешування другого рівня в межах кластера. Не підтримує кешування запитів.

- JBossCache. Підтримка кешування другого рівня в межах кластера. Підтримує кешування запитів.

Про підтримку стратегій кешування різними провайдерами можна дізнатися із наступної таблиці:

Провайдер	Read-only	Read-write	Nonstrict-read-write	Transactional
EHCache	+	+	+
OSCache	+	+	+
SwarmCache	+		+
JBossCache	+			+

Підтримка кешування другого рівня в Hibernate

Кешування другого рівня в Hibernate потрібно увімкнути, для того, щоб його використовувати. Увімкнути кешування другого рівня можна встановши property в конфігурації сесії Hibernate:

Якщо необхідно увімкнути також кешування для запитів, то слід також встановити значення для property в конфігурації сесії Hibernate:

Також необхідно вказати клас провайдера кешування, а для цього треба задати наступний property в конфігурації сесії Hibernate :

- для провайдера EHCache

<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

- для провайдера OSCache

<property name="cache.provider_class">org.hibernate.cache.OSCacheProvider</property>

- для провайдера SwarmCache

<property name="cache.provider_class">org.hibernate.cache.SwarmCacheProvider</property>

Але для того, щоб кешування другого рівня було в дії, слід позначити хоча б один клас для кешування. Позначити певний клас для кешування можна двома способами:

В описі маппінгу класу у файлі *.hbm.xml добавити елемент cache із відповідним значенням.

…

</class>

Вище описаний клас Country, який мапиться на таблицю Country. Ця таблиця є словником країн. Словник зміні не підлягає, тобто значення не добавляється, не редагується та не видаляється. <cache> вказує на те, що дані підлягають кешуванню, стратегія кешування read-only.

У файлі конфігурації сесії hibernate.cfg.xml. Для цього використовується елемент <class-cache>, який наводиться після списку ресурсів. Ось як може описуватися кешування для класу Country:

<hibernate-configuration>

<session-factory>

….

….

<class-cache class=”org.prisoft.sample.hibernate.Country”

usage=”read-only”/>

</session-factory>

</hibernate-configuration>

Я надаю перевагу конфігурації кешування другого рівня через файл hibernate.cfg.xml, оскільки так видно повний список класів, що підлягають кешуванню, а також при необхідності, можна легко відключити кешування.

Отже, ми розглянули, як включити кешування другого рівня, а також як вказати які саме ентіті підлягають кешуванню. Ми не розглянули, як задається кешування для запитів.

Також ми не розглянули таке поняття, як регіони. Регіони – це так би мовити іменовані екземпляри кешу, в якому знаходяться різні класи із різними політиками часу на існування. По замовчуванню, ім’я регіону складає повна назва класу (якщо це кеш класу) або повна назва класу плюс імя property класу (якщо це колекція). За допомогою property сесії Hibernate hibernate.cache.region_prefix. Тоді ім’я регіону буде складатися із префіксу та повного імені класу. Вказати ім’я регіону можна явно за допомогою атрибута region в елементі <cache> або <class-cache>.

EHCache (http://ehcache.sourceforge.net)

Останнє обновлення аплікації це є ehcache-1.4-beta, яка вийшла 1 січня 2008. А це означає, що продукт не тільки живий, але і розвивається. Розповсюджується EhCache за ліцензією The Apache Software License, Version 2.0. Спонсори там також далеко не з послідніх. Так що, проект живе і розвивається. Не може не радувати повна підтримка JSR107 (JCache API).

Серед вказаних характеристик слід відзначити:

- Простота (API є досить простим, початкова конфігурація також не є необхідною).

- Залежність тільки від commons-logging та commons-collections. Вони в свою чергу також поширюються за APL. Та й більшість проектів їх використовує. То ж, ця залежність не є проблематичною.

- Кешування в оперативній пам’яті та на диск. Підтримка великих розмірів.

- Підтримка великої кількості кешів.

- Підтримка розширень для кешу (а також розширення для загружчиків та обробників виключень).

- А також багато чого іншого, про що ви можете точніше дізнатися за адресом http://ehcache.sourceforge.net/features.html

Як уже зазначено, можна і не конфігурувати EHCache. Але я не думаю, що це хороша ідея. Нам вона явно не підходить. Ми повинні навчитися конфігурувати EhCache.

Отже, конфігурація EHCache знаходиться у файлі ehcache.xml, який у свою чергу знаходиться в класспасі аплікації.

Отже, структура конфігураційного файла:

</ehcache>

Конфігураційний файл може містити не тільки ці елементи, але й інші. Але вони розглядатися не будуть.

Роглянемо детальніше ці елементи.

<diskStore path=”java.io.tmpdir”/> - вказує шлях до каталогу, де файли кешу створюються.

Наступні значення є можливими:

- user.home – домашній каталог користувача;

- user.dir – текучий робочий каталог користувача;

- java.io.tmpdir – каталог тимчасових файлів.

Можна також вказувати субдиректорії, наприклад <diskStore path=”java.io.tmpdir/cache/myapp”/>

Конфігурація кешу, який не описаний за допомогою власного <cache> елемента, відбувається через <defaultCache>.

<defaultCache

maxElementsInMemory=”10000”

eternal=”false”

timeToIdleSeconds=”120”

timeToLiveSeconds=”120”

overflowToDisk=”true”

diskSpoolBufferSizeMB=”30”

maxElementsOnDisk=”1000000”

diskPersistent=”false”

diskExpiryThreadInternalSeconds=”120”

memoryStoreEvictionPolicy=”LRU”/>

Можна також задавати конфігурацію для окремого кешу; а для цього використовується наступний елемент

<сache name=”CacheName”

maxElementsInMemory=”10000”

eternal=”false”

timeToIdleSeconds=”120”

timeToLiveSeconds=”120”

overflowToDisk=”true”

maxElementsOnDisk=”1000000”

diskPersistent=”false”

diskExpiryThreadInternalSeconds=”120”

memoryStoreEvictionPolicy=”LRU”/>

А тепер детальніше про кожен атрибут.

mame – назва кешу; назва, як ви вже, мабуть, зрозуміли має бути унікальна.

maxElementsInMemory – максимальна кількість об’єктів, які будуть створені та зберігатися в кеші в оперативній пам’яті.

maxElementsOnDisk – максимальна кількість об’єктів, які будуть збережені на диск.

eternal – вказує на те, чи є елементи вічними. Якщо вони є вічними, то будь-які настройки Idle та Live Seconds ігноруються, елементи зберігаються до кінця.

timeToIdleSeconds – час життя невикористаного елемента кешу (за умови, якщо eternal рівний false). Якщо значення 0, то це значить, що елемент може залишатися в кеші в стані не використовуваного нескінченний період.

timeToLiveSeconds – час життя елемента кешу (за умови, якщо eternal рівний false). Якщо значення 0, то це значить, що елемент може залишатися в кеші в стані невикористаного нескінченний період.

overflowToDisk – вказує на те, чи зберігати елементи на диск, якщо досягнуто максимуму елементів в пам’яті.

diskPersistent - чи зберігаються закешовані дані між пере запуском віртуальної машини. Значення по-замовчуванню false.

diskExpiryThreadInternalSeconds – кількість секунд, через які відбувається запуск потоку очищення диску від елементів кешу, що завершили свій час життя.

memoryStoreEvectionPolicy. Розрізняються наступні політики LRU – Least Recently Used, FIFO – First In First Out, LFU – Last Frequently Used.

Приклад аплікації із використанням кешу EHCache

Отже, розглянуто трохи теорії, а тепер ближче до практики. Для цього було створено просту аплікацію, яка містить 4 доменних об’єкта: Country, Materials, Product, ProductMaterial.

Отже, ми маємо аплікацію, яка містить інформацію про матеріали (назва, код, ціна, країна виробник), про продукцію (назва, код, ціна, країна виробник, матеріали із яких виготовлена продукція) і власне словник країн виробників.

Кешування класів та стратегії кешування описані у файлі hibernate.cfg.xml.

Отже, hibernate.cfg.xml має вигляд:

<hibernate-configuration>

<session-factory>

<property name="hibernate.connection.url">jdbc:mysql://localhost/proregister</property>

<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

<property name="hibernate.show_sql">false</property>

<class-cache class="org.prisoft.sample.proregister.objects.Country" usage="read-only"/>

<class-cache class="org.prisoft.sample.proregister.objects.Material" usage="read-write"/>

<class-cache class="org.prisoft.sample.proregister.objects.Product" usage="read-write"/>

<class-cache class="org.prisoft.sample.proregister.objects.ProductMaterial" usage="read-write"/>

</session-factory>

</hibernate-configuration>

Клас Country має стратегію кешування read-only, в той час як всім іншим задана стратегія read-write. Country є по факту незмінним словником країн; його не можна змінювати.

Кеши класів Material, Product та ProductMaterial повинні підтримувати зміну, оскільки елементи можуть як добавлятися, так і редагуватися та видалятися. Саме тому їм задана стратегія read-write.

Аплікація працюватиме із базою даних на одній машині, тому виконувати кешування на диск немає потреби. Окрім того, кількість даних є невеликою, тому їх можна спокійно зберігати в базу даних.

Для детальної конфігурації EHCache потрібно конфігурувати кожен кеш у файлі ehcache.xml.

Отже, конфігурація має наступний вигляд:

<defaultCache

maxElementsInMemory="10000"

eternal="false"

timeToIdleSeconds="120"

timeToLiveSeconds="120"

overflowToDisk="false"

diskPersistent="false"

diskExpiryThreadIntervalSeconds="120"

memoryStoreEvictionPolicy="LRU"/>

[тут має бути конфігурація кешів, розглянута дальше]

</ehcache>

Отже, ми вказали на каталог для файлів кешування та конфігурацію кешу по-замовчуванню.

Нижче подана конфігурація кешу для класу Country. Задаємо максимальну кількість елементів в пам’яті, забороняється записувати дані на диск, дані можуть зберігатися тривалий час. Якщо кількість елементів в пам’яті перевищує 200, то тоді відбувається очистка кешу.

<cache name="org.prisoft.sample.proregister.objects.Country "

maxElementsInMemory="200"

eternal="true"

overflowToDisk="false"/>

Настройка кешу для об’єктів Product, Material та ProductMaterial має відмінності, оскільки ці об’єкти можуть змінюватися, тому для них задана конфігурація тривалості існування елементів кешу. Конфігурація подана нижче.

<cache name=”org.prisoft.sample.proregister.Product”

maxElemenentsInMemory=”2000”

eternal=”false”

overflowToDisk=”false”

timeToIdleSeconds=”120”

timeToLiveSeconds=”300”/>

<cache name=”org.prisoft.sample.proregister.Material”

maxElemenentsInMemory=”5000”

eternal=”false”

overflowToDisk=”false”

timeToIdleSeconds=”240”

timeToLiveSeconds=”300”/>

<cache name=”org.prisoft.sample.proregister.ProductMaterial”

maxElemenentsInMemory=”10000”

eternal=”false”

overflowToDisk=”false”

timeToIdleSeconds=”120”

timeToLiveSeconds=”120”/>

Як бачите, для різних кешів задана різна кількість елементів в памяті. Атрибут eternal має значення false, тому конфігурація періоду існування елементів у кеші не буде ігноруватися. Дані не зберігаються на диск для жодного із кешів, використовуваних в аплікації.

Отже, ми розглянули які існують провайдери кешу другого рівня для Hibernate, також ми розглянули, як настроїти Hibernate для використання кешу другого рівня для класів (проте не зачепили теми кешування запитів та колекцій). Розглянуто було також більш детально провайдер EHCache.

Додаткова література

1. Hibernate In Action, Manning Publications, 2005

2. EhCache User Guide at http://ehcache.sourceforge.net/EhcacheUserGuide.html

Кешування другого рівня в Hibernate.

2007-11-24T12:50:00.001+02:00

Частина I: Трохи теорії

Є багато способів пришвидшити роботу Hibernate. Одним із них є кешування другого рівня (second level cache).

Для мене він знадобився при оптимізації роботи проекту, який використовує Hibernate 3.2.3. В межах аплікації використовується кілька наборів даних, які рідко змінюються. Декотрі дані взагалі не змінюються. Витягувати їх із бази даних кожен раз виходить доволі накладно і навіть довго. Після використання кешування, на звичайній машині різниця почала відмічатися одразу ж.

Взагалі про розгляді кешування в Hibernate, слід розрізняти кешування першого та другого рівнів. Кешування першого рівня є обовязковим, його не можна відключити. Це є кешування рівня одиниці виконання роботи (unit of work) і виконується воно через Session.

Трохи детальніше про кешування першого рівня, адже воно є необхідним для розуміння кешування другого рівня. Перш за все, слід зрозуміти, що це є кешування перстистетних об'єктів, тобто, в межах однієї Session, кешуються об’єкти класу, а не окремі дані, і отримуються для одного і того самого же рядка в базі даних один і той самий об'єкт. Що ж це дає, і чому зрозблено саме так? По-перше, це дозволяє виконувати ідентифікацію по об’єкту, а не по значенню в межах однієї сесії. По-друге, це дозволяє зберігати інформацію про зміни до рядку в межах одного об’єкта, що уже спасає від будь-яких подальших проблем пов’язаних із синхронізацією із базою даних. Отже, кешування першого рівня, використовується в межах сесії одного користувача, і не впливає на роботу інших користувачів. Це пришвидшує роботу.

Кешування другого рівня має зовсім інші межі використання. Навідміну від кешування першого рівня (яке використовується в межах запиту користувача або бізнес транзакції користувача), кешування другого рівня використовується в межах процесу або кластера виконання аплікації. Цей кеш є спільним для багатьох користувачів системи, відповідно, його потрібно осторожно використовувати, та володіти основними правилами.

Перш за все, слід сказати, що кеш другого рівня в Hibernate може мати межі процесу або кластера. Всі сесії використовують спільний кеш. Фактично кеш другого рівня має межі SessionFactory, в той час як кеш першого рівня має межі Session.

Для того, щоб робота кешу другого рівня була задовільною в багатокористувацькому середовищі, слід розуміти стратегії кешування. Стратегія кешування для об’єкта кешування встановлюється незалежно.

Так виділяють наступні стратегії кешування:

- read-only – для об’єктів, що не змінюються ніколи в межах роботи аплікації.

Типове для використання у випадку, якщо значення об’єктів не змінюється в процесі роботи аплікації (наприклад, ролі користувачів, список країн, мов, інші специфічні словники). Для подібних об’єктів можна також використовувати mutable = “false”, що дозволяє Hibernate пришвидшувати роботу для незмінюваних об’єктів.

- read-write – для об’єктів, що можуть змінюватися в межах роботи аплікації, але частота зміни не є великою.

Підходить для використання у більшості випадків. Велика кількість об’єктів в системі змінюється, але при цьому кешування об’єктів є необхідною для покращення роботи.

- nonstrict read-write – для об’єктів, що можуть змінюються в процесі роботи аплікації дуже рідко.

Кеш другого рівня дозволяє зберігати дані як в оперативній пам’яті так і на жорсткому диску. Зберігання даних на жорсткому диску актуально у випадках, коли аплікація та база даних знаходяться на різних машинах.

Коли відбувається загрузка об’єкта за допомогою Session, перш за все, Session виконує перевірку кешу на рахунок наявності в ньому об’єкту із відповідною значенням поля ідентифікації. Перевірка виконується у випадку, якщо для даного типу включено кешування другого рівня. Отже, якщо кеш містить закешований об’єкт відповідним значенням поля ідентифікації, то відбувається створення ново об’єкта у віртувальній машині та заповнення його даними.

Звідси можна зробити наступний висновок. В кеші зберігаються не об’єкти віртуальної машини, а прості дані. На основі цих даних, відбувається заповнення новоствореного об’єкту.

Якщо ж кеш не містить шуканий об’єкт, то відбувається запит до бази даних, і якщо рядок із таким ідентифікатором все-таки є в базі даних, то відбувається його поміщення в кеш. Тепер кеш містить запис для рядка із даним ідентифікатором.