The file “beans.xml” used for you application is already a kind of configuration file. However, this file is designed for the developer who can quickly customize the application with less coding changes. It is not recommended for an end user to change the file.

For example, you can, of course, define the database connection properties in the beans.xml file straight away. This way, every time a user wants the application to connect to a database at a different location, the beans.xml file needs to be modified. For a complicated application, the file can grow very complicated as well. Therefore, making changes to the beans.xml file directly may not seem obvious to the end user.

Fortunately, Spring have already come up with a solution for this problem. You can define the properties in the “beans.xml” file with place holders and use the Spring provided bean PropertyPlaceholderConfigurer to replace the place holders with the value from a properties file. Here is an example of the use of PropertyPlaceholderConfigurer.

In the example from the above link, it specifies one location for the properties file with a classpath: “classpath:com/foo/jdbc.properties”. In addition to that, you can also specify a file on your file system. When using a file on file system, remember to add “file:/” to an absolute path; otherwise, Spring will treat it as a relative path even the value starts with “/”.

PropertyPlaceholderConfigurer also allows you to define some default values using the property “properties“. The following is an example of using the default values if the file defined by “locations” property does not exist. Please note setting “ignoreResourceNotFound” to true is necessary. If not set, the application will throw exception if the defined property does not exist even we’ve defined the default values.

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="ignoreResourceNotFound" value="true" />
  <property name="locations">
    <value>file:///etc/app/jdbc.properties</value>
  </property>
  <property name="properties">
    <props>
      <prop key="jdbc.driverClassName">com.mysql.jdbc.Driver</prop>
      <prop key="jdbc.url">jdbc:mysql://localhost:3306/mytechtip</prop>
      <prop key="jdbc.username">jdbc_username</prop>
      <prop key="jdbc.password">xxx</prop>
    </props>
  </property>
 
</bean>
 
<bean id="dataSource" destroy-method="close" 
    class="org.apache.commons.dbcp.BasicDataSource">
  <property name="driverClassName" value="${jdbc.driverClassName}"/>
  <property name="url" value="${jdbc.url}"/>
  <property name="username" value="${jdbc.username}"/>
  <property name="password" value="${jdbc.password}"/>
</bean>

Java beans in Spring can also have their collection properties populated in the beans.xml file. The collection properties here mean things like List, Map and Array.

For example, if you want to create a JPA EntityManagerFactory with a set of connection properties, these properties can be configured in beans.xml like this:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  xmlns:p="http://www.springframework.org/schema/p"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <bean id="entityManagerFactoryCreator" 
    class="com.mytechtip.example.EntityManagerFactoryCreator">
    <property name="persistenceUnitName" value="HRMN_Repository"/>
    <property name="jpaProperties">
      <props>
        <prop key="openjpa.ConnectionURL">the_url</prop>
        <prop key="openjpa.ConnectionDriverName">the_driver_class_name</prop> 
        <prop key="openjpa.ConnectionUserName">the_user_name</prop>
        <prop key="openjpa.ConnectionPassword">the_password</prop>
      </props>
    </property>
  </bean>
</beans>

Here, jpaProperties in the actual java class “EntityManagerFactoryCreator” is an instance of Properties. And you can just use this properties to create EntityManagerFactory.

    // ...
    private Properties jpaProperties;
    //...
    public void setJpaProperties(Properties prop) {
        this.jpaProperties = prop;
    }
    // ...
    public EntityManagerFactory create() {
        return Persistence.createEntityManagerFactory("myPersistenceUnit", prop);
    }

Actually, Spring already have something similar for you to access EntityManagerFactory with ease. The beans used for the task are:

• org.springframework.orm.jpa.LocalEntityManagerFactoryBean
• org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean

More information / examples can be found here about the support of JPA entity manager factory creatation in Spring.

Spring is a very flexible java framework. In spring, beans are the main building bricks of an application while the bean configuration file (mostly beans.xml) acts as cement that glues the beans together.

The file beans.xml also allows beans to be initialized with particular values. For example, you can set the JDBC driver, user name, password for a java bean that is in charge of database connection in the beans.xml file as the following example.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 
	<bean id="dbManager" class="com.mytechtip.example.DbManager">
		<property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
		<property name="jdbcUrl" value="jdbc:mysql://localhost/app"/>
		<property name="jdbcUser" value="app" />
		<property name="jdbcPassword" value="app" />
	</bean>
</beans>

So in the java class “com.example.app.DbManager”, you can make JDBC connections with the fields/properties value set as in the beans.xml file. The DbManager class may look as simple as the following:

package com.mytechtip.example;
 
import java.sql.Connection;
import java.sql.DriverManager;
 
public class DbManager {
 
	private String jdbcDriver;
	private String jdbcUrl;
	private String jdbcUser;
	private String jdbcPassword;
 
	public String getJdbcDriver() {
		return jdbcDriver;
	}
	public void setJdbcDriver(String jdbcDriver) {
		this.jdbcDriver = jdbcDriver;
	}
 
        // more getters and setters ...
 
	public Connection getConnection() throws Exception {
             Class.forName (getJdbcDriver()).newInstance();
             return DriverManager.getConnection(
                   getJdbcUrl(), getJdbcUser(), getJdbcPassword());
	}
}

There is one note: These properties are set after the constructor of the bean is called. So if you try to make a JDBC connection in the constructor with the fields, you will mostly get exceptions.

Anyway, this is a very simple example of the bean configuration. We will show more examples to learn the flexibility of the bean configuration in Spring. ]]> http://robin.mytechtip.com/2010/05/18/how-to-configure-spring-beans-xml-file-basic-usage/feed/ 0 http://robin.mytechtip.com/2010/03/24/remember-to-clear-entity-manager-if-entities-no-longer-used/ http://robin.mytechtip.com/2010/03/24/remember-to-clear-entity-manager-if-entities-no-longer-used/#comments Wed, 24 Mar 2010 05:04:55 +0000 robin http://robin.mytechtip.com/?p=67 Recently  a lesson was learned about the proper use of Java JPA to persist a large number of records into database in a batch process.

Some times it is necessary to load the records line by line from a large file and insert into the database table. There can be several ways to do this:

• Use the database provided tool to load the data into table. It can be a special sql command or a special stored procedure. This method is quite database specific and not portable.
• Write the program to load the data into the database table (Using JDBC if the program is written in Java).  This method can be applied to different databases if the insert SQL statement conforms to a level of standard.
• Use JPA to persist the object one by one. This allows for changing database more easily (under the condition that the JPA provider supports the database.

We used the third options to load the records into the database as we want to support multiple databases without  low level tweaking. However, the first implementation seemed very slow compared with the second option. And it became slower and slower when process of persisting records  progressed.

After a few checking, we realized that we didn’t call the method “clear” of the class EntityManager each time we persisted the object.  The EntityManager kept managing these objects so the resource was not released immediately, making it become slower and slower.

Once we add the “clear” method call, the performance became acceptable. So lesson learned about the use of JPA.

For example, if you want to make the folder “/opt/mysite_v1.2″ have the alias as “/mysite” so it can be accessed as http://www.mydomain.com/mysite. And you want to have clean url “/mysite/page1″ mapped to “/mysite/index.php?p=page1″.

To define the alias, just add the following in the httpd.conf file:

Alias /mysite/ “/opt/mysite_v1.2/”
<Directory “/opt/mysite_v1.2/”>
Options Indexes FollowSymLinks MultiViews
AllowOverride all
Order allow,deny
Allow from all
</Directory>

To allow clean URL. you need to have the following in the “.htaccess” file in the folder “/opt/mysite_v1.2″

RewriteEngine On
# Rewrite base
RewriteBase   /mysite

#  now the rewriting rules
RewriteRule   ^([0-9a-zA-Z_]+)$  index.php?p=$1

Please NOTE that “RewriteBase” Directive is very essential. Without it, you will get the well known “Bad Request” Error.

More information can be found in Apache mod_rewrite documentation.

Change the default storage engine

By default, OpenJPA uses innodb as the storage engine. While my application does not need to support transactions and other fancy db features, i’d like to use more plain and “traditional” myisam storage engine. To do so, I just need to set the property “openjpa.jdbc.DBDictionary” with the value “TableType=myisam”. This property object is the one passed to the method “Persistence.createEntityManagerFactory(String, Properties)”.

Allow to store bigger objects (blobs)
By default, OpenJPA maps the java object to mysql data type “blob”. However, as you may be aware of, blob type in mysql only can store up to 65536(2¹⁶) bytes of data (check http://dev.mysql.com/doc/refman/5.0/en/storage-requirements.html), which is quite smaller than the blob in JavaDB or Derby (2G).

Mysql does provide other data types which supports larger storage. mediumblob supports up to 16M while longblob up to 4G. So if I want to store objects other than 64K, I need to change the mapping in OpenJPA. To change the mapping, just set the same property “openjpa.jdbc.DBDictionary”, but with value “blobTypeName=mediumblob”.

If I want both myisam as storage engine and mediumblob as mapped blob type, the property should be set as: “TableType=myisam,blobTypeName=mediumblob”.

Avoid the error “Packet too large”
Now i can save objects up to 16M in size to the database. I run my program, only to find another exception popped up. It says something like “Packet too large”.

This requires the change of mysql server setting as indicated in mysql documentation. The setting “max_allowed_packet“, default to 1M bytes, is too small in my case.

If you have some RMVB files and want to play them on the DVD player, Then you need to convert the RMVB format to AVI.

Currently, I found out two methods to do this.

The first method is from this article: “How to Convert RMVB“. This method requires you install/download several pieces of software to do this. It’s a bit troublesome, but the article provides very detailed step-by-step instructions and it works.

The other method is to use the open source software alltoavi. It’s quite straight forward to use this software to convert RMVB. And it seems that this method takes less time to do the conversion compared with the first method.

The above two methods both use free software to accomplish the task. There are of course other software that can do this task and they may allow you to have better control for the conversion. Well, you have to pay for it.

Since version 1.6.1, Ant, the java build tool, has a core task called “cvschangelog“. It is quite useful to use this task to grab a list of recent changes committed to the CVS repository. The output of this task is in XML format. Something like the following:

<changelog>
<entry>
<date>2009-09-02</date>
<time>12:00</time>
<author>robin</author>
<file>
<name>test/ant/task/ChangeLog.txt</name>
<revision>1.2</revision>
<prevrevision>1.1</prevrevision>
</file>
<msg><![CDATA[A commit message]]></msg>
</entry>
<entry>
…
</entry>
…
</changelog>

To transform the xml formatted changelog into a human friendly html, you can do an XSL transformation with a XSL file. There is a default one in the Ant distribution, so you can use the following task to get a change log in html format.

<style in=”changelog.xml”
out=”changelog.html”
style=”${ant.home}/etc/changelog.xsl”>
<param name=”title” expression=”Ant ChangeLog”/>
<param name=”module” expression=”the_module”/>
<param name=”cvsweb” expression=”the_url”/>
</style>

The default generated html lists each commit change one by one. In some cases, we want to group the commit changes by dates. To do so, we have to change the default xsl file.

It seems that the new XSLT version 2.0 has specified a group functionality. However, it turns out only a few XSLT tools support this new feature. Fortunately, There is a way that allows us to do the grouping using XSLT version 1.0. By applying this method, we have the following looking xsl code for the HTML <BODY> part.

<body>
<h1>
<a name=”top”><xsl:value-of select=”$title”/></a>
</h1>
<p style=”text-align: right”>Designed for use with <a href=”http://ant.apache.org/”>Apache Ant</a>.</p>
<hr/>

<xsl:key name=”log-by-date” match=”entry” use=”date” />

<xsl:template match=”changelog”>
<xsl:for-each select=”entry[count(. | key('log-by-date', date)[1]) = 1]”>
<xsl:sort select=”date” order=”descending” />
<h2><xsl:value-of select=”date”/><xsl:text></xsl:text></h2>
<xsl:for-each select=”key(’log-by-date’, date)”>

<xsl:sort select=”time” order=”descending” />

<table border=”0″ width=”100%” cellspacing=”1″>
<tr>
<td class=”dateAndAuthor”>
<!– <xsl:value-of select=”date”/><xsl:text> </xsl:text> –>
<xsl:value-of select=”time”/><xsl:text> </xsl:text><xsl:value-of select=”author”/>
</td>
</tr>
<tr>
<td>
<pre><xsl:apply-templates select=”msg”/></pre>
<ul>
<xsl:apply-templates select=”file”/>
</ul>
</td>
</tr>
</table>
</xsl:for-each>
</xsl:for-each>
</xsl:template>

</body>

Use the above code to replace the <body> part in the original changelog.xsl file, then it  will allow you to group the change logs by date.

Google Web Toolkit (GWT) is a handy Ajax Web application development tool. Since version 1.6.4, GWT uses Jetty instead of Tomcat as the embedded Web application container.

However, when I installed GWT plugin (version 1.6.4) for Eclipse, the default generated web application used the version 2.3. So when i used expression language in the jsp pages, it didn’t evaluate. Something like “${title}” as the output in the hosted mode running on jetty. It should also be the same result even i deployed to a tomcat container, as the web app version is still 2.3. This is understandable, as Expression Language is part of JSP version 2.0 standard, which is bound with Servlet (Web App) version 2.4. So if you want to make the expression language work, make sure your web app is using 2.4 or higher.

However, while using version 2.4 works fine, i’ve got the same problem when i use version 2.5, which is hard to understand why. This problem seems only in Jetty, not in Tomcat. I don’t know if anyone else have encountered the same problem as I did, but the following link seems to explain the reason behind: http://docs.codehaus.org/display/JETTY/JSP+expression+do+not+evaluate

Apart from this problem (which can be worked around), the use of GWT plugin seems more convenient than the traditional web app development in eclipse.

Although bank statements, credit card statement or online bank accounts provide all such information, these pieces of information scatter here and there and you lose track quickly and don’t have a whole picture to see where you are going. It gets worse when there are several bank / credit card accounts. So having a software or web sites to consolidate all such information seems a good idea.

Other than using a spread sheet to keep all the information together, there are quite a few sophisticated software or web site to do this job, some cost your money, some just free. The following lists some choices.

Desktop Financial Software – not free
Quicken, Microsoft Money. They are traditional desktop applications. That means you have to install them one your computer before you want to use them to manage your money. I haven’t used them but it should be easy to get started for a normal person.
It seems that quicken has a free online version for money management. However, don’t know how “free” it is and how many features it has.

Desktop Financial Software – free
GnuCash, jGnash. Both of them are free and probably open source software. GnuCash is actually beyond the personal level and can be used for catering small business (seems equivalent to Microsoft office accounting software). To use them, you may probably need to have a little bit of financial knowledge. For example, what is double entry?

Websites / online services / personal finance 2.0?
If you are confident enough to allow third party websites to handle your financial information, then you may embrace such so-called personal finance 2.0 websites. Among them are greensherpa.com, justthrive.com, rudder.com, mint.com and etc.

Most of them can retrieve your transactions from your nominated financial institutions or banks and aggregate them automatically for you and provide basic financial advice based on the data. Some of them charge you subscribe fee to use the online service, while some of them have free versions. However, it seems most of them are US version, i.e., they can only retrieve data from US banks.

Finally, a few words on the financial data formats and standards.
Quicken Interchange Format (QIF) is an open specification for reading and writing financial data to media.
Open Financial Exchange (OFX) comes from Microsoft and Intuit (the maker of Quicken) and it is a data-stream format for exchanging financial information.

The above two formats are quite popular and most of the financial software support the importation and exportation of the files in such formats. And most of the online banking system support them as well.