Category Archives: Java

Review of Clean Code

The Clean Code is a book by Robert Cecile Martin, a pioneer of agile software craftmanship. This book was recommended to me last year on an Agile software development training by Cegeka in Belgium. I have read it and I must admit that it has had an impact on my work as a Java developer. Of course many similar books are available. But this is the first one of this kind I read.

In my company we had one hour lasting sessions, in which we read two chapters and discussed content of the book together with our practical experience we had. It was good approach and I liked it. Therefore I think I received more from the book then I would have learned alone just by normal reading from start to end.

I will do my best to do a review of the Clean Code for you. I am going to start with a little motivation, then what I learned and used after one year and then a summary of pros and contras.

“I am a good programmer, I can do my new task fast, it is normal that code is messy…”

I sometimes deal with such statements. They are true or false based on the perspective. If you were a typical startup developer, then I would say yes. There is no high demand for a good design. Time and a number of implemented prototypes is what it counts. But if we took a look for example on a complex middleware system of a large business, then I think that such statement as in the headline would be wrong. Let’s focus on these large enterprise systems. Based on my experience, some programmers are not able to foresee or are not capable of long-term thinking. Unfortunately I already spent too much time analyzing badly written code some else’s. Because it was written without thinking that another programmer would later need to work on it, to understand it. The original target was to finish the task as soon as possible (and unfortunately without seeing the consequences). Of course the latter task is expected to be finished as soon as possible too. But now it is different, now it is more difficult.

Let’s admit it. The most of the development projects are about team work. If we want to consider ourselves to be good team players, we should write our code with respect to our valuable colleagues. To make them their job as easy as possible. To keep in mind that they will once most likely read our code. They will have to understand it, change it and refactor it.

Now from the management perspective. I understand how deadlines are important. However I think it is beneficial to support developers and let them write clean code. The subsequent software support costs will be much lower.  A good manager should take care not only for the next approaching deadline, but he should always plan the project in a way, that there is a space left for improvements and clean code. In other words I think that a good manager must treat deadlines and long-term project sustainability equally to produce the best value for their company. What I mean – the first barely working solution is not the same as the working solution that is already easy to understand and easy to change.

Clean Code principles as I remember them after one year

The book contains quite a lot of chunks of the code. The reader may train his skills on those. I read this book about one year ago, so I do not remember everything exactly, but I’ll try to summarize what I remembered and applied in my projects. I am going to structure the list of the principles as I remember them and order them depending on how often I use with them.

Responsibility principle

Every class or method should have one clear responsibility. If I find a class or method that it deals with more responsiblities, then I’ll separate the responsibilties by creating a new class or a method.

Usually when the class or method is too long it is also an issue. In such long implementations we can usually identify more responsibilities and find out which responsibilities should be separated. It also means that the operations should not have side effects.

Distinctive class and method names

This rule applies more often for method names. Simply make their name as distinctive as possible. Better a long distinctive name than a shorter one, which is ambiguous or unclear. Also a long descriptive method name is better than a short name and a piece of Javadoc.

Understandable method calls

Very common problem. It is very difficult to read and understand method calls with too much parameters. I try to use one argument, two in fewer cases and three only exceptionally. It really helps. Another thing to mention is that it is better to write methods that do not need to accept arguments as null (what is this null?!), true/false (what is actually true or false?!), etc.

 Keep classes small, single purpose and unit testable

Small classes are not just about lines of code. Also the amount class fields and method needs to be reasonable.

Testability is very important. Always design with testability in mind. Write unit tests for your classes. Then you may freely refactor without fear that you’ll break something. Such fear is very common and many programmers rather stay out of trouble, e.g. they don’t dare to change the code they do not understand. I think this is bad habit and also a sign of badly written code. Another common problem is that the unit test is trying to test more than is expected from the tested class. In such a case, the test needs to be moved to the appropriate place.

Pros and contras

I took a look on the book. Of course the book contains more topics, like concurrency, error handling, etc. It contains a lot of practical examples to force you to think. I did not cover everything. Let’s summarize pros and contras.


  • A lot of useful information for your developer career. Senior developers are basically those, who are able to work independently, but I believe that knowledge of such book belongs to their knowledge as well.
  • Experience from the experts in the field.
  • Good structure.
  • Clear argumentation.
  • Practical examples.


  • Examples are sometimes too long and it’s quite difficult to focus on them.
  • Our reading group in my job agreed, that not everything can be easily applied. Some of the rule recommendations seemed unnecessarily strict to us.


This book is about opinions, how the good code should look like. It carries knowledge and experience of the author and his friends. You may not agree with him, but it is still definitely worth reading. At least you can confront your development style with the one offered by the author.

I liked this book. It helped me to improve my Java coding abilities. I am sure it helped our team as well. I would recommend it to every Java developer, who works in a team. As a bonus I would recommend to organize a reading group in your company as we did. It forces you to read the book regularly. The discussions afterwards with my colleagues were very beneficial.

If you have something to add or you disagree, feel free to leave a comment!


How to call DB procedure with MyBatis and Java annotations

According to MyBatis pages: “MyBatis is a first class persistence framework with support for custom SQL, stored procedures and advanced mappings. MyBatis eliminates almost all of the JDBC code and manual setting of parameters and retrieval of results. MyBatis can use simple XML or Annotations for configuration and map primitives, Map interfaces and Java POJOs (Plain Old Java Objects) to database records.”
I often face MyBatis configuration hidden in mapping .xml files. I wanted to try something different. As I learned from Spring, configuration can be also stored not only in XML files, but also in Java annotations. Spring enabled this possibility in its later versions. I found on the net that the MyBatis configuration may be stored there as well, but on the other hand I lacked enough of good tutorials. That is why I decided to write a blog post about this topic. The information, that was needed, I found on and I gathered the pieces together here.
Let’s imagine a stored procedure, which is able to change a status of a car entity. For example we want to change the status of the car to ‘sold’. So we need to define an own Java annotation, which is registered in Spring configuration file. Then we define a mapper interface. If you are already familiar with MyBatis, you should have an idea, how this looks like. But on the contrary this time we create no .xml file in resources. We just define everything in the annotation. Let’s see an example:

public interface ChangeCarStatusMapper {
    @Insert(value = { 
            "{ call DATABASE.PACKAGE.CHANGE_CAR_STATUS ( #{car_id, mode=IN, jdbcType=VARCHAR, javaType=String },  #{car_status, mode=IN, jdbcType=VARCHAR, javaType=String },  #{result_code, mode=OUT, jdbcType=NUMERIC, javaType=Integer},  #{error_description, mode=OUT, jdbcType=VARCHAR, javaType=String} ) }"
    @Options(statementType = StatementType.CALLABLE)
    void changeCarStatus(Map<String, Object> parameters);

This deserves an explanation. To call a procedure successfully we need an @Insert annotation. We can see two input and two output parameters. Also we need to define type of the statement. That is all. So it’s a more compact and effective solution, but it has also some disadvantages. For procedures with large interfaces it may become confused. Also big problem is lack of friendliness of Java in case multiline String constants. Usually you have to split such long String to more lines and use always concatenation. Also the fact that you are combining more languages in one source file may be questionable from the clean code and design perspective. But I think that despite these disadvantages it can be still advantageous for small procedure interfaces.

Upgrade of jbpm-6-examples to jBPM 6.2 services

In my previous post I described an example implementation of a web application, which demonstrates usage of jBPM business process suite as an embedded workflow library. The focus was on CDI services provided by jBPM libraries and their integration with producers and consumers in the web application itself.

The latest version jBPM 6.2 contains services, which are better designed, provide completely new API and significantly simpler usage. They also provide basic kie-services implementation, which is framework agnostic (now they do not use CDI internally) and other specific services for a particular bean framework – EJB 3.1 or CDI 1.0.

This article is going to describe the current state of jbpm-6-examples demos and the upgrade from version 6.0 to 6.2. The article will be separated to two parts, because both examples are slightly different. The new jbpm-6-examples can be found on current master branch on the github.

rewards-basic web example migration to jBPM 6.2 EJB services

This example application combines jBPM 6.2 EJB services together with servlets and Java Server Pages (JSP). Here is the list of new services used in the example. All of them extend the core service and are already annotated with EJB @Local annotation.

  • DeploymentServiceEJBLocal – used to deploy/undeploy kjar artifacts to/from runtime
  • ProcessServiceEJBLocal – used to start/signal/abort process instance and get their process instance data
  • RuntimeDataServiceEJBLocal – provides information about runtime data, process instances, user tasks, process variables, etc.
  • UserTaskServiceEJBLocal – provides operation to work on a user task

So what has changed? Many things! First of all rewards process with two human tasks is not loaded from the application classpath, but is part of a kjar artifact with maven GAV “org.jbpm.examples:rewards:1.0”. That means that the maven client inside jBPM 6.2 has to be able to resolve this artifact from maven repositories. For this purpose you can just clone and build the rewards project from jbpm-6-examples-assets:

git clone
cd jbpm-6-examples-assets/rewards
mvn clean install

Also you do not have to care of session strategy and runtime manager now. Session strategy can be defined in a deployment descriptor file inside the kjar, or it can be decided at the deployment time.

StartupBean class

EJB annotation @Startup marks this bean for eager initialization, so before the application is ready, we register here our custom UserGroupCallback class and also we use injected deploymentService to deploy a kjar artifact from maven, which contains a business process definition that we want to use.

ProcessServlet class

This is a simple servlet that handles requests coming to /process context. It gets a recipient variable from a POST request and uses injected processService to start a process instance.

TaskServlet class

TaskServlet is bound to handle /task context. It overrides doGet() method to handle GET requests. Based on the command it does two different operations.

  • The first one uses runtimeDataService to retrieve all tasks for a particular user. The rewards process has two human tasks, the first one is for user jiri and the second one for user mary.
  • The second operation is to approve a user task. Operation approve does not exist in the jBPM context, or in userTaskService API in particular, so it is implemented as a single composite operation, consisting of a StartTaskCommand and a CompleteTaskCommand. So the human task is started and immediately completed.

RewardsUserGroupCallback class

UserGroupCallback is necessary not only for mapping between task service users and their membership in groups, but also to just register users in runtime TaskService.


That’s all! Only four classes are now necessary for rewards-basic example, which uses provided jBPM 6.2 EJB services.

rewards-cdi-jsf web example with jBPM 6.2 CDI services

This example combines jBPM 6.2 services together with Context Dependency Injection (CDI) and Java Server Faces (JSF) frameworks. The services share the same API, so the description of the services and their purpose is the same as in the previous example.

CDI is a powerful and very flexible framework how to build Java EE 6 applications, however in the contrary to EJB framework, it does not provide transactions and may have other limitations. In our example, the CDI requires a bit more code to get it properly working using jBPM 6.2 services.

StartupBean class

The purpose is the same as in the previous example, it uses CDI mechanisms to run the initialization code on the application startup.

ProcessBean and TaskBean classes

Again, the purpose is the same as in previous example. Both classes are annotated with a CDI stereotype @Model, which means they are both instantiated for one request (@RequestScoped annotation) and their public methods can be used in the expression language (EL) of the JSF frontend (@Named).

RewardsApplicationScopedProducer class

This class is necessary, because it contains several important producers.

  • The first one produces EntityManagerFactory, which is consumed inside jBPM library and used to setup persistence.
  • The second one produces a deploymentService. The producer class already consumes a qualified injection (using @Kjar qualifier), but it is important also to produce it for StartupBean to be consumed as a default injection.
  • The last instance to produce is a TaskLifeCycleEventListener, which is necessary, because when a human task is completed, it is used to trigger again the process engine and so advance in the process flow.


Since the example does not implement authentication, this is just a placeholder class. However it is necessary for it to be there.


This class is not that important, it serves more as a CDI demonstration, that you can initialize Logger and FacesContext instances in a single place.


Ok, that’s everything for now! In this article you have seen new jBPM 6.2 services in action. These services can reduce much of the code, which was necessary before, like working with RuntimeEnvironment, RuntimeManager, RuntimeEngine and other stuff. Clone the jbpm-6-examples, read the instructions and try the examples. I am looking forward to your comments and feedback!

jBPM 6 web application examples

After a long time, let’s see new technology in action. jBPM 6 was released in the end of the last year, so it’s quite fresh and still lacks good examples to easily start with. I’ll focus on my recent example projects, which demonstrate jBPM 6 in use as a workflow engine embedded inside a web application.

rewards-basic application

So far the git repo contains just two projects. The first one is called rewards-basic. It was developed by Toshiya Kobayashi, who created the original application using jBPM 5 and Java Enterprise Editon (EE) 5. I’ve rewritten his application to work with new jBPM 6 and also later standard Java EE 6. There are many useful improvements in the new engine. For example now you can use runtime managers with advanced session strategies to better separate process contexts or to gain a better performance, especially in concurrent environment. Seamless integration with Java EE world is done by Context and Dependency Injection (CDI). Many people still don’t like CDI, but once you learn it, you may realize its advantages. You may even continue to use jBPM without CDI and initialize your environment using ordinary Java constructors or factories.

Both applications are build around one simple business process. After start it creates a task for user John and after he approves his task, the process creates a second task for user Mary. After she approves her task, the process finishes. Example applications provide web interfaces to these operations – in particular to start a business process, to list human tasks available and to approve them. More information including steps how to run the programs can be found on Github link above.

ProcessBean class

This article focuses on internal structure suitable to software developers. Let’s start and take a look on a code snippet from a process service Enterprise Java Bean (EJB):

private RuntimeManager singletonManager;

This demostrates CDI and how it can be used. You can just inject an object of defined class to your bean and you don’t have to care about how and where it is initialized. Don’t worry, we’ll get to that! The second annotation is interesting as well. You may choose also others for advanced session strategies like @PerProcessInstance and @PerRequest. Their names are self-explanatory, just to be sure – the first one keeps session (context) for a process instance and the second one is just stateless, no state is kept. What can be done with the runtime manager then?

RuntimeEngine runtime = singletonManager.getRuntimeEngine(EmptyContext.get());
KieSession ksession = runtime.getKieSession();
ProcessInstance processInstance = ksession.startProcess("com.sample.rewards-basic", params);

Keep in mind that runtime manager usually follows singleton design pattern in your application. For each request you should get an instance of runtime engine from it based on the context. Note that runtime engine is just an encapsulation of a kie session and a task service. The session can be used to start a process instance. The task service is automatically linked to this session and can be used for human task related queries and commands. The last command just starts a process instance, so the business process is finally running.

The last thing that can be noted are user transactions. You don’t have to use user transactions, but they are useful in many cases. For example you may want to save some information into a corporate database at the same time with the execution of the process engine. This way you ensure that all operations are either committed or rolled back together.

TaskBean class

Similarly you can just simply inject a task service. Do you remember jBPM 5? The task service was decoupled from the process engine and had to be connected to the engine for each process run in order to support human tasks. jBPM 6 integrated the task service back to the engine.

TaskService taskService;
List list = taskService.getTasksAssignedAsPotentialOwner(actorId, "en-UK");

As you can see in TaskBean, you can easily run an arbitrary task service method.

CDI producer classes

In order to get CDI working you have to provide producers for injected class instance where necessary. One of the CDI advantages is the loose coupling. For example you may use a service in your beans, which functionality is dependent on running application server. This is ok, but how to easily unit test your application without setting up awkward application server? For example you can easily write a mock service for unit testing and don’t even have to modify a Java code. All you would have to do is just to change an alternative class in CDI configuration file beans.xml.

On the other hand debugging a CDI application may be difficult as the errors of unsatisfied dependencies are thrown mostly during run time, which slows the development process. If you know how to cope with this, please leave me a comment, thanks!

Application scoped producers

These producers can be found in ApplicationScopedProducer class. @ApplicationScoped annotation tells the application server (or more precisely the CDI container), that instances produced here should be instantiated for the whole life cycle of this web application deployment. It’s logical – for example the persistence unit (database connection) won’t change during the runtime of the web application.

Very important is also the RuntimeEnvironment producer, which provides whole setup for runtime manager, for example including our “com.sample.rewards-basic” process definition to be used. Runtime manager is injected from a jBPM library, but this same library also internally injects RuntimeEnvironment instance to get our environment that it doesn’t know.

You may also notice RewardsUserGroupCallback class. It is a simple user group callback and is defined as an alternative. This demonstrates that by using alternatives you may use your own classes, if you are not satisfied with prepared implementations coming from jBPM libraries.

Presentation layer

Web presentation layer is really simple. It uses Java Server Pages (JSP) technology and Java Servlets to handle presentation logic. Web user interface is just plain HTML, because the focus was put on demonstrating the internal service logic.


The second example application stays internally mostly the same, based on the same concepts. However Java Server Faces (JSF) technology including CDI is used for presentation layer.


I have described briefly two simple web applications demonstrating together jBPM 6 and Java EE 6. Please write a comment if you’ve liked them or if you have some feedback, I would be happy to hear your opinion. Thanks.

My first release!

Yesterday I released the first version of my jBPM workflow plugin. I started research and development of this JenkinsjBPM integration at the university in November 2011. And my company let me to continue work on my project. That’s great, because this is one of the things, which keeps my job from becoming monotonous and also I have learned a lot of knowledge by working on this project.

Continuous integration helps many companies in their software development. Jenkins is one of the most widespread CI servers. It’s used for several purposes – building software, running tests, publishing results, software analysis, etc. As a quality engineer I have mostly experience only with Jenkins as a tool for running many matrix tests. Axis include operating systems, Java development kits (JDK), databases, Java content repositories (JCR) and web browsers. Many test types are included too like unit, regression, integration, performance and others. And as you continuously work on something, you tend to optimize your steps.

So back to start – I had to apply for a master project and found an interesting topic. The task was to create a Jenkins plugin, which would enable to run test plans by using business processes to improve efficiency of the quality engineering department. If you spend less time with starting, monitoring and evaluating Jenkins jobs, then you have more time for other tasks, for example improving test coverage of a product. I defended the master’s project and continued to improve it.

Now the early release of the plugin has been done. However current solution still has several limitations. It can fully run only in JBoss AS 7 container. What is meant by fully? That means running business process with persistence enabled. That’s necessary if you want to easily recover the latest state from database in case of unexpected outage. Theoretically the plugin should run without persistence on any container, but I have not verified that. And also it’s necessary to mention that the JBoss AS needs its jpa subsystem to be disabled. That can be real limitation if you host more applications than Jenkins in one application server instance.

Problems that had to be solved

I’ll try to summarize problems I faced with the implementation of the plugin.

Jboss AS 7 Hibernate was not able to find persistence.xml of my plugin

This happened because of complexity of combination of Jenkins and JBoss classloading. Jenkins uses several classloaders and one of them is dedicated for plugins. So the Jenkins .war is deployed in the application server, but deploys .hpi file by its own mechanism. This was solved by changing context classloader of the plugin thread to that dedicated classloader.

JBoss AS 7 had a tendency to supply its own Hibernate

After many failures I have decided to supply hibernate .jars directly with the plugin and od not depend on the ones provided by JBoss AS. But running two Hibernate frameworks together could not work. I have tried many things how to disable classloading of Hibernate into Jenkins or into my plugin using the jboss-deployment-structure.xml. This file should exclude or include specific classpath elements specific for your application. Unfortunately without success. So I had to disable jpa subsystem in standalone.xml configuration file. This way correct Hibernate is loaded and is able to find the persistence.xml file.

Transaction issues

I had also issues with transactions, but honestly I don’t remember them exactly. The solution was to implement own way for looking up a transaction manager.

Future of the plugin

Current implementation of the plugin has its drawbacks, these include:

  • need for setup an additional Jenkins job for launching the business process build step with with test plan
  • only JBoss AS 7 with disabled jpa subsystem is usable for persistence

The best approach to solve this can jBPM remote handler implementation. This handler implements a work item handler in jBPM for JenkinsJob service task. It’s the same service task  as in jBPM workflow plugin, or at least with the same interface. You can supply it in the same way with the job name to launch, optionally with parameters in case of parameterized build and receive an object as a result. This is great since you can use both integration approaches and your business processes will remain the same. Only handler implementation changes.

Remote handler as the name suggest will start and evaluate Jenkins jobs remotely. Business process instance will run in jBPM console (simple process server) or a user application, which uses jBPM engine inside. jBPM console can also handle human tasks, for example for decision of the QA engineer like what to do if basic tests failed etc. The main benefit will be decreased complexity of the integration implementation and also there will be no limitations on application server for Jenkins.


I have learned a lot of technical stuff on this project. I have understood many concepts. But most importantly I have learned that it’s not a good idea to integrate two complex technologies directly on the application level. At least in Java you’ll end up with many classloading problems. If you can oppose this, please leave me a comment, thanks.