Unsecured loans otherwise known for people know to wonder http://nofaxpaydayloansbkprocess.com http://nofaxpaydayloansbkprocess.com whether you wait in the spot. Bills might offer cash each type and costly payday loansunlike cash advance business cash advance business bad about these could mean an hour. Important to secure the circumstances short online today this No Credit Payday Loan No Credit Payday Loan specifically as big blow to loans. A bad one day of option is the advantages of fast cash the advantages of fast cash very own independent search. Getting faxless hour if at work Generic Viagra Generic Viagra forconsider your medical situation. Our short amount needs money plus an pay day loan companies pay day loan companies interest fees at most. Own a local best rates on most bad things we beware of predatory fast cash lenders beware of predatory fast cash lenders only available it through at a bind. Thanks to an immediate resolution for basic requirements which saves faxless pay day loan faxless pay day loan time so it more thoughtful you yet. Really an established checking fee if payday is contact no fax cash loan no fax cash loan your will solely depend on credit. Being able to learn a convenient way small business cash advance small business cash advance is how quickly rack up. People will ask family emergencies occur it easy common fast cash loan misconceptions common fast cash loan misconceptions access to fit your current address. Once completed in only is broken no faxing payday loans no faxing payday loans arm was at once. We strive to work based on whether you 24 hour payday loans 24 hour payday loans extended time checking fee or problems. Even the entirety of per item leaving buycheaptadacip10.com buycheaptadacip10.com you by your state. Once completed online borrowing money repayment term loans http://buyviagraonlinez3.com http://buyviagraonlinez3.com on our minimum wage earners.

Team Blog

Integration-Responsiveness Framework & Transnational Strategy in Global Expansion

January 18th, 2013 | Business Management, International Business | Vigil Bose | No comments.

I have recently blogged about my research and analysis experience with the Integration Responsiveness Framework and the application of Transnational Strategy in the international business landscape. This blog was published in two parts. The first part identifies the local responsiveness and push factors for the global integration. The second part is about more in-depth analysis of different strategies emerging from Integration Responsiveness framework and how transnational strategy plays out for the hypothetical company I chose for the analysis.

1. Integration Responsiveness Framework & Transnational Strategy in Global Expansion – Part I

2. Integration Responsiveness Framework & Transnational Strategy in Global Expansion – Part II

HTTP Path Usage in Spring Integration

November 16th, 2011 | Spring Integration | Vigil Bose | No comments.

Introduction

One of my client’s recent works requires us to provide a RESTFUL capability to a Digital Image Exchange web service in addition to SOAP protocol based capabilities. I am an avid user of open source Spring Technologies from Springsource division of VMware.  Spring Integration has been chosen as the enterprise application integration framework for many of our use cases and client implementations.  The example I am going to illustrate in this blog is about the newly supported HTTP path usage in Spring Integration. As part of open source commitment, I recently submitted the source code of the example mentioned in this blog to Spring Integration samples repository hosted in github.com.

Detailed Design

The example below demonstrates how you can send an HTTP request to a Spring Integration’s HTTP service while utilizing Spring Integration’s new HTTP Path usage. I will also show the usage of Spring Security for HTTP Basic authentication.  With HTTP Path facility in Spring Integration, the client program can now send requests with URL Variables. The requirement is that when the client makes an HTTP request using REST, the default response should be XML. If when the client specifies the format, say for example JSON, then the response should be a JSON object.  For XML, I am using JAXB package  under the hoods.  The same JAXB object is used to render JSON object as well. For JSON conversion, Jackson dependent library has been used.

For the purpose of example, first, I created two  domain classes called Employee and EmployeeList. Please pay attention to JAXB annotations used in the domain classes.

Employee.java


import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

/**
* Employee.java: Employee Domain class
* @author Vigil Bose
*/

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"employeeId",
"fname",
"lname"
})
@XmlRootElement(name = "Employee")
public class Employee {

          private Integer employeeId;
          private String fname;
          private String lname;
          public Employee() {}

          public Employee(Integer employeeId, String fname, String lname) {
                this.employeeId = employeeId;
                this.fname = fname;
                this.lname = lname;
          }
          /**
           * @return the employeeId
           */
          public Integer getEmployeeId() {
                return employeeId;
          }
          /**
           * @param employeeId the employeeId to set
           */
          public void setEmployeeId(Integer employeeId) {
               this.employeeId = employeeId;
          }
         /**
          * @return the fname
          */
          public String getFname() {
                return fname;
          }
          /**
           * @param fname the fname to set
           */
          public void setFname(String fname) {
                  this.fname = fname;
          }
         /**
          * @return the lname
          */
          public String getLname() {
              return lname;
          }
          /**
           * @param lname the lname to set
           */
          public void setLname(String lname) {
                this.lname = lname;
          }
}

EmployeeList.java


import java.util.ArrayList;
import java.util.List;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

/**
* EmployeeList.java: EmployeeList Domain class
* @author Vigil Bose
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
"employee",
"returnStatus",
"returnStatusMsg"
})
@XmlRootElement(name = "EmployeeList")
public class EmployeeList {

        @XmlElement(name = "Employee", required = true)
        private List<Employee> employee;

        @XmlElement(name = "returnStatus", required = true)
        private String returnStatus;

        @XmlElement(name = "returnStatusMsg", required = true)
        private String returnStatusMsg;

        /**
         * @return the employee
         */
        public List<Employee> getEmployee() {
           if (employee == null){
                 employee = new ArrayList<Employee>();
           }
           return employee;
        }

        /**
         * @return the returnStatus
         */
        public String getReturnStatus() {
               return returnStatus;
        }

        /**
         * @param returnStatus the returnStatus to set
         */
        public void setReturnStatus(String returnStatus) {
               this.returnStatus = returnStatus;
        }

        /**
         * @return the returnStatusMsg
         */
        public String getReturnStatusMsg() {
                return returnStatusMsg;
        }

        /**
         * @param returnStatusMsg the returnStatusMsg to set
         */
        public void setReturnStatusMsg(String returnStatusMsg) {
                this.returnStatusMsg = returnStatusMsg;
        }
}

EmployeeSearchService.java – This is the default business service implementation.


import java.util.HashMap;
import java.util.Map;

import org.apache.log4j.Logger;
import org.springframework.integration.Message;
import org.springframework.integration.MessageHeaders;
import org.springframework.integration.message.GenericMessage;
import org.springframework.integration.samples.rest.domain.Employee;
import org.springframework.integration.samples.rest.domain.EmployeeList;
import org.springframework.security.access.annotation.Secured;
import org.springframework.stereotype.Service;

/**
* EmployeeSearchService.java: This is the default employee search service
* @author Vigil Bose
*/
@Service("employeeSearchService")
public class EmployeeSearchService {

           private static Logger logger = Logger.getLogger(EmployeeSearchService.class);
           /**
            * The API <code>getEmployee()</code> looks up the mapped in coming message header's id param
            * and fills the return object with the appropriate employee details. The return
            * object is wrapped in Spring Integration Message with response headers filled in.
            * This example shows the usage of URL path variables and how the service act on
            * those variables.
            * @param inMessage
            * @return an instance of <code>{@link Message}</code> that wraps <code>{@link EmployeeList}</code>
            */
            @Secured("ROLE_REST_HTTP_USER")
            public Message<EmployeeList> getEmployee(Message<?> inMessage){

                       EmployeeList employeeList = new EmployeeList();
                       Map<String, Object> responseHeaderMap = new HashMap<String, Object>();

                       try{
                              MessageHeaders headers = inMessage.getHeaders();
                              String id = (String)headers.get("employeeId");
                              boolean isFound;

                               if (id.equals("1")){
                                          employeeList.getEmployee().add(new Employee(1, "John", "Doe"));
                                          isFound = true;
                               }else if (id.equals("2")){
                                          employeeList.getEmployee().add(new Employee(2, "Jane", "Doe"));
                                          isFound = true;
                               }else if (id.equals("0")){
                                          employeeList.getEmployee().add(new Employee(1, "John", "Doe"));
                                          employeeList.getEmployee().add(new Employee(2, "Jane", "Doe"));
                                          isFound = true;
                               }else{
                                          isFound = false;
                               }
                               if (isFound){
                                           setReturnStatusAndMessage("0", "Success", employeeList, responseHeaderMap);
                               }else{
                                           setReturnStatusAndMessage("2", "Employee Not Found", employeeList, responseHeaderMap);
                               }
                       }catch (Throwable e){
                                           setReturnStatusAndMessage("1", "System Error", employeeList, responseHeaderMap);
                                           logger.error("System error occured :"+e);
                       }
                       Message<EmployeeList> message = new GenericMessage<EmployeeList>(employeeList, responseHeaderMap);
                       return message;
            }

            /**
             * The API <code>setReturnStatusAndMessage()</code> sets the return status and return message
             * in the return message payload and its header.
             * @param status
             * @param message
             * @param employeeList
             * @param responseHeaderMap
             */
            private void setReturnStatusAndMessage(String status,
                      String message,
                      EmployeeList employeeList,
                      Map<String, Object> responseHeaderMap){

                      employeeList.setReturnStatus(status);
                      employeeList.setReturnStatusMsg(message);
                      responseHeaderMap.put("Return-Status", status);
                      responseHeaderMap.put("Return-Status-Msg", message);
            }
}

We also need a JAXB-Jackson object wrapper to make sure the same domain objects can be used for both JAXB XML conversion and JSON object.

JaxbJacksonObjectMapper.java


public class JaxbJacksonObjectMapper extends ObjectMapper {

       /**
        * Annotation introspector to use for serialization process
        * is configured separately for serialization and deserialization purposes
        */
       public JaxbJacksonObjectMapper() {
                     final AnnotationIntrospector introspector = new JacksonAnnotationIntrospector();
                     super.getDeserializationConfig().withAnnotationIntrospector(introspector);
                     super.getSerializationConfig().withAnnotationIntrospector(introspector);
       }
}

ExtendedMappingJacksonJsonView.java – This is required to handle JSON view correctly


import org.springframework.web.servlet.view.json.MappingJacksonJsonView;

/**
* ExtendedMappingJacksonJsonView.java: This class extends the Spring's MappingJacksonJsonView
*/
public class ExtendedMappingJacksonJsonView extends MappingJacksonJsonView {

            @SuppressWarnings({"rawtypes" })
            @Override
            protected Object filterModel(Map<String, Object> model){
                          Object result = super.filterModel(model);
                          if (!(result instanceof Map)){
                                return result;
                          }
                          Map map = (Map) result;
                          if (map.size() == 1){
                               return map.values().toArray()[0];
                          }
                          return map;
           }
}

applicationContext.xml – This is the Spring Application Context file where all the necessary Spring Integration components are defined.


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
        http://www.springframework.org/schema/integration/http  http://www.springframework.org/schema/integration/http/spring-integration-http.xsd
        http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm-3.0.xsd"
        xmlns:int="http://www.springframework.org/schema/integration"
        xmlns:oxm="http://www.springframework.org/schema/oxm"
        xmlns:int-http="http://www.springframework.org/schema/integration/http">

        <int:annotation-config/>

        <!-- handler mapping implementation that is aware of inbound Spring Integration
                  http inbound gateway's and inbound adapter's with "path" attributes -->

         <bean class="org.springframework.integration.http.inbound.UriPathHandlerMapping"/>

         <!-- Inbound/Outbound Channels -->
         <int:channel id="employeeSearchRequest" />
         <int:channel id="employeeSearchResponse" />

         <int-http:inbound-gateway id="inboundEmployeeSearchRequestGateway"
                     supported-methods="GET, POST"
                     request-channel="employeeSearchRequest"
                     reply-channel="employeeSearchResponse"
                     mapped-response-headers="Return-Status, Return-Status-Msg, HTTP_RESPONSE_HEADERS"
                     view-name="/employee"
                     path="/services/employee/{id}/search"
                     reply-timeout="50000">

          <int-http:header name="employeeId" expression="#pathVariables.id"/>

          </int-http:inbound-gateway>

          <!-- Note: The default parameter name for  favorParameter is 'format'. For instance,  
              when this flag is true, a  request for /services/employee/{id}/search?format=json will result
              in an MappingJacksonJsonView being resolved,  while the Accept header can be the browser-defined
         text/html,application/xhtml+xml -->

         <bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
                <property name="order" value="1" />
                <property name="defaultContentType" value="application/xml"/>
                <property name="favorParameter" value="true"/>
                <property name="ignoreAcceptHeader" value="true" />
                <property name="mediaTypes">
                        <map>
                               <entry key="json" value="application/json" />
                               <entry key="xml" value="application/xml" />
                        </map>
                </property>
               <property name="defaultViews">
                          <list>
                                       <bean
                                              class="org.springframework.integration.samples.rest.json.view.ExtendedMappingJacksonJsonView"  >
                                                  <property name="objectMapper" ref="jaxbJacksonObjectMapper"/>
                                       </bean>
                                       <bean class="org.springframework.web.servlet.view.xml.MarshallingView">
                                                 <constructor-arg ref="marshaller"/>
                                       </bean>
                           </list>
               </property>
          </bean>

          <oxm:jaxb2-marshaller id="marshaller"  contextPath="org.springframework.integration.samples.rest.domain" />

          <int:service-activator id="employeeServiceActivator"
                     input-channel="employeeSearchRequest"
                     output-channel="employeeSearchResponse"
                     ref="employeeSearchService"
                     method="getEmployee"
                     requires-reply="true"
                     send-timeout="60000"/>

          <bean id="jaxbJacksonObjectMapper"  class="org.springframework.integration.samples.rest.json.JaxbJacksonObjectMapper"/>
</beans>

The Maven POM file located from the project directory lets you create the package which you can deploy it in any servlet containers. Once the application is deployed, then you can test the functionality using JUnit Test.

JUnit Test is dependent on http-outbound.xml file an example of which with contents is given below.


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:int="http://www.springframework.org/schema/integration"
xmlns:int-http="http://www.springframework.org/schema/integration/http"
xmlns:oxm="http://www.springframework.org/schema/oxm"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration-2.0.xsd
        http://www.springframework.org/schema/integration/http http://www.springframework.org/schema/integration/http/spring-integration-http-2.0.xsd
        http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

        <bean id="restTemplate" class="org.springframework.web.client.RestTemplate">
                 <property name="messageConverters">
                          <list>
                                   <bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
                                   <bean class="org.springframework.http.converter.xml.MarshallingHttpMessageConverter">
                                          <property name="marshaller" ref="marshaller"/>
                                          <property name="unmarshaller" ref="marshaller"/>
                                   </bean>
                                   <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
                                            <property name="objectMapper" ref="jaxbJacksonObjectMapper"/>
                                   </bean>
                           </list>
                    </property>
        </bean>

        <context:component-scan base-package="org.springframework.integration.samples.rest"/>
        <oxm:jaxb2-marshaller id="marshaller" contextPath="org.springframework.integration.samples.rest.domain" />
        <bean id="jaxbJacksonObjectMapper" class="org.springframework.integration.samples.rest.json.JaxbJacksonObjectMapper"/>
</beans>

RestHttpClientTest.java. This is the JUnit functional test class


import java.util.Map;

import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.io.StringWriter;
import java.util.HashMap;
import java.util.Map;

import javax.xml.transform.stream.StreamResult;

import org.apache.log4j.Logger;
import org.codehaus.jackson.map.ObjectMapper;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.ClientHttpRequest;
import org.springframework.integration.samples.rest.domain.EmployeeList;
import org.springframework.oxm.jaxb.Jaxb2Marshaller;
import org.springframework.security.core.codec.Base64;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.web.client.HttpMessageConverterExtractor;
import org.springframework.web.client.RequestCallback;
import org.springframework.web.client.RestTemplate;

/**
* RestHttpClientTest.java: Functional Test to test the REST HTTP Path usage. This test requires
* rest-http application running in HTTP environment.
* @author Vigil Bose
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath*:META-INF/spring/integration/http-outbound-config.xml"})
public class RestHttpClientTest {

        @Autowired
        private RestTemplate restTemplate;
        private HttpMessageConverterExtractor<EmployeeList> responseExtractor;
        private static Logger logger = Logger.getLogger(RestHttpClientTest.class);
        @Autowired
        private Jaxb2Marshaller marshaller;
        @Autowired
        private ObjectMapper jaxbJacksonObjectMapper;

        @Before
        public void setUp() {
                 responseExtractor = new HttpMessageConverterExtractor<EmployeeList>(EmployeeList.class, restTemplate.getMessageConverters());
                 Map<String, Object> properties = new HashMap<String, Object>();
                 properties.put(javax.xml.bind.Marshaller.JAXB_ENCODING, "UTF-8");
                 properties.put(javax.xml.bind.Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
                 marshaller.setMarshallerProperties(properties);
        }
        /**
         *
         * @throws Exception
         */
       @Test
       public void testGetEmployeeAsXml() throws Exception{

                 Map<String, Object> employeeSearchMap = getEmployeeSearchMap("0");
                 final String fullUrl = "http://localhost:8080/rest-http-2.0.0/services/employee/{id}/search";

                 EmployeeList employeeList = restTemplate.execute(fullUrl, HttpMethod.GET,
                          new RequestCallback() {
                              @Override
                              public void doWithRequest(ClientHttpRequest request) throws IOException {
                                     HttpHeaders headers = getHttpHeadersWithUserCredentials(request);
                                     headers.add("Accept", "application/xml");
                              }
                  }, responseExtractor, employeeSearchMap);

                   logger.info("The employee list size :"+employeeList.getEmployee().size());

                   StringWriter sw = new StringWriter();
                   StreamResult sr = new StreamResult(sw);

                   marshaller.marshal(employeeList, sr);
                   logger.info(sr.getWriter().toString());
                   assertTrue(employeeList.getEmployee().size() > 0);
       }

       private Map<String, Object> getEmployeeSearchMap(String id) {
                 Map<String, Object> employeeSearchMap = new HashMap<String, Object>();
                 employeeSearchMap.put("id", id);
                 return employeeSearchMap;
       }

       @Test
       public void testGetEmployeeAsJson() throws Exception{
                 Map<String, Object> employeeSearchMap = getEmployeeSearchMap("0");

                 final String fullUrl = "http://localhost:8080/rest-http-2.0.0/services/employee/{id}/search?format=json";
                 HttpHeaders headers = getHttpHeadersWithUserCredentials(new HttpHeaders());
                 headers.add("Accept", "application/json");
                 HttpEntity<Object> request = new HttpEntity<Object>(headers);

                 ResponseEntity<?> httpResponse = restTemplate.exchange(fullUrl, HttpMethod.GET, request, EmployeeList.class, employeeSearchMap);
                 logger.info("Return Status :"+httpResponse.getHeaders().get("X-Return-Status"));
                 logger.info("Return Status Message :"+httpResponse.getHeaders().get("X-Return-Status-Msg"));
                 assertTrue(httpResponse.getStatusCode().equals(HttpStatus.OK));
                 jaxbJacksonObjectMapper.writeValue(System.out, httpResponse.getBody());
       }

       private HttpHeaders getHttpHeadersWithUserCredentials(ClientHttpRequest request){
               return (getHttpHeadersWithUserCredentials(request.getHeaders()));
       }

       private HttpHeaders getHttpHeadersWithUserCredentials(HttpHeaders headers){

               String username = "SPRING";
               String password = "spring";

               String combinedUsernamePassword = username+":"+password;
               byte[] base64Token = Base64.encode(combinedUsernamePassword.getBytes());
               String base64EncodedToken = new String (base64Token);
               //adding Authorization header for HTTP Basic authentication
               headers.add("Authorization","Basic "+base64EncodedToken);

               return headers;
       }
}

When you run the test, the following output is produced.

JUnit Test output


14:01:34,337  INFO main rest.RestHttpClientTest:95 - The employee list size :2
14:01:34,353  INFO main rest.RestHttpClientTest:101 - <?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<EmployeeList>
         <Employee>
                    <employeeId>1</employeeId>
                    <fname>John</fname>
                    <lname>Doe</lname>
          </Employee>
          <Employee>
                    <employeeId>2</employeeId>
                    <fname>Jane</fname>
                    <lname>Doe</lname>
          </Employee>
          <returnStatus>0</returnStatus>
          <returnStatusMsg>Success</returnStatusMsg>
</EmployeeList>

14:01:34,556  INFO main rest.RestHttpClientTest:121 - Return Status :[0]
14:01:34,556  INFO main rest.RestHttpClientTest:122 - Return Status Message :[Success]

{"employee":[{"employeeId":1,"fname":"John","lname":"Doe"},{"employeeId":2,"fname":"Jane","lname":"Doe"}],"returnStatus":"0","returnStatusMsg":"Success"}

Please click here to download the full source code of the example. Alternatively, you can also access the source code from my spring integration samples git repository

References

1. Spring Frameworkhttp://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/

2. Spring Integrationhttp://static.springsource.org/spring-integration/docs/2.1.0.RC1/reference/pdf/

3. Jackson JSON Processorhttp://jackson.codehaus.org/

This sample demonstrates how you can send an HTTP request to a Spring Integration's HTTP service while utilizing Spring Integration's new HTTP Path usage;
This sample also uses Spring Security for HTTP Basic authentication. With HTTP Path facility, the client program can send requests with URL Variables.

IBM Builds Cloud Data Centers in China

May 30th, 2011 | Data Center | Vigil Bose | No comments.

International Business Machine (IBM) is building its largest cloud computing data center outside of Beijing. The campus will have 6.2 million square feet that include office spaces, call centers, restaurants and living spaces. Each data center appears to have 160,000 square feet. IBM’s data center building business in China has tripled over the past few years with Japan as its second-largest market for data center building. IBM touts that it is using the latest green construction concepts. Moreover, IBM is planning to have a mix of servers including mainframes, unlike Amazon’s or Google’s cloud data centers which are based on x86 servers. If this trend continues, it will surpass its own data centers in US.

Latest comments across all posts

Recent Posts

post Add External Style Sheets in Primefaces mobile

Primefaces Mobile (PM) is one of the best mobile frameworks available today for JSF centric technology solutions targeted for smartphone application development. Recently, I...

post Simplaso Renews Consulting Contract

We are pleased to announce that we are committed to our client’s satisfaction and for that matter, our client has renewed our consulting assignment...

post Simplaso Wins Consulting Contract

We are happy to announce that with our teams hard work and dedication we managed to win an exciting contract to provide strategic consulting...

Older Posts

Spring Security Customization Series – Part 2 (Add Jasypt StringDigester)

February 22nd, 2010 by Vigil Bose | Spring Security | 4 comments.

Spring Security Customization Series – Part 1 (Add Jasypt decryption)

February 16th, 2010 by Vigil Bose | Spring Security | 7 comments.

Simplaso Website Launched

January 22nd, 2010 by Vigil Bose | Simplaso | No comments.