Pages

Showing posts with label JRebel. Show all posts
Showing posts with label JRebel. Show all posts

Friday, August 8, 2014

Spring 4 MVC without Web.XML configuration - static resources handling

This short post is the update to the previous ones: 
    Previously was only defined the way how to link symbolic links and components location  to scan which are normally defined by specific ServletContext *.xml file as in following example :
...
    
    
        
        
    
...
and we've transformed such *.xml file into the Java code in github project miko-s4netty:
@Configuration
@ComponentScan("com.miko.s4netty")
@EnableWebMvc
public class WebConfig {
    @Bean
    public UrlBasedViewResolver setupViewResolver() {
        UrlBasedViewResolver resolver = new UrlBasedViewResolver();
        resolver.setPrefix("/WEB-INF/pages/");
        resolver.setSuffix(".jsp");
        resolver.setViewClass(JstlView.class);
        return resolver;
    }
}

Let's give *.jsp pages access to the static resources and consider following project structure (Img.1.)
Img.1. - part of project structure with static resources
From the Img.1. comes the necessity to link the two folders ("/app", "/lib") which will by available for the front-end development after the application deployment. In such case we need to extend the implementation of the WebConfig class and configure callback methods to correctly customise Java-based configuration of the project. 

1. WebConfig extends WebMvcConfiguredAdapter which give us possibility to directly override necessary methods from WebMvcConfigurerWebMvcConfigurer is normally imported by adding @EnableWebMvc annotation to @Configuration application class. The result it then delegated to WebMvcConfigurationSupport which provides Java-based config possibility. 
@Configuration
@ComponentScan("com.miko.s4netty")
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {
2. XML tag annotation for handling servlet requests <mvc:default-servlet-handler /> needs to be reflected in the WebConfig class by overriding  configureDefaultServletHandling method


...
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
   configurer.enable();
}
...
3. Also resources request handling needs to be reflected by overriding appropriate method in the class WebConfig. This is normally done by XML tags <mvc:resources/> 


...
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
   registry.addResourceHandler("/app/**").addResourceLocations("/app/").setCachePeriod(31550522);
   registry.addResourceHandler("/lib/**").addResourceLocations("/lib/").setCachePeriod(31550522);
}
...
The last WebConfig class modification opens the possibility to continue building front-end application with appropriate resources. 
The final result of WebConfig class according to the front-end project structure (Img.1.) can looks like following example.
@Configuration
@ComponentScan("com.miko.s4netty")
@EnableWebMvc
public class WebConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/app/**").addResourceLocations("/app/").setCachePeriod(31550522);
        registry.addResourceHandler("/lib/**").addResourceLocations("/lib/").setCachePeriod(31550522);
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }

    @Bean
    public UrlBasedViewResolver setupViewResolver() {
        UrlBasedViewResolver resolver = new UrlBasedViewResolver();
        resolver.setPrefix("/WEB-INF/pages/");
        resolver.setSuffix(".jsp");
        resolver.setViewClass(JstlView.class);
        return resolver;
    }
}
Enjoy building rich front-end application!

Friday, June 27, 2014

Spring4Netty without Web.XML configuration on Java 8 (JBoss WildFly and Tomcat 8) - part.5:: Application Servers and logging

  
img.1.: official log



  This part about selected application start normally, just by downloading both of them and setting them up in your favorite IDE (img.2.) which is in my case IntelliJ IDEA (img.1.)


img.2.: Application Serves bond with IDE
   So here we go, app servers inside (like the intel processor). What it good to point out already at the beginning is the servlet-api versions support. 

Don't try to run this example project (GiTHub repository) on Tomcat 6.x. Why ? It's because Tomcat 6.x supports servlet-api ver. 2.5, and as you can find in the parent pom.xml file, the version 3.x of servlet-api is required. It's because of features we have touched earlier  (part.4..

   Almost every project uses some logging framework, in project case we use Simple Logging  Facade (SLF4j) together with well known Log4j. I don't want to write a lot about application logging design it's the another story (this project is just hot setup of usage). 
   What I want to touch here is the topic "How to enable logging under JBoss WildFly per deployment for SLF4j" 
   It 's because by the default installation of WildFly it not allowed. You see actually any Logger output in your SystemOut or log file.  

Let's edit in following way the ../standalone.xml file that you can find in the WildFly directory
   ...
   
        
            
            <!-- IMPORTANT LINE --> 
            

            
                
                
                ...
                
                
            
            
        ...
        
   ...
   
   ...
The logging is not fully setup but important details are there so you can enjoy my project. 
s4netty project GiTHub repository



ps: Also I've not merged JUnit, Mockito  tests in case I didn't want to touch this topic in this blogpost. 

Spring4Netty without Web.XML configuration on Java 8 (JBoss WildFly and Tomcat 8) - part.4:: Base - Spring MVC without Web.xml usage 2

  
img.1.: s4netty-web deployment result

  The base web module s4netty-web is almost similar to  the previous worker module (s4netty-worker) from the perspective of the Spring MVC configuration. 

  The main difference is the Servlet Context setup. In the usage 1 (s4netty-worker) everything was defined by appropriate annotations. In the usage 2 (s4netty-web) the Servlet Context is defined in traditional XML way from perspective of servlet definition. 
   ...
   

   
     
     
   
   ...
  The WebApplicationContext is instantiated by XmlWebApplicationContext which (img.2.) extends AbstractRefreshableWebApplicationContext. Here we go deeper to all WebApplicationContext implementations which are supposed to instantiate themselves  according to the provided configuration over the interface. 
img.2.: s4netty-web module structure 
  The purpose of  XmlWebApplicationContext  class is to load WebApplicationContext from the XML configuration files.  
public class WebInitializer implements WebApplicationInitializer {
    ...
    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        ...
        XmlWebApplicationContext ctx = new XmlWebApplicationContext();
        ctx.setConfigLocation("WEB-INF/spring/dispatcher-servlet.xml");
        ctx.setServletContext(servletContext);
        ...

  What was also earlier only briefly touched (part1:: img.0.) is the ability of s4netty-web module to communicate with s4netty-worker  module utilising JSON serialisation/deserialisation over the service and pre-defined port P.

  The s4netty-web module uses instantiation of the RestTemplate which simplifies communication with HTTP server, its synchronous and it enforces RESTful principles, what is obvious from it name RestTemplate ;), but honestly it's pretty handy to use. 
@Controller
@RequestMapping("/")
public class MainController {
    ...
    RestTemplate restTemplate = new RestTemplate();

    @RequestMapping(method = RequestMethod.GET)
    public String printWelcome(ModelMap model) {
    ... 
  Let's ask s4netty-worker module for the car list using newly instantiated RestTemplate
    ...
   private List getSimpleCarList(){
        List result = new ArrayList<>();
        try{
            result = restTemplate.getForObject(S4_NETTY_WORKER_LINK, List.class);
            logger.debug("getSimpleCarList result= " + result);
        }catch (HttpClientErrorException e){
            logger.error("getSimpleCarList jsonCarList e= " + e);
        }
        return result;
   }
   ...

  Now we have ready two deployable war files and we can take a look at the result. But before we do so it's fair to mention why such configuration works.  The reason is that we do use for
 registering servlets in both cases  
   ...
   import javax.servlet.ServletRegistration.Dynamic
   ...

interface which uses one of addServlet()  methods into ServletContext. The interface is the part of javax.servlet-api imported previously by Maven into the project. 
  ...
  
        javax.servlet
        javax.servlet-api
        3.0.1
        provided
  
  ...
After this final hit we do know all and we can start with deployment on application servers (JBoss WildFly & Tomcat 8 were selected).
Let's make it in the Next part (Click Next

s4netty project GiTHub repository

  

Thursday, June 26, 2014

Spring4Netty without Web.XML configuration on Java 8 (JBoss WildFly and Tomcat 8) - part.3:: Worker - Spring MVC without Web.xml usage 1

  

  Now we are entering the last stage in case of s4netty-worker.  Although we have already enabled Netty usage under spring ecosystem, we still want to provide some simple web (Spring MVC) for this module to see the output from the Netty JSON service.  


s4netty-worker - spring mvc output
img.1.: Spring MVC output from s4netty-worker

  I won't go into the details how to build up the basic Spring MVC project because it's easy to find out by our friend google. What is interesting is how to not use web.xml (Deployment Descriptor Element which determinates the urls mapping to appropriate servlets ) definition alias get some freedom for Java web applications. In case of s4netty-worker we do almost everything over annotations, only beans will be defined in separate app-worker-config.xml file (viz. img.2).  


img.2.: s4netty-worker module structure 

  Before we initiate web application itself by WorkerWebInitializer, that implements WebApplicationInitializerwe need to do some configuration here. (ps. WebApplicationInitializer allows us to configure servlets, filters and etc. by @Override onStatrup method)
public class WorkerWebInitializer implements WebApplicationInitializer {
   ...
   @Override
   public void onStartup(ServletContext servletContext) throws ServletException {
       AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
       ctx.register(WorkerWebConfig.class);
       ctx.setConfigLocation("spring/app-worker-config.xml");
   ...
without such configuration our WorkerWebInitializer is useless because after WebApplicationContext instantiation Spring looks for Spring configuration files annotated by @Configuration annotation. For this purpose we create WorkerWebConfig class. 


@Configuration
@ComponentScan("com.miko.s4netty")
@EnableWebMvc
public class WorkerWebConfig {
   ...
   @Bean
   public UrlBasedViewResolver setupViewResolver() {
   ...

in WorkerWebConfig class we tell to the Spring where it should look for the rest of components (example: classes annotated by @Controller). By using @EnableWebMvc we import  the DelegatingWebMvcConfiguration which delegates us to all beans reliable for WebMvcConfigurer and our customisation.  At the end the method setupViewResolver allows us to briefly solve symbolic link name to the URL. Pretty cool, isn't it ?

  The one of the impact is that we can store our favorite ;) *.jsp pages in the appropriate directory (img.2.)

  Now we have ready s4netty-worker web output with appropriate Beans initialisation, which is done by ServletContext configuration definition located in the file spring/app-worker-config.xml

  

  
    
  
   And finally our result looks according to the img.1. mentioned at the beginning of this part. 
The big moment is here because we are moving to the stage 2 (s4netty-web).
The next part (Click Next

s4netty project GiTHub repository 
  

Spring4Netty without Web.XML configuration on Java 8 (JBoss WildFly and Tomcat 8) - part.2::netty and JSON

  

  In the introduction (part.1). we've pictured out the basic idea of the project  abstraction(car exchange;). In this part we are going to configure Netty as the part of maven spring module (s4netty-worker). 

  Let's draw the agenda that allows us to start netty server under the spring ecosystem:
  1. initiate serverBootstrap object and configure the Netty server from properties file (worker-server.properties).
  2. configure the group, channel, handler and some channel options (ps: keep alive signal has been ignored in this project)
  3. Channel initialisation  
  4. Netty JSON service response
  5. Netty JSON request handling
  Let's begin and configure WorkerNettyServer which contains the instance of the serverBootstrap bean (add.1.). ServerBootstrap definition can be found in WorkerNettyConfig class.
@Bean(name = "serverBootstrap")
public ServerBootstrap bootstrap() {
All necessary  properties for WorkerNettyConfig class used by serverBoostrap (add.1.) bean initialisation are taken from the config the file (worker-server.properties) 
@Configuration
@ComponentScan("com.miko.s4netty")
@PropertySource("classpath:worker-server.properties")
public class WorkerNettyConfig {
  To make possible reading from the *.properties file   
@Value("${tcp.port}")
private int tcpPort;
we need to have access to the current Spring Context. This goal we achieve by using property sources place holder :
@Bean
public static PropertySourcesPlaceholderConfigurer propertyPlaceholderConfigurer() {
   return new PropertySourcesPlaceholderConfigurer();
}
Now WorkerNettyConfig knows all values for its initiation 
@Bean(name = "serverBootstrap")
public ServerBootstrap bootstrap() {
   ServerBootstrap b = new ServerBootstrap();
After all those configuration steps, we get access, inside the WorkerNettyServer class, to the bean "serverBootstrap" by using Qualifier annotation for candidate Bean serverBootstrap (add.2.). 
@Component
public class WorkerNettyServer {
    ...
    @Autowired
    @Qualifier("serverBootstrap")
    private ServerBootstrap serverBootstrap;
    ...
and we can have quickly assign all serverBootstrap properties (add.2.
@Bean(name = "serverBootstrap")
public ServerBootstrap bootstrap() {
    ServerBootstrap b = new ServerBootstrap();
    b.group(bossGroup(), workerGroup())
    .channel(NioServerSocketChannel.class)
    .childHandler(workerInitializer);
  So move forward and initiate the Channel and it's pipeline in the WorkerInitializer class (add.3.). Of course all according to our "master plan" to have JSON service listening on the specified port P and exchanging car list with base.
  In this case we need totell Netty how it should deal with such type of the request by utilising HttpServerCodec (add.4.). 
pipeline.addLast(new HttpServerCodec());
pipeline.addLast(workerProviderHandler);
  Currently it looks like JSON service  is listening on the port P and everything is almost ready to go. Well not exactly, there is still a some work do. 
  One good question could be about some missing definition :) oh, yes, where is 
workerProviderHandler ? (add.5.)  and here we go.
@Component
@ChannelHandler.Sharable
@Qualifier("workerProviderHandler")
public class WorkerProviderHandler extends ChannelInboundHandlerAdapter {
  ...
  @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        if (msg instanceof HttpRequest) {
            HttpRequest req = (HttpRequest) msg; 
  ...
  The workerProviderHandler is the extension of ChannelInboundHandlerAdapter and it handles our request and provides the JSON response to the requestor (s4netty-web). 
The request itself consists from results provided by spring service. 
...
@Autowired
SimpleCarService simpleCarService;
...
Gson library has been used to serialise and deserialise POJO objects.

After defining handler and assigning to the pipeline we are done with Spring-Netty Configuration and ready to define module (s4netty-worker) Spring MVC without Web.xml usage. 
Sure, in the next part (Click Next

s4netty project GiTHub repository




Spring4Netty without Web.XML configuration on Java 8 (JBoss WildFly and Tomcat 8) - part.1::introduction

  
  Although I'm working with Netty for while ( in different scenarios ;) ,  I've not found so much examples how to use Netty 4.x together with Spring Framework 4.x. Honestly I've found mostly some pieces of the whole solution (maybe I was not search so much around). 
  My following project shows how to make it  run. Another purpose of it is to present Spring 4 configuration without web.xml.

  My idea at the beginning was that this blog post will be just only small description how to. Pretty soon I realised that there is no chance to sum everything up into one blog post. I'd rather split everything into smaller parts than long fuzzy text (hopefully this text won't be fuzzy :). So I've separated everything  and parts could be accessed individually if  it's needed.  

The project is also available over my GiTHub repository .


img.0.: s4netty results (s4netty-web, s4netty-worker and JSON)


agenda:

  1. Configure Netty as service provider (s4netty-worker) 
  2. Configure s4netty-worker Spring MVC without Web.xml usage 1
  3. Configure Spring MVC without web.xml (s4netty-web) usage 2
  4. Run everything on JBoss Wildfly or Tomcat 8 with logging
servers: 
  1. Tomcat 8
  2. JBoss WildFly

development IDE: IntelliJ IDEA 13.x
other technologies: JRebel 6.x Experimental 
building tool: Maven 3.2.x
libraries: see the maven pom.xml - the parent module

Introduction: 
  The basic abstraction behind the application is exchanging JSON object between web spring MVC BASE (s4netty-web) and s4netty WORKER (s4netty-worker) (img.1.). The object exchange is done over defined port P.  For this purpose JSON has been used as the type of object serialisation. 
img.1.: s4netty app abstraction
  Both Spring-Base (s4netty-web) and Netty-Worker (s4netty-worker) modules use Spring MVC Framework with different type of WebApplication context initialisation. Aside Netty-Worker uses Netty (asynchronous event-driven framework) to open the Port P to provide the result of the spring service to the Spring-Base (s4netty-web). Spring-Base uses restTemplate for communication with  Netty-Worker. 

  So let's start to exchanging cars and move to the PART 2. (click).



Friday, May 30, 2014

BIRT , Spring framework and Neo4j (BSN) - one more thing ~ Cypher

The main intent of the previous blog post (ref.1.: "BIRT , Spring framework and Neo4j (BSN)") was to describe sample BIRT integration into the Spring-Ecosystem with usage of Neo4j GraphDB over spring-data-neo4j project. 

GiTHub project: miko-spring-birt is waiting to be tested

I got some open questions there and some fun with running on different machines. The answer to the FeatureTwo (ref.1.), is still postponed, but it's coming, let's keep in mind. 

This additional blog post I would like to focuse on awesome features of Cypher and show some nice use-cases, how to get POJOs from Neo4j and deal with them. 
(moto: keep it simple just Cars and Garages)

Let's start with few words at the beginning. 
Cypher (intro) is a declarative graph query language which allows us to do lot of things (expressive and efficient queries , creating or updating GraphDB etc.). The main goal has been to create language suitable for developer and professionals (human readable declarations).  Cypher language has been also inspired by couple of different approaches (SQL, SPARQL for expressions and also some semantic details from other languages) as is visible from the updated demo (GiTHub miko-spring-birt)


BSN - Neo4jDB initial state
pic.1.:: initial state of Neo4jDB Cars are located in their Garages

By using Cypher language over native Neo4j interface (http://localhost:7474) written in AngularJS we can employ Cypher abilities to get specific NCar located in NGarage (pic.1.)
Let's find the 'Ford' node with its NGarage
CYPHER $: MATCH MATCH (ncar:NCar {make: 'Ford'})<-[:located]-(garage: NGarage {name:'GarageOne'}) return ncar, garage
Using defined command query we should get the following result (pic.2.)
pic.2.::NCar Ford is located in the GarageOne
We can also check which cars are located in the NGarege {name: 'GarageOne') by doing small changes into the Cypher query:
CYPHER $: MATCH MATCH (ncar:NCar {coreName: 'CAR'})<-[:located]-(garage: NGarage {name:'GarageOne'}) return ncar, garage
At the end we should get expected result (pic.3.):
pic.3.:: GarageOne has some cars
Now is good time to move to the next step. 

Let's merge Cypher abilities with Spring-Data-Neo4j GraphRepository interface implementation. Maybe it can be useful to make small comparison with Spring-Data-JPA project to see tiny differences between passing @Param into the @Query (service.3.)

To see how everything works we will create following simple services: 

1. service will find and return the Car made by Ford by using @Query annotation in repository service. We define 
public interface NeoCarService {
NCar findByMakeFord();
method which calls repository implemented service
@Query("MATCH (ncar:NCar) WHERE ncar.make = 'Ford' return ncar")
NCar findByMakeFord();
2. service is almost similar but the difference is new condition. It will return the car made by 'Ford' only if the car is located in the garage and return.  In this case we extend our service 1. by adding also reference to the car garage : 
public interface NeoCarService {
  ...
  NCar findByMakeFord();
  NCar findByMakeForWithGarage();
  ...
the service implementation
...
@Override
public NCar findByMakeForWithGarage() {
  NCar car = nCarEntityRepository.findByMakeFordWithGarage();
  car.setGarage(nGarageEntityRepository.findOne(car.getGarage().getId()));
  return car;
}
...
now do update to the related repository
public interface NCarEntityRepository extends GraphRepository<NCar> {
...
@Query("MATCH (ncar:NCar {make:'Ford'})<-[:located]-(garage) return ncar")
NCar findByMakeFordWithGarage();
...   
3. service will return the number of located cars in the chosen Garage by name. To do so is necessary to define new method provided by NeoGarageService
public interface NeoGarageService {
  ...
  int getCarNumberByName(String garageName);
  ...
and we can call over the repository directly Cypher query:
public interface NGarageEntityRepository extends GraphRepository<NGarage> {
  ...
  @Query("MATCH (g:NGarage)-->(nCar: NCar)-->(g_of_nCar) WHERE g.name = {name} RETURN count(g_of_nCar)")
  int getCarNumberByName(@Param("name") String name);
  ...
 
When you try Cypher query over Neo4j AngularJS interface you should see the following result (pic.4.)


pic.4.:: In the GarageOne are located following number of cars

Here is visible the tiny difference between passing @Param int the query in case of JPA CrudRepository
@Query("select c from Car c where u.make in :names")
Iterable<Car> findByNames(@Param("names")Set<String> makeList);
At the end of the story we create simple BIRT report by creating simple Report Design File (SampleNeCarGarage.rptdesing) and new link to the hellp.jsp to the BirtController.
The final result looks pretty cool, we know which model of Ford we do have. Additionally we know his location and Total number of Cars located at the same Garage (pic.5.). 

pic.5.:: Cypher in Action and giving us information where the Ford is and how many cars are located in the GarageOne => 3 (pic.3.)
Conclusion: 
Enjoy and have a fun with BIRT, Neo4j and Spring 

Thursday, May 29, 2014

bright future ... alias ... future posts

Whole life is one big studY
pic.1.: student for ever ~ we are all students
I was not active in blogging for last few years (pic.1.), I've been almost completely overloaded by work and focused on project to kick them out or make them just work. Some of them were mine and the rest for companies (pic.2.). 


connect dots together and move things forward
pic.2.: retrospective at GeeCON : connecting dot's together and moving forward
Overall big part of my heart belongs to cutting-edge technologies ... just like small child (never stop discovering bright future) (pic.2.). I've spent big portion of my time by studying Machine Learning possibilities because behind all this will be always clear math. (algebra, probability, statistics ... just fun and getting better in various predictions)(pic.3.)

pic.3.: One day the result of our investigations -> it just works (maybe)
This area is in one hand pretty awesome because it connects many branches together, not  just only math. world but also langues or any other technologies, concepts or methodologies (servers, databases , big data, map reduce etc.)

RaspberryPI traveler package
pic.4.: one of RaspberryPI traveler packages

This blog I would like to focuse on small powerful systems (RaspberryPi, CuBox ...), spring projects, redhat projects (Netty, Vert.x, WildFly, Infinispan etc.) , JetBrains (IntelliJ IDEA, etc.), ZeroTurnaround technologies (JRebel, etc.), GraphDatabases ( Neo4j, etc.), Languages (Java, Scala, Groovy, Ruby, Python etc.)  and many other opensource technologies like JavaFx or NetBeans....(MineCraft) ps: List is too Long (StackOverflow ;)  

Another intent of this blog is to create utilized collection of links I may need currently or in near future with demo apps.

And at the and of course to share some cool news from the Java Virtual Machine World
 (GeeCON: Let's move the Java World!)