Eclipse RCP+Spring+EMF+Teneo and the data source

One issue when using these technologies together is the configuration of the HbSessionDataStore. Under spring, you can configure the LocalSessionFactoryBean by setting the data source directly. The data source is typically defined in your context XML as well. But there is no data source property setter under HbSessionDataStore.  Under standard hibernate you can set configuration parameter hibernate.connection.provider_class to the name of the connection provider class and spring provides a data source called LocalDataSourceConnectionProvider which can be instantiated without parameters to get a data source. The trick of this spring class is that it access a thread local storage (therefore global location for that thread) to retrieve the data source you may have set in the LocalSessionFactoryBean instance under setDataSource(). The LocalSessionFactoryBean sets the thread local storage when you call setDataSource().

So under teneo’s HbSessionDataStore, we can just extend the class to include this type of property setter, create a small connection provider class just like LocalDataSourceConnectionProvider and do what spring does. Then we just need to ensure that our connection provider is used and that the user does not set it twice, once through the setter and through standard hibernate configuration approaches in the properties specification. Note that the teneo page http://www.elver.org/hibernate/hbdatastore.html describes having to set the data store factory in the HbHelper class. However, since we are using spring, you don’t need to do that (the HbHelper class is acting as a service locator) because it is done for you.

Here’s the example data source connection provider:

   1: public class DataSourceConnectionProvider implements ConnectionProvider {
   2:  
   3:     private DataSource dataSource;
   4:     private DataSource dataSourceToUse;
   5:  
   6:     @Override
   7:     public void close() throws HibernateException {
   8:     }
   9:  
  10:     @Override
  11:     public void closeConnection(Connection arg0) throws SQLException {
  12:         try{
  13:             arg0.close();
  14:         } catch(SQLException ex) { 
  15:             JDBCExceptionReporter.logExceptions(ex);
  16:             throw ex;
  17:         }
  18:  
  19:     }
  20:  
  21:     @Override
  22:     public void configure(Properties arg0) throws HibernateException {
  23:         this.dataSource = LocalHbSessionDataStoreBean
  24:                 .getConfigTimeDataSource();
  25:         if (this.dataSource == null) {
  26:             throw new HibernateException(
  27:                     "No data source to use. Set data source property on LocalHbSessionDataStore");
  28:         }
  29:         this.dataSourceToUse = getDataSourceToUse(this.dataSource);
  30:     }
  31:  
  32:     /**
  33:      * Return a data source to use. The data source passed in is the one
  34:      * configured locally. Subclasses may wish to proxy or otherwise modify the
  35:      * data source in some way.
  36:      * 
  37:      * @param originalDataSource
  38:      * @return
  39:      */
  40:     protected DataSource getDataSourceToUse(DataSource originalDataSource) {
  41:         return originalDataSource;
  42:     }
  43:     
  44:     public DataSource getDataSource() { 
  45:         return dataSource;
  46:     }
  47:     
  48:  
  49:     @Override
  50:     public Connection getConnection() throws SQLException {
  51:         try { 
  52:             return this.dataSourceToUse.getConnection();
  53:         } catch(SQLException ex) { 
  54:             JDBCExceptionReporter.logExceptions(ex);
  55:             throw ex;
  56:         }
  57:     }
  58:  
  59:     @Override
  60:     public boolean supportsAggressiveRelease() {
  61:         return false;
  62:     }
  63:  
  64: }

The new bean to use:



   1: public class LocalHbSessionDataStoreBean extends HbSessionDataStore {
   2:  
   3:     private static final long serialVersionUID = 767809917573382770L;
   4:  
   5:     private static final ThreadLocal<DataSource> configTimeDataSourceHolder = new ThreadLocal<DataSource>();
   6:  
   7:     public static void setConfigTimeDataSource(DataSource ds) {
   8:         configTimeDataSourceHolder.set(ds);
   9:     }
  10:  
  11:     public static DataSource getConfigTimeDataSource() {
  12:         return configTimeDataSourceHolder.get();
  13:     }
  14:  
  15:     public void setDataSource(DataSource ds) {
  16:         setConfigTimeDataSource(ds);
  17:     }
  18:  
  19:     public DataSource getDataSource() {
  20:         return getConfigTimeDataSource();
  21:     }
  22:  
  23:     @Override
  24:     protected void setPropertiesInConfiguration() {
  25:         super.setPropertiesInConfiguration();
  26:         getConfiguration().setProperty(
  27:                 org.hibernate.cfg.Environment.CONNECTION_PROVIDER,
  28:                 DataSourceConnectionProvider.class.getName());
  29:     }
  30:  
  31: }


The namespace org.eclipse.mf.teneo.spring.hibernate has been used but you can change this.


Further investigation is needed to see if the standard spring transaction machinery is working as expected. More on this later.


If you need to dynamically set the properties of the data source, i have blogged about ways to dynamically created hierarchical contexts and other tricks, however, you can easily configure the data source by defining a FactoryBeanPostProcessor, obtaining the bean definition, setting the properties based on your “stored” data source configuration then add the post processor programmatically or by defining the post processor bean in your context (in which case it is automatically picked up). Bean definitions are partially instantiated beans that you can alter/override the configuration of properties with. Its very convenient and easier than what I described in previous blogs. In your post processor callback:



   1: public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0)
   2:                 throws BeansException {
   3:     BeanDefinition bd = arg0.getBeanDefinition("yourDataSourceBeanName");
   4:     MutablePropertyValues v = bd.getPropertyValues();
   5:     v.addPropertyValue("username", "yourUsername);
   6:     v.addPropertyValue("password", "yourPassword");
   7:     v.addPropertyValue("url", "jdcb:yourURL");
   8:     v.addPropertyValue("driverClassName", "com.yourSQLDriver");
   9: }

Comments

Post a Comment

Popular posts from this blog

quick note on scala.js, react hooks, monix, auth

quick note on scala.js, react hooks, monix, auth Reactjs hooks finally came out of preview in a recent version of React. scalajs-reaction has had support for hooks since they were in preview. React hooks seem like the hot new thing but for me the question is, do hooks help improve your code by improving maintainability, time to market, TCO, etc.? Let’s take a look using authentication as an example and employ monix , a reactive observable framework that also builds on cats . We will assume we are building a SPA. Does it improve your code and make your application & development experience better? Auth Auth processing can be complex. Many react auth examples you find in blogs like to show how to use “react-routing” and “auth” as a switch that determines which routes are protected or unprotected. Protected routes show application specific data. Unprotected routes show login content . Based on storing a “User” object in the browser session/local storage, th...
Read more

zio environment and modules pattern: zio, scala.js, react, query management

zio environment and modules pattern: zio, scala.js, react, query management This blog covers a zio-based fetch design for scala.js, react web applications. It heavily uses the zio “environment” feature to help motivate a point of view on the modules pattern in effect systems. At the end, I summarize some thoughts on ergonomics and complexity. This blog assumes a basic knowledge of zio and react. scala.js is just like scala so you mostly already know scala.js. This blog is a follow-on to previous blogs: https://appddeevvmeanderings.blogspot.com/2019/10/scalajs-react-fetcher-hook_48.html and https://appddeevvmeanderings.blogspot.com/2019/11/scalajs-and-react-suspense.html . I have been keeping an eye on and culling ideas from typscript/javascript fetching libraries that address query management concerns. The formulation below incorporates some of those concerns but does not try to comprehensively duplicate well established javascript libraries. I only care about ...
Read more

attributes with react and typescript.md

If you use typescript with react you may wonder what the right signature is for your “properties” interface. Obviously, your component will have few to many specific properties that reflect your domain. However, you may wish to also provide for the ability to add other attributes, such as those valid for a div property. In other words, you want to extend your props interface with that of the properties from a div element. How do you do that? There are really two issues: How do you extend your props interfaces How do you filter the props once you receive them to just those that apply. Extend Your Prop Interface or Use Sum Types It’s not uncommon to see interface Props { className ? : string yourProp ? : number } with the idea of using it in class MyComponent extends React.Component<Props, any> somewhere. If your component will have an outer div, you may also pass in a react element so that its configurable. But let’s say your outer element is a div and you wan...
Read more