I created an Android app for World Health Organization long ago. I made different kinds of search engines before with full-text indexing. This time I wanted to do something different. I had only 4 days to make the app. They had different kinds of contents like
Plain text files
And they needed a search engine to search all the contents and show a unified result set ( Showing results in a same page with relevancy ). Now I could implement it in SQLite, but that would mean a lot of task and the gain would be much lesser than a document-based search engine like Apache Lucene.
As I built many applications before, when I started building with springboot, following the springboot books is not enough for my architectural needs. So, I ran into many critical problems by going beyond those books. I will write them up to help beginners in spring ecosystem like me.
I started writing my first spring and the first springboot application today. The project requires mongodb and mysql as databases. My application’s domain objects are highly hierarchical and we need to make different kinds of search engines for many child classes. So, there needs to be some violations from common patterns like “field shadowing”. Though it’s only for the purpose of data and search layer, it doesn’t affect the object model of the application. So, I needed to change field behavior in subclasses which are different entities or collections in Mongo store. Basically I needed to put a annotation on subclass to enable an index on a field.
Handling null can be problematic in code organization and management. So, there are two very common patterns used by experienced developers now and then. One is “Null object pattern”, where you return an object which states a missing object, and another is “Special Case Pattern”. This article is to “How you can write effective objects for those patterns and why you should use them instead of returning null or throwing exceptions”
I read through many discussions related to Singleton Patterns, and different developers dislike it for different reasons. Not all the reasons make a pattern evil, because many of those reasons doesn’t really make your software really bad. I will be writing here each of the reason, and try to explain whether the reason is justified to call Singleton Evil:
I don’t know how many times I saw this question asked by many PHP developers. It happens when some developer is not developing in Java actively, need to do some quick codes, and does PHP development regularly. Associative arrays are one of the most used feature (or is it the most?) of PHP.
Though collections are basic java features, and why many of PHP developers cannot readily catch that they can use Maps or Properties collections? It’s mainly because of OOP pattern. Java collections are objects. And many PHP developers are too accustomed to using Non-OOP patterns even if they are coding in a object oriented framework like laravel, or symfony, or zend.
This is a concept might be overlooked by the beginners in Spring framework. When a Bean configuration is loaded in a IoC container, all the beans are constructed by default if you don’t specifically mentioned lazy loading on a bean. So,
When defining a <bean> in Spring, you have the option of declaring a scope for that bean. For example, To force Spring to produce a new bean instance each time one is needed, you should declare the bean’s scope attribute to be prototype. Similar way if you want Spring to return the same bean instance each time one is needed, you should declare the bean’s scope attribute to be singleton.
The Spring Framework supports following five scopes, three of which are available only if you use a web-aware ApplicationContext.
This scopes the bean definition to a single instance per Spring IoC container (default).
This scopes a single bean definition to have any number of object instances.
This scopes a bean definition to an HTTP request. Only valid in the context of a web-aware Spring ApplicationContext.
I am learning Java Spring Framework out of personal interest. I am trying to understand how it works. Today I was learning dependency injection in Spring. I started with injecting java collections through xml beans. As you already know, if you want to set a property of primitive type, you need to put exactly the same property name in bean xml definition. I started with that for injecting a List collection named addressList.