Thursday, October 20, 2016

RESTEasy Spring 4 integration

Recently when I was going through the RESTEasy documentation to find out the proper way to integrate it with Spring. There are several ways to do it. This is the first post in this series which will cover the ways to integrate RESTEasy with Spring.

We will start with the one which is mentioned in the RESTEasy documentation. We will be using Maven for dependency management in our project. First of all, add the RESTEasy dependency in your project,


  org.jboss.resteasy
  resteasy-spring
  whatever version you are using


Above code will add resteasy dependencies in your project. Next step is to define RESTEasy configuration in your web.xml.


 Archetype Created Web Application
 
  
   org.jboss.resteasy.plugins.server.servlet.ResteasyBootstrap
  
 

 
  
   org.jboss.resteasy.plugins.spring.SpringContextLoaderListener
  
 

 
  Resteasy
  
   org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher
  
 
 
 
  Resteasy
  /*
 


This will initialize RESTEasy and Spring. RESTEasy includes SpringBeanProcesor which is an implementation of BeanFactoryPostProcessor. This bean processor checks whether the created bean contains RESTEasy annotation and if it does then adds it to the RESTEasy repository.
RESTEasy repository is initialized by ResteasyBootstrap class. So the sequence must be in the order which is specified above.

There is a problem (Bug#1012) with Spring 4 and RESTEasy (3.0.6 version) integration. SpringContextLoaderListener of RESTEasy has overridden createContextLoader method from ContextLoaderListener class of Spring which was deprecated in Spring 3.0 and has been removed in Spring 4.
To fix this issue, we need to provide our own implementation of Spring ContextLoaderListener which will register RESTEasy's SpringBeanProcessor and integration will work.

public class PatchedSpringContextLoaderListener extends ContextLoaderListener {

 private SpringContextLoaderSupport springContextLoaderSupport = new SpringContextLoaderSupport();
  
 @Override
 public void contextInitialized(ServletContextEvent event) {
  System.out.println("Initializing context");
  
  boolean scanProviders = false;
  boolean scanResources = false;
 
  String sProviders = event.getServletContext().getInitParameter(
    "resteasy.scan.providers");
  if (sProviders != null) {
   scanProviders = Boolean.valueOf(sProviders.trim());
  }
  String scanAll = event.getServletContext().getInitParameter(
    "resteasy.scan");
  if (scanAll != null) {
   boolean tmp = Boolean.valueOf(scanAll.trim());
   scanProviders = tmp || scanProviders;
   scanResources = tmp || scanResources;
  }
  String sResources = event.getServletContext().getInitParameter(
    "resteasy.scan.resources");
  if (sResources != null) {
   scanResources = Boolean.valueOf(sResources.trim());
  }
 
  if (scanProviders || scanResources) {
   throw new RuntimeException(
     "You cannot use resteasy.scan, resteasy.scan.resources, or resteasy.scan.providers with the SpringContextLoaderLister as this may cause serious deployment errors in your application");
  }
 
  super.contextInitialized(event);
 } 

 @Override
 protected void customizeContext(ServletContext servletContext, ConfigurableWebApplicationContext configurableWebApplicationContext) {
  System.out.println("Customizing context");

  super.customizeContext(servletContext, configurableWebApplicationContext);  
  this.springContextLoaderSupport.customizeContext(servletContext, configurableWebApplicationContext);
 }
 
}

Monday, April 20, 2015

Spring AOP : JDK Proxy vs CGLib Proxy

Spring framework is one of the most widely used framework in Enterprise application development. It has so many features such as Dependency injection, Data access integration, MVC, AOP which takes care of most of the boilerplate part of project, and developers can then focus on business logic only.

One of the important feature in Spring is AOP. It is used by almost every enterprise application which is being developed using Spring.

AOP

So what is AOP? Definition of AOP -
Aspect oriented programming is a programming paradigm which aims to increase modularity by allowing the separation of cross cutting concerns.
Well, my understanding of AOP is - AOP allows us to introduce/join new modules in your project at pre-specified dynamic locations without having to code for it. Traditional examples of AOP is Transaction management, logging etc. You can read more about AOP at here.

This article is for those who know AOP, have used AOP in their projects but do not know how Spring or other DI frameworks provide this functionality.

Now lets take an example, suppose we want to process user related data. But we also want to mandate authorized users access only. So we add an interface UserService to our project.

@AuthorizationRequired(role=ADMIN)
public interface UserService {
    public User getUserById(Long id);
}

// dummy implementation

public class UserServiceImpl implements UserService {
     public User getUserById(Long id) {
          // logic to get user information from database
     }
}


You must have noticed AuthorizationRequired annotation. Well we use this annotation to specify required authorization for current user.

Now, we bind the dependency in application context.


Lets define our Aspect as
@Pointcut("execution(* com.techsach.example.services..*.*(..))")
public void beforeAnyServiceMethod(){}

@Before("beforeAnyServiceMethod()")
public void before(JoinPoint joinPoint) throws AuthorizationException {
 MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
 Method method = methodSignature.getMethod();
 AuthorizationRequired annotation = method.getAnnotation(AuthorizationRequired.class);
 // now we check whether current user had role specified in Annotation, if not then throw exception
}

This will tell Spring to intercept all the methods of all classes inside services package. Before executing any method from services package, execute our code which validates that current user has authorization to perform current operation.

If you know the Proxy class and has worked with reflection then you should have an idea that how Spring would be doing this internally. Even if you don't, no problem. Lets see how Spring or any DI framework would be doing this.

To intercept the calls we need to have a Proxy, which will perform some operation which we specify and then delegate the call to real worker(in our case class). So we use proxy pattern to perform this, but what is Proxy pattern? It is -
Proxy pattern is an interface which is functioning as something else
Generally, interfaces are used in code and concrete implementations are bound in the application context. By using this abstraction we can replace the different implementation without changing the code.
There are two ways to create Proxy classes in Java

  1. JDK Proxy
  2. CGLib Proxy

JDK Proxy


JDK Proxy allows us to create proxy classes at runtime with specified interfaces. To use Proxy class, we also need an InvocationHandler. When calls to a proxy class are made, calls are delegated to InvocationHandler. In our case, we already have an interface UserService and implementation UserServiceImpl. Lets create an InvocationHandler first,
public class UserServiceInvocationHandler implements InvocationHandler {
 private UserServiceImpl userServiceImpl;
 public UserServiceInvocationHandler(UserServiceImpl userServiceImpl) {
  this.userServiceImpl = userServiceImpl;
 }
 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  // here we can invoke our own logic before executing method of real class
  // We can execute code from 'before' method which we defined earlier in our Aspect
  return method.invoke(userServiceImpl, args);
 }
}


UserServiceInvocationHandler accepts UserServiceImpl as we want to delegate the calls to real class after intercepting the calls. Now to create a Proxy class of UserService we use static method of Proxy class,
// implementing class
UserServiceImpl userServiceImpl = new UserServiceImpl();

// proxy 
UserService userServiceProxy = Proxy.newProxyInstance(
  UserServiceImpl.class.getClassLoader(), 
  UserServiceImpl.getInterfaces(), 
  new UserServiceInvocationHandler(userServiceImpl));
This will return the proxy instance of UserService, which will intercept the calls to UserServiceImpl and execute our code before invoking real method.

But as stated earlier, JDK proxy allows us to create proxy class using interfaces only. So what if we have a method in the implementation which is not declared in the interface? Well, calls to these methods cannot be intercepted using JDK proxy.

CGLib Proxy

CGLib allows us to create proxy classes at runtime by creating sub class of specified class using Byte code generation. CGLib proxies are used in the case where Proxy is to be created for those class which does not have any interfaces or have methods which are not declared in the implementing interface.
To create CGLib based proxy, we need InvocationHandler same as JDK proxy InvocationHandler but from CGLib package.
public class UserServiceImplInvocationHandler implements net.sf.cglib.proxy.InvocationHandler {
 private UserServiceImpl userServiceImpl;
 public UserServiceImplInvocationHandler(UserServiceImpl userServiceImpl) {
  this.userServiceImpl = userServiceImpl;
 }
 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  // we invoke 'before' method of our Aspect here to check user authorization.
  return method.invoke(userServiceImpl, args);
 }
}
This invocation handler will be used to create proxy class of UserServiceImpl.

Lets create a proxy class,
// object of implementing class
UserServiceImpl userServiceImpl = new UserServiceImpl();

// create proxy using CGLIB
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserServiceImpl.class);
enhancer.setCallback(new UserServiceImplInvocationHandler(userServiceImpl));
UserServiceImpl userServiceImplProxy = (UserServiceImpl)enhancer.create();
Above code will create UserServiceImpl proxy, which will intercept all public methods of UserServiceImpl class.

Although this proxy will intercept the calls but our logic to check authorization will fail which you can figure out why :)

Wednesday, December 24, 2014

Importance of Facade Layer

I still remember that around mid 2013, I was arguing for the same concept of Facade layer in our application in my earlier company. I was unable to digest the importance of Facade layer, so I was of firm opinion that Facade layer is unnecessary and should not be used!!

After 3 years, today when I was working on some code I realized that if we would have used Facade layer in our application then my work would have been much simpler than what I was doing...

Structure of our application -


Controllers/CommandHandlers
                                                  | <----- Aspect execute at here
Service Layer
|
Accessor/DAO
|             |
DB      Server

This is the structure of our application, in which Service layer handles the gathering and processing of data from DB and server process.
We have a concept of MSU, where our application hosted of a central server gathers data from various servers and shows it on the centralized server. Now when call from controller or command handler goes to service layer, our custom Aspect comes into picture and performs the same operation for various servers mapped into our application.
Now this operation can be of four types -

Wednesday, November 19, 2014

Spring Custom Scope

Spring framework is one of the DI frameworks which is largely used to develop web applications(enterprise). It provides almost every feature which is required to develop a enterprise web application. Also it is extendable, so you can customize it the way it suits for your application.


Custom bean scope

Although bean scopes provided by Spring fulfills requirements of the application, some times you may need something different which is not available by default. In our application we faced the same situation.

Requirement

We had a requirement of the scope which uses an application value to decide which bean to use(return). The default scopes provided by Spring were not useful and was not providing the required functionality.

Implementation

As I said earlier, Spring is extendable. It provides an interface Scope, which you can implement to introduce custom scope in your application.

To create custom scope, Scope interface needs to be implemented. Scope interface has following methods -

Thursday, February 14, 2013

Notepad++ Compile and Run Java Programs

Notepad++ is a great file editor. It has many features. The most important feature which I like about Notepad++ is its light weight. It loads up so quickly, that's great. It also provides syntax highlighting for many languages. I use notepad++ to edit general files as well as my simple Java programs.
Although notepad++ provides functionality to run external programs, I prefer NppJavaTools plugin to compile and run Java programs using notepad++.
You can download NppJavaTools plugin from this page - NppJavaTools.

Installation

Installation of plugins in notepad++ is very simple process. All you have to do is copy plugin dll into plugins folder of notepad++ installation directory and restart the notepad++.

Features
This plugin provides following features,

  1. Compile and run your Java files within Notepad++
  2. Set custom hotkeys for compiling and running Java Code
  3. Library support

Compile and Run

This function allows you to run your Java programs to compile and run from Notepad++.
NppJavaTools Plugin Update
NppJavaTools Plugin Update

Set Custom hotkeys

This function allows you to set custom hotkeys for Compile and Run command.
NppJavaTools Settings
NppJavaTools Settings

Library support

You can specify which libraries to use while compiling and running your Java programs using NppJavaTools. As shown in above image of Settings window, you can add, remove single or clear all the library files.

Tuesday, February 12, 2013

Windows Media Player Transparent Seek Bar How To

If you are a Visual C++ programmer or you have learnt Visual C++, you might have seen and wondered how Windows Media Player Seek Bar is designed. Well, I have always wondered about it before today..
The Seek bar which Windows Media Player is a transparent seek bar. It uses a gradient fill from bottom to top. When you are playing some video in Windows Media Player, you can see the video running behind this seek bar.
Many times I tried to design a control like this, where a control is transparent and the control which is placed behind this control should be visible. Although I never succeeded in this one, but I tried it a lot of times.
Today when I was listening to songs using Windows Media Player(!!), I saw when I click on the area near to seek bar Windows Media Player's main window gets de-activated. The technique behind the transparent seek bar is to create a separate top level window.
This second top level window should be a Layered Window, you can read more about Layered Window here. Now when ever you main window gets a WM_SIZE message, set the size of your second top level window as well. As the second window is layered, we don't need to repaint it again and again unless user interacts with this window.

Tuesday, February 5, 2013

Valentines Day Screen Saver

Few years back when I was in college I used to get huge amount of time to learn new technologies. In those days once I was trying to learn DirectX programming using Visual C++. I started with few tutorials and learnt a lot about the DirectX programming. At that time I designed my first screen saver using DirectX and Visual C++ which was Falling Hearts screen saver.
Every time valentines day comes close, I still get many mails regarding this screen saver. Some of them are to modify the screen saver, some of them are for the download link and some of them are Thank you mail.
Well, I am happy about it but as said earlier I wrote it long time back and neither I have source code for it anymore with me to modify it nor the time.
To download the screen saver please visit Softpedia at http://www.softpedia.com/get/Desktop-Enhancements/Screensavers/Valentine-Screensaver-CM.shtml

After this screen saver I wrote another small and very simple game using DirectX, here is the video for it.

Programming with Visual C++ and DirectX API is fun.

Ads Inside Post